# DP: updates from the 16 branch upto 20260613 (1997e95e4e8).

LANG=C git diff --no-renames --src-prefix=a/src/ --dst-prefix=b/src/ \
	6afcc4f6da931eb93f3ab001a0dd9650ea71d1ea 1997e95e4e8da1a7a2c9dd6712730bf6f12cd99b \
	| awk '/^diff .*\.texi/ {skip=1; next} /^diff / { skip=0 } skip==0' \
	| grep -v -E '^(diff|index)'

--- a/src/contrib/ChangeLog
+++ b/src/contrib/ChangeLog
@@ -1,3 +1,10 @@
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	* gennews (files): Add files for GCC 16.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/ChangeLog
+++ b/src/gcc/ChangeLog
@@ -1,3 +1,1145 @@
+2026-06-11  Georg-Johann Lay  <avr@gjlay.de>
+
+	Backported from master:
+	2026-06-11  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/125751
+	* config/avr/avr.cc (avr_out_fract): Fix too small sequence
+	lengths in avr_asm_len calls.
+
+2026-06-11  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	PR testsuite/113276
+	* doc/sourcebuild.texi (arm_mixed_fp): Document.
+
+2026-06-09  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-06-08  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/mips/sync.md (sync_old_<optab><mode>): Fix
+	uninitialized operand use.
+	(sync_new_<optab><mode>): Fix uninitialized operand use, use the
+	same expression for the set source of operand 0 and 1.
+
+2026-06-09  Kewen Lin  <linkewen@hygon.cn>
+
+	Backported from master:
+	2026-05-28  Kewen Lin  <linkewen@hygon.cn>
+		    Xin Liu  <liulxx@hygon.cn>
+
+	* config/i386/c86-4g-m7.md (c86_4g_m7_fpu): Remove automaton.
+	(c86_4g_m7_fpu02): New automaton.
+	(c86_4g_m7_fpu13): Ditto.
+	(c86-4g-m7-fpu0): Move to c86_4g_m7_fpu02 automaton.
+	(c86-4g-m7-fpu1): Move to c86_4g_m7_fpu13 automaton.
+	(c86-4g-m7-fpu2): Move to c86_4g_m7_fpu02 automaton.
+	(c86-4g-m7-fpu3): Move to c86_4g_m7_fpu13 automaton.
+	(c86-4g-m7-fdiv): Remove cpu unit.
+	(c86-4g-m7-fdiv1): New cpu unit.
+	(c86-4g-m7-fdiv3): Ditto.
+	(c86-4g-m7-fpu_0_3): New reservation.
+	(c86-4g-m7-fpu_1_3x2): Ditto.
+	(c86-4g-m7-fpu_1_3x3): Ditto.
+	(c86-4g-m7-fpu_1_3x6): Ditto.
+	(c86-4g-m7-fpux2): Ditto.
+	(c86-4g-m7-fpux4): Ditto.
+	(c86-4g-m7-fpux6): Ditto.
+	(c86-4g-m7-fpux8): Ditto.
+	(c86-4g-m7-fpux16): Ditto.
+	(c86-4g-m7-fp1fdiv1x4): Ditto.
+	(c86-4g-m7-fp3fdiv3x4): Ditto.
+	(c86-4g-m7-fdiv13): Ditto.
+	(c86-4g-m7-fp13div13): Ditto.
+	(c86-4g-m7-fp13div13x4): Ditto.
+	(c86-4g-m7-fp1div1_fp3div3_x4x8): Ditto.
+	(c86-4g-m7-fp1div1_fp3div3_x4x9): Ditto.
+	(c86-4g-m7-fp1div1_fp3div3_x4x11): Ditto.
+	(c86-4g-m7-fp1div1_fp3div3_x4x15): Ditto.
+	(c86-4g-m7-fp1div1_fp3div3_x4x18): Ditto.
+	(c86_4g_m7_idiv): New reservation.
+	(c86_4g_m7_idiv_QI): Adjust reservation latency and unit occupancy.
+	(c86_4g_m7_idiv_load): New reservation.
+	(c86_4g_m7_idiv_QI_load): Adjust reservation latency and unit
+	occupancy.
+	(c86_4g_m7_idiv_DI): Remove reservation.
+	(c86_4g_m7_idiv_SI): Ditto.
+	(c86_4g_m7_idiv_HI): Ditto.
+	(c86_4g_m7_idiv_DI_load): Ditto.
+	(c86_4g_m7_idiv_SI_load): Ditto.
+	(c86_4g_m7_idiv_HI_load): Ditto.
+	(c86_4g_m7_sse_insertimm): Adjust reservation units and unit
+	occupancy.
+	(c86_4g_m7_sse_insert): Ditto.
+	(c86_4g_m7_fp_sqrt): Adjust reservation.
+	(c86_4g_m7_fp_div): Ditto.
+	(c86_4g_m7_fp_div_load): Ditto.
+	(c86_4g_m7_fp_idiv_load): Ditto.
+	(c86_4g_m7_sse_pinsr_reg): Adjust reservation units and unit
+	occupancy.
+	(c86_4g_m7_sse_pinsr_reg_load): Ditto.
+	(c86_4g_m7_avx_vpinsr_reg): Ditto.
+	(c86_4g_m7_avx_vpinsr_reg_load): Ditto.
+	(c86_4g_m7_avx512_perm_xmm): Delete the prefix condition.
+	(c86_4g_m7_avx512_perm_xmm_opload): Ditto.
+	(c86_4g_m7_avx512_permi2_ymm): Adjust reservation units and unit
+	occupancy.
+	(c86_4g_m7_avx512_permi2_zmm): Ditto.
+	(c86_4g_m7_avx512_permi2_ymm_load): Ditto.
+	(c86_4g_m7_avx512_permi2_zmm_load): Ditto.
+	(c86_4g_m7_avx512_perm_zmm_imm): Ditto.
+	(c86_4g_m7_avx512_perm_zmm_imm_load): Ditto.
+	(c86_4g_m7_avx512_perm_zmm_noimm): Ditto.
+	(c86_4g_m7_sse_perm_zmm_noimm_load): Ditto.
+	(c86_4g_m7_avx_perm_ymm): Remove.
+	(c86_4g_m7_avx_perm_ymem): Ditto.
+	(c86_4g_m7_avx512_shuf_zmm): Adjust reservation units and unit
+	occupancy.
+	(c86_4g_m7_avx512_shuf_zmem): Ditto.
+	(c86_4g_m7_avx512_cmpestr): Ditto.
+	(c86_4g_m7_avx512_cmpestr_load): Ditto.
+	(c86_4g_m7_avx512_vdbpsadbw_zmm): Ditto.
+	(c86_4g_m7_avx512_vdbpsadbw_zmem): Ditto.
+	(c86_4g_m7_avx_ssecomi_comi): Ditto.
+	(c86_4g_m7_avx_ssecomi_comi_load): Ditto.
+	(c86_4g_m7_avx512_expand): Ditto.
+	(c86_4g_m7_avx512_expand_load): Ditto.
+	(c86_4g_m7_avx512_expand_z): Ditto.
+	(c86_4g_m7_avx512_expand_z_load): Ditto.
+	(c86_4g_m7_sse_movnt_xy): Rename to c86_4g_m7_sse_movnt.
+	(c86_4g_m7_avx512_sseadd_xy): Adjust reservation units.
+	(c86_4g_m7_avx512_sseadd_xy_load): Ditto.
+	(c86_4g_m7_sse_sseiadd_hplus): Adjust reservation units and unit
+	occupancy.
+	(c86_4g_m7_sse_sseiadd_hplus_load): Ditto.
+	(c86_4g_m7_avx512_ssemul): Adjust reservation units.
+	(c86_4g_m7_avx512_ssemul_load): Ditto.
+	(c86_4g_m7_avx512_ssediv): Remove.
+	(c86_4g_m7_avx512_ssediv_mem): Remove.
+	(c86_4g_m7_avx512_ssediv_x): New.
+	(c86_4g_m7_avx512_ssediv_xmem): New.
+	(c86_4g_m7_avx512_ssediv_y): New.
+	(c86_4g_m7_avx512_ssediv_ymem): New.
+	(c86_4g_m7_avx512_ssediv_z): Adjust reservation units.
+	(c86_4g_m7_avx512_ssediv_zmem): Ditto.
+	(c86_4g_m7_avx512_ssecmp_z): Add reservation units and unit
+	occupancy.
+	(c86_4g_m7_avx512_ssecmp_z_load): Ditto.
+	(c86_4g_m7_avx512_ssecmp_vp_z): New reservation.
+	(c86_4g_m7_avx512_ssecmp_vp_z_load): Ditto.
+	(c86_4g_m7_avx512_ssecmp_test_z): Remove reservation.
+	(c86_4g_m7_avx512_ssecmp_test_z_load): Ditto.
+	(c86_4g_m7_avx512_muladd): Broaden matching condition.
+	(c86_4g_m7_avx512_muladd_load): Ditto.
+	(c86_4g_m7_fma_muladd): Remove reservation.
+	(c86_4g_m7_fma_muladd_load): Ditto.
+	(c86_4g_m7_avx512_sse_conflict_x): Add reservation units and unit
+	occupancy.
+	(c86_4g_m7_avx512_sse_conflict_x_load): Ditto.
+	(c86_4g_m7_avx512_sse_conflict_y): Ditto.
+	(c86_4g_m7_avx512_sse_conflict_y_load): Ditto.
+	(c86_4g_m7_avx512_sse_conflict_z): Ditto.
+	(c86_4g_m7_avx512_sse_conflict_z_load): Ditto.
+	(c86_4g_m7_avx512_sse_class_z): Add reservation units and unit
+	occupancy.
+	(c86_4g_m7_avx512_sse_class_z_load): Ditto.
+	(c86_4g_m7_avx512_sse_sqrt): Remove.
+	(c86_4g_m7_avx512_sse_sqrt_load): Remove.
+	(c86_4g_m7_avx512_sse_sqrt_sf_x): New.
+	(c86_4g_m7_avx512_sse_sqrt_sf_xload): New.
+	(c86_4g_m7_avx512_sse_sqrt_sf_y): New.
+	(c86_4g_m7_avx512_sse_sqrt_sf_yload): New.
+	(c86_4g_m7_avx512_sse_sqrt_sf_z): New.
+	(c86_4g_m7_avx512_sse_sqrt_sf_zload): New.
+	(c86_4g_m7_avx512_sse_sqrt_df_x): New.
+	(c86_4g_m7_avx512_sse_sqrt_df_xload): New.
+	(c86_4g_m7_avx512_sse_sqrt_df_y): New.
+	(c86_4g_m7_avx512_sse_sqrt_df_yload): New.
+	(c86_4g_m7_avx512_sse_sqrt_df_z): New.
+	(c86_4g_m7_avx512_sse_sqrt_df_zload): New.
+	(c86_4g_m7_avx512_msklog_vector): Add reservation units and unit
+	occupancy.
+	(c86_4g_m7_avx512_mskmov_z_k): Ditto.
+	(c86_4g_m7_avx512_mskmov_k_reg): Ditto.
+	* config/i386/c86-4g.md (c86_4g_fp): Remove automaton.
+	(c86_4g_fp024): New automaton.
+	(c86_4g_fp1): Ditto.
+	(c86-4g-fp0): Move to c86_4g_fp024 automaton.
+	(c86-4g-fp1): Move to c86_4g_fp1 automaton.
+	(c86-4g-fp2): Move to c86_4g_fp024 automaton.
+	(c86-4g-fp3): Ditto.
+	(c86-4g-fp1fdivx4): New reservation.
+	(c86_4g_fp_sqrt): Adjust reservation.
+	(c86_4g_sse_sqrt_sf): Ditto.
+	(c86_4g_sse_sqrt_sf_mem): Ditto.
+	(c86_4g_sse_sqrt_df): Ditto.
+	(c86_4g_sse_sqrt_df_mem): Ditto.
+	(c86_4g_fp_op_div): Ditto.
+	(c86_4g_fp_op_div_load): Ditto.
+	(c86_4g_fp_op_idiv_load): Adjust reservation latency.
+	(c86_4g_ssediv_ss_ps): Adjust reservation.
+	(c86_4g_ssediv_ss_ps_load): Ditto.
+	(c86_4g_ssediv_sd_pd): Ditto.
+	(c86_4g_ssediv_sd_pd_load): Ditto.
+	(c86_4g_ssediv_avx256_ps): Ditto.
+	(c86_4g_ssediv_avx256_ps_load): Ditto.
+	(c86_4g_ssediv_avx256_pd): Ditto.
+	(c86_4g_ssediv_avx256_pd_load): Ditto.
+
+2026-06-09  Kewen Lin  <linkewen@hygon.cn>
+
+	Backported from master:
+	2026-05-01  Kewen Lin  <linkewen@hygon.cn>
+
+	* config/i386/c86-4g-m7.md (c86_4g_m7_idiv): New automaton.
+	(c86_4g_m7_fdiv): Ditto.
+	(c86-4g-m7-idiv): New unit.
+	(c86-4g-m7-fdiv): Ditto.
+	(c86_4g_m7_idiv_DI): Adjust unit in the reservation.
+	(c86_4g_m7_idiv_SI): Ditto.
+	(c86_4g_m7_idiv_HI): Ditto.
+	(c86_4g_m7_idiv_QI): Ditto.
+	(c86_4g_m7_idiv_DI_load): Ditto.
+	(c86_4g_m7_idiv_SI_load): Ditto.
+	(c86_4g_m7_idiv_HI_load): Ditto.
+	(c86_4g_m7_idiv_QI_load): Ditto.
+	(c86_4g_m7_fp_div): Ditto.
+	(c86_4g_m7_fp_div_load): Ditto.
+	(c86_4g_m7_fp_idiv_load): Ditto.
+	(c86_4g_m7_avx512_ssediv): Ditto.
+	(c86_4g_m7_avx512_ssediv_mem): Ditto.
+	(c86_4g_m7_avx512_ssediv_z): Ditto.
+	(c86_4g_m7_avx512_ssediv_zmem): Ditto.
+	(c86_4g_m7_avx512_sse_sqrt): Ditto.
+	(c86_4g_m7_avx512_sse_sqrt_load): Ditto.
+	(c86_4g_m7_fp_sqrt): Ditto.  Rename from ...
+	(c86_4g_m7fp_sqrt): ... here.
+	* config/i386/c86-4g.md (c86_4g_idiv): New automaton.
+	(c86_4g_fdiv): Ditto.
+	(c86-4g-idiv): New unit.
+	(c86-4g-fdiv): Ditto.
+	(c86_4g_idiv_DI): Ditto.
+	(c86_4g_idiv_SI): Ditto.
+	(c86_4g_idiv_HI): Ditto.
+	(c86_4g_idiv_QI): Ditto.
+	(c86_4g_idiv_mem_DI): Ditto.
+	(c86_4g_idiv_mem_SI): Ditto.
+	(c86_4g_idiv_mem_HI): Ditto.
+	(c86_4g_idiv_mem_QI): Ditto.
+	(c86_4g_fp_sqrt): Ditto.
+	(c86_4g_sse_sqrt_sf): Ditto.
+	(c86_4g_sse_sqrt_sf_mem): Ditto.
+	(c86_4g_sse_sqrt_df): Ditto.
+	(c86_4g_sse_sqrt_df_mem): Ditto.
+	(c86_4g_fp_op_div): Ditto.
+	(c86_4g_fp_op_div_load): Ditto.
+	(c86_4g_fp_op_idiv_load): Ditto.
+	(c86_4g_ssediv_ss_ps): Ditto.
+	(c86_4g_ssediv_ss_ps_load): Ditto.
+	(c86_4g_ssediv_ss_pd): Ditto.
+	(c86_4g_ssediv_ss_pd_load): Ditto.
+	(c86_4g_ssediv_avx256_ps): Ditto.
+	(c86_4g_ssediv_avx256_ps_load): Ditto.
+	(c86_4g_ssediv_avx256_pd): Ditto.
+	(c86_4g_ssediv_avx256_pd_load): Ditto.
+
+2026-06-09  Xin Liu  <liulxx@hygon.cn>
+
+	Backported from master:
+	2026-04-29  Xin Liu  <liulxx@hygon.cn>
+		    Zhaoling Bao  <baozhaoling@hygon.cn>
+
+	* common/config/i386/cpuinfo.h (get_hygon_cpu): Detect the specific
+	type of HYGON CPU and return HYGON CPU name.
+	(cpu_indicator_init): Handle HYGON CPU.
+	* common/config/i386/i386-common.cc (processor_names): Add HYGON
+	C86-4G processors c86-4g-m{4,6,7}.
+	(processor_alias_table): Add hygon, hygonfam18h and c86-4g-m{4,6,7}
+	entries.
+	(ARRAY_SIZE): Update as new entries added.
+	* common/config/i386/i386-cpuinfo.h (enum processor_vendor): Add
+	VENDOR_HYGON.
+	(enum processor_types): Add HYGONFAM18H.
+	(enum processor_subtypes): Add HYGONFAM18H_C86_4G_M{4,6,7}.
+	* config.gcc: Add support for c86_4g_m{4,6,7}.
+	* config/i386/cpuid.h (signature_HYGON_ebx):  Add signature for HYGON.
+	(signature_HYGON_ecx): Ditto.
+	(signature_HYGON_edx): Ditto.
+	* config/i386/driver-i386.cc (host_detect_local_cpu): Support HYGON
+	c86-4g-m4{4,6,7} processors.
+	* config/i386/i386-c.cc (ix86_target_macros_internal): Ditto.
+	* config/i386/i386-options.cc (m_C86_4G_M4): New definition.
+	(m_C86_4G_M6): Ditto.
+	(m_C86_4G_M7): Ditto.
+	(m_C86_4G): Ditto.
+	(processor_cost_table): Add cost entries for c86-4g-m4{4,6,7}.
+	* config/i386/i386.cc (ix86_reassociation_width): Add handlings for
+	PROCESSOR_C86_4G_M{4,6,7}.
+	* config/i386/i386.h (enum processor_type): Define
+	PROCESSOR_C86_4G_M{4,6,7}.
+	(PTA_C86_4G_M4): New define.
+	(PTA_C86_4G_M6): Ditto.
+	(PTA_C86_4G_M7): Ditto.
+	* config/i386/x86-tune-costs.h (c86_4g_m4_memcpy): New stringop_algs.
+	(c86_4g_m4_cost): New processor_costs.
+	(c86_4g_m6_cost): Ditto.
+	(c86_4g_m7_cost): Ditto.
+	* config/i386/x86-tune-sched.cc (ix86_issue_rate): Handle
+	PROCESSOR_C86_4G_M{4,6,7}.
+	(ix86_adjust_cost): Ditto.
+	* config/i386/x86-tune.def (X86_TUNE_SCHEDULE): Handle m_C86_4G.
+	(X86_TUNE_PARTIAL_REG_DEPENDENCY): Ditto.
+	(X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY): Ditto.
+	(X86_TUNE_SSE_PARTIAL_REG_FP_CONVERTS_DEPENDENCY): Ditto.
+	(X86_TUNE_SSE_PARTIAL_REG_CONVERTS_DEPENDENCY): Ditto.
+	(X86_TUNE_MEMORY_MISMATCH_STALL): Ditto.
+	(X86_TUNE_FUSE_CMP_AND_BRANCH_32): Ditto.
+	(X86_TUNE_FUSE_CMP_AND_BRANCH_64): Ditto.
+	(X86_TUNE_FUSE_CMP_AND_BRANCH_SOFLAGS): Ditto.
+	(X86_TUNE_USE_LEAVE): Ditto.
+	(X86_TUNE_PUSH_MEMORY): Ditto.
+	(X86_TUNE_INTEGER_DFMODE_MOVES): Ditto.
+	(X86_TUNE_MISALIGNED_MOVE_STRING_PRO_EPILOGUES): Ditto.
+	(X86_TUNE_USE_SAHF): Ditto.
+	(X86_TUNE_USE_BT): Ditto.
+	(X86_TUNE_AVOID_MFENCE): Ditto.
+	(X86_TUNE_USE_FFREEP): Ditto.
+	(X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL): Ditto.
+	(X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL): Ditto.
+	(X86_TUNE_SSE_TYPELESS_STORES): Ditto.
+	(X86_TUNE_SSE_LOAD0_BY_PXOR): Ditto.
+	(X86_TUNE_USE_GATHER_2PARTS): Ditto.
+	(X86_TUNE_USE_GATHER_4PARTS): Ditto.
+	(X86_TUNE_USE_GATHER_8PARTS): Ditto.
+	(X86_TUNE_AVOID_128FMA_CHAINS): Ditto.
+	(X86_TUNE_AVOID_256FMA_CHAINS): Ditto.
+	(X86_TUNE_USE_RCR): Ditto.
+	(X86_TUNE_AVX256_MOVE_BY_PIECES): Handle m_C86_4G_M{4,6}.
+	(X86_TUNE_USE_SCATTER_2PARTS): Handle m_C86_4G_M7.
+	(X86_TUNE_USE_SCATTER_4PARTS): Ditto.
+	(X86_TUNE_USE_SCATTER_8PARTS): Ditto.
+	(X86_TUNE_SSE_REDUCTION_PREFER_PSHUF): Ditto.
+	(X86_TUNE_AVX512_SPLIT_REGS): Ditto.
+	(X86_TUNE_AVX512_MOVE_BY_PIECES): Ditto.
+	(X86_TUNE_AVX512_MASKED_EPILOGUES): Ditto.
+	* doc/extend.texi: Document about hygonfam18h and c86-4g-m{4,6,7}.
+	* doc/invoke.texi: Document about c86-4g-m{4,6,7}.
+	* config/i386/c86-4g-m7.md: New file for c86-4g-m7 scheduling model
+	information.
+	* config/i386/c86-4g.md: New file for c86-4g-m{4,6} scheduling model
+	information.
+	* config/i386/i386.md (cpu attr): Add c86_4g_m{4,6,7}.
+	(c86-4g.md): New include.
+	(c86-4g-m7.md): Ditto.
+	(*cmpi<unord>xf_i387): Set attr c86_decode.
+	(*cmpi<unord><MODEF:mode>): Ditto.
+	(swap<mode>): Ditto.
+	(*swap<mode>): Ditto.
+	(extendhisi2): Ditto.
+	(floathi<mode>2): Ditto.
+	(float<SWI48x:mode>xf2): Ditto.
+	(*float<SWI48:mode><MODEF:mode>2): Ditto.
+	(*floatdi<MODEF:mode>2_i387): Ditto.
+	(*anddi_1_bt): Ditto.
+	(*iordi_1_bts): Ditto.
+	(*xordi_1_btc): Ditto.
+	(*<btsc><mode>): Ditto.
+	(*btr<mode>): Ditto.
+	(*btsq_imm): Ditto.
+	(*btrq_imm): Ditto.
+	(*btcq_imm): Ditto.
+	(*tzcnt<mode>_1): Ditto.
+	(*tzcnt<mode>_1_falsedep): Ditto.
+	(*bsf<mode>_1): Ditto.
+	(*ctz<mode>2_falsedep): Ditto.
+	(*ctzsi2_zext): Ditto.
+	(*ctzsi2_zext_falsedep): Ditto.
+	(bsr_rex64): Ditto.
+	(bsr_rex64_1): Ditto.
+	(bsr_rex64_1_zext): Ditto.
+	(bsr): Ditto.
+	(bsr_1): Ditto.
+	(bsr_zext_1): Ditto.
+	(*bswaphi2_movbe): Ditto.
+	(*bswaphi2): Ditto.
+	(bswaphisi2_lowpart): Ditto.
+	(fpremxf4_i387): Ditto.
+	(fprem1xf4_i387): Ditto.
+	(<sincos>xf2): Ditto.
+	(sincosxf3): Ditto.
+	(fptanxf4_i387): Ditto.
+	(atan2xf3): Ditto.
+	(fyl2xxf3_i387): Ditto.
+	(fyl2xp1xf3_i387): Ditto.
+	(fxtractxf3_i387): Ditto.
+	(*f2xm1xf2_i387): Ditto.
+	(fscalexf4_i387): Ditto.
+	(rintxf2): Ditto.
+	(*movxi_internal_avx512f): Set attr c86_attr.
+	(*movoi_internal_avx): Ditto.
+	(*movti_internal): Ditto.
+	(*movdi_internal): Ditto.
+	(*movsi_internal): Ditto.
+	(*movhi_internal): Ditto.
+	(*movtf_internal): Ditto.
+	(*movdf_internal): Ditto.
+	(*movsf_internal): Ditto.
+	(*zero_extendsidi2): Ditto.
+	(sqrtxf2): Ditto.
+	(<smaxmin:code><mode>3): Ditto.
+	(*ieee_s<ieee_maxmin><mode>3): Ditto.
+	* config/i386/mmx.md (*mmx_maskmovq): Set attr c86_decode.
+	(*mmx_maskmovq): Ditto.
+	(sse_movntq): Set attr c86_attr.
+	(*mmx_blendps): Ditto.
+	(mmx_blendvps): Ditto.
+	(*mmx_pmaddwd): Ditto.
+	(mmx_pblendvb_v8qi): Ditto.
+	(mmx_pblendvb_<mode>): Ditto.
+	(sse4_1_<code>v4qiv4hi2): Ditto.
+	(sse4_1_<code>v2hiv2si2): Ditto.
+	(sse4_1_<code>v2qiv2si2): Ditto.
+	(sse4_1_<code>v2qiv2hi2): Ditto.
+	(*mmx_pinsrd): Ditto.
+	(*mmx_pinsrw): Ditto.
+	(*mmx_pinsrb): Ditto.
+	(*mmx_pextrw): Ditto.
+	(*mmx_pextrw<mode>): Ditto.
+	(*mmx_pextrw_zext): Ditto.
+	(*mmx_pextrb): Ditto.
+	(*mmx_pextrb_zext): Ditto.
+	(*mmx_pblendw64): Ditto.
+	(*mmx_pblendw32): Ditto.
+	(*vec_extractv2si_1): Ditto.
+	(*vec_extractv2si_1_zext): Ditto.
+	(*pinsrw): Ditto.
+	(*pinsrb): Ditto.
+	(*pextrw): Ditto.
+	(*pextrw<mode>): Ditto.
+	(*pextrw_zext): Ditto.
+	(*pextrb): Ditto.
+	(*pextrb_zext): Ditto.
+	(*mmx_psadbw): Ditto.
+	* config/i386/sse.md (ktest<mode>): Set attr c86_decode.
+	(*kortest<mode>): Ditto.
+	(sse_cvtsi2ss<rex64namesuffix><round_name>): Ditto.
+	(sse2_cvtsi2sd): Ditto.
+	(sse2_maskmovdqu): Ditto.
+	(*<sse>_dp<ssemodesuffix><avxsizesuffix>): Ditto.
+	(*<sse4_1_avx2>_mpsadbw): Ditto.
+	(pclmulqdq): Ditto.
+	(<mask_codefor>conflict<mode><mask_name>): Ditto.
+	(<avx512>_blendm<mode>): Set attr c86_attr.
+	(sse2_movnti<mode>): Ditto.
+	(<sse>_movnt<mode>): Ditto.
+	(<sse2>_movnt<mode>): Ditto.
+	(<sse>_rcp<mode>2): Ditto.
+	(sse_vmrcpv4sf2): Ditto.
+	(<mask_codefor>rcp14<mode><mask_name>): Ditto.
+	(srcp14<mode>): Ditto.
+	(srcp14<mode>_mask): Ditto.
+	(<sse>_sqrt<mode>2<mask_name><round_name>): Ditto.
+	(<sse>_vmsqrt<mode>2<mask_scalar_name><round_scalar_name>): Ditto.
+	(*<sse>_vmsqrt<mode>2<mask_scalar_name><round_scalar_name>): Ditto.
+	(<mask_codefor>rsqrt14<mode><mask_name>): Ditto.
+	(rsqrt14<mode>): Ditto.
+	(rsqrt14_<mode>_mask"): Ditto.
+	(*<code><mode>3<mask_name><round_saeonly_name>): Ditto.
+	(ieee_<ieee_maxmin><mode>3<mask_name><round_saeonly_name>): Ditto.
+	(*<sse>_vm<code><mode>3<mask_scalar_name><round_saeonly_scalar_name>):
+	Ditto.
+	(<sse>_ieee_vm<ieee_maxmin><mode>3<mask_scalar_name>
+	<round_saeonly_scalar_name>): Ditto.
+	(*ieee_<ieee_maxmin><mode>3): Ditto.
+	(avx_h<insn>v4df3): Ditto.
+	(*sse3_haddv2df3): Ditto.
+	(sse3_hsubv2df3): Ditto.
+	(*sse3_haddv2df3_low): Ditto.
+	(*sse3_hsubv2df3_low): Ditto.
+	(avx_h<insn>v8sf3): Ditto.
+	(sse3_h<insn>v4sf3): Ditto.
+	(*<mask_codefor>reducep<mode><mask_name><round_saeonly_name>): Ditto.
+	(reduces<mode><mask_scalar_name><round_saeonly_scalar_name>): Ditto.
+	(*<avx512>_eq<mode>3<mask_scalar_merge_name>_1): Ditto.
+	(<sse>_andnot<mode>3<mask_name>): Ditto.
+	(*<code><mode>3<mask_name>): Ditto.
+	(*andnot<mode>3): Ditto.
+	(<code><mode>3): Ditto.
+	(*<code>tf3): Ditto.
+	(vec_set<mode>_0): Ditto.
+	(@vec_set<mode>_0): Ditto.
+	(*sse4_1_extractps): Ditto.
+	(vec_extract<mode>): Ditto.
+	(<mask_codefor><avx512>_align<mode><mask_name>): Ditto.
+	(avx512bw_pmaddwd512<mode><mask_name>): Ditto.
+	(*avx2_pmaddw): Ditto.
+	(*sse2_pmaddwd): Ditto.
+	(*avx2_<code><mode>3): Ditto.
+	(*avx512f_<code><mode>3<mask_name>): Ditto.
+	(*avx512bw_<code><mode>3<mask_name>): Ditto.
+	(*sse4_1_<code><mode>3<mask_name>): Ditto.
+	(*<code>v8hi3): Ditto.
+	(*<code>v16qi3): Ditto.
+	(*andnot<mode>3_mask): Ditto.
+	(*<code><mode>3): Ditto.
+	(<code>v1ti3): Ditto.
+	(<sse2p4_1>_pinsr<ssemodesuffix>): Ditto.
+	(*<extract_type>_vinsert<shuffletype><extract_suf>_0): Ditto.
+	(<mask_codefor><extract_type>_vinsert<shuffletype><extract_suf>
+	_1<mask_name>): Ditto.
+	(vec_set_lo_<mode><mask_name>): Ditto.
+	(vec_set_hi_<mode><mask_name>): Ditto.
+	(<mask_codefor>avx512dq_shuf_<shuffletype>64x2_1<mask_name>): Ditto.
+	(avx512f_shuf_<shuffletype>64x2_1<mask_name>): Ditto.
+	(*avx512f_shuf_<shuffletype>64x2_1<mask_name>_1): Ditto.
+	(avx512vl_shuf_<shuffletype>32x4_1<mask_name>): Ditto.
+	(avx512f_shuf_<shuffletype>32x4_1<mask_name>): Ditto.
+	(*avx512f_shuf_<shuffletype>32x4_1<mask_name>_1): Ditto.
+	(*vec_extract<mode>): Ditto.
+	(*vec_extract<PEXTR_MODE12:mode>_zext): Ditto.
+	(*vec_extractv16qi_zext): Ditto.
+	(*vec_extractv4si): Ditto.
+	(*vec_extractv4si_zext): Ditto.
+	(*vec_extractv2di_1): Ditto.
+	(*vec_concatv2si_sse4_1): Ditto.
+	(vec_concatv2di): Ditto.
+	(*<sse2_avx2>_uavg<mode>3<mask_name>): Ditto.
+	(*<sse2_avx2>_psadbw): Ditto.
+	(<sse>_movmsk<ssemodesuffix><avxsizesuffix>): Ditto.
+	(*<sse>_movmsk<ssemodesuffix><avxsizesuffix>_<u>ext): Ditto.
+	(<sse2_avx2>_pmovmskb): Ditto.
+	(*<sse2_avx2>_pmovmskb_zext): Ditto.
+	(*sse2_maskmovdqu): Ditto.
+	(avx2_ph<plusminus_mnemonic>wv16hi3): Ditto.
+	(ssse3_ph<plusminus_mnemonic>wv8hi3): Ditto.
+	(ssse3_ph<plusminus_mnemonic>dv4si3): Ditto.
+	(avx2_ph<plusminus_mnemonic>dv8si3): Ditto.
+	(avx2_pmaddubsw256): Ditto.
+	(avx512bw_pmaddubsw512<mode><mask_name>): Ditto.
+	(ssse3_pmaddubsw128): Ditto.
+	(<ssse3_avx2>_psign<mode>3): Ditto.
+	(ssse3_psign<mode>3): Ditto.
+	(*abs<mode>2): Ditto.
+	(abs<mode>2_mask): Ditto.
+	(abs<mode>2_mask): Ditto.
+	(sse4a_movnt<mode>): Ditto.
+	(sse4a_vmmovnt<mode>): Ditto.
+	(<sse4_1>_blend<ssemodesuffix><avxsizesuffix>): Ditto.
+	(<sse4_1>_blendv<ssemodesuffix><avxsizesuffix>): Ditto.
+	(sse4_1_blendv<ssemodesuffix>): Ditto.
+	(<vi8_sse4_1_avx2_avx512>_movntdqa): Ditto.
+	(<sse4_1_avx2>_pblendvb): Ditto.
+	(sse4_1_pblend<ssemodesuffix>): Ditto.
+	(*avx2_pblend<ssemodesuffix>): Ditto.
+	(avx2_pblendd<mode>): Ditto.
+	(avx2_<code>v16qiv16hi2<mask_name>): Ditto.
+	(avx512bw_<code>v32qiv32hi2<mask_name>): Ditto.
+	(sse4_1_<code>v8qiv8hi2<mask_name>): Ditto.
+	(*sse4_1_<code>v8qiv8hi2<mask_name>_1): Ditto.
+	(<mask_codefor>avx512f_<code>v16qiv16si2<mask_name>): Ditto.
+	(avx2_<code>v8qiv8si2<mask_name>): Ditto.
+	(*avx2_<code>v8qiv8si2<mask_name>_1): Ditto.
+	(sse4_1_<code>v4qiv4si2<mask_name>): Ditto.
+	(*sse4_1_<code>v4qiv4si2<mask_name>_1): Ditto.
+	(avx512f_<code>v16hiv16si2<mask_name>): Ditto.
+	(avx2_<code>v8hiv8si2<mask_name>): Ditto.
+	(sse4_1_<code>v4hiv4si2<mask_name>): Ditto.
+	(*sse4_1_<code>v4hiv4si2<mask_name>_1): Ditto.
+	(avx512f_<code>v8qiv8di2<mask_name>): Ditto.
+	(*avx512f_<code>v8qiv8di2<mask_name>_1): Ditto.
+	(avx2_<code>v4qiv4di2<mask_name>): Ditto.
+	(*avx2_<code>v4qiv4di2<mask_name>_1): Ditto.
+	(sse4_1_<code>v2qiv2di2<mask_name>): Ditto.
+	(*sse4_1_<code>v2qiv2di2<mask_name>_1): Ditto.
+	(avx512f_<code>v8hiv8di2<mask_name>): Ditto.
+	(avx2_<code>v4hiv4di2<mask_name>): Ditto.
+	(*avx2_<code>v4hiv4di2<mask_name>_1): Ditto.
+	(sse4_1_<code>v2hiv2di2<mask_name>): Ditto.
+	(*sse4_1_<code>v2hiv2di2<mask_name>_1): Ditto.
+	(avx512f_<code>v8siv8di2<mask_name>): Ditto.
+	(avx2_<code>v4siv4di2<mask_name>): Ditto.
+	(sse4_1_<code>v2siv2di2<mask_name>): Ditto.
+	(*sse4_1_<code>v2siv2di2<mask_name>_1): Ditto.
+	(sse4_1_round<ssescalarmodesuffix>): Ditto.
+	(*sse4_1_round<ssescalarmodesuffix>"): Ditto.
+	(sse4_2_pcmpestri): Ditto.
+	(sse4_2_pcmpestrm): Ditto.
+	(sse4_2_pcmpestr_cconly): Ditto.
+	(sse4_2_pcmpistri): Ditto.
+	(sse4_2_pcmpistrm): Ditto.
+	(sse4_2_pcmpistr_cconly): Ditto.
+	(xop_phadd<u>bw): Ditto.
+	(xop_phadd<u>bd): Ditto.
+	(xop_phadd<u>bq): Ditto.
+	(xop_phadd<u>wd): Ditto.
+	(xop_phadd<u>wq): Ditto.
+	(xop_phadd<u>dq): Ditto.
+	(xop_phsubbw): Ditto.
+	(xop_phsubwd): Ditto.
+	(xop_phsubdq): Ditto.
+	(aesenc): Ditto.
+	(aesenclast): Ditto.
+	(aesdec): Ditto.
+	(aesdeclast): Ditto.
+	(aesimc): Ditto.
+	(aeskeygenassist): Ditto.
+	(<avx2_avx512>_permvar<mode><mask_name>): Ditto.
+	(avx2_perm<mode>_1<mask_name>): Ditto.
+	(<avx512>_permvar<mode><mask_name>): Ditto.
+	(avx512f_perm<mode>_1<mask_name>): Ditto.
+	(<mask_codefor>avx512f_broadcast<mode><mask_name>): Ditto.
+	(avx_vbroadcastf128_<mode>): Ditto.
+	(<mask_codefor>avx512vl_broadcast<mode><mask_name>_1): Ditto.
+	(<mask_codefor>avx512dq_broadcast<mode><mask_name>_1): Ditto.
+	(*<avx512>_vpermi2var<mode>3_mask): Ditto.
+	(<avx512>_vpermt2var<mode>3<sd_maskz_name>): Ditto.
+	(<avx512>_vpermt2var<mode>3_mask): Ditto.
+	(*avx_vperm2f128<mode>_nozero): Ditto.
+	(vec_set_lo_<mode><mask_name>): Ditto.
+	(vec_set_hi_<mode><mask_name>): Ditto.
+	(vec_set_lo_<mode>): Ditto.
+	(vec_set_hi_<mode>): Ditto.
+	(vec_set_lo_v32qi): Ditto.
+	(<avx_avx2>_maskload<ssemodesuffix><avxsizesuffix>): Ditto.
+	(<avx_avx2>_maskstore<ssemodesuffix><avxsizesuffix>): Ditto.
+	(avx_vec_concat<mode>): Ditto.
+	(<avx512>_compress<mode>_mask): Ditto.
+	(compress<mode>_mask): Ditto.
+	(<avx512>_compressstore<mode>_mask): Ditto.
+	(compressstore<mode>_mask): Ditto.
+	(expand<mode>_mask): Ditto.
+	(<mask_codefor>avx512bw_dbpsadbw<mode><mask_name>): Ditto.
+	(clz<mode>2<mask_name>): Ditto.
+	(vpmadd52<vpmadd52type>v8di): Ditto.
+	(vpmadd52<vpmadd52type><mode>): Ditto.
+	(vpmadd52<vpmadd52type><mode>_maskz_1): Ditto.
+	(vpmadd52<vpmadd52type><mode>_mask): Ditto.
+	(vaesdec_<mode>): Ditto.
+	(vaesdeclast_<mode>): Ditto.
+	(vaesenc_<mode>): Ditto.
+	(vaesenclast_<mode>): Ditto.
+
+2026-06-06  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-06-06  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125611
+	* config/i386/sse.md (<ssse3_avx2>_pmulhrsw<mode>3, smulhrs<mode>3):
+	Use vector_operand instead of nonimmediate_operand.
+
+2026-06-03  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	PR rtl-optimization/125375
+	* cfgrtl.cc (flow_active_insn_p): Return true for clobbers.
+
+2026-06-03  Kyrylo Tkachov  <ktkachov@nvidia.com>
+
+	Backported from master:
+	2026-06-01  Kyrylo Tkachov  <ktkachov@nvidia.com>
+
+	* config/aarch64/tuning_models/olympus.h (olympus_scalar_issue_info,
+	olympus_advsimd_issue_info, olympus_sve_issue_info): Set
+	loads_stores_per_cycle to 6.
+
+2026-06-03  Kyrylo Tkachov  <ktkachov@nvidia.com>
+
+	Backported from master:
+	2026-06-01  Kyrylo Tkachov  <ktkachov@nvidia.com>
+
+	PR target/122827
+	* config/aarch64/aarch64.cc (aarch64_hard_regno_call_part_clobbered):
+	For SVE modes use BYTES_PER_SVE_VECTOR for the per-register size
+	rather than GET_MODE_SIZE.
+	* config/aarch64/aarch64-early-ra.cc (early_ra::get_allocno_subgroup):
+	Classify any SVE mode as FPR_Z.
+
+2026-06-02  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-11  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125250
+	* tree-ssa-loop-im.cc (execute_sm): For modes that cannot
+	transfer bits, _Bool and bitfield accesses force the
+	multi-threaded model.
+
+2026-06-02  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-04  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/125156
+	* tree-cfgcleanup.cc (cleanup_control_expr_graph): Clear
+	EDGE_TRUE_VALUE and EDGE_FALSE_VALUE edge flags only.
+
+2026-06-01  John David Anglin  <danglin@gcc.gnu.org>
+
+	* config/pa/pa.cc (pa_trampoline_init): Rework to use
+	clear_cache pattern.
+	* config/pa/pa.md (dcacheflush): Use "<<" condition instead
+	of "<<=".
+	(icacheflush): Remove.
+	(icacheflush1, icacheflush2, icacheflush3): New flush patterns
+	for PA 1.x targets, PA 2.0 targets, and PA 1.x no space
+	register targets.
+	(clear_cache): Rework to flush data and instruction caches.
+	Skip flush if the start address is greater than or equal to
+	the end address.  Don't align the end address to a cacheline
+	boundary.  Handle instruction flushes for PA 1.x targets,
+	PA 2.0 targets, and PA 1.x no space register targets.
+
+2026-06-01  Christophe Lyon  <christophe.lyon@arm.com>
+
+	Backported from master:
+	2026-05-19  Christophe Lyon  <christophe.lyon@arm.com>
+
+	PR target/124870
+	* config/arm/arm-mve-builtins-base.cc (vstrq_scatter_base_impl)
+	(vldrq_gather_base_impl): Fix call_properties.
+
+2026-06-01  Hongyu Wang  <hongyu.wang@intel.com>
+
+	Backported from master:
+	2026-06-01  Hongyu Wang  <hongyu.wang@intel.com>
+
+	* config/i386/x86-tune.def (X86_TUNE_DISABLE_SETZUCC): New.
+	Enable for m_DIAMONDRAPIDS | m_NOVALAKE.
+	* config/i386/i386.h (TARGET_DISABLE_SETZUCC): New define.
+	* config/i386/i386.md (*setcc_<mode>_zu): Guard with
+	TARGET_APX_ZU && !TARGET_DISABLE_SETZUCC.
+	(*setcc_di_1, *setcc_<mode>_1_movzbl): Guard with
+	(!TARGET_APX_ZU || TARGET_DISABLE_SETZUCC).
+	(*setcc_qi, *setcc_qi_slp): Emit setzucc only when
+	TARGET_APX_ZU && !TARGET_DISABLE_SETZUCC.
+
+2026-05-31  Zhongyao Chen  <chen.zhongyao@zte.com.cn>
+
+	Backported from master:
+	2026-05-13  Zhongyao Chen  <chen.zhongyao@zte.com.cn>
+
+	PR target/125215
+	* config/riscv/riscv-v.cc (expand_const_vector_interleaved_stepped_npatterns):
+	Remove hi/lo optimization and always use the merge fallback.
+
+2026-05-28  Martin Jambor  <mjambor@suse.cz>
+
+	Backported from master:
+	2026-05-12  Martin Jambor  <mjambor@suse.cz>
+
+	PR tree-optimization/124151
+	* tree-sra.cc (build_user_friendly_ref_for_offset): Added parameters
+	CUR_SIZE and EXP_SIZE.  Added code passing the correct CUR_SIZE and
+	checking it against EXP_SIZE.  Removed unused code for the case when
+	EXP_TYPE was NULL_TREE.
+	(create_artificial_child_access): Adjusted the call to
+	build_user_friendly_ref_for_offset.
+	(propagate_subaccesses_from_rhs): Likewise.
+	(propagate_subaccesses_from_rhs): Removed a check that the size of
+	lchild is a multiple of BITS_PER_UNIT.
+	(propagate_subaccesses_from_lhs): Likewise.
+
+2026-05-27  liuhongt  <hongtao.liu@intel.com>
+
+	Backported from master:
+	2026-05-27  liuhongt  <hongtao.liu@intel.com>
+
+	* config/i386/x86-tune.def (X86_TUNE_USE_GATHER_2PARTS): Disable
+	for m_DIAMONDRAPIDS.
+	(X86_TUNE_USE_GATHER_4PARTS): Likewise.
+
+2026-05-26  Soumya AR  <soumyaa@nvidia.com>
+
+	Backported from master:
+	2026-05-08  Soumya AR  <soumyaa@nvidia.com>
+
+	PR target/124895
+	* config/aarch64/aarch64-passes.def (pass_narrow_gp_writes): Move pass
+	before pass_free_cfg.
+
+2026-05-25  Georg-Johann Lay  <avr@gjlay.de>
+
+	Backported from master:
+	2026-05-25  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/125409
+	* config/avr/avr-fixed.md (FIXED_A, FIXED_B): Add PSI to iterators.
+
+2026-05-22  Zhou Qiankang  <wszqkzqk@qq.com>
+
+	Backported from master:
+	2026-05-20  Zhou Qiankang  <wszqkzqk@qq.com>
+
+	PR target/125362
+	* config/loongarch/t-loongarch (TM_H): Add
+	common/config/loongarch/cpu-features.h.
+
+2026-05-21  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-21  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/125320
+	* config/riscv/riscv.md (stack_protect_test_<mode>): Call
+	riscv_output_move() instead of hard coding <load>.
+	(stack_protect_set_<mode>): Call riscv_output_move() instead of
+	hard coding <load> and <store>.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125373
+	* config/i386/i386.md
+	(Convert imul by three, five and nine into lea define_peephole2s): Use
+	index_reg_operand instead of register_operand.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/125348
+	* config/i386/i386-expand.cc (ix86_expand_builtin): Fix diagnostic
+	typo, forth -> fourth.
+
+2026-05-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/125355
+	* config/i386/i386-expand.cc (ix86_expand_movmem): Replace
+	optimize_function_for_size_p with optimize_insn_for_size_p.
+
+2026-05-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-18  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/125355
+	* config/i386/i386-expand.cc (ix86_expand_movmem): Return false
+	for -Os.
+
+2026-05-19  Andi Kleen  <ak@gcc.gnu.org>
+
+	PR target/125351
+	* config/i386/i386.md: Use alternative to handle masm ptwrite
+	syntax.
+
+2026-05-15  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-13  H.J. Lu  <hjl.tools@gmail.com>
+		    Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/120870
+	* config/i386/i386.cc (ix86_save_reg): Return true for DRAP
+	register early at entry.
+	(find_drap_reg): Use R11_REG in preserve_none functions in
+	64-bit mode.
+
+2026-05-15  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-15  Xi Ruoyao  <xry111@xry111.site>
+
+	PR tree-optimization/125291
+	* tree-scalar-evolution.cc (simplify_peeled_chrec): Sign-extend
+	the step for peeled converted IV.
+
+2026-05-15  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-15  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125308
+	* config/i386/sse.md (*minmax<mode>3_4): Force also
+	operands[2] into a REG.
+
+2026-05-14  Andi Kleen  <ak@gcc.gnu.org>
+
+	PR target/124316
+	* config/i386/i386.md (ptwrite): Add explicit mode to
+	instruction.
+
+2026-05-14  Georg-Johann Lay  <avr@gjlay.de>
+
+	Backported from master:
+	2026-05-14  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/125194
+	* config/avr/avr.cc (avr_no_call_main_p): Remove variable...
+	(avr_file_end): ...and code that uses it.
+	(avr_insert_attributes): Same.  Add "used" to main attributes
+	when -mno-call-main.
+	* config/avr/gen-avr-mmcu-specs.cc (print_mcu): Emit code
+	for link_no_call_main specs.
+	* config/avr/specs.h (LINK_SPEC): Add %(link_no_call_main).
+
+2026-05-13  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-08  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/125049
+	* config/loongarch/predicates.md (ssp_operand): New
+	define_predicate.
+	(ssp_normal_operand): New define_predicate.
+	* config/loongarch/constraints.md (ZE): New define_constraint.
+	(ZF): New define_constraint.
+	* config/loongarch/loongarch.md (UNSPEC_SSP): New unspec.
+	(cbranch4): Add "@" to create gen_cbranch4(machine_mode, ...).
+	(@stack_protect_combined_set_normal_<mode>): New define_insn.
+	(@stack_protect_combined_set_extreme_<mode>): New define_insn.
+	(@stack_protect_combined_test_internal_<mode>): New define_insn.
+	(stack_protect_combined_set): New define_expand.
+	(stack_protect_combined_test): New define_expand.
+	* config/loongarch/loongarch-protos.h
+	(loongarch_output_asm_load_canary): Declare.
+	* config/loongarch/loongarch.cc (loongarch_print_operand): Allow
+	'v' to print d/w for DImode/SImode.
+	(loongarch_output_asm_load_canary): Implement.
+
+2026-05-13  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-08  Xi Ruoyao  <xry111@xry111.site>
+
+	* config/loongarch/loongarch.cc (loongarch_print_operand): Print
+	the symbol name for SYMBOL_REF with %c.
+
+2026-05-12  Artemiy Volkov  <artemiy.volkov@arm.com>
+
+	Backported from master:
+	2026-05-12  Artemiy Volkov  <artemiy.volkov@arm.com>
+
+	PR middle-end/125259
+	* match.pd: Fix the view_convert (BIT_FIELD_REF) pattern.
+
+2026-05-11  LIU Hao  <lh_mouse@126.com>
+
+	Backported from master:
+	2026-05-11  LIU Hao  <lh_mouse@126.com>
+
+	PR target/53929
+	* config/mingw/winnt.cc (mingw_pe_file_end): Use `ASM_OUTPUT_LABELREF`
+	to emit `name`.
+
+2026-05-11  Stefan Schulze Frielinghaus  <stefansf@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-01  Stefan Schulze Frielinghaus  <stefansf@gcc.gnu.org>
+
+	* config/s390/s390.cc (s390_secondary_reload): Add cases for HF
+	vector modes.
+	* config/s390/s390.md: Add modes V{1,2,4,8}HF to mode iterator
+	ALL.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-05  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125185
+	* tree-vect-slp.cc (vect_analyze_slp_reduc_chain): Guard
+	first vect_slp_linearize_chain call.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Revert:
+	2025-04-30  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/120003
+	* tree-ssa-threadbackward.cc (back_threader::find_paths_to_names):
+	Allow block re-use but do not enlarge the path beyond such a
+	re-use.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-04  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/125146
+	* gimple-fold.cc (fold_stmt_1): Discard stmts in seq
+	after failed gimple_simplify as well.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-04-27  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125025
+	* tree-ssa-loop-niter.cc (number_of_iterations_ne): Avoid
+	negation of most negative signed integer.
+	(number_of_iterations_lt): Likewise.
+
+2026-05-06  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-05  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/120587
+	PR target/125155
+	* config/or1k/or1k.cc (or1k_hard_regno_mode_ok): Allow condition
+	condition flag register in SImode.
+
+2026-05-06  Lulu Cheng  <chenglulu@loongson.cn>
+
+	Backported from master:
+	2026-05-06  Lulu Cheng  <chenglulu@loongson.cn>
+
+	PR target/125057
+	* config/loongarch/loongarch.cc
+	(loongarch_split_vector_move): Complete the split condition.
+	* config/loongarch/loongarch.h (LSX_REG_RTX_P): Delete.
+	(LASX_REG_RTX_P): Delete.
+	(GP_REG_RTX_P): Define macro.
+
+2026-05-06  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-06  Richard Biener  <rguenther@suse.de>
+
+	* config/i386/x86-tune.def (avx512_two_epilogues): Enable
+	for m_ZNVER6.
+	(avx512_masked_epilogues): Likewise.
+
+2026-05-05  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-05  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125180
+	* config/i386/i386.md (HI/SI test -> QI test splitter): Punt if
+	operands[2] is a volatile MEM.
+
+2026-05-04  Nathan Myers  <ncm@cantrip.org>
+
+	Backported from master:
+	2026-05-04  Nathan Myers  <ncm@cantrip.org>
+
+	* doc/invoke.texi: insert "result" in comment text
+
+2026-05-03  Collin Funk  <collin.funk1@gmail.com>
+
+	Backported from master:
+	2026-05-03  Collin Funk  <collin.funk1@gmail.com>
+
+	* glimits.h (__STDC_VERSION_LIMITS_H__): Only define the macro
+	if it was not already defined.
+
+2026-05-02  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/125079
+	* tree-ssa-strlen.cc (get_string_length): Don't overwrite
+	lenstmt variable with another stmt.
+
+2026-05-01  Jeff Law  <jeffrey.law@oss.qualcomm.com>
+
+	Revert:
+	2026-05-01  Daniel Barboza  <daniel.barboza@oss.qualcomm.com>
+
+	PR rtl-optimization/123967
+	* match.pd(`if (cond) (A | CST1) : (A & ~CST1)`)`: New pattern.
+
+2026-05-01  Daniel Barboza  <daniel.barboza@oss.qualcomm.com>
+
+	PR rtl-optimization/123967
+	* match.pd(`if (cond) (A | CST1) : (A & ~CST1)`)`: New pattern.
+
+2026-05-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-01  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/125079
+	* tree-ssa-strlen.cc (get_string_length): Transform
+	__strcat_chk (x, y, z) when we need strlen (x) afterwards into
+	l1 = strlen (x); l = __stpcpy_chk (x + l1, y, z - l1) - x;
+	where l is the strlen (x), instead of using z as last __stpcpy_chk
+	argument.
+
+2026-05-01  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-01  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/125117
+	* config/i386/i386-expand.cc (ix86_expand_movmem): Generate
+	last_4x_vec_label when min_size <= 4 * MOVE_MAX.
+
+2026-05-01  Soumya AR  <soumyaa@nvidia.com>
+
+	Backported from master:
+	2026-04-27  Soumya AR  <soumyaa@nvidia.com>
+
+	* config/aarch64/tuning_models/generic.h: Update br_mispredict_factor
+	to 7.
+
+2026-05-01  Jeff Law  <jeffrey.law@oss.qualcomm.com>
+
+	Backported from master:
+	2026-04-25  Jeff Law  <jeffrey.law@oss.qualcomm.com>
+
+	PR target/124984
+	* config/riscv/thead.cc (th_memidx_classify_address_index): Extract
+	constant multiplicand value from the right object.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-29  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/123635
+	* gimple-lower-bitint.cc (bitint_large_huge::finish_arith_overflow):
+	Move obj_nelts/atype computation before bitint_extended handling.  For
+	bitint_big_endian in the bitint_extended handling use size_zero_node
+	only for limb_access_type calls, otherwise use
+	size_int (nelts - obj_nelts) and pass NULL_TREE as first argument to
+	limb_access calls.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-28  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/125039
+	* range-op-float.cc (operator_not_equal::fold_range): Call
+	empty_range_varying when not calling frelop_early_resolve.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/124133
+	* config/rs6000/rs6000-c.cc (c_fold_convert): New function.
+	(c_fold_build2_loc): Likewise.
+	(fully_fold_convert): Use c_fold_convert instead of fold_convert.
+	(altivec_build_resolved_builtin): Likewise.  Use c_fold_build2_loc
+	instead of fold_build2.
+	(resolve_vec_mul, resolve_vec_adde_sube, resolve_vec_addec_subec):
+	Use c_fold_build2_loc instead of fold_build2_loc.
+	(resolve_vec_splats, resolve_vec_extract): Use c_fold_convert instead
+	of fold_convert.
+	(resolve_vec_insert): Use c_fold_build2_loc instead of fold_build2.
+	(altivec_resolve_overloaded_builtin): Use c_fold_convert instead
+	of fold_convert.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/123635
+	PR tree-optimization/124988
+	* gimple-lower-bitint.cc (bitint_large_huge::finish_arith_overflow):
+	Handle bitint_extend.
+	(bitint_large_huge::lower_addsub_overflow): Fix up comment spelling.
+	For bitint_extended extend the partial limb if any.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/DATESTAMP
+++ b/src/gcc/DATESTAMP
@@ -1 +1 @@
-20260430
+20260613
--- a/src/gcc/ada/ChangeLog
+++ b/src/gcc/ada/ChangeLog
@@ -1,3 +1,474 @@
+2026-06-09  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR ada/125695
+	* libgnat/s-genbig.adb ("**"): Do not drop the sign on the floor.
+	(Big_Exp): Take into account the parity of the exponent for -2.
+
+2026-06-06  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_ch3.adb (Analyze_Private_Extension_Declaration): Revert latest
+	change.
+	(Find_Type_Of_Subtype_Indic): Return Any_Type if Find_Type fails to
+	resolve the type.
+	* sem_ch12.adb (Analyze_Formal_Derived_Type): Restore more specific
+	error recovery path.
+
+2026-06-06  Ronan Desplanques  <desplanques@adacore.com>
+
+	* exp_ch6.adb (Needs_BIP_Collection): Fix condition.
+
+2026-06-06  Mathias Aparicio  <aparicio@adacore.com>
+
+	* libgnat/a-textio.adb
+	(Get_Upper_Half_Char, Get_Upper_Half_Char_Immed): Replace
+	Constraint_Error with Data_Error
+
+2026-06-06  Viljar Indus  <indus@adacore.com>
+
+	* sem_warn.adb (Warn_On_Suspicious_Index): Only check elements
+	that are coming from source.
+
+2026-06-06  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_ch3.adb (Analyze_Private_Extension_Declaration): Be prepared
+	for Find_Type_Of_Subtype_Indic returning no type.
+	* sem_ch4.adb (Process_Generic_Instantiation): Give an error if the
+	generic instantation is referenced in a generic formal part.
+	* sem_ch12.adb (Analyze_Formal_Derived_Type): Return early in every
+	case of serious errors.
+
+2026-06-04  Artur Pietrek  <pietrek@adacore.com>
+
+	* exp_ch7.adb (Make_Address_For_Finalize): check
+	Has_Controlled_Component predicate before emitting the shift to be
+	consistant with what Is_Constr_Array_Subt_With_Bounds says.
+
+2026-06-04  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch4.adb (Expand_Allocator_Expression): In the case of access
+	discriminants, pass Zero_On_Dynamic_Level to compute the static
+	accessibility level of the expression.
+	* sem_res.adb (Check_Aliased_Parameter): Pass Zero_On_Dynamic_Level
+	to compute the static accessibility level of actual parameters.
+
+2026-06-04  Piotr Trojanek  <trojanek@adacore.com>
+
+	* sem_ch9.adb (Analyze_Requeue): Fix unbalanced parens.
+
+2026-06-04  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_util.ads (In_Reverse_Storage_Order_Object): Adjust.
+	* sem_util.adb (In_Reverse_Storage_Order_Object): Rewrite.
+
+2026-06-02  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/decl.cc (gnat_to_gnu_entity) <E_Variable>: Validate
+	a known alignment on the object even if there is an address clause.
+
+2026-06-02  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/decl.cc (gnat_to_gnu_entity) <E_Variable>: Do not
+	give the warning about too large a size here but...
+	* gcc-interface/utils2.cc (build_allocator): ...here instead.
+
+2026-06-02  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gcc-interface/utils.cc (maybe_pad_type): Propagate the flag
+	TYPE_REVERSE_STORAGE_ORDER from the inner type to the record type
+	if the former is also an aggregate type.
+
+2026-06-02  Gary Dismukes  <dismukes@adacore.com>
+
+	* sem_ch3.adb (Copy_Parent_Attributes): Inherit Linker_Section_Pragma.
+
+2026-06-02  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR ada/18205
+	* exp_attr.adb (Rewrite_Attribute_Proc_Call): Skip the conversion to
+	the formal type only if the actual is of a class-wide type. Generate
+	a dispatching call when both the prefix is a class-wide type and the
+	subprogram is a dispatching operation.
+	(Expand_N_Attribute_Reference) <Input>: Use U_Type consistently and
+	remove an useless invocation of Root_Type.
+	<Put_Image>: Minor comment tweak.
+	<Read>: Likewise.
+	<Write>: Likewise.
+
+2026-06-02  Ronan Desplanques  <desplanques@adacore.com>
+
+	* par.adb, par-util.adb (Check_Bad_Layout_At): New procedure.
+	* par-ch3.adb (P_Declarative_Item): Use new procedure.
+	* par-ch5.adb (P_Sequence_Of_Statements): Likewise.
+
+2026-06-02  Viljar Indus  <indus@adacore.com>
+
+	* sem_util.adb (Normalize_Actuals): Improve error message.
+
+2026-05-29  Marc Poulhiès  <poulhies@adacore.com>
+
+	* sysdep.c (getc_immediate_common): Read character as unsigned
+	value.
+
+2026-05-29  Piotr Trojanek  <trojanek@adacore.com>
+
+	* sem_ch4.adb (Analyze_Quantified_Expression): If there is a filter,
+	then suppress the warning.
+
+2026-05-29  Piotr Trojanek  <trojanek@adacore.com>
+
+	* sem_ch4.adb (Analyze_Quantified_Expression): Suppress warning for
+	trivial conditions.
+
+2026-05-29  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_util.adb (Statically_Names_Object) <N_Selected_Component>:
+	Return False if the selector is neither component nor discriminant.
+
+2026-05-29  Javier Miranda  <miranda@adacore.com>
+
+	* sem_ch3.adb (Build_Derived_Record_Type): Record type derivations
+	inherit Is_Unchecked_Union and Has_Unchecked_Union flags.
+	(Inherit_Component): Add discriminals to the associations list.
+	* exp_ch3.adb (Build_Record_Init_Proc): Derivations of Unchecked_Union
+	types don't need an initialization procedure; they reuse the init proc
+	of their parent type.
+
+2026-05-29  Ronan Desplanques  <desplanques@adacore.com>
+
+	* doc/gnat_ugn/building_executable_programs_with_gnat.rst: Fix
+	markup.
+	* gnat_ugn.texi: Regenerate.
+
+2026-05-29  Piotr Trojanek  <trojanek@adacore.com>
+
+	* sem_ch4.adb (Analyze_Quantified_Expression): Suppress warning for
+	variables with junk names.
+
+2026-05-28  Sebastian Poeplau  <poeplau@adacore.com>
+
+	* init.c (__gnat_alternate_stack): add alignment attribute.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_aggr.adb (Resolve_Array_Aggregate): Also rewrite a choice list
+	with a single choice as an iterator specification when the choice's
+	type has the GNAT Iterable aspect specified.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_aggr.adb (Resolve_Array_Aggregate): Analyze the choice before
+	testing whether it is the name of a subtype with a predicate.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_ch13.adb (Resolve_Aspect_Aggregate.Resolve_Operation): Add
+	missing guard for the presence of Entity on the node.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* doc/gnat_rm/gnat_language_extensions.rst
+	(Generalized Finalization): Document the new restriction.
+	* sem_ch13.adb (Resolve_Finalizable_Argument): Adjust wording of
+	error message.
+	(Resolve_Finalization_Procedure.Is_Finalizable_Primitive): Require
+	the procedure to be a primitive operation.
+	* gnat_rm.texi: Regenerate.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Make_Controlling_Function_Wrappers): Manually set the
+	Has_Controlling_Result flag on the wrappers.
+	* sem_disp.ads (Override_Dispatching_Operation): Move to...
+	* sem_disp.adb (Override_Dispatching_Operation): ...here.
+	(Find_Dispatching_Type): Return the (controlling) result type for a
+	controlling function wrapper.
+
+2026-05-28  Vadim Godunko  <godunko@adacore.com>
+
+	* doc/gnat_rm/implementation_of_ada_2022_features.rst: Fix casing.
+	* gnat_rm.texi: Regenerate.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch4.adb (Expand_N_Op_Eq): Do not expand an array comparison
+	for validity checking purposes when the component type is covered
+	by the suppression of validity checks.
+
+2026-05-28  Steve Baird  <baird@adacore.com>
+
+	* sem_ch6.adb (Install_Entity): If the entity to be installed is
+	already installed, assert that an error has already been flagged
+	and then return without introducing a cycle in the entity's
+	Homonyms list.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* sem_ch8.adb (Find_Renamed_Entity): Protect call to First_Formal.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_attr.adb (Expand_N_Attribute_Reference) <Constrained>: If the
+	prefix is a non-In formal parameter of an unchecked union type, give
+	a warning and insert a raise statement for Program_Error.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_util.ads (Is_Distributable_Declaration): New predicate.
+	* exp_util.adb (Is_Distributable_Declaration): New predicate coming
+	from Expand_N_Case_Expression and Expand_N_If_Expression.  Return
+	False for variables of an unconstrained definite nonlimited subtype.
+	* exp_ch4.adb (Expand_N_Case_Expression): Replace calls to local
+	Is_Optimizable_Declaration by calls to Is_Distributable_Declaration.
+	(Expand_N_If_Expression): Likewise.
+	* exp_ch6.adb (Expand_Ctrl_Function_Call): Likewise.
+
+2026-05-28  Marc Poulhiès  <poulhies@adacore.com>
+	    Eric Botcazou  <botcazou@adacore.com>
+
+	* sem_ch3.adb (Find_Type_Of_Object): Adjust freezing of the base
+	type of a discriminated type.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* gen_il-fields.ads (Scope_Link): New field.
+	* gen_il-gen-gen_nodes.adb (N_Expression_With_Actions): Added Scope_Link.
+	* sinfo.ads (N_Expression_With_Actions): Add field Scope_Link.
+	* sem_ch4.adb (Analyze_Expression_With_Actions): Set field Scope_Link
+	* sem_ch5.ads (Has_Sec_Stack_Call): Declaration moved to the package spec.
+	* sem_ch5.adb (Has_Sec_Stack_Call): ditto.
+	* sem_res.adb (Resolve_Declare_Expression): Push/Pop internally created
+	scope to provide proper visibility of the declare_items.
+
+2026-05-28  Denis Mazzucato  <mazzucato@adacore.com>
+
+	* sem_prag.adb (Check_References): Don't call Class_Wide_Type if the
+	subprogram is a non-primitive procedure as the dispatching type may be
+	empty.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_ch4.adb (Analyze_Qualified_Expression): For a class-wide type,
+	check for an exact match modulo the Non_Limited_View attribute.
+
+2026-05-28  Steve Baird  <baird@adacore.com>
+
+	* aspects.adb (Has_Aspect): In the call to Find_Aspect, pass in
+	True for the Or_Rep_Item parameter instead of letting it default
+	to False.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* exp_util.adb (Remove_Side_Effects): Propagate actuals in
+	recursion calls, unless this is a known side-effect free
+	attribute whose expressions are also side-effect free.
+
+2026-05-28  Ronan Desplanques  <desplanques@adacore.com>
+
+	* libgnarl/s-interr__vxworks.adb (Unprotected_Exchange_Handler): Fix
+	exception message.
+
+2026-05-28  Ronan Desplanques  <desplanques@adacore.com>
+
+	* libgnarl/s-interr.adb (Interrupt_Manager, Server_Task): Fix
+	comments.
+
+2026-05-28  Ronan Desplanques  <desplanques@adacore.com>
+
+	* libgnarl/s-interr.adb (User_Handler): Improve comment.
+	(Unprotected_Exchange_Handler): Fix message string.
+
+2026-05-28  Steve Baird  <baird@adacore.com>
+
+	* doc/gnat_rm/gnat_language_extensions.rst: Correct example
+	to avoid using a not-yet-implemented form of deep delta aggregate.
+	* exp_aggr.adb (Make_Delta_Choice_LHS): Call Core_Extensions_Allowed
+	instead of All_Extensions_Allowed.
+	* par-ch4.adb (P_Simple_Expression): Likewise.
+	* sem_aggr.adb (Resolve_Delta_Array_Aggregate): Likewise.
+	* gnat_rm.texi: Regenerate.
+
+2026-05-28  Gary Dismukes  <dismukes@adacore.com>
+
+	* par.adb (P_Expression_If_OK): Add declare expression to spec comment.
+	* par-ch4.adb (P_Expression_If_OK): Add declare expression to comments.
+	* par-ch12.adb (P_Formal_Subprogram_Declaration): Call
+	P_Expression_If_OK rather than P_Expression.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* sem_ch13.adb (Analyze_One_Aspect): For Unsigned_Base_Range aspect,
+	skip generating its corresponding pragma when the aspect is set
+	to False.
+	* sem_ch3.adb (Analyze_Full_Type_Declaration): Fix initialization
+	of local variable Is_Unsigned_Base_Range_Type_Decl to handle
+	Unsigned_Base_Range aspect set to False.
+
+2026-05-28  Ronan Desplanques  <desplanques@adacore.com>
+
+	* libgnarl/s-interr.adb (Unprotected_Exchange_Handler): Fix
+	exception message.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* aspects.adb (Get_Aspect_Id): Enable aspect Unsigned_Base_Range
+	* debug.adb (Debug_Flag_Dot_U): Leave free this switch
+	* par-ch4.adb (Scan_Apostrophe): Enable attribute Unsigned_Base_Range
+	* sem_prag.adb (Analyze_Pragma): Enable pragma Unsigned_Base_Range
+	* doc/gnat_rm/gnat_language_extensions.rst: Document unsigned base range.
+	* gnat_rm.texi: Regenerate.
+	* gnat_ugn.texi: Regenerate.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_util.adb (Prefix_Is_Formal_Parameter): Rename into...
+	(Prefix_Is_Formal_Parameter_Of_EQ): ...this.  Return True only if
+	the formal parameter is that of an equality function built for an
+	unchecked union type.
+	(Has_Inferable_Discriminants): Adjust to above renaming.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_put_image.ads (Image_Should_Call_Put_Image): Rename into...
+	(Image_Must_Call_Put_Image): ...this.
+	* exp_put_image.adb (Image_Should_Call_Put_Image): Rename into...
+	(Image_Must_Call_Put_Image): ...this.
+	* exp_imgv.adb (Expand_Image_Attribute): Adjust to above renaming.
+	(Expand_Wide_Image_Attribute): Likewise.
+	(Expand_Wide_Wide_Image_Attribute): Likewise.
+	* sem_attr.adb (Eval_Attribute): Likewise.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sem_attr.adb: Add with and use clauses for Exp_Put_Image.
+	(Eval_Attribute.Fold_Compile_Time_Known_Enumeration_Image): New
+	procedure factored out from....
+	(Eval_Attribute): ...here.  Attempt to fold 'Img and 'Image for all
+	compile-time known values of enumeration, but not character, types,
+	provided that Put_Image need not be called, by invoking the nested
+	Fold_Compile_Time_Known_Enumeration_Image procedure on the value.
+
+2026-05-28  Denis Mazzucato  <mazzucato@adacore.com>
+
+	* sem_util.adb: Fix RM references.
+	* sem_util.ads: Likewise.
+	* sem_warn.adb: Likewise.
+
+2026-05-28  Gary Dismukes  <dismukes@adacore.com>
+
+	* par-ch12.adb (P_Formal_Subprogram_Declaration): Pass True for
+	the Is_Core_Extension parameter on call to Error_Msg_GNAT_Extension.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gen_il-gen-gen_entities.adb (E_Subprogram_Type): Add the missing
+	Scope_Depth_Value field.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* sem_disp.adb (Check_Controlling_Formals): Formals of a type
+	specifying aspect First_Controlling_Parameter are not candidate
+	controlling parameters when they are not the first formal of
+	the dispatching primitive.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* exp_ch5.adb (Expand_N_Assignment_Statement): Handle internally
+	generated initialization invoking a C++ constructor.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch6.adb (Expand_Ctrl_Function_Call): Bail out for the name
+	of an object renaming declaration at library level, if the call
+	does not return on the secondary stack.
+	* exp_ch8.adb (Expand_N_Object_Renaming_Declaration): Rewrite the
+	renaming as a regular object declaration if it is declared at
+	library level and the name is a controlled function call whose
+	result is not returned on the secondary stack.
+	* exp_util.adb (Rewrite_Object_Declaration_As_Renaming): Minor fix.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* sem_ch3.adb (Analyze_Subtype_Declaration): Record subtypes
+	inherit the CPP_Class attribute; required for instantiations.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_util.adb (Remove_Init_Call.Find_Init_Call_In_List): Check that
+	the first actual denotes the expected variable modulo qualification
+	and conversion.
+
+2026-05-28  Javier Miranda  <miranda@adacore.com>
+
+	* sem_ch3.adb (Analyze_Object_Declaration): Report an error if the
+	return statement of a function with foreign convention has a call
+	to a C++ constructor.
+	* exp_ch3.adb (Expand_N_Object_Declaration): Handle initialization
+	expression calling a C++ constructor in an extended return statement
+	of a subprogram with Ada convention.
+
+2026-05-28  Denis Mazzucato  <mazzucato@adacore.com>
+
+	* exp_disp.adb (Expand_Dispatching_Call): Remove suppression of checks
+	during analysis of expanded dispatching calls.
+
+2026-05-28  Ronan Desplanques  <desplanques@adacore.com>
+
+	* doc/gnat_rm/gnat_language_extensions.rst: Add that finally is a
+	non-reserved keyword.
+	* par-ch5.adb (P_Sequence_Of_Statements): handle "finally" syntax
+	extension.
+	* snames.ads-tmpl: Remove the concept of GNAT extension reserved
+	word.
+	* snames.adb-tmpl (Is_Keyword_Name): Likewise.
+	* scans.adb (Initialize_Ada_Keywords): Likewise.
+	* par-util.adb (Check_Future_Keyword): Likewise.
+	* gnat_rm.texi: Regenerate.
+
+2026-05-28  Denis Mazzucato  <mazzucato@adacore.com>
+
+	* exp_ch6.adb (Build_Helper_Call): Refactor code to handle both static and
+	dynamic precondition calls in the same way.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* exp_ch3.adb (Expand_N_Object_Declaration): Minor comment fixes.
+
+2026-05-28  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* sinput.ads: Small tweak to head comment.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/125348
+	* libgnat/s-regpat.ads: Fix comment spelling, paramter -> parameter.
+
+2026-05-10  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR ada/125240
+	* gen_il-gen-gen_entities.adb (Enumeration_Kind): Make
+	Lit_Indexes and Lit_Strings be defined for root types only.
+	* einfo.ads (Lit_Hash): Adjust description.
+	(Lit_Indexes): Likewise.
+	(Lit_Strings): Likewise.
+	(E_Enumeration_Type): Likewise.
+	* exp_imgv.adb (Expand_Image_Attribute): Do not fetch the root type
+	for enumeration types, except for character types, and adjust.
+
+2026-05-03  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR ada/125168
+	* libgnat/s-dorepr__freebsd.adb (Two_Prod): Adjust to renaming.
+	(Two_Sqr): Likewise.
+
+2026-04-30  Eric Botcazou  <ebotcazou@adacore.com>
+
+	PR ada/125044
+	* sem_disp.adb (Check_Controlling_Formals): Apply the same massaging
+	to the result subtype as to the parameter subtypes.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/ada/aspects.adb
+++ b/src/gcc/ada/aspects.adb
@@ -24,7 +24,6 @@
 ------------------------------------------------------------------------------
 
 with Atree;          use Atree;
-with Debug;          use Debug;
 with Einfo.Entities; use Einfo.Entities;
 with Einfo.Utils;    use Einfo.Utils;
 with Nlists;         use Nlists;
@@ -279,14 +278,6 @@ package body Aspects is
 
    function Get_Aspect_Id (Name : Name_Id) return Aspect_Id is
    begin
-      --  Aspect Unsigned_Base_Range temporarily disabled
-
-      if Name = Name_Unsigned_Base_Range
-        and then not Debug_Flag_Dot_U
-      then
-         return No_Aspect;
-      end if;
-
       return Aspect_Id_Hash_Table.Get (Name);
    end Get_Aspect_Id;
 
@@ -306,7 +297,9 @@ package body Aspects is
       Class_Present : Boolean := False) return Boolean
    is
    begin
-      return Present (Find_Aspect (Id, A, Class_Present => Class_Present));
+      return Present
+              (Find_Aspect
+                (Id, A, Class_Present => Class_Present, Or_Rep_Item => True));
    end Has_Aspect;
 
    function Has_Aspects (N : Node_Id) return Boolean
--- a/src/gcc/ada/debug.adb
+++ b/src/gcc/ada/debug.adb
@@ -105,7 +105,7 @@ package body Debug is
    --  d.r  Disable reordering of components in record types
    --  d.s  Strict secondary stack management
    --  d.t  Disable static allocation of library level dispatch tables
-   --  d.u  Enable Unsigned_Base_Range aspect language extension
+   --  d.u
    --  d.v  Enforce SPARK elaboration rules in SPARK code
    --  d.w  Do not check for infinite loops
    --  d.x  No exception handlers
@@ -800,8 +800,7 @@ package body Debug is
    --       previous dynamic construction of tables. It is there as a possible
    --       work around if we run into trouble with the new implementation.
 
-   --  d.u  Enable the support for Unsigned_Base_Range aspect, attribute, and
-   --       pragma.
+   --  d.u
 
    --  d.v  This flag enforces the elaboration rules defined in the SPARK
    --       Reference Manual, chapter 7.7, to all SPARK code within a unit. As
--- a/src/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
+++ b/src/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
@@ -272,9 +272,9 @@ Examples
       S : Segment := (1 .. 2 => (0, 0));
       T : Triangle := (1 .. 3 => (1 .. 2 => (0, 0)));
    begin
-      S := (S with delta (1).X | (2).Y => 12, (1).Y => 15);
+      S := (S with delta (1).X => 11, (2).Y => 12, (1).Y => 15);
 
-      pragma Assert (S (1).X = 12);
+      pragma Assert (S (1).X = 11);
       pragma Assert (S (2).Y = 12);
       pragma Assert (S (1).Y = 15);
 
@@ -584,6 +584,30 @@ Restricting the position of controlling parameter offers several advantages:
 
 * The result of a function is never a controlling result.
 
+``Unsigned_Base_Range`` aspect
+------------------------------
+
+A new pragma/aspect, ``Unsigned_Base_Range``, is introduced to explicitly
+enforce the use of an unsigned base type for signed integer types.
+RM-3.5.4(9) mandates a symmetric base range for signed integer types. This
+requirement often requires the use of larger data types for arithmetic
+operations, potentially introducing undesirable run-time overhead and
+performance penalties, particularly in embedded systems. For instance,
+on a 64-bit architecture, a 64-bit multiplication can be performed with
+a single hardware instruction, whereas a 128-bit multiplication requires
+multiple instructions and intermediate steps.
+
+Here is an example of this feature:
+
+.. code-block:: ada
+
+  type Uns_64 is range 0 .. 2 ** 64 - 1
+    with Size => 64,
+         Unsigned_Base_Range => True;
+
+It ensures that arithmetic operations of type ``Uns_64`` are carried
+out using 64 bits.
+
 Generalized Finalization
 ------------------------
 
@@ -611,8 +635,9 @@ Here is the archetypal example:
     procedure Finalize   (Obj : in out T);
     procedure Initialize (Obj : in out T);
 
-The three procedures have the same profile, with a single ``in out`` parameter,
-and also have the same dynamic semantics as for controlled types:
+The three procedures must be primitive operations of ``T`` and have a single
+``in out`` parameter. They need not be all specified by the aspect. If they
+are specified, they have the same dynamic semantics as for controlled types:
 
  - ``Initialize`` is called when an object of type ``T`` is declared without
    initialization expression.
@@ -1746,6 +1771,9 @@ another sequence of statements is completed, whether normally or abnormally.
 
 This feature is similar to the one with the same name in other languages such as Java.
 
+Note that ``finally`` is a keyword but it is not a reserved word. This is a
+configuration that does not exist in standard Ada.
+
 Syntax
 ^^^^^^
 
--- a/src/gcc/ada/doc/gnat_rm/implementation_of_ada_2022_features.rst
+++ b/src/gcc/ada/doc/gnat_rm/implementation_of_ada_2022_features.rst
@@ -356,7 +356,7 @@ http://www.ada-auth.org/AI12-SUMMARY.HTML.
 
   .. code::
 
-    Array (1 .. 10) of Integer :=
+    array (1 .. 10) of Integer :=
       (for I in 1 .. 10 => I ** 2);
     type Matrix is
     array
--- a/src/gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst
+++ b/src/gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst
@@ -7345,9 +7345,9 @@ correctly, the two variables
 
 are declared in one of the GNAT library routines. These variables must
 be set from the actual ``argc`` and ``argv`` values passed to the
-main program. With no *n* present, ``gnatbind``
+main program. With no :switch:`-n` present, ``gnatbind``
 generates the C main program to automatically set these variables.
-If the *n* switch is used, there is no automatic way to
+If the :switch:`-n` switch is used, there is no automatic way to
 set these variables. If they are not set, the procedures in
 ``Ada.Command_Line`` will not be available, and any attempt to use
 them will raise ``Constraint_Error``. If command line access is
--- a/src/gcc/ada/einfo.ads
+++ b/src/gcc/ada/einfo.ads
@@ -3647,22 +3647,19 @@ package Einfo is
 --       type of the object.
 
 --    Lit_Hash [root type only]
---       Defined in enumeration types and subtypes. Non-empty only for the
---       case of an enumeration root type, where it contains the entity for
+--       Defined in enumeration types and subtypes. Contains the entity for
 --       the generated hash function. See unit Exp_Imgv for full details of
 --       the nature and use of this entity for implementing the Value
 --       attribute for the enumeration type in question.
 
---    Lit_Indexes
---       Defined in enumeration types and subtypes. Non-empty only for the
---       case of an enumeration root type, where it contains the entity for
+--    Lit_Indexes [root type only]
+--       Defined in enumeration types and subtypes. Contains the entity for
 --       the generated indexes entity. See unit Exp_Imgv for full details of
 --       the nature and use of this entity for implementing the Image and
 --       Value attributes for the enumeration type in question.
 
---    Lit_Strings
---       Defined in enumeration types and subtypes. Non-empty only for the
---       case of an enumeration root type, where it contains the entity for
+--    Lit_Strings [root type only]
+--       Defined in enumeration types and subtypes. Contains the entity for
 --       the literals string entity. See unit Exp_Imgv for full details of
 --       the nature and use of this entity for implementing the Image and
 --       Value attributes for the enumeration type in question.
@@ -5530,12 +5527,12 @@ package Einfo is
    --  E_Enumeration_Subtype
    --    First_Entity $$$ type
    --    Renamed_Object $$$
-   --    Lit_Strings                          (root type only)
    --    First_Literal
+   --    Lit_Hash                             (root type only)
    --    Lit_Indexes                          (root type only)
+   --    Lit_Strings                          (root type only)
    --    Default_Aspect_Value                 (base type only)
    --    Scalar_Range
-   --    Lit_Hash                             (root type only)
    --    Enum_Pos_To_Rep                      (type only)
    --    Static_Discrete_Predicate
    --    Has_Biased_Representation
--- a/src/gcc/ada/exp_aggr.adb
+++ b/src/gcc/ada/exp_aggr.adb
@@ -7848,7 +7848,7 @@ package body Exp_Aggr is
 
             else
                --  a deep delta aggregate choice
-               pragma Assert (All_Extensions_Allowed);
+               pragma Assert (Core_Extensions_Allowed);
 
                declare
                   --  recursively get name for prefix
--- a/src/gcc/ada/exp_attr.adb
+++ b/src/gcc/ada/exp_attr.adb
@@ -2233,6 +2233,8 @@ package body Exp_Attr is
          Formal_Typ : constant Entity_Id := Etype (Formal);
          Is_Written : constant Boolean   := Ekind (Formal) /= E_In_Parameter;
 
+         Call : Node_Id;
+
       begin
          --  The expansion depends on Item, the second actual, which is
          --  the object being streamed in or out.
@@ -2286,8 +2288,8 @@ package body Exp_Attr is
          --  operation is not inherited), we are all set, and can use the
          --  argument unchanged.
 
-         if not Is_Class_Wide_Type (Entity (Pref))
-           and then not Is_Class_Wide_Type (Etype (Item))
+         if not Is_Class_Wide_Type (Item_Typ)
+           and then not Is_Class_Wide_Type (Formal_Typ)
            and then Base_Type (Item_Typ) /= Base_Type (Formal_Typ)
          then
             --  Perform an unchecked conversion when either the argument or
@@ -2333,11 +2335,21 @@ package body Exp_Attr is
 
          --  And now rewrite the call
 
-         Rewrite (N,
-           Make_Procedure_Call_Statement (Loc,
-             Name                   => New_Occurrence_Of (Pname, Loc),
-             Parameter_Associations => Exprs));
+         Call := Make_Procedure_Call_Statement (Loc,
+           Name                   => New_Occurrence_Of (Pname, Loc),
+           Parameter_Associations => Exprs);
+
+         --  If the attribute has not been specified for a CW type, then we
+         --  must dispatch to the attribute of the specific type identified
+         --  by the tag of Item.
+
+         if Is_Class_Wide_Type (Entity (Pref))
+           and then Is_Dispatching_Operation (Pname)
+         then
+            Set_Controlling_Argument (Call, Item);
+         end if;
 
+         Rewrite (N, Call);
          Analyze (N);
       end Rewrite_Attribute_Proc_Call;
 
@@ -3553,6 +3565,25 @@ package body Exp_Attr is
               New_Occurrence_Of
                 (Extra_Constrained (Formal_Ent), Loc));
 
+         --  Extra formals are not created for Unchecked_Union parameters
+
+         elsif Present (Formal_Ent)
+           and then Ekind (Formal_Ent) /= E_In_Parameter
+           and then Is_Unchecked_Union (Base_Type (Etype (Formal_Ent)))
+         then
+            if Comes_From_Source (N) then
+               Error_Msg_N
+                 ("constraints cannot be determined for Unchecked_Union??", N);
+               Error_Msg_N
+                 ("\Program_Error will be raised for ''Constrained??", N);
+            end if;
+
+            Insert_Action (N,
+              Make_Raise_Program_Error (Loc,
+                Reason => PE_Unchecked_Union_Restriction));
+
+            Rewrite (N, New_Occurrence_Of (Boolean_Literals (False), Loc));
+
          --  If the prefix is an access to object, the attribute applies to
          --  the designated object, so rewrite with an explicit dereference.
 
@@ -4931,9 +4962,9 @@ package body Exp_Attr is
 
             --  Dispatching case with class-wide type
 
-            elsif Is_Class_Wide_Type (P_Type) then
+            elsif Is_Class_Wide_Type (U_Type) then
 
-               if Is_Mutably_Tagged_Type (P_Type) then
+               if Is_Mutably_Tagged_Type (U_Type) then
 
                   --  In mutably tagged case, rewrite
                   --    T'Class'Input (Strm)
@@ -4983,7 +5014,7 @@ package body Exp_Attr is
                end if;
 
                Read_Controlling_Tag (P_Type, Cntrl);
-               Fname := Find_Prim_Op (Root_Type (P_Type), TSS_Stream_Input);
+               Fname := Find_Prim_Op (U_Type, TSS_Stream_Input);
 
             --  For tagged types, use the primitive Input function
 
@@ -6622,8 +6653,7 @@ package body Exp_Attr is
                end if;
 
             --  Tagged type case, use the primitive Put_Image function. Note
-            --  that this will dispatch in the class-wide case which is what we
-            --  want.
+            --  that this will dispatch in the class-wide case as required.
 
             elsif Is_Tagged_Type (U_Type) then
                Pname := Find_Optional_Prim_Op (U_Type, TSS_Put_Image);
@@ -7044,7 +7074,7 @@ package body Exp_Attr is
                end;
 
             --  Tagged type case, use the primitive Read function. Note that
-            --  this will dispatch in the class-wide case which is what we want
+            --  this will dispatch in the class-wide case as required.
 
             elsif Is_Tagged_Type (U_Type) then
 
@@ -8770,7 +8800,7 @@ package body Exp_Attr is
                end;
 
             --  Tagged type case, use the primitive Write function. Note that
-            --  this will dispatch in the class-wide case which is what we want
+            --  this will dispatch in the class-wide case as required.
 
             elsif Is_Tagged_Type (U_Type) then
 
--- a/src/gcc/ada/exp_ch3.adb
+++ b/src/gcc/ada/exp_ch3.adb
@@ -4865,13 +4865,15 @@ package body Exp_Ch3 is
 
       --  Derived types that have no type extension can use the initialization
       --  procedure of their parent and do not need a procedure of their own.
+      --  Same for derivations of unchecked_union types.
       --  This is only correct if there are no representation clauses for the
       --  type or its parent, and if the parent has in fact been frozen so
       --  that its initialization procedure exists.
 
       if Is_Derived_Type (Rec_Type)
         and then not Is_Tagged_Type (Rec_Type)
-        and then not Is_Unchecked_Union (Rec_Type)
+        and then Is_Unchecked_Union (Rec_Type)
+                   = Is_Unchecked_Union (Etype (Rec_Type))
         and then not Has_New_Non_Standard_Rep (Rec_Type)
         and then not Parent_Subtype_Renaming_Discrims
         and then Present (Base_Init_Proc (Etype (Rec_Type)))
@@ -8491,6 +8493,44 @@ package body Exp_Ch3 is
             --  class that has no virtual methods is an untagged limited
             --  record type.
 
+            --  a) C++ constructor call placed in a return statement. The
+            --     BIP_Object_Access param of the enclosing function has
+            --     the pointer to the object; convert it to the type of the
+            --     first formal of the called C++ constructor.
+
+            elsif Is_CPP_Constructor_Call (Expr)
+              and then Is_Return_Object (Def_Id)
+            then
+               declare
+                  Encl_Func   : constant Entity_Id :=
+                                  Return_Applies_To (Scope (Def_Id));
+                  BIP_Object  : constant Node_Id :=
+                                  Build_In_Place_Formal (Encl_Func,
+                                    BIP_Object_Access);
+                  Id_Ctor     : constant Entity_Id := Entity (Name (Expr));
+                  Id_Ref      : constant Node_Id :=
+                                  Unchecked_Convert_To (Etype (Id_Ctor),
+                                    Make_Explicit_Dereference (Loc,
+                                      New_Occurrence_Of (BIP_Object, Loc)));
+                  BIP_Obj_Ref : constant Node_Id :=
+                                  Make_Explicit_Dereference (Loc,
+                                    New_Occurrence_Of (BIP_Object, Loc));
+
+               begin
+                  Insert_List_Before_And_Analyze (N,
+                    Build_Initialization_Call (N, Id_Ref, Typ,
+                      Constructor_Ref => Expr));
+
+                  --  Generate:
+                  --    obj : T := renames BIP_Object_Access.all;
+
+                  Analyze (BIP_Obj_Ref);
+                  Rewrite_Object_Declaration_As_Renaming (N, BIP_Obj_Ref);
+                  return;
+               end;
+
+            --  b) C++ constructor call not placed in a return statement
+
             elsif Is_CPP_Constructor_Call (Expr) then
                declare
                   Id_Ref : constant Node_Id := New_Occurrence_Of (Def_Id, Loc);
@@ -9313,7 +9353,7 @@ package body Exp_Ch3 is
          end if;
 
       --  If this is the return object of a function returning on the secondary
-      --  stack, convert the declaration to a renaming of the dereference of ah
+      --  stack, convert the declaration to a renaming of the dereference of an
       --  allocator for the secondary stack.
 
       --    Result : T [:= <expression>];
@@ -9404,7 +9444,7 @@ package body Exp_Ch3 is
          end;
 
       --  If this is the return object of a function returning a by-reference
-      --  type, convert the declaration to a renaming of the dereference of ah
+      --  type, convert the declaration to a renaming of the dereference of an
       --  allocator for the return stack.
 
       --    Result : T [:= <expression>];
@@ -9477,10 +9517,10 @@ package body Exp_Ch3 is
          end;
       end if;
 
-      --  Final transformation - turn the object declaration into a renaming
-      --  if appropriate. If this is the completion of a deferred constant
-      --  declaration, then this transformation generates what would be
-      --  illegal code if written by hand, but that's OK.
+      --  Final transformation: turn the object declaration into a renaming if
+      --  needed. If this is the completion of a deferred constant declaration,
+      --  this transformation generates what would be illegal code if written
+      --  by hand, but that's OK.
 
       if Rewrite_As_Renaming then
          Rewrite_Object_Declaration_As_Renaming (N, Expr_Q);
@@ -11683,6 +11723,7 @@ package body Exp_Ch3 is
             Func_Id := Defining_Unit_Name (Specification (Func_Decl));
 
             Mutate_Ekind (Func_Id, E_Function);
+            Set_Has_Controlling_Result (Func_Id);
             Set_Is_Wrapper (Func_Id);
 
             --  Corresponding_Spec will be set again to the same value during
--- a/src/gcc/ada/exp_ch4.adb
+++ b/src/gcc/ada/exp_ch4.adb
@@ -839,7 +839,7 @@ package body Exp_Ch4 is
 
       if Is_Entity_Name (Exp)
         and then Has_Anonymous_Access_Discriminant (Etype (Exp))
-        and then Static_Accessibility_Level (Exp, Object_Decl_Level)
+        and then Static_Accessibility_Level (Exp, Zero_On_Dynamic_Level)
                    > Static_Accessibility_Level (N, Object_Decl_Level)
       then
          --  A dynamic check and a warning are generated when we are within
@@ -5162,9 +5162,6 @@ package body Exp_Ch4 is
       --  Return True if we can copy objects of this type when expanding a case
       --  expression.
 
-      function Is_Optimizable_Declaration (N : Node_Id) return Boolean;
-      --  Return True if N is an object declaration that can be optimized
-
       ------------------
       -- Is_Copy_Type --
       ------------------
@@ -5174,20 +5171,6 @@ package body Exp_Ch4 is
          return Is_Elementary_Type (Underlying_Type (Typ));
       end Is_Copy_Type;
 
-      --------------------------------
-      -- Is_Optimizable_Declaration --
-      --------------------------------
-
-      function Is_Optimizable_Declaration (N : Node_Id) return Boolean is
-      begin
-         return Nkind (N) = N_Object_Declaration
-           and then not (Is_Entity_Name (Object_Definition (N))
-                          and then Is_Class_Wide_Type
-                                     (Entity (Object_Definition (N))))
-           and then not Is_Return_Object (Defining_Identifier (N))
-           and then not Is_Copy_Type (Typ);
-      end Is_Optimizable_Declaration;
-
       --  Local variables
 
       Acts       : List_Id;
@@ -5265,7 +5248,8 @@ package body Exp_Ch4 is
                            Unqualified_Unconditional_Parent (N);
          begin
             if Nkind (Uncond_Par) = N_Simple_Return_Statement
-              or else Is_Optimizable_Declaration (Uncond_Par)
+              or else (Is_Distributable_Declaration (Uncond_Par)
+                        and then not Is_Copy_Type (Typ))
               or else (Parent_Is_Regular_Aggregate (Uncond_Par)
                         and then not Is_Copy_Type (Typ))
             then
@@ -5286,7 +5270,7 @@ package body Exp_Ch4 is
          elsif Nkind (Par) = N_Simple_Return_Statement then
             Optimize_Return_Stmt := True;
 
-         elsif Is_Optimizable_Declaration (Par) then
+         elsif Is_Distributable_Declaration (Par) then
             Optimize_Object_Decl := True;
 
          else
@@ -5762,9 +5746,6 @@ package body Exp_Ch4 is
       --  Return True if we can copy objects of this type when expanding an if
       --  expression.
 
-      function Is_Optimizable_Declaration (N : Node_Id) return Boolean;
-      --  Return True if N is an object declaration that can be optimized
-
       function OK_For_Single_Subtype (T1, T2 : Entity_Id) return Boolean;
       --  Return true if it is acceptable to use a single subtype for two
       --  dependent expressions of subtype T1 and T2 respectively, which are
@@ -5782,20 +5763,6 @@ package body Exp_Ch4 is
            and then not Is_By_Reference_Type (Utyp);
       end Is_Copy_Type;
 
-      --------------------------------
-      -- Is_Optimizable_Declaration --
-      --------------------------------
-
-      function Is_Optimizable_Declaration (N : Node_Id) return Boolean is
-      begin
-         return Nkind (N) = N_Object_Declaration
-           and then not (Is_Entity_Name (Object_Definition (N))
-                          and then Is_Class_Wide_Type
-                                     (Entity (Object_Definition (N))))
-           and then not Is_Return_Object (Defining_Identifier (N))
-           and then not Is_Copy_Type (Typ);
-      end Is_Optimizable_Declaration;
-
       ---------------------------
       -- OK_For_Single_Subtype --
       ---------------------------
@@ -5885,7 +5852,8 @@ package body Exp_Ch4 is
                            Unqualified_Unconditional_Parent (N);
          begin
             if Nkind (Uncond_Par) = N_Simple_Return_Statement
-              or else Is_Optimizable_Declaration (Uncond_Par)
+              or else (Is_Distributable_Declaration (Uncond_Par)
+                        and then not Is_Copy_Type (Typ))
               or else (Parent_Is_Regular_Aggregate (Uncond_Par)
                         and then not Is_Copy_Type (Typ))
             then
@@ -5906,7 +5874,7 @@ package body Exp_Ch4 is
          elsif Nkind (Par) = N_Simple_Return_Statement then
             Optimize_Return_Stmt := True;
 
-         elsif Is_Optimizable_Declaration (Par) then
+         elsif Is_Distributable_Declaration (Par) then
             Optimize_Object_Decl := True;
 
          else
@@ -8610,6 +8578,8 @@ package body Exp_Ch4 is
 
          if Validity_Check_Operands
            and then not Is_Known_Valid (Component_Type (Typl))
+           and then not
+             Is_Check_Suppressed (Component_Type (Typl), Validity_Check)
          then
             declare
                Save_Force_Validity_Checks : constant Boolean :=
--- a/src/gcc/ada/exp_ch5.adb
+++ b/src/gcc/ada/exp_ch5.adb
@@ -32,6 +32,7 @@ with Einfo.Entities; use Einfo.Entities;
 with Einfo.Utils;    use Einfo.Utils;
 with Elists;         use Elists;
 with Exp_Aggr;       use Exp_Aggr;
+with Exp_Ch3;        use Exp_Ch3;
 with Exp_Ch6;        use Exp_Ch6;
 with Exp_Ch7;        use Exp_Ch7;
 with Exp_Ch11;       use Exp_Ch11;
@@ -2412,6 +2413,26 @@ package body Exp_Ch5 is
       if Componentwise_Assignment (N) then
          Expand_Assign_Record (N);
          return;
+
+      --  Another special case: internally generated initialization invoking
+      --  a C++ constructor. This case corresponds with the initialization
+      --  of an aggregate component.
+
+      elsif not Comes_From_Source (N)
+        and then (No_Ctrl_Actions (N) or else No_Finalize_Actions (N))
+        and then Is_CPP_Constructor_Call (Rhs)
+      then
+         declare
+            Expr   : constant Node_Id := Relocate_Node (Rhs);
+            Id_Ref : constant Node_Id := Relocate_Node (Lhs);
+
+         begin
+            Insert_List_Before_And_Analyze (N,
+              Build_Initialization_Call (N, Id_Ref, Typ,
+                Constructor_Ref => Expr));
+            Rewrite (N, Make_Null_Statement (Loc));
+            return;
+         end;
       end if;
 
       --  Defend against invalid subscripts on left side if we are in standard
--- a/src/gcc/ada/exp_ch6.adb
+++ b/src/gcc/ada/exp_ch6.adb
@@ -5781,13 +5781,8 @@ package body Exp_Ch6 is
 
       --  Note that object declarations are also distributed into conditional
       --  expressions, but we may be invoked before this distribution is done.
-      --  However that's not the case for the declarations of return objects,
-      --  see the twin Is_Optimizable_Declaration predicates that are present
-      --  in Expand_N_Case_Expression and Expand_N_If_Expression of Exp_Ch4.
 
-      elsif Nkind (Uncond_Par) = N_Object_Declaration
-        and then not Is_Return_Object (Defining_Identifier (Uncond_Par))
-      then
+      elsif Is_Distributable_Declaration  (Uncond_Par) then
          return;
       end if;
 
@@ -5824,6 +5819,18 @@ package body Exp_Ch6 is
          return;
       end if;
 
+      --  Do not expand the name of an object renaming declaration at library
+      --  level if the call does not return on the secondary stack, since the
+      --  renaming will eventually be turned into a regular object declaration
+      --  in Expand_N_Object_Renaming_Declaration.
+
+      if Nkind (Par) = N_Object_Renaming_Declaration
+        and then not Use_Sec_Stack
+        and then Is_Library_Level_Entity (Defining_Identifier (Par))
+      then
+         return;
+      end if;
+
       --  Resolution is now finished, make sure we don't start analysis again
       --  because of the duplication.
 
@@ -8295,19 +8302,14 @@ package body Exp_Ch6 is
    procedure Install_Class_Preconditions_Check (Call_Node : Node_Id) is
       Loc : constant Source_Ptr := Sloc (Call_Node);
 
-      function Build_Dynamic_Check_Helper_Call return Node_Id;
-      --  Build call to the helper runtime function of the nearest ancestor
-      --  of the target subprogram that dynamically evaluates the merged
-      --  or-else preconditions.
-
       function Build_Error_Message (Subp_Id : Entity_Id) return Node_Id;
       --  Build message associated with the class-wide precondition of Subp_Id
       --  indicating the call that caused it.
 
-      function Build_Static_Check_Helper_Call return Node_Id;
+      function Build_Helper_Call (Dynamic : Boolean) return Node_Id;
       --  Build call to the helper runtime function of the nearest ancestor
-      --  of the target subprogram that dynamically evaluates the merged
-      --  or-else preconditions.
+      --  of the target subprogram that statically or dynamically (depending on
+      --  the Dynamic flag) evaluates the merged or-else preconditions.
 
       function Class_Preconditions_Subprogram
         (Spec_Id : Entity_Id;
@@ -8320,39 +8322,6 @@ package body Exp_Ch6 is
       --  preconditions; return Empty when not available (which means that no
       --  preconditions check is required).
 
-      -------------------------------------
-      -- Build_Dynamic_Check_Helper_Call --
-      -------------------------------------
-
-      function Build_Dynamic_Check_Helper_Call return Node_Id is
-         Spec_Id   : constant Entity_Id := Entity (Name (Call_Node));
-         CW_Subp   : constant Entity_Id :=
-                       Class_Preconditions_Subprogram (Spec_Id,
-                         Dynamic => True);
-         Helper_Id : constant Entity_Id :=
-                       Dynamic_Call_Helper (CW_Subp);
-         Actuals   : constant List_Id := New_List;
-         A         : Node_Id   := First_Actual (Call_Node);
-
-      begin
-         while Present (A) loop
-
-            --  Ensure that the evaluation of the actuals will not produce
-            --  side effects.
-
-            Remove_Side_Effects (A);
-
-            Append_To (Actuals, New_Copy_Tree (A));
-
-            Next_Actual (A);
-         end loop;
-
-         return
-           Make_Function_Call (Loc,
-             Name => New_Occurrence_Of (Helper_Id, Loc),
-             Parameter_Associations => Actuals);
-      end Build_Dynamic_Check_Helper_Call;
-
       -------------------------
       -- Build_Error_Message --
       -------------------------
@@ -8434,11 +8403,11 @@ package body Exp_Ch6 is
          return Make_String_Literal (Loc, Name_Buffer (1 .. Name_Len));
       end Build_Error_Message;
 
-      ------------------------------------
-      -- Build_Static_Check_Helper_Call --
-      ------------------------------------
+      -----------------------
+      -- Build_Helper_Call --
+      -----------------------
 
-      function Build_Static_Check_Helper_Call return Node_Id is
+      function Build_Helper_Call (Dynamic : Boolean) return Node_Id is
          Actuals   : constant List_Id := New_List;
          A         : Node_Id;
          Helper_Id : Entity_Id;
@@ -8456,11 +8425,14 @@ package body Exp_Ch6 is
          --  Common case
 
          else
-            CW_Subp := Class_Preconditions_Subprogram (Spec_Id,
-                         Dynamic => False);
+            CW_Subp := Class_Preconditions_Subprogram (Spec_Id, Dynamic);
          end if;
 
-         Helper_Id := Static_Call_Helper (CW_Subp);
+         if Dynamic then
+            Helper_Id := Dynamic_Call_Helper (CW_Subp);
+         else
+            Helper_Id := Static_Call_Helper (CW_Subp);
+         end if;
 
          F := First_Formal (Helper_Id);
          A := First_Actual (Call_Node);
@@ -8489,7 +8461,7 @@ package body Exp_Ch6 is
            Make_Function_Call (Loc,
              Name => New_Occurrence_Of (Helper_Id, Loc),
              Parameter_Associations => Actuals);
-      end Build_Static_Check_Helper_Call;
+      end Build_Helper_Call;
 
       ------------------------------------
       -- Class_Preconditions_Subprogram --
@@ -8632,11 +8604,7 @@ package body Exp_Ch6 is
 
       --  Build and install the check
 
-      if Dynamic_Check then
-         Cond := Build_Dynamic_Check_Helper_Call;
-      else
-         Cond := Build_Static_Check_Helper_Call;
-      end if;
+      Cond := Build_Helper_Call (Dynamic_Check);
 
       if Exception_Locations_Suppressed then
          Fail :=
@@ -10315,8 +10283,7 @@ package body Exp_Ch6 is
 
       return not Restriction_Active (No_Finalization)
         and then (Needs_Finalization (Typ) or else Is_Tagged_Type (Typ))
-        and then not Has_Relaxed_Finalization (Typ)
-        and then not Has_Foreign_Convention (Typ);
+        and then not Has_Relaxed_Finalization (Typ);
    end Needs_BIP_Collection;
 
    --------------------------
--- a/src/gcc/ada/exp_ch7.adb
+++ b/src/gcc/ada/exp_ch7.adb
@@ -5463,11 +5463,12 @@ package body Exp_Ch7 is
       --  subtype, its Finalize_Address primitive expects the address of
       --  an object with a dope vector (see Make_Finalize_Address_Stmts).
       --  This is achieved by setting Is_Constr_Array_Subt_With_Bounds,
-      --  but the address of the object is still that of its elements,
-      --  so we need to shift it back to skip the dope vector.
+      --  whose predicate also requires Has_Controlled_Component, so we
+      --  have to check for the controlled component here, too.
 
       if Is_Array_Type (Utyp)
         and then not Is_Constrained (First_Subtype (Utyp))
+        and then Has_Controlled_Component (Utyp)
       then
          Obj_Addr :=
            Shift_Address_For_Descriptor
--- a/src/gcc/ada/exp_ch8.adb
+++ b/src/gcc/ada/exp_ch8.adb
@@ -160,9 +160,11 @@ package body Exp_Ch8 is
 
       --  Local variables
 
+      Def_Id : constant Entity_Id := Defining_Identifier (N);
+      Nam    : constant Node_Id   := Name (N);
+      T      : constant Entity_Id := Etype (Def_Id);
+
       Decl : Node_Id;
-      Nam  : constant Node_Id   := Name (N);
-      T    : constant Entity_Id := Etype (Defining_Identifier (N));
 
    --  Start of processing for Expand_N_Object_Renaming_Declaration
 
@@ -171,7 +173,7 @@ package body Exp_Ch8 is
 
       if Evaluation_Required (Nam) then
          Evaluate_Name (Nam);
-         Set_Is_Renaming_Of_Object (Defining_Identifier (N));
+         Set_Is_Renaming_Of_Object (Def_Id);
       end if;
 
       --  Deal with construction of subtype in class-wide case
@@ -179,7 +181,7 @@ package body Exp_Ch8 is
       if Is_Class_Wide_Type (T) then
          Expand_Subtype_From_Expr (N, T, Subtype_Mark (N), Name (N));
          Find_Type (Subtype_Mark (N));
-         Set_Etype (Defining_Identifier (N), Entity (Subtype_Mark (N)));
+         Set_Etype (Def_Id, Entity (Subtype_Mark (N)));
 
          --  Freeze the class-wide subtype here to ensure that the subtype
          --  and equivalent type are frozen before the renaming.
@@ -200,6 +202,37 @@ package body Exp_Ch8 is
 
       elsif Present (Unqual_BIP_Iface_Function_Call (Nam)) then
          Make_Build_In_Place_Iface_Call_In_Anonymous_Context (Nam);
+
+      --  The renaming of a controlled function call declared at library level
+      --  must be turned into a regular object declaration if the result is not
+      --  returned on the secondary stack because, otherwise, the finalization
+      --  machinery of the library level would have the address of a temporary
+      --  created on the stack of the elaboration routine to hold the result.
+
+      elsif Nkind (Nam) = N_Function_Call
+        and then Is_Controlled (T)
+        and then not Needs_Secondary_Stack (T)
+        and then Is_Library_Level_Entity (Def_Id)
+      then
+         Rewrite (N,
+           Make_Object_Declaration (Sloc (N),
+             Defining_Identifier => Def_Id,
+             Constant_Present    => True,
+             Object_Definition   => New_Occurrence_Of (T, Sloc (N)),
+             Expression          => Nam));
+
+         --  We do not analyze this object declaration, because all its
+         --  components have already been analyzed, and if we were to go
+         --  ahead and analyze it, we would in effect be trying to generate
+         --  another declaration of Def_Id, which won't do.
+
+         Set_Analyzed (N);
+
+         --  Therefore we need to set the Has_Completion flag manually
+
+         Set_Has_Completion (Def_Id);
+
+         return;
       end if;
 
       --  Create renaming entry for debug information. Mark the entity as
--- a/src/gcc/ada/exp_disp.adb
+++ b/src/gcc/ada/exp_disp.adb
@@ -1203,10 +1203,7 @@ package body Exp_Disp is
          Set_SCIL_Node (SCIL_Related_Node, SCIL_Node);
       end if;
 
-      --  Suppress all checks during the analysis of the expanded code to avoid
-      --  the generation of spurious warnings under ZFP run-time.
-
-      Analyze_And_Resolve (Call_Node, Call_Typ, Suppress => All_Checks);
+      Analyze_And_Resolve (Call_Node, Call_Typ);
 
       Set_Is_Expanded_Dispatching_Call (Call_Node);
    end Expand_Dispatching_Call;
--- a/src/gcc/ada/exp_imgv.adb
+++ b/src/gcc/ada/exp_imgv.adb
@@ -1047,10 +1047,9 @@ package body Exp_Imgv is
          return;
       end if;
 
-      --  If Image should be transformed using Put_Image, then do so. See
-      --  Exp_Put_Image for details.
+      --  If Image must be turned into Put_Image, then do so
 
-      if Exp_Put_Image.Image_Should_Call_Put_Image (N) then
+      if Exp_Put_Image.Image_Must_Call_Put_Image (N) then
          Establish_Transient_Scope (N, Manage_Sec_Stack => True);
          Rewrite (N, Exp_Put_Image.Build_Image_Call (N));
          Analyze_And_Resolve (N, Standard_String, Suppress => All_Checks);
@@ -1061,11 +1060,10 @@ package body Exp_Imgv is
 
       --  Ada 2022 allows 'Image on private types, so fetch the underlying
       --  type to obtain the structure of the type. We use the base type,
-      --  not the root type for discrete types, to handle properly derived
-      --  types, but we use the root type for enumeration types, because the
-      --  literal map is attached to the root. Should be inherited ???
+      --  not the root type, for discrete types in order to handle derived
+      --  types, except for character types for which this is not needed.
 
-      if Is_Real_Type (Ptyp) or else Is_Enumeration_Type (Ptyp) then
+      if Is_Real_Type (Ptyp) or else Is_Character_Type (Ptyp) then
          Rtyp := Underlying_Type (Root_Type (Ptyp));
       else
          Rtyp := Underlying_Type (Base_Type (Ptyp));
@@ -1076,7 +1074,7 @@ package body Exp_Imgv is
 
       Enum_Case := False;
 
-      if Rtyp = Standard_Boolean then
+      if Is_Boolean_Type (Rtyp) then
          --  Use inline expansion if the -gnatd_x switch is not passed to the
          --  compiler. Otherwise expand into a call to the runtime.
 
@@ -1861,10 +1859,9 @@ package body Exp_Imgv is
          return;
       end if;
 
-      --  If Image should be transformed using Put_Image, then do so. See
-      --  Exp_Put_Image for details.
+      --  If Image must be turned into Put_Image, then do so
 
-      if Exp_Put_Image.Image_Should_Call_Put_Image (N) then
+      if Exp_Put_Image.Image_Must_Call_Put_Image (N) then
          Establish_Transient_Scope (N, Manage_Sec_Stack => True);
          Rewrite (N, Exp_Put_Image.Build_Image_Call (N));
          Analyze_And_Resolve (N, Standard_Wide_String, Suppress => All_Checks);
@@ -1971,10 +1968,9 @@ package body Exp_Imgv is
          return;
       end if;
 
-      --  If Image should be transformed using Put_Image, then do so. See
-      --  Exp_Put_Image for details.
+      --  If Image must be turned into Put_Image, then do so
 
-      if Exp_Put_Image.Image_Should_Call_Put_Image (N) then
+      if Exp_Put_Image.Image_Must_Call_Put_Image (N) then
          Establish_Transient_Scope (N, Manage_Sec_Stack => True);
          Rewrite (N, Exp_Put_Image.Build_Image_Call (N));
          Analyze_And_Resolve
--- a/src/gcc/ada/exp_put_image.adb
+++ b/src/gcc/ada/exp_put_image.adb
@@ -1240,11 +1240,11 @@ package body Exp_Put_Image is
       return Make_Defining_Identifier (Loc, Sname);
    end Make_Put_Image_Name;
 
-   ---------------------------------
-   -- Image_Should_Call_Put_Image --
-   ---------------------------------
+   -------------------------------
+   -- Image_Must_Call_Put_Image --
+   -------------------------------
 
-   function Image_Should_Call_Put_Image (N : Node_Id) return Boolean is
+   function Image_Must_Call_Put_Image (N : Node_Id) return Boolean is
    begin
       if Ada_Version < Ada_2022 then
          return False;
@@ -1282,7 +1282,7 @@ package body Exp_Put_Image is
 
          return False;
       end;
-   end Image_Should_Call_Put_Image;
+   end Image_Must_Call_Put_Image;
 
    ----------------------
    -- Build_Image_Call --
--- a/src/gcc/ada/exp_put_image.ads
+++ b/src/gcc/ada/exp_put_image.ads
@@ -82,9 +82,9 @@ package Exp_Put_Image is
    function Build_Unknown_Put_Image_Call (N : Node_Id) return Node_Id;
    --  Build a call to Put_Image_Unknown
 
-   function Image_Should_Call_Put_Image (N : Node_Id) return Boolean;
-   --  True if T'Image should call T'Put_Image. N is the attribute_reference
-   --  T'Image.
+   function Image_Must_Call_Put_Image (N : Node_Id) return Boolean;
+   --  True if T'Image must be implemented by a call to T'Put_Image. N is the
+   --  attribute reference to T'Image.
 
    function Build_Image_Call (N : Node_Id) return Node_Id;
    --  N is a call to T'[[Wide_]Wide_]Image, and this translates it into the
--- a/src/gcc/ada/exp_util.adb
+++ b/src/gcc/ada/exp_util.adb
@@ -8955,6 +8955,43 @@ package body Exp_Util is
         and then Expansion_Delayed (Unqual_N);
    end Is_Delayed_Conditional_Expression;
 
+   --------------------------------
+   -- Is_Distributable_Declaration --
+   --------------------------------
+
+   function Is_Distributable_Declaration (N : Node_Id) return Boolean is
+      Obj_Def : Node_Id;
+
+   begin
+      --  First limitation: distribution is not implemented for return objects
+
+      if Nkind (N) /= N_Object_Declaration
+        or else Is_Return_Object (Defining_Identifier (N))
+      then
+         return False;
+      end if;
+
+      Obj_Def := Object_Definition (N);
+
+      --  Second limitation: distribution is not implemented for CW types
+
+      if Is_Entity_Name (Obj_Def)
+        and then Is_Class_Wide_Type (Entity (Obj_Def))
+      then
+         return False;
+      end if;
+
+      --  The declaration of a variable of an unconstrained definite nonlimited
+      --  subtype cannot be distributed because the variable is mutable and the
+      --  expansion of 'Constrained must statically return False for it.
+
+      return Constant_Present (N)
+        or else not Is_Entity_Name (Obj_Def)
+        or else Is_Constrained (Entity (Obj_Def))
+        or else not Is_Definite_Subtype (Entity (Obj_Def))
+        or else Is_Inherently_Limited_Type (Entity (Obj_Def));
+   end Is_Distributable_Declaration;
+
    --------------------------------------------------
    -- Is_Expanded_Class_Wide_Interface_Object_Decl --
    --------------------------------------------------
@@ -12415,7 +12452,15 @@ package body Exp_Util is
               and then Is_Entity_Name (Name (Init_Call))
               and then Entity (Name (Init_Call)) = Init_Proc
             then
-               return Init_Call;
+               declare
+                  Act : constant Node_Id :=
+                    Unqual_Conv (First (Parameter_Associations (Init_Call)));
+
+               begin
+                  if Is_Entity_Name (Act) and then Entity (Act) = Var then
+                     return Init_Call;
+                  end if;
+               end;
             end if;
 
             Next (Init_Call);
@@ -12745,7 +12790,16 @@ package body Exp_Util is
                    or else Nkind (Prefix (Exp)) /= N_Aggregate)
         and then not Is_Name_Reference (Prefix (Exp))
       then
-         Remove_Side_Effects (Prefix (Exp), Name_Req, Variable_Ref);
+         Remove_Side_Effects
+           (Exp                => Prefix (Exp),
+            Name_Req           => Name_Req,
+            Renaming_Req       => Renaming_Req,
+            Variable_Ref       => False,
+            Related_Id         => Related_Id,
+            Is_Low_Bound       => False,
+            Is_High_Bound      => False,
+            Discr_Number       => 0,
+            Check_Side_Effects => Check_Side_Effects);
          goto Leave;
 
       --  If this is an elementary or a small not-by-reference record type, and
@@ -12847,7 +12901,16 @@ package body Exp_Util is
       elsif Nkind (Exp) = N_Unchecked_Type_Conversion
         and then Nkind (Expression (Exp)) = N_Explicit_Dereference
       then
-         Remove_Side_Effects (Expression (Exp), Name_Req, Variable_Ref);
+         Remove_Side_Effects
+           (Exp                => Expression (Exp),
+            Name_Req           => Name_Req,
+            Renaming_Req       => Renaming_Req,
+            Variable_Ref       => Variable_Ref,
+            Related_Id         => Related_Id,
+            Is_Low_Bound       => Is_Low_Bound,
+            Is_High_Bound      => Is_High_Bound,
+            Discr_Number       => Discr_Number,
+            Check_Side_Effects => Check_Side_Effects);
          goto Leave;
 
       --  If this is a type conversion, leave the type conversion and remove
@@ -12860,7 +12923,16 @@ package body Exp_Util is
       elsif Nkind (Exp) = N_Type_Conversion
         and then Etype (Expression (Exp)) /= Universal_Integer
       then
-         Remove_Side_Effects (Expression (Exp), Name_Req, Variable_Ref);
+         Remove_Side_Effects
+           (Exp                => Expression (Exp),
+            Name_Req           => Name_Req,
+            Renaming_Req       => Renaming_Req,
+            Variable_Ref       => Variable_Ref,
+            Related_Id         => Related_Id,
+            Is_Low_Bound       => Is_Low_Bound,
+            Is_High_Bound      => Is_High_Bound,
+            Discr_Number       => Discr_Number,
+            Check_Side_Effects => Check_Side_Effects);
          goto Leave;
 
       --  If this is an unchecked conversion that Gigi can't handle, make
@@ -12941,7 +13013,16 @@ package body Exp_Util is
         and then Nkind (Prefix (Exp)) = N_Function_Call
         and then Is_Array_Type (Und_Typ)
       then
-         Remove_Side_Effects (Prefix (Exp), Name_Req, Variable_Ref);
+         Remove_Side_Effects
+           (Exp                => Prefix (Exp),
+            Name_Req           => Name_Req,
+            Renaming_Req       => Renaming_Req,
+            Variable_Ref       => Variable_Ref,
+            Related_Id         => Related_Id,
+            Is_Low_Bound       => Is_Low_Bound,
+            Is_High_Bound      => Is_High_Bound,
+            Discr_Number       => Discr_Number,
+            Check_Side_Effects => Check_Side_Effects);
          goto Leave;
 
       --  Otherwise we generate a reference to the expression
@@ -13808,7 +13889,7 @@ package body Exp_Util is
       --  We do not analyze this renaming declaration, because all its
       --  components have already been analyzed, and if we were to go
       --  ahead and analyze it, we would in effect be trying to generate
-      --  another declaration of X, which won't do.
+      --  another declaration of Def_Id, which won't do.
 
       Set_Renamed_Object (Def_Id, Nam);
       Set_Analyzed (N);
--- a/src/gcc/ada/exp_util.ads
+++ b/src/gcc/ada/exp_util.ads
@@ -830,6 +830,13 @@ package Exp_Util is
    --  Return True if N is a type conversion, or a dereference thereof, or a
    --  reference to a formal parameter.
 
+   function Is_Distributable_Declaration (N : Node_Id) return Boolean;
+   --  Return True if N is an object declaration that can be distributed into
+   --  the dependent expressions of a conditional expression, given that the
+   --  conditional expression is the initialization expression of N. Such a
+   --  distribution avoids a copy operation and is required for limited types
+   --  and, more generally, desirable for all by-reference types.
+
    function Is_Expanded_Class_Wide_Interface_Object_Decl
       (N : Node_Id) return Boolean;
    --  Determine if N is the expanded code for a class-wide interface type
--- a/src/gcc/ada/gcc-interface/decl.cc
+++ b/src/gcc/ada/gcc-interface/decl.cc
@@ -814,12 +814,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition)
 	  }
 
 	/* If an alignment is specified, use it if valid.  Note that exceptions
-	   are objects but don't have an alignment and there is also no point in
-	   setting it for an address clause, since the final type of the object
-	   will be a reference type.  */
-	if (Known_Alignment (gnat_entity)
-	    && kind != E_Exception
-	    && No (Address_Clause (gnat_entity)))
+	   are objects but don't have an alignment.  */
+	if (Known_Alignment (gnat_entity) && kind != E_Exception)
 	  align = validate_alignment (Alignment (gnat_entity), gnat_entity,
 				      TYPE_ALIGN (gnu_type));
 
@@ -1489,12 +1485,6 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition)
 			     false);
 		  }
 
-		/* Give a warning if the size is constant but too large.  */
-		if (TREE_CODE (TYPE_SIZE_UNIT (gnu_alloc_type)) == INTEGER_CST
-		    && !valid_constant_size_p (TYPE_SIZE_UNIT (gnu_alloc_type)))
-		  post_error ("??Storage_Error will be raised at run time!",
-			      gnat_entity);
-
 		gnu_expr
 		  = build_allocator (gnu_alloc_type, gnu_expr, gnu_type,
 				     Empty, Empty, gnat_entity, mutable_p);
--- a/src/gcc/ada/gcc-interface/utils.cc
+++ b/src/gcc/ada/gcc-interface/utils.cc
@@ -1763,6 +1763,16 @@ maybe_pad_type (tree type, tree size, unsigned int align,
 	       size_binop (EXACT_DIV_EXPR, TYPE_SIZE (record),
 			   bitsize_unit_node));
 
+  /* Propagate the storage order from an aggregate type to the padded type.
+     Ideally this should not be necessary, because the flag on the padded
+     type has no semantic effects given that its only field is not scalar.
+     However, when the aggregate type contains a single scalar field, SRA
+     may totally scalarize the padded type without taking into account the
+     intermediate aggregate type and, therefore, may test the flag on the
+     former instead of the latter to generate a reverse memory access.  */
+  if (AGGREGATE_TYPE_P (type))
+    TYPE_REVERSE_STORAGE_ORDER (record) = TYPE_REVERSE_STORAGE_ORDER (type);
+
   /* If we are changing the alignment and the input type is a record with
      BLKmode and a small constant size, try to make a form that has an
      integral mode.  This might allow the padding record to also have an
--- a/src/gcc/ada/gcc-interface/utils2.cc
+++ b/src/gcc/ada/gcc-interface/utils2.cc
@@ -2731,7 +2731,10 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc,
 
   /* If the size overflows, pass -1 so Storage_Error will be raised.  */
   if (TREE_CODE (size) == INTEGER_CST && !valid_constant_size_p (size))
-    size = size_int (-1);
+    {
+      post_error ("??Storage_Error will be raised at run time!", gnat_node);
+      size = size_int (-1);
+    }
 
   storage = convert (result_type,
 		     build_call_alloc_dealloc (NULL_TREE, size, type,
--- a/src/gcc/ada/gen_il-fields.ads
+++ b/src/gcc/ada/gen_il-fields.ads
@@ -384,6 +384,7 @@ package Gen_IL.Fields is
       SCIL_Tag_Value,
       SCIL_Target_Prim,
       Scope,
+      Scope_Link,
       Select_Alternatives,
       Selector_Name,
       Selector_Names,
--- a/src/gcc/ada/gen_il-gen-gen_entities.adb
+++ b/src/gcc/ada/gen_il-gen-gen_entities.adb
@@ -551,11 +551,11 @@ begin -- Gen_IL.Gen.Gen_Entities
        (Sm (First_Literal, Node_Id),
         Sm (Has_Enumeration_Rep_Clause, Flag),
         Sm (Has_Pragma_Ordered, Flag, Impl_Base_Type_Only),
-        Sm (Lit_Indexes, Node_Id),
-        Sm (Lit_Strings, Node_Id),
+        Sm (Lit_Hash, Node_Id, Root_Type_Only),
+        Sm (Lit_Indexes, Node_Id, Root_Type_Only),
+        Sm (Lit_Strings, Node_Id, Root_Type_Only),
         Sm (Nonzero_Is_True, Flag, Base_Type_Only,
-            Pre => "Root_Type (N) = Standard_Boolean"),
-        Sm (Lit_Hash, Node_Id, Root_Type_Only)));
+            Pre => "Root_Type (N) = Standard_Boolean")));
 
    Cc (E_Enumeration_Type, Enumeration_Kind,
        --  Enumeration types, created by an enumeration type declaration
@@ -942,7 +942,8 @@ begin -- Gen_IL.Gen.Gen_Entities
         Sm (Extra_Accessibility_Of_Result, Node_Id),
         Sm (Extra_Formals, Node_Id),
         Sm (Extra_Formals_Known, Flag),
-        Sm (Needs_No_Actuals, Flag)));
+        Sm (Needs_No_Actuals, Flag),
+        Sm (Scope_Depth_Value, Unat)));
 
    Ab (Overloadable_Kind, Entity_Kind,
        (Sm (Renamed_Or_Alias, Node_Id),
--- a/src/gcc/ada/gen_il-gen-gen_nodes.adb
+++ b/src/gcc/ada/gen_il-gen-gen_nodes.adb
@@ -364,7 +364,8 @@ begin -- Gen_IL.Gen.Gen_Nodes
 
    Cc (N_Expression_With_Actions, N_Subexpr,
        (Sy (Actions, List_Id, Default_No_List),
-        Sy (Expression, Node_Id, Default_Empty)));
+        Sy (Expression, Node_Id, Default_Empty),
+        Sm (Scope_Link, Node_Id)));
 
    Cc (N_External_Initializer, N_Subexpr,
        (Sy (File_Index, Source_File_Index)));
--- a/src/gcc/ada/init.c
+++ b/src/gcc/ada/init.c
@@ -594,8 +594,10 @@ __gnat_error_handler (int sig, siginfo_t *si ATTRIBUTE_UNUSED, void *ucontext)
 
 #ifndef __ia64__
 #define HAVE_GNAT_ALTERNATE_STACK 1
-/* This must be in keeping with System.OS_Interface.Alternate_Stack_Size.  */
-char __gnat_alternate_stack[32 * 1024];
+/* Address sanitizer requires the alternate stack to be 8-byte aligned,
+   regardless of any extra alignment added by the operating system.  The size
+   must be in keeping with System.OS_Interface.Alternate_Stack_Size.  */
+char __gnat_alternate_stack[32 * 1024] __attribute__ ((aligned (8)));
 #endif
 
 #ifdef __XENO__
--- a/src/gcc/ada/libgnarl/s-interr.adb
+++ b/src/gcc/ada/libgnarl/s-interr.adb
@@ -156,10 +156,10 @@ package body System.Interrupts is
    User_Handler : array (Interrupt_ID'Range) of Handler_Assoc :=
                     [others => (null, Static => False)];
    pragma Volatile_Components (User_Handler);
-   --  Holds the protected procedure handler (if any) and its Static
-   --  information for each interrupt. A handler is a Static one if it is
-   --  specified through the pragma Attach_Handler. Attach_Handler. Otherwise,
-   --  not static)
+   --  Holds the protected procedure handler (if any) and whether it is Static
+   --  for each interrupt. A handler is a Static one if and only if it is
+   --  specified through the Attach_Handler aspect (or the obsolescent
+   --  Attach_Handler pragma).
 
    User_Entry : array (Interrupt_ID'Range) of Entry_Assoc :=
                   [others => (T => Null_Task, E => Null_Task_Entry)];
@@ -861,21 +861,22 @@ package body System.Interrupts is
          --  We don't check anything if Restoration is True, since we may be
          --  detaching a static handler to restore a dynamic one.
 
-         if not Restoration and then not Static
-
+         if not Restoration and then not Static then
             --  Tries to overwrite a static Interrupt Handler with a dynamic
             --  Handler
+            if User_Handler (Interrupt).Static then
+               raise Program_Error
+                 with
+                   "trying to overwrite a static Interrupt Handler with a "
+                   & "dynamic handler";
+            end if;
 
-           and then (User_Handler (Interrupt).Static
-
-                       --  The new handler is not specified as an
-                       --  Interrupt Handler by a pragma.
-
-                       or else not Is_Registered (New_Handler))
-         then
-            raise Program_Error with
-              "trying to overwrite a static Interrupt Handler with a " &
-              "dynamic handler";
+            --  The new handler is not specified as an interrupt handler by an
+            --  aspect (see the second sentence of RM C.3.2 (17/3)).
+            if not Is_Registered (New_Handler) then
+               raise Program_Error
+                 with "trying to attach procedure without Interrupt_Handler";
+            end if;
          end if;
 
          --  The interrupt should no longer be ignored if
@@ -952,9 +953,8 @@ package body System.Interrupts is
          end;
       end Initialize;
 
-      --  Note: All tasks in RTS will have all the Reserve Interrupts being
-      --  masked (except the Interrupt_Manager) and Keep_Unmasked unmasked
-      --  when created.
+      --  Note: All tasks in RTS will have all the Keep_Unmasked interrupts
+      --  unmasked when created.
 
       --  Abort_Task_Interrupt is one of the Interrupt unmasked in all tasks.
       --  We mask the Interrupt in this particular task so that "sigwait" is
@@ -1239,9 +1239,8 @@ package body System.Interrupts is
 
       IMOP.Install_Default_Action (IMNG.Interrupt_ID (Interrupt));
 
-      --  Note: All tasks in RTS will have all the Reserve Interrupts being
-      --  masked (except the Interrupt_Manager) and Keep_Unmasked unmasked when
-      --  created.
+      --  Note: All tasks in RTS will have all the Keep_Unmasked interrupts
+      --  unmasked when created.
 
       --  Abort_Task_Interrupt is one of the Interrupt unmasked in all tasks.
       --  We mask the Interrupt in this particular task so that "sigwait" is
--- a/src/gcc/ada/libgnarl/s-interr__vxworks.adb
+++ b/src/gcc/ada/libgnarl/s-interr__vxworks.adb
@@ -866,20 +866,22 @@ package body System.Interrupts is
          --  We don't check anything if Restoration is True, since we may be
          --  detaching a static handler to restore a dynamic one.
 
-         if not Restoration and then not Static
-           and then (User_Handler (Interrupt).Static
-
+         if not Restoration and then not Static then
             --  Trying to overwrite a static Interrupt Handler with a dynamic
             --  Handler
+            if User_Handler (Interrupt).Static then
+               raise Program_Error
+                 with
+                   "trying to overwrite a static Interrupt Handler with a "
+                   & "dynamic handler";
+            end if;
 
-            --  The new handler is not specified as an Interrupt Handler by a
-            --  pragma.
-
-           or else not Is_Registered (New_Handler))
-         then
-            raise Program_Error with
-               "trying to overwrite a static interrupt handler with a "
-               & "dynamic handler";
+            --  The new handler is not specified as an interrupt handler by an
+            --  aspect (see the second sentence of RM C.3.2 (17/3)).
+            if not Is_Registered (New_Handler) then
+               raise Program_Error
+                 with "trying to attach procedure without Interrupt_Handler";
+            end if;
          end if;
 
          --  Save the old handler
--- a/src/gcc/ada/libgnat/a-textio.adb
+++ b/src/gcc/ada/libgnat/a-textio.adb
@@ -100,7 +100,7 @@ is
    --  upper half character value from the given File. The first byte has
    --  already been read and is passed in C. The character value is returned as
    --  the result, and the file pointer is bumped past the character.
-   --  Constraint_Error is raised if the encoded value is outside the bounds of
+   --  Data_Error is raised if the encoded value is outside the bounds of
    --  type Character.
 
    function Get_Upper_Half_Char_Immed
@@ -806,7 +806,7 @@ is
       Result := WC_In (C, File.WC_Method);
 
       if Wide_Character'Pos (Result) > 16#FF# then
-         raise Constraint_Error with
+         raise Data_Error with
            "invalid wide character in Text_'I'O input";
       else
          return Character'Val (Wide_Character'Pos (Result));
@@ -849,7 +849,7 @@ is
       Result := WC_In (C, File.WC_Method);
 
       if Wide_Character'Pos (Result) > 16#FF# then
-         raise Constraint_Error with
+         raise Data_Error with
            "invalid wide character in Text_'I'O input";
       else
          return Character'Val (Wide_Character'Pos (Result));
--- a/src/gcc/ada/libgnat/s-dorepr__freebsd.adb
+++ b/src/gcc/ada/libgnat/s-dorepr__freebsd.adb
@@ -134,7 +134,7 @@ package body Product is
       Ahi, Alo, Bhi, Blo, E : Num;
 
    begin
-      if Is_Infinity (P) or else Is_Zero (P) then
+      if Is_Infinity_Or_NaN (P) or else Is_Zero (P) then
          return (P, 0.0);
 
       else
@@ -157,7 +157,7 @@ package body Product is
       Hi, Lo, E : Num;
 
    begin
-      if Is_Infinity (Q) or else Is_Zero (Q) then
+      if Is_Infinity_Or_NaN (Q) or else Is_Zero (Q) then
          return (Q, 0.0);
 
       else
--- a/src/gcc/ada/libgnat/s-genbig.adb
+++ b/src/gcc/ada/libgnat/s-genbig.adb
@@ -262,7 +262,7 @@ package body System.Generic_Bignums is
          --  X ** 1 is X
 
          when 1 =>
-            return Normalize (X.D);
+            return Normalize (X.D, X.Neg);
 
          --  X ** 2 is X * X
 
@@ -331,14 +331,14 @@ package body System.Generic_Bignums is
       elsif Y.Len > 1 then
          raise Storage_Error with "exponentiation result is too large";
 
-      --  Special case (+/-)2 ** K, where K is 1 .. 31 using a shift
+      --  Special case (+/-)2 ** K, where K is in 1 .. 31, using a left shift
 
       elsif X.Len = 1 and then X.D (1) = 2 and then Y.D (1) < 32 then
          declare
             D : constant Digit_Vector (1 .. 1) :=
                   [Shift_Left (SD'(1), Natural (Y.D (1)))];
          begin
-            return Normalize (D, X.Neg);
+            return Normalize (D, X.Neg and then (Y.D (1) and 1) = 1);
          end;
 
       --  Remaining cases have right operand of one word
--- a/src/gcc/ada/libgnat/s-regpat.ads
+++ b/src/gcc/ada/libgnat/s-regpat.ads
@@ -428,7 +428,7 @@ package System.Regpat is
    --
    --  This function raises Storage_Error if Matcher is too small to hold
    --  the resulting code (i.e. Matcher.Size has too small a value) only when
-   --  the paramter Error_When_Too_Small is set to True. Otherwise, no error
+   --  the parameter Error_When_Too_Small is set to True. Otherwise, no error
    --  will be raised and the required size will be placed in the
    --  Final_Code_Size parameter.
    --
--- a/src/gcc/ada/par-ch12.adb
+++ b/src/gcc/ada/par-ch12.adb
@@ -1207,12 +1207,13 @@ package body Ch12 is
 
          elsif Token = Tok_Left_Paren then
             Error_Msg_GNAT_Extension
-              ("expression default for formal subprograms", Token_Ptr);
+              ("expression default for formal subprograms", Token_Ptr,
+               Is_Core_Extension => True);
 
             if Nkind (Spec_Node) = N_Function_Specification then
                Scan;  --  past "("
 
-               Set_Expression (Def_Node, P_Expression);
+               Set_Expression (Def_Node, P_Expression_If_OK);
 
                if Token /= Tok_Right_Paren then
                   Error_Msg_SC ("missing "")"" at end of expression default");
--- a/src/gcc/ada/par-ch3.adb
+++ b/src/gcc/ada/par-ch3.adb
@@ -4613,7 +4613,7 @@ package body Ch3 is
             Append (P_Generic, Decls);
 
          when Tok_Identifier =>
-            Check_Bad_Layout;
+            Save_Scan_State (Scan_State);
 
             --  Special check for misuse of overriding not in Ada 2005 mode
 
@@ -4632,6 +4632,10 @@ package body Ch3 is
                P_Identifier_Declarations (Decls, Done, In_Spec, In_Statements);
             end if;
 
+            if not Done then
+               Check_Bad_Layout_At (Scan_State);
+            end if;
+
          when Tok_Package =>
             Check_Bad_Layout;
             Append (P_Package (Pf_Decl_Gins_Pbod_Rnam_Stub_Pexp), Decls);
--- a/src/gcc/ada/par-ch4.adb
+++ b/src/gcc/ada/par-ch4.adb
@@ -482,12 +482,7 @@ package body Ch4 is
          elsif Token = Tok_Identifier then
             Attr_Name := Token_Name;
 
-            --  Attribute Unsigned_Base_Range temporarily disabled
-
-            if not Is_Attribute_Name (Attr_Name)
-              or else (Attr_Name = Name_Unsigned_Base_Range
-                         and then not Debug_Flag_Dot_U)
-            then
+            if not Is_Attribute_Name (Attr_Name) then
                if Apostrophe_Should_Be_Semicolon then
                   Expr_Form := EF_Name;
                   return Name_Node;
@@ -2140,19 +2135,19 @@ package body Ch4 is
    end P_Expression;
 
    --  This function is identical to the normal P_Expression, except that it
-   --  also permits the appearance of a case, conditional, or quantified
+   --  also permits the appearance of a conditional, quantified, or declare
    --  expression if the call immediately follows a left paren, and followed
    --  by a right parenthesis. These forms are allowed if these conditions
    --  are not met, but an error message will be issued.
 
    function P_Expression_If_OK return Node_Id is
    begin
-      --  Case of conditional, case or quantified expression
+      --  Case of conditional, quantified, or declare expression
 
       if Token in Tok_Case | Tok_If | Tok_For | Tok_Declare then
          return P_Unparen_Cond_Expr_Etc;
 
-      --  Normal case, not case/conditional/quantified expression
+      --  Normal case: not a conditional, quantified, or declare expression
 
       else
          return P_Expression;
@@ -2660,7 +2655,7 @@ package body Ch4 is
          end;
       end if;
 
-      --  If all extensions are enabled and we have a deep delta aggregate
+      --  If core extensions are enabled and we have a deep delta aggregate
       --  whose type is an array type with an element type that is a
       --  record type, then we can encounter legal things like
       --    with delta (Some_Index_Expression).Some_Component
@@ -2673,7 +2668,7 @@ package body Ch4 is
         and then Prev_Token = Tok_Right_Paren
         and then Serious_Errors_Detected = 0
         and then Inside_Delta_Aggregate
-        and then All_Extensions_Allowed
+        and then Core_Extensions_Allowed
       then
          if Token = Tok_Dot then
             Node2 := New_Node (N_Selected_Component, Token_Ptr);
--- a/src/gcc/ada/par-ch5.adb
+++ b/src/gcc/ada/par-ch5.adb
@@ -497,8 +497,6 @@ package body Ch5 is
                --  Cases of statements starting with an identifier
 
                when Tok_Identifier =>
-                  Check_Bad_Layout;
-
                   --  Save scan pointers and line number in case block label
 
                   Id_Node := Token_Node;
@@ -720,11 +718,21 @@ package body Ch5 is
                         Statement_Required := False;
                      end if;
 
-                  --  If junk after identifier, check if identifier is an
-                  --  instance of an incorrectly spelled keyword. If so, we
-                  --  do nothing. The Bad_Spelling_Of will have reset Token
-                  --  to the appropriate keyword, so the next time round the
-                  --  loop we will process the modified token.
+                  --  If junk after identifier, check if identifier is one of:
+                  --
+                  --  - An instance of an incorrectly spelled keyword.
+                  --  - One of the non-reserved keywords introduced by GNAT
+                  --    syntax extensions (currently, "finally" is the only
+                  --    such keyword that can occur here).
+                  --
+                  --  In the incorrect spelling case, we do nothing.
+                  --  Bad_Spelling_Of will have reset Token to the appropriate
+                  --  keyword, so the next time round the loop we will process
+                  --  the modified token.
+                  --
+                  --  In the non-reserved keyword case, we replace the
+                  --  identifier token with a token for the appropriate
+                  --  keyword.
                   --
                   --  Note that we check for ELSIF before ELSE here, because
                   --  we don't want to identify a misspelling of ELSE as ELSIF,
@@ -758,8 +766,14 @@ package body Ch5 is
                        or else Bad_Spelling_Of (Tok_While)
                      then
                         null;
+                     elsif Token_Name = Name_Finally then
+                        Error_Msg_GNAT_Extension
+                          ("the finally construct", Token_Ptr);
+                        Token := Tok_Finally;
+                        exit;
 
-                     --  If not a bad spelling, then we really have junk
+                     --  If not a bad spelling or non-reserved keyword, then we
+                     --  really have junk.
 
                      else
                         Scan; -- past identifier again
@@ -786,6 +800,8 @@ package body Ch5 is
                      end if;
                   end if;
 
+                  Check_Bad_Layout_At (Scan_State_Label);
+
                --  Statement starting with operator symbol. This could be
                --  a call, a name starting an assignment, or a qualified
                --  expression.
--- a/src/gcc/ada/par-util.adb
+++ b/src/gcc/ada/par-util.adb
@@ -197,6 +197,19 @@ package body Util is
       end if;
    end Check_Bad_Layout;
 
+   -------------------------
+   -- Check_Bad_Layout_At --
+   -------------------------
+
+   procedure Check_Bad_Layout_At (Scan_State : Saved_Scan_State) is
+      S : Saved_Scan_State;
+   begin
+      Save_Scan_State (S);
+      Restore_Scan_State (Scan_State);
+      Check_Bad_Layout;
+      Restore_Scan_State (S);
+   end Check_Bad_Layout_At;
+
    --------------------------
    -- Check_Future_Keyword --
    --------------------------
@@ -230,14 +243,6 @@ package body Util is
          end if;
       end if;
 
-      if Ada_Version < Ada_With_All_Extensions then
-         if Token_Name in GNAT_Extensions_Reserved_Words then
-            Error_Msg_N
-              ("& is a reserved word with all extensions enabled?",
-               Token_Node);
-         end if;
-      end if;
-
       --  Note: we deliberately do not emit these warnings when operating in
       --  Ada 83 mode because in that case we assume the user is building
       --  legacy code anyway and is not interested in updating Ada versions.
--- a/src/gcc/ada/par.adb
+++ b/src/gcc/ada/par.adb
@@ -839,10 +839,10 @@ function Par (Configuration_Pragmas : Boolean) return List_Id is
 
       function P_Expression_If_OK return Node_Id;
       --  Scans out an expression allowing an unparenthesized case expression,
-      --  if expression, or quantified expression to appear without enclosing
-      --  parentheses. However, if such an expression is not preceded by a left
-      --  paren, and followed by a right paren, an error message will be output
-      --  noting that parenthesization is required.
+      --  if expression, quantified expression, or declare expression to appear
+      --  without enclosing parentheses. However, if such an expression is not
+      --  preceded by a left paren, and followed by a right paren, an error
+      --  message will be output noting that parenthesization is required.
 
       function P_Expression_No_Right_Paren return Node_Id;
       --  Scans out an expression in contexts where the expression cannot be
@@ -1324,6 +1324,9 @@ function Par (Configuration_Pragmas : Boolean) return List_Id is
       --  is exdented from the current expected end column, and if so an
       --  error message is generated.
 
+      procedure Check_Bad_Layout_At (Scan_State : Saved_Scan_State);
+      --  Same as Check_Bad_Layout with Scan_State as the current scan state
+
       procedure Check_Misspelling_Of (T : Token_Type);
       pragma Inline (Check_Misspelling_Of);
       --  This is similar to the function above, except that it does not
--- a/src/gcc/ada/scans.adb
+++ b/src/gcc/ada/scans.adb
@@ -134,9 +134,6 @@ package body Scans is
       --  Ada 2012 reserved words
 
       Set_Reserved (Name_Some, Tok_Some);
-
-      --  GNAT extensions reserved words
-      Set_Reserved (Name_Finally, Tok_Finally);
    end Initialize_Ada_Keywords;
 
    ------------------
--- a/src/gcc/ada/sem_aggr.adb
+++ b/src/gcc/ada/sem_aggr.adb
@@ -2581,7 +2581,10 @@ package body Sem_Aggr is
                         Analyze (Choice);
 
                         if Is_Object_Reference (Choice)
-                          and then Is_Iterator (Etype (Choice))
+                          and then (Is_Iterator (Etype (Choice))
+                                     or else
+                                       Has_Aspect
+                                         (Etype (Choice), Aspect_Iterable))
                         then
                            Set_Iterator_Specification
                              (Assoc,
@@ -2700,17 +2703,21 @@ package body Sem_Aggr is
                        ("(Ada 83) illegal context for OTHERS choice", N);
                   end if;
 
-               elsif Is_Entity_Name (Choice) then
+               else
                   Analyze (Choice);
 
-                  declare
-                     E      : constant Entity_Id := Entity (Choice);
-                     New_Cs : List_Id;
-                     P      : Node_Id;
-                     C      : Node_Id;
+                  if Is_Entity_Name (Choice)
+                    and then Is_Type (Entity (Choice))
+                    and then Has_Predicates (Entity (Choice))
+                  then
+                     declare
+                        E : constant Entity_Id := Entity (Choice);
 
-                  begin
-                     if Is_Type (E) and then Has_Predicates (E) then
+                        C : Node_Id;
+                        L : List_Id;
+                        P : Node_Id;
+
+                     begin
                         Freeze_Before (N, E);
 
                         if Has_Dynamic_Predicate_Aspect (E)
@@ -2734,19 +2741,19 @@ package body Sem_Aggr is
                         if Present (Static_Discrete_Predicate (E)) then
                            Delete_Choice := True;
 
-                           New_Cs := New_List;
+                           L := New_List;
                            P := First (Static_Discrete_Predicate (E));
                            while Present (P) loop
                               C := New_Copy (P);
                               Set_Sloc (C, Sloc (Choice));
-                              Append_To (New_Cs, C);
+                              Append_To (L, C);
                               Next (P);
                            end loop;
 
-                           Insert_List_After (Choice, New_Cs);
+                           Insert_List_After (Choice, L);
                         end if;
-                     end if;
-                  end;
+                     end;
+                  end if;
                end if;
 
                Nb_Choices := Nb_Choices + 1;
@@ -2873,8 +2880,8 @@ package body Sem_Aggr is
 
                   --  Test for subtype mark without constraint
 
-                  elsif Is_Entity_Name (Choice) and then
-                    Is_Type (Entity (Choice))
+                  elsif Is_Entity_Name (Choice)
+                    and then Is_Type (Entity (Choice))
                   then
                      if Base_Type (Entity (Choice)) /= Index_Base then
                         Error_Msg_N
@@ -4520,7 +4527,7 @@ package body Sem_Aggr is
             Choice := First (Choice_List (Assoc));
             while Present (Choice) loop
                if Is_Deep_Choice (Choice, Typ) then
-                  pragma Assert (All_Extensions_Allowed);
+                  pragma Assert (Core_Extensions_Allowed);
                   Deep_Choice_Seen := True;
 
                   --  a deep delta aggregate
@@ -4796,7 +4803,8 @@ package body Sem_Aggr is
             Deep_Choice := Nkind (Choice) /= N_Identifier;
             if Deep_Choice then
                Error_Msg_GNAT_Extension
-                 ("deep delta aggregate", Sloc (Choice));
+                 ("deep delta aggregate", Sloc (Choice),
+                  Is_Core_Extension => True);
             end if;
 
             Comp_Type := Get_Component_Type
--- a/src/gcc/ada/sem_attr.adb
+++ b/src/gcc/ada/sem_attr.adb
@@ -37,6 +37,7 @@ with Elists;         use Elists;
 with Errout;         use Errout;
 with Eval_Fat;
 with Exp_Dist;       use Exp_Dist;
+with Exp_Put_Image;  use Exp_Put_Image;
 with Exp_Util;       use Exp_Util;
 with Expander;       use Expander;
 with Freeze;         use Freeze;
@@ -8096,6 +8097,10 @@ package body Sem_Attr is
       function Mantissa return Uint;
       --  Returns the Mantissa value for the prefix type
 
+      procedure Fold_Compile_Time_Known_Enumeration_Image (Expr : Node_Id);
+      --  Folds 'Image of a compile-time known enumeration value into a string
+      --  literal whose contents depend on whether names are available.
+
       procedure Set_Bounds;
       --  Used for First, Last and Length attributes applied to an array or
       --  array subtype. Sets the variables Lo_Bound and Hi_Bound to the low
@@ -8193,6 +8198,37 @@ package body Sem_Attr is
            Compile_Time_Known_Value (Type_High_Bound (Typ));
       end Compile_Time_Known_Bounds;
 
+      -----------------------------------------------
+      -- Fold_Compile_Time_Known_Enumeration_Image --
+      -----------------------------------------------
+
+      procedure Fold_Compile_Time_Known_Enumeration_Image (Expr : Node_Id) is
+         Lit : constant Entity_Id := Expr_Value_E (Expr);
+         Typ : constant Entity_Id := First_Subtype (Etype (Expr));
+
+      begin
+         pragma Assert (Ekind (Lit) = E_Enumeration_Literal);
+
+         Start_String;
+
+         --  If Discard_Names is in effect for the type, either specifically
+         --  or globally, then we emit the numeric representation of the 'Pos
+         --  attribute of the enumeration literal with a leading space.
+
+         if Discard_Names (Typ) or else Global_Discard_Names then
+            UI_Image (Enumeration_Pos (Lit), Decimal);
+            Store_String_Char  (' ');
+            Store_String_Chars (UI_Image_Buffer (1 .. UI_Image_Length));
+         else
+            Get_Unqualified_Decoded_Name_String (Chars (Lit));
+            Set_Casing (All_Upper_Case);
+            Store_String_Chars (Name_Buffer (1 .. Name_Len));
+         end if;
+
+         Rewrite (N, Make_String_Literal (Loc, Strval => End_String));
+         Analyze_And_Resolve (N, Standard_String);
+      end Fold_Compile_Time_Known_Enumeration_Image;
+
       ----------------
       -- Fore_Value --
       ----------------
@@ -8478,43 +8514,20 @@ package body Sem_Attr is
 
       --  Attribute 'Img applied to a static enumeration value is static, and
       --  we will do the folding right here (things get confused if we let this
-      --  case go through the normal circuitry).
-
-      if Id = Attribute_Img
-        and then Is_Entity_Name (P)
-        and then Is_Enumeration_Type (Etype (Entity (P)))
-        and then Is_OK_Static_Expression (P)
+      --  case go through the normal circuitry) provided that the default Image
+      --  implementation has not been overridden. Likewise for 'Image applied
+      --  to an object, except that it is never static, see a few lines below.
+
+      if (Id = Attribute_Img
+           or else (Id = Attribute_Image and then Is_Object_Reference (P)))
+        and then Is_Enumeration_Type (Etype (P))
+        and then not Is_Character_Type (Etype (P))
+        and then Compile_Time_Known_Value (P)
+        and then not Image_Must_Call_Put_Image (N)
       then
-         declare
-            Lit : constant Entity_Id := Expr_Value_E (P);
-            Typ : constant Entity_Id := Etype (Entity (P));
-            Str : String_Id;
-
-         begin
-            Start_String;
-
-            --  If Discard_Names is in effect for the type, then we emit the
-            --  numeric representation of the prefix literal 'Pos attribute,
-            --  prefixed with a single space.
-
-            if Discard_Names (Typ) then
-               UI_Image (Enumeration_Pos (Lit), Decimal);
-               Store_String_Char  (' ');
-               Store_String_Chars (UI_Image_Buffer (1 .. UI_Image_Length));
-            else
-               Get_Unqualified_Decoded_Name_String (Chars (Lit));
-               Set_Casing (All_Upper_Case);
-               Store_String_Chars (Name_Buffer (1 .. Name_Len));
-            end if;
-
-            Str := End_String;
-
-            Rewrite (N, Make_String_Literal (Loc, Strval => Str));
-            Analyze_And_Resolve (N, Standard_String);
-            Set_Is_Static_Expression (N, True);
-         end;
-
-         return;
+         Fold_Compile_Time_Known_Enumeration_Image (P);
+         Set_Is_Static_Expression
+           (N, Id = Attribute_Img and then Is_OK_Static_Expression (P));
       end if;
 
       --  Special processing for cases where the prefix is an object or value,
@@ -9716,32 +9729,19 @@ package body Sem_Attr is
       -- Image --
       -----------
 
-      --  Image is a scalar attribute, but is never static, because it is
-      --  not a static function (having a non-scalar argument (RM 4.9(22)).
+      --  Image is a scalar attribute, but is never static, because it is not
+      --  a static function (as having a non-scalar result type (RM 4.9(22)).
       --  However, we can constant-fold the image of an enumeration literal
-      --  if names are available and default Image implementation has not
-      --  been overridden.
+      --  if the default Image implementation has not been overridden.
 
       when Attribute_Image =>
-         if Is_Entity_Name (E1)
-           and then Ekind (Entity (E1)) = E_Enumeration_Literal
-           and then not Discard_Names (First_Subtype (Etype (E1)))
-           and then not Global_Discard_Names
-           and then not Has_Aspect (Etype (E1), Aspect_Put_Image)
+         if Is_Enumeration_Type (Etype (P))
+           and then not Is_Character_Type (Etype (P))
+           and then Compile_Time_Known_Value (E1)
+           and then not Image_Must_Call_Put_Image (N)
          then
-            declare
-               Lit : constant Entity_Id := Entity (E1);
-               Str : String_Id;
-            begin
-               Start_String;
-               Get_Unqualified_Decoded_Name_String (Chars (Lit));
-               Set_Casing (All_Upper_Case);
-               Store_String_Chars (Name_Buffer (1 .. Name_Len));
-               Str := End_String;
-               Rewrite (N, Make_String_Literal (Loc, Strval => Str));
-               Analyze_And_Resolve (N, Standard_String);
-               Set_Is_Static_Expression (N, False);
-            end;
+            Fold_Compile_Time_Known_Enumeration_Image (E1);
+            Set_Is_Static_Expression (N, False);
          end if;
 
       -------------------
--- a/src/gcc/ada/sem_ch12.adb
+++ b/src/gcc/ada/sem_ch12.adb
@@ -3200,9 +3200,9 @@ package body Sem_Ch12 is
          end if;
       end if;
 
-      if Subtype_Mark (Def) in Empty | Error then
+      if not Is_Entity_Name (Subtype_Mark (Def)) then
          pragma Assert (Serious_Errors_Detected > 0);
-         --  avoid passing bad argument to Entity
+         --  Avoid passing bad argument to Entity
          return;
       end if;
 
--- a/src/gcc/ada/sem_ch13.adb
+++ b/src/gcc/ada/sem_ch13.adb
@@ -3734,7 +3734,7 @@ package body Sem_Ch13 is
                   then
                      Delay_Required := False;
 
-                  --  For Unsigned_Base_Range aspect, do not delay becase we
+                  --  For Unsigned_Base_Range aspect, do not delay because we
                   --  need to process it before any type or subtype derivation
                   --  is analyzed.
 
@@ -5505,10 +5505,17 @@ package body Sem_Ch13 is
                      goto Continue;
 
                   --  GNAT Core Extension: Checks for this aspect are performed
-                  --  when the corresponding pragma is analyzed.
+                  --  when the corresponding pragma is analyzed; if aspect has
+                  --  no effect, pragma generation is skipped.
 
                   elsif A_Id = Aspect_Unsigned_Base_Range then
-                     null;
+                     if Present (Expr) then
+                        Analyze_And_Resolve (Expr, Standard_Boolean);
+
+                        if Is_False (Static_Boolean (Expr)) then
+                           goto Continue;
+                        end if;
+                     end if;
 
                   --  Ada 2022 (AI12-0279)
 
@@ -17864,10 +17871,14 @@ package body Sem_Ch13 is
       end if;
 
       Error_Msg_N
-        ("finalizable primitive must be local procedure whose only formal " &
+        ("subprogram must denote primitive procedure whose only formal " &
          "parameter has mode `IN OUT` and is of the finalizable type", N);
    end Resolve_Finalizable_Argument;
 
+   ------------------------------------
+   -- Resolve_Finalization_Procedure --
+   ------------------------------------
+
    function Resolve_Finalization_Procedure
      (N   : Node_Id;
       Typ : Entity_Id)
@@ -17884,6 +17895,7 @@ package body Sem_Ch13 is
       begin
          return Ekind (E) = E_Procedure
            and then Scope (E) = Scope (Typ)
+           and then Is_Primitive (E)
            and then Present (First_Formal (E))
            and then Ekind (First_Formal (E)) = E_In_Out_Parameter
            and then Etype (First_Formal (E)) = Typ
@@ -18224,7 +18236,9 @@ package body Sem_Ch13 is
 
       begin
          if not Is_Overloaded (Subp_Id) then
-            if not Pred (Entity (Subp_Id)) then
+            if not Is_Entity_Name (Subp_Id)
+              or else not Pred (Entity (Subp_Id))
+            then
                Error_Msg_NE
                  ("improper aggregate operation for&", Subp_Id, Typ);
             end if;
--- a/src/gcc/ada/sem_ch3.adb
+++ b/src/gcc/ada/sem_ch3.adb
@@ -3197,12 +3197,22 @@ package body Sem_Ch3 is
    begin
       if Present (Aspect_Specifications (Parent (Def))) then
          declare
-            Asp : Node_Id;
+            Asp  : Node_Id;
+            Expr : Node_Id;
+
          begin
             Asp := First (Aspect_Specifications (Parent (Def)));
             while Present (Asp) loop
                if Chars (Identifier (Asp)) = Name_Unsigned_Base_Range then
-                  Is_Unsigned_Base_Range_Type_Decl := True;
+                  Expr := Expression (Asp);
+
+                  if Present (Expr) then
+                     Analyze_And_Resolve (Expr, Standard_Boolean);
+                  end if;
+
+                  Is_Unsigned_Base_Range_Type_Decl :=
+                    No (Expression (Asp))
+                      or else Is_True (Static_Boolean (Expr));
                   exit;
                end if;
 
@@ -4865,6 +4875,19 @@ package body Sem_Ch3 is
               ("formal parameter cannot be implicitly converted to "
                & "class-wide type when Extensions_Visible is False", E);
          end if;
+
+         --  Cannot invoke a C++ constructor in the return statement of
+         --  a function with foreign convention, because the extra formal
+         --  BIP_Object_Access is not available.
+
+         if Is_CPP_Constructor_Call (E)
+           and then Is_Return_Object (Id)
+           and then Has_Foreign_Convention (Return_Applies_To (Scope (Id)))
+         then
+            Error_Msg_N
+              ("C++ constructor call in return statement of "
+               &  "function with foreign convention", E);
+         end if;
       end if;
 
       --  If the No_Streams restriction is set, check that the type of the
@@ -5782,6 +5805,8 @@ package body Sem_Ch3 is
          Set_Treat_As_Volatile (Id, Treat_As_Volatile (T));
          Set_Is_Generic_Type (Id, Is_Generic_Type (Base_Type (T)));
          Set_Convention (Id, Convention (T));
+         Set_Linker_Section_Pragma
+           (Id, Linker_Section_Pragma (Base_Type (T)));
       end Copy_Parent_Attributes;
 
    --  Start of processing for Analyze_Subtype_Declaration
@@ -6021,6 +6046,7 @@ package body Sem_Ch3 is
                   Set_No_Tagged_Streams_Pragma
                                         (Id, No_Tagged_Streams_Pragma (T));
                   Set_Is_Abstract_Type  (Id, Is_Abstract_Type (T));
+                  Set_Is_CPP_Class      (Id, Is_CPP_Class (T));
                   Set_Class_Wide_Type   (Id, Class_Wide_Type (T));
 
                   if Is_Interface (T) then
@@ -10115,6 +10141,13 @@ package body Sem_Ch3 is
       Set_Has_Primitive_Operations
         (Derived_Type, Has_Primitive_Operations (Parent_Base));
 
+      if Ekind (Derived_Type) = E_Record_Type then
+         Set_Is_Unchecked_Union
+           (Derived_Type, Is_Unchecked_Union (Parent_Base));
+         Set_Has_Unchecked_Union
+           (Derived_Type, Has_Unchecked_Union (Parent_Base));
+      end if;
+
       --  Set fields for private derived types
 
       if Is_Private_Type (Derived_Type) then
@@ -19185,7 +19218,7 @@ package body Sem_Ch3 is
          --  of discriminated private type without a full view.
 
          else
-            Insert_Actions (Obj_Def, Freeze_Entity (Base_Type (T), P));
+            Freeze_Before (Obj_Def, Base_Type (T));
          end if;
 
       --  Ada 2005 AI-406: the object definition in an object declaration
@@ -19245,6 +19278,11 @@ package body Sem_Ch3 is
 
       else
          Find_Type (S);
+         if not Is_Entity_Name (S) then
+            pragma Assert (Serious_Errors_Detected > 0);
+            --  Avoid passing bad argument to Entity
+            return Any_Type;
+         end if;
          Typ := Entity (S);
       end if;
 
@@ -19964,6 +20002,11 @@ package body Sem_Ch3 is
          if not Is_Tagged then
             Append_Elmt (Old_C, Assoc_List);
             Append_Elmt (New_C, Assoc_List);
+
+            if Plain_Discrim then
+               Append_Elmt (Discriminal (Old_C), Assoc_List);
+               Append_Elmt (Discriminal (New_C), Assoc_List);
+            end if;
          end if;
       end Inherit_Component;
 
--- a/src/gcc/ada/sem_ch4.adb
+++ b/src/gcc/ada/sem_ch4.adb
@@ -2482,6 +2482,8 @@ package body Sem_Ch4 is
          Error_Msg_N ("object renaming or constant declaration expected", A);
       end Check_Action_OK;
 
+      --  Local variables
+
       A        : Node_Id;
       EWA_Scop : Entity_Id;
 
@@ -2497,6 +2499,8 @@ package body Sem_Ch4 is
       Set_Parent (EWA_Scop, N);
       Push_Scope (EWA_Scop);
 
+      Set_Scope_Link (N, EWA_Scop);
+
       --  If this Expression_With_Actions node comes from source, then it
       --  represents a declare_expression; increment the counter to take note
       --  of that.
@@ -2514,11 +2518,13 @@ package body Sem_Ch4 is
 
       Analyze_Expression (Expression (N));
       Set_Etype (N, Etype (Expression (N)));
-      End_Scope;
 
       if Comes_From_Source (N) then
          In_Declare_Expr := In_Declare_Expr - 1;
       end if;
+
+      pragma Assert (Current_Scope = Scope_Link (N));
+      End_Scope;
    end Analyze_Expression_With_Actions;
 
    ---------------------------
@@ -3062,8 +3068,42 @@ package body Sem_Ch4 is
          Act_List : List_Id;
          Expr     : Node_Id;
          Inst_Id  : Entity_Id;
+         Par      : Node_Id;
+         Prev_Par : Node_Id;
 
       begin
+         Prev_Par := N;
+         Par := Parent (N);
+
+         --  A structural instance cannot be used as a formal package with the
+         --  current implementation of structural instantiation.
+
+         while Present (Par) loop
+            if Nkind (Par) in N_Generic_Declaration
+              and then Is_List_Member (Prev_Par)
+              and then
+                Generic_Formal_Declarations (Par) = List_Containing (Prev_Par)
+            then
+               Error_Msg_N
+                 ("structural instantiation cannot be used in generic formal"
+                  & " part", N);
+               Rewrite (N,
+                 Make_Raise_Program_Error (Sloc (N),
+                   Reason => PE_Explicit_Raise));
+               Analyze (N);
+               return;
+
+            else
+               --  Prevent the search from going too far
+
+               exit when Is_Statement (Par)
+                 or else Is_Body_Or_Package_Declaration (Par);
+            end if;
+
+            Prev_Par := Par;
+            Par := Parent (Par);
+         end loop;
+
          Act_List := New_List;
          Expr := First (Expressions (N));
          while Present (Expr) loop
@@ -4528,9 +4568,36 @@ package body Sem_Ch4 is
       Expr : constant Node_Id   := Expression (N);
       Mark : constant Entity_Id := Subtype_Mark (N);
 
-      I    : Interp_Index;
-      It   : Interp;
-      T    : Entity_Id;
+      function Same_Class_Wide_Type (Typ, CW_Typ : Entity_Id) return Boolean;
+      --  Return whether Typ is the same class-wide type as CW_Typ. This is
+      --  essentially an equality test modulo the Non_Limited_View attribute.
+
+      --------------------------
+      -- Same_Class_Wide_Type --
+      --------------------------
+
+      function Same_Class_Wide_Type (Typ, CW_Typ : Entity_Id) return Boolean is
+         Btyp : constant Entity_Id := Base_Type (Typ);
+
+      begin
+         if Ekind (Btyp) /= E_Class_Wide_Type then
+            return False;
+         end if;
+
+         if Has_Non_Limited_View (Btyp) then
+            return Non_Limited_View (Btyp) = Base_Type (CW_Typ);
+         else
+            return Btyp = Base_Type (CW_Typ);
+         end if;
+      end Same_Class_Wide_Type;
+
+      --  Local variables
+
+      I  : Interp_Index;
+      It : Interp;
+      T  : Entity_Id;
+
+   --  Start of processing for Analyze_Qualified_Expression
 
    begin
       Find_Type (Mark);
@@ -4569,7 +4636,7 @@ package body Sem_Ch4 is
 
       if Is_Class_Wide_Type (T) then
          if not Is_Overloaded (Expr) then
-            if Base_Type (Etype (Expr)) /= Base_Type (T)
+            if not Same_Class_Wide_Type (Etype (Expr), T)
               and then Etype (Expr) /= Raise_Type
             then
                if Nkind (Expr) = N_Aggregate then
@@ -4583,7 +4650,7 @@ package body Sem_Ch4 is
             Get_First_Interp (Expr, I, It);
 
             while Present (It.Nam) loop
-               if Base_Type (It.Typ) /= Base_Type (T) then
+               if not Same_Class_Wide_Type (It.Typ, T) then
                   Remove_Interp (I);
                end if;
 
@@ -4637,6 +4704,7 @@ package body Sem_Ch4 is
 
       Cond    : constant Node_Id := Condition (N);
       Loc     : constant Source_Ptr := Sloc (N);
+      Filter  : Node_Id;
       Loop_Id : Entity_Id;
       QE_Scop : Entity_Id;
 
@@ -4732,8 +4800,10 @@ package body Sem_Ch4 is
 
       if Present (Iterator_Specification (N)) then
          Loop_Id := Defining_Identifier (Iterator_Specification (N));
+         Filter  := Iterator_Filter (Iterator_Specification (N));
       else
          Loop_Id := Defining_Identifier (Loop_Parameter_Specification (N));
+         Filter  := Iterator_Filter (Loop_Parameter_Specification (N));
       end if;
 
       declare
@@ -4782,11 +4852,17 @@ package body Sem_Ch4 is
       begin
          if Warn_On_Suspicious_Contract
            and then not Is_Internal_Name (Chars (Loop_Id))
+           and then not Has_Junk_Name (Loop_Id)
          then
-            if not Referenced (Loop_Id, Cond) then
-               Error_Msg_N ("?.t?unused variable &", Loop_Id);
-            else
+            --  If there is a filter, then it is less clear whether the loop
+            --  variable is used or not; just ignore this case, for simplicity.
+
+            if Present (Filter) then
+               null;
+            elsif Referenced (Loop_Id, Cond) then
                Check_Subexpr (Cond, Kind => Full);
+            elsif not Is_Trivial_Boolean (Cond) then
+               Error_Msg_N ("?.t?unused variable &", Loop_Id);
             end if;
          end if;
       end;
--- a/src/gcc/ada/sem_ch5.adb
+++ b/src/gcc/ada/sem_ch5.adb
@@ -94,17 +94,6 @@ package body Sem_Ch5 is
    --  statements. On success, the return value is the entity of the loop
    --  referenced by the statement.
 
-   function Has_Sec_Stack_Call (N : Node_Id) return Boolean;
-   --  N is the node for an arbitrary construct. This function searches the
-   --  construct N to see if it contains a function call that returns on the
-   --  secondary stack, returning True if any such call is found, and False
-   --  otherwise.
-
-   --  ??? The implementation invokes Sem_Util.Requires_Transient_Scope so it
-   --  will return True if N contains a function call that needs finalization,
-   --  in addition to the above specification. See Analyze_Loop_Statement for
-   --  a similar comment about this entanglement.
-
    procedure Preanalyze_Range (R_Copy : Node_Id);
    --  Determine expected type of range or domain of iteration of Ada 2012
    --  loop by analyzing separate copy. Do the analysis and resolution of the
--- a/src/gcc/ada/sem_ch5.ads
+++ b/src/gcc/ada/sem_ch5.ads
@@ -52,4 +52,15 @@ package Sem_Ch5 is
    --  checks to see if the statement is followed by some other statement, and
    --  if so generates an appropriate warning for unreachable code.
 
+   function Has_Sec_Stack_Call (N : Node_Id) return Boolean;
+   --  N is the node for an arbitrary construct. This function searches the
+   --  construct N to see if it contains a function call that returns on the
+   --  secondary stack, returning True if any such call is found, and False
+   --  otherwise.
+
+   --  ??? The implementation invokes Sem_Util.Requires_Transient_Scope so it
+   --  will return True if N contains a function call that needs finalization,
+   --  in addition to the above specification. See Analyze_Loop_Statement for
+   --  a similar comment about this entanglement.
+
 end Sem_Ch5;
--- a/src/gcc/ada/sem_ch6.adb
+++ b/src/gcc/ada/sem_ch6.adb
@@ -10930,9 +10930,14 @@ package body Sem_Ch6 is
    procedure Install_Entity (E : Entity_Id) is
       Prev : constant Entity_Id := Current_Entity (E);
    begin
+      if Prev = E then
+         --  avoid creating a Homonym-list cycle
+         pragma Assert (Serious_Errors_Detected > 0);
+         return;
+      end if;
+
       Set_Is_Immediately_Visible (E);
       Set_Current_Entity (E);
-      pragma Assert (Prev /= E);
       Set_Homonym (E, Prev);
    end Install_Entity;
 
--- a/src/gcc/ada/sem_ch8.adb
+++ b/src/gcc/ada/sem_ch8.adb
@@ -8167,7 +8167,8 @@ package body Sem_Ch8 is
                Old_S := Entity (Nam);
             end if;
 
-         elsif Present (First_Formal (Entity (Nam)))
+         elsif Can_Have_Formals (Entity (Nam))
+           and then Present (First_Formal (Entity (Nam)))
            and then Present (First_Formal (New_S))
            and then Base_Type (Etype (First_Formal (Entity (Nam)))) =
                     Base_Type (Etype (First_Formal (New_S)))
--- a/src/gcc/ada/sem_ch9.adb
+++ b/src/gcc/ada/sem_ch9.adb
@@ -2564,7 +2564,7 @@ package body Sem_Ch9 is
          end if;
 
       --  If we had a requeue of the form REQUEUE A (B), then the parser
-      --  accepted it (because it could have been a requeue on an entry index.
+      --  accepted it (because it could have been a requeue on an entry index).
       --  If A turns out not to be an entry family, then the analysis of A (B)
       --  turned it into a function call.
 
--- a/src/gcc/ada/sem_disp.adb
+++ b/src/gcc/ada/sem_disp.adb
@@ -96,6 +96,14 @@ package body Sem_Disp is
    --  Check whether a primitive operation is inherited from an operation
    --  declared in the visible part of its package.
 
+   procedure Override_Dispatching_Operation
+     (Tagged_Type : Entity_Id;
+      Prev_Op     : Entity_Id;
+      New_Op      : Entity_Id);
+   --  Replace an implicit dispatching operation of the type Tagged_Type
+   --  with an explicit one. Prev_Op is an inherited primitive operation which
+   --  is overridden by the explicit declaration of New_Op.
+
    -------------------------------
    -- Add_Dispatching_Operation --
    -------------------------------
@@ -309,7 +317,29 @@ package body Sem_Disp is
          --  Common Ada case
 
          if not Has_First_Controlling_Parameter_Aspect (Typ) then
-            Ctrl_Type := Check_Controlling_Type (Etype (Formal), Subp);
+
+            --  Formals of a type specifying aspect First_Controlling_Parameter
+            --  are not candidate controlling parameters when they are not
+            --  the first formal of the dispatching primitive. For example:
+            --
+            --     type T1 is tagged ...
+            --     type T2 is tagged ... with First_Controlling_Parameter;
+            --     procedure Prim (X : T1; Y : T2);
+            --
+            --  When T2 does not have the First_Controlling_Parameter aspect
+            --  this example is rejected because a primitive can be dispatching
+            --  in only one type. However, T2 cannot be a candidate controlling
+            --  type for Prim because Y is not its first formal. Therefore,
+            --  this example is accepted.
+
+            if Is_Tagged_Type (Etype (Formal))
+              and then Has_First_Controlling_Parameter_Aspect (Etype (Formal))
+              and then Formal /= First_Formal (Subp)
+            then
+               null;
+            else
+               Ctrl_Type := Check_Controlling_Type (Etype (Formal), Subp);
+            end if;
 
          --  Type with the First_Controlling_Parameter aspect: for overriding
          --  primitives of a parent type that lacks this aspect, we cannot be
@@ -336,9 +366,7 @@ package body Sem_Disp is
          end if;
 
          if Present (Ctrl_Type) then
-
-            --  Obtain the full type in case we are looking at an incomplete
-            --  view.
+            --  Use the full view for an incomplete type
 
             if Ekind (Ctrl_Type) = E_Incomplete_Type
               and then Present (Full_View (Ctrl_Type))
@@ -346,8 +374,7 @@ package body Sem_Disp is
                Ctrl_Type := Full_View (Ctrl_Type);
             end if;
 
-            --  When controlling type is concurrent and declared within a
-            --  generic or inside an instance use corresponding record type.
+            --  Use the corresponding record type for a concurrent type
 
             if Is_Concurrent_Type (Ctrl_Type)
               and then Present (Corresponding_Record_Type (Ctrl_Type))
@@ -439,6 +466,22 @@ package body Sem_Disp is
          Ctrl_Type := Check_Controlling_Type (Etype (Subp), Subp);
 
          if Present (Ctrl_Type) then
+            --  Use the full view for an incomplete type
+
+            if Ekind (Ctrl_Type) = E_Incomplete_Type
+              and then Present (Full_View (Ctrl_Type))
+            then
+               Ctrl_Type := Full_View (Ctrl_Type);
+            end if;
+
+            --  Use the corresponding record type for a concurrent type
+
+            if Is_Concurrent_Type (Ctrl_Type)
+              and then Present (Corresponding_Record_Type (Ctrl_Type))
+            then
+               Ctrl_Type := Corresponding_Record_Type (Ctrl_Type);
+            end if;
+
             if Ctrl_Type = Typ then
                Set_Has_Controlling_Result (Subp);
 
@@ -2401,6 +2444,14 @@ package body Sem_Disp is
             return Empty;
          end if;
 
+      --  Deal with controlling function wrappers
+
+      elsif Ekind (Subp) = E_Function
+        and then Has_Controlling_Result (Subp)
+        and then Is_Wrapper (Subp)
+      then
+         return Check_Controlling_Type (Etype (Subp), Subp);
+
       --  General case
 
       else
--- a/src/gcc/ada/sem_disp.ads
+++ b/src/gcc/ada/sem_disp.ads
@@ -173,14 +173,6 @@ package Sem_Disp is
    --  controlling operands are also indeterminate. Such a function call may
    --  inherit a tag from an enclosing call.
 
-   procedure Override_Dispatching_Operation
-     (Tagged_Type : Entity_Id;
-      Prev_Op     : Entity_Id;
-      New_Op      : Entity_Id);
-   --  Replace an implicit dispatching operation of the type Tagged_Type
-   --  with an explicit one. Prev_Op is an inherited primitive operation which
-   --  is overridden by the explicit declaration of New_Op.
-
    procedure Propagate_Tag (Control : Node_Id; Actual : Node_Id);
    --  If a function call given by Actual is tag-indeterminate, its controlling
    --  argument is found in the context, given by Control: either from an
--- a/src/gcc/ada/sem_prag.adb
+++ b/src/gcc/ada/sem_prag.adb
@@ -12708,12 +12708,7 @@ package body Sem_Prag is
 
       --  Deal with unrecognized pragma
 
-      --  Pragma Unsigned_Base_Range temporarily disabled
-
-      if not Is_Pragma_Name (Pname)
-        or else (Pname = Name_Unsigned_Base_Range
-                  and then not Debug_Flag_Dot_U)
-      then
+      if not Is_Pragma_Name (Pname) then
          declare
             Msg_Issued : Boolean := False;
          begin
@@ -29133,6 +29128,10 @@ package body Sem_Prag is
       ----------------------
 
       function Check_References (Nod : Node_Id) return Traverse_Result is
+         CW_Disp_Typ : constant Entity_Id :=
+           (if Present (Disp_Typ)
+             then Class_Wide_Type (Disp_Typ)
+             else Empty);
       begin
          if Nkind (Nod) = N_Function_Call
            and then Is_Entity_Name (Name (Nod))
@@ -29159,7 +29158,7 @@ package body Sem_Prag is
                   --  A return object of the type is illegal as well
 
                   if Etype (Func) = Disp_Typ
-                    or else Etype (Func) = Class_Wide_Type (Disp_Typ)
+                    or else Etype (Func) = CW_Disp_Typ
                   then
                      Error_Msg_NE
                        ("operation in class-wide condition must be primitive "
@@ -29171,7 +29170,7 @@ package body Sem_Prag is
          elsif Is_Entity_Name (Nod)
            and then
              (Etype (Nod) = Disp_Typ
-               or else Etype (Nod) = Class_Wide_Type (Disp_Typ))
+               or else Etype (Nod) = CW_Disp_Typ)
            and then Ekind (Entity (Nod)) in E_Constant | E_Variable
          then
             Error_Msg_NE
@@ -29180,7 +29179,7 @@ package body Sem_Prag is
 
          elsif Nkind (Nod) = N_Explicit_Dereference
            and then (Etype (Nod) = Disp_Typ
-                      or else Etype (Nod) = Class_Wide_Type (Disp_Typ))
+                      or else Etype (Nod) = CW_Disp_Typ)
            and then (not Is_Entity_Name (Prefix (Nod))
                       or else not Is_Formal (Entity (Prefix (Nod))))
          then
--- a/src/gcc/ada/sem_res.adb
+++ b/src/gcc/ada/sem_res.adb
@@ -3772,31 +3772,35 @@ package body Sem_Res is
 
             elsif Ekind (Etype (Nam)) = E_Anonymous_Access_Type
               and then Nkind (Parent (N)) = N_Type_Conversion
-              and then Type_Access_Level (Etype (Parent (N)))
-                         < Static_Accessibility_Level (A, Object_Decl_Level)
+              and then
+                Type_Access_Level (Etype (Parent (N)))
+                  < Static_Accessibility_Level (A, Zero_On_Dynamic_Level)
             then
                Accessibility_Error ("conversion");
 
             elsif Ekind (Etype (Nam)) = E_Anonymous_Access_Type
               and then Nkind (Parent (N)) = N_Assignment_Statement
-              and then Static_Accessibility_Level
-                         (Name (Parent (N)), Object_Decl_Level)
-                           < Static_Accessibility_Level (A, Object_Decl_Level)
+              and then
+                Static_Accessibility_Level
+                  (Name (Parent (N)), Object_Decl_Level)
+                    < Static_Accessibility_Level (A, Zero_On_Dynamic_Level)
             then
                Accessibility_Error ("assignment");
 
             elsif Nkind (Parent (N)) = N_Qualified_Expression
               and then Nkind (Parent (Parent (N))) = N_Allocator
-              and then Type_Access_Level (Etype (Parent (Parent (N))))
-                         < Static_Accessibility_Level (A, Object_Decl_Level)
+              and then
+                Type_Access_Level (Etype (Parent (Parent (N))))
+                  < Static_Accessibility_Level (A, Zero_On_Dynamic_Level)
             then
                Accessibility_Error ("allocator");
 
             elsif In_Return_Value (N)
               and then Comes_From_Source (N)
-              and then Subprogram_Access_Level (Current_Subprogram)
-                         < Static_Accessibility_Level
-                             (A, Object_Decl_Level, In_Return_Context => True)
+              and then
+                Subprogram_Access_Level (Current_Subprogram)
+                  < Static_Accessibility_Level
+                      (A, Zero_On_Dynamic_Level, In_Return_Context => True)
             then
                Accessibility_Error ("return");
             end if;
@@ -7793,6 +7797,22 @@ package body Sem_Res is
    --  Start of processing for Resolve_Declare_Expression
 
    begin
+      --  Create a transient scope if the type of this declare-expression
+      --  or its expression requires it; this must be done before we push
+      --  in the scope stack the scope of this declare expression (in order
+      --  to properly remove it from the stack on exit from this routine).
+      --  Given that we don't know yet if secondary stack management will
+      --  be needed, we assume the worst case.
+
+      if not Preanalysis_Active
+        and then (Requires_Transient_Scope (Typ)
+                    or else Has_Sec_Stack_Call (Expr))
+      then
+         Establish_Transient_Scope (N, Manage_Sec_Stack => True);
+      end if;
+
+      Push_Scope (Scope_Link (N));
+
       Decl := First (Actions (N));
 
       while Present (Decl) loop
@@ -7857,6 +7877,9 @@ package body Sem_Res is
             Next_Elmt (Cursor);
          end loop;
       end;
+
+      pragma Assert (Current_Scope = Scope_Link (N));
+      End_Scope;
    end Resolve_Declare_Expression;
 
    -----------------------------------
--- a/src/gcc/ada/sem_util.adb
+++ b/src/gcc/ada/sem_util.adb
@@ -2796,7 +2796,7 @@ package body Sem_Util is
                if Is_Writable_Actual then
 
                   --  Skip checking the error in non-elementary types since
-                  --  RM 6.4.1(6.15/3) is restricted to elementary types, but
+                  --  RM 6.4.1(6.16/3) is restricted to elementary types, but
                   --  store this actual in Writable_Actuals_List since it is
                   --  needed to perform checks on other constructs that have
                   --  arbitrary order of evaluation (for example, aggregates).
@@ -2954,7 +2954,7 @@ package body Sem_Util is
       --  call C2 (not including the construct C itself), there is no other
       --  name anywhere within a direct constituent of the construct C other
       --  than the one containing C2, that is known to refer to the same
-      --  object (RM 6.4.1(6.17/3)).
+      --  object (RM 6.4.1(6.18/3)).
 
       case Nkind (N) is
          when N_Range =>
@@ -3201,7 +3201,7 @@ package body Sem_Util is
 
                --  For an array aggregate, a discrete_choice_list that has
                --  a nonstatic range is considered as two or more separate
-               --  occurrences of the expression (RM 6.4.1(6.20/3)).
+               --  occurrences of the expression (RM 6.4.1(6.21/3)).
 
                elsif Is_Array_Type (Etype (N))
                  and then Nkind (N) = N_Aggregate
@@ -7047,7 +7047,7 @@ package body Sem_Util is
       --  For renamings, return False if the prefix of any dereference within
       --  the renamed object_name is a variable, or any expression within the
       --  renamed object_name contains references to variables or calls on
-      --  nonstatic functions; otherwise return True (RM 6.4.1(6.10/3))
+      --  nonstatic functions; otherwise return True (RM 6.4.1(6.11/3))
 
       ------------------------
       -- Is_Object_Renaming --
@@ -12493,15 +12493,16 @@ package body Sem_Util is
 
    function Has_Inferable_Discriminants (N : Node_Id) return Boolean is
 
-      function Prefix_Is_Formal_Parameter (N : Node_Id) return Boolean;
-      --  Determines whether the left-most prefix of a selected component is a
-      --  formal parameter in a subprogram. Assumes N is a selected component.
+      function Prefix_Is_Formal_Parameter_Of_EQ (N : Node_Id) return Boolean;
+      --  Determines whether the left-most prefix of selected component N
+      --  is a formal parameter of the predefined equality function of an
+      --  Unchecked_Union type.
 
-      --------------------------------
-      -- Prefix_Is_Formal_Parameter --
-      --------------------------------
+      --------------------------------------
+      -- Prefix_Is_Formal_Parameter_Of_EQ --
+      --------------------------------------
 
-      function Prefix_Is_Formal_Parameter (N : Node_Id) return Boolean is
+      function Prefix_Is_Formal_Parameter_Of_EQ (N : Node_Id) return Boolean is
          Sel_Comp : Node_Id;
 
       begin
@@ -12514,8 +12515,10 @@ package body Sem_Util is
             Sel_Comp := Parent (Sel_Comp);
          end loop;
 
-         return Is_Formal (Entity (Prefix (Sel_Comp)));
-      end Prefix_Is_Formal_Parameter;
+         return Is_Formal (Entity (Prefix (Sel_Comp)))
+           and then
+             Is_Unchecked_Union_Equality (Scope (Entity (Prefix (Sel_Comp))));
+      end Prefix_Is_Formal_Parameter_Of_EQ;
 
    --  Start of processing for Has_Inferable_Discriminants
 
@@ -12533,14 +12536,14 @@ package body Sem_Util is
             return False;
          end if;
 
-         --  A small hack. If we have a per-object constrained selected
-         --  component of a formal parameter, return True since we do not
-         --  know the actual parameter association yet.
+         --  We need to return True for the component of a formal parameter
+         --  of the predefined equality function of an Unchecked_Union type
+         --  when expanding it (see Expand_Unchecked_Union_Equality).
 
          return not Has_Per_Object_Constraint (Entity (Selector_Name (N)))
            or else not Is_Unchecked_Union (Etype (Prefix (N)))
            or else Has_Inferable_Discriminants (Prefix (N))
-           or else Prefix_Is_Formal_Parameter (N);
+           or else Prefix_Is_Formal_Parameter_Of_EQ (N);
 
       --  A qualified expression has inferable discriminants if its subtype
       --  mark is a constrained Unchecked_Union subtype.
@@ -14921,34 +14924,20 @@ package body Sem_Util is
 
    function In_Reverse_Storage_Order_Object (N : Node_Id) return Boolean is
       Pref : Node_Id;
-      Btyp : Entity_Id := Empty;
+      Btyp : Entity_Id;
 
    begin
-      --  Climb up indexed components
-
-      Pref := N;
-      loop
-         case Nkind (Pref) is
-            when N_Selected_Component =>
-               Pref := Prefix (Pref);
-               exit;
+      if Nkind (N) in N_Indexed_Component | N_Selected_Component then
+         Pref := Prefix (N);
+         Btyp := Base_Type (Etype (Pref));
 
-            when N_Indexed_Component =>
-               Pref := Prefix (Pref);
+         return Present (Btyp)
+           and then (Is_Record_Type (Btyp) or else Is_Array_Type (Btyp))
+           and then Reverse_Storage_Order (Btyp);
 
-            when others =>
-               Pref := Empty;
-               exit;
-         end case;
-      end loop;
-
-      if Present (Pref) then
-         Btyp := Base_Type (Etype (Pref));
+      else
+         return False;
       end if;
-
-      return Present (Btyp)
-        and then (Is_Record_Type (Btyp) or else Is_Array_Type (Btyp))
-        and then Reverse_Storage_Order (Btyp);
    end In_Reverse_Storage_Order_Object;
 
    ------------------------------
@@ -25946,7 +25935,19 @@ package body Sem_Util is
 
          if Reporting then
             if Is_Entity_Name (Name (N)) then
-               Error_Msg_N ("too many arguments in call to&", Name (N));
+               if Ekind (S) = E_Enumeration_Literal then
+                  Error_Msg_N ("cannot index enumeration literal &", Name (N));
+                  if Present (Homonym (S))
+                    and then Sloc (Homonym (S)) = Standard_Location
+                  then
+                     Error_Msg_NE
+                       ("\\did you mean & in Standard'?",
+                        Name (N),
+                        Homonym (S));
+                  end if;
+               else
+                  Error_Msg_N ("too many arguments in call to&", Name (N));
+               end if;
             else
                Error_Msg_N ("too many arguments in call", N);
             end if;
@@ -29339,13 +29340,21 @@ package body Sem_Util is
                return False;
             end if;
 
+            --  Reject for example subprogram calls in object notation
+
+            if Ekind (Entity (Selector_Name (N))) not in E_Component
+                                                       | E_Discriminant
+            then
+               return False;
+            end if;
+
             declare
                Comp : constant Entity_Id :=
                  Original_Record_Component (Entity (Selector_Name (N)));
             begin
-              --  AI12-0373 confirms that we should not call
-              --  Has_Discriminant_Dependent_Constraint here which would be
-              --  too strong.
+               --  AI12-0373 confirms that we should not call
+               --  Has_Discriminant_Dependent_Constraint here,
+               --  which would be too strong.
 
                if Is_Declared_Within_Variant (Comp) then
                   return False;
--- a/src/gcc/ada/sem_util.ads
+++ b/src/gcc/ada/sem_util.ads
@@ -711,7 +711,7 @@ package Sem_Util is
 
    function Denotes_Same_Object (A1, A2 : Node_Id) return Boolean;
    --  Detect suspicious overlapping between actuals in a call, when both are
-   --  writable (RM 2012 6.4.1(6.4/3)).
+   --  writable (RM 2012 6.4.1(6.5/3)).
 
    function Denotes_Same_Prefix (A1, A2 : Node_Id) return Boolean;
    --  Functions to detect suspicious overlapping between actuals in a call,
@@ -1760,8 +1760,8 @@ package Sem_Util is
    --  result of the enclosing function.
 
    function In_Reverse_Storage_Order_Object (N : Node_Id) return Boolean;
-   --  Returns True if N denotes a component or subcomponent in a record or
-   --  array that has Reverse_Storage_Order.
+   --  Returns True if N denotes a component in an array or a record that has
+   --  Reverse_Storage_Order.
 
    function In_Same_Declarative_Part
      (Context : Node_Id;
--- a/src/gcc/ada/sem_warn.adb
+++ b/src/gcc/ada/sem_warn.adb
@@ -3920,7 +3920,7 @@ package body Sem_Warn is
       --  known to refer to the same object as the other name; or one of the
       --  two names statically denotes a renaming declaration whose renamed
       --  object_name is known to refer to the same object as the other name
-      --  (RM 6.4.1(6.11/3))
+      --  (RM 6.4.1(6.12/3))
 
       -----------------------------
       -- Explicitly_By_Reference --
@@ -3979,7 +3979,7 @@ package body Sem_Warn is
       --  of an elementary type, then the call is legal only if for each name
       --  N that is passed as a parameter of mode in out or out to the call C,
       --  there is no other name among the other parameters of mode in out or
-      --  out to C that is known to denote the same object (RM 6.4.1(6.15/3))
+      --  out to C that is known to denote the same object (RM 6.4.1(6.16/3))
       --  This has been clarified in AI12-0216 to indicate that the illegality
       --  only occurs if both formals are of an elementary type, because of the
       --  nondeterminism on the write-back of the corresponding actuals.
@@ -4422,6 +4422,7 @@ package body Sem_Warn is
             if Is_Formal (Ent)
               and then Is_Suspicious_Type (Typ)
               and then not Low_Bound_Tested (Ent)
+              and then Comes_From_Source (Ent)
             then
                Test_Suspicious_Index;
             end if;
--- a/src/gcc/ada/sinfo.ads
+++ b/src/gcc/ada/sinfo.ads
@@ -2265,6 +2265,11 @@ package Sinfo is
    --    scope all use this field to reference the corresponding scope entity.
    --    See Einfo for further details.
 
+   --  Scope_Link
+   --    Present in N_Expression_With_Actions nodes. References the internally
+   --    built scope created to provide proper visibility of the declare_items
+   --    to the expander.
+
    --  Selector_Name
    --    Present in N_Expanded_Name N_Selected_Component,
    --    N_Generic_Association, and N_Parameter_Association nodes.
@@ -8103,6 +8108,7 @@ package Sinfo is
       --  N_Expression_With_Actions
       --  Actions
       --  Expression
+      --  Scope_Link
       --  plus fields for expression
 
       --  Note: In the final generated tree presented to the code generator,
--- a/src/gcc/ada/sinput.ads
+++ b/src/gcc/ada/sinput.ads
@@ -46,13 +46,13 @@
 --    significance, but they are significant for error reporting purposes,
 --    since errors are identified by line and column location.
 
---  In GNAT, a physical line is ended by any of the sequences LF, CR/LF, or
---  CR. LF is used in typical Unix systems, CR/LF in DOS systems, and CR
---  alone in System 7. In addition, we recognize any of these sequences in
+--  In GNAT, a physical line is ended by any of the sequences CR, LF, or CR/LF.
+--  CR is used in some MAC systems, LF is used in Unix systems, and CR/LF in
+--  DOS/Windows systems. In addition, we recognize any of these sequences in
 --  any of the operating systems, for better behavior in treating foreign
 --  files (e.g. a Unix file with LF terminators transferred to a DOS system).
 --  Finally, wide character codes in categories Separator, Line and Separator,
---  Paragraph are considered to be physical line terminators.
+--  Paragraph are considered to be logical line terminators.
 
 with Alloc;
 with Casing; use Casing;
--- a/src/gcc/ada/snames.adb-tmpl
+++ b/src/gcc/ada/snames.adb-tmpl
@@ -458,9 +458,7 @@ package body Snames is
                    --  for compatibility with Ada 95 compilers implementing
                    --  only this Ada 2005 extension.
         and then (Ada_Version >= Ada_2012
-                   or else N not in Ada_2012_Reserved_Words)
-        and then (Ada_Version >= Ada_With_All_Extensions
-                   or else N not in GNAT_Extensions_Reserved_Words);
+                   or else N not in Ada_2012_Reserved_Words);
    end Is_Keyword_Name;
 
    --------------------------------
--- a/src/gcc/ada/snames.ads-tmpl
+++ b/src/gcc/ada/snames.ads-tmpl
@@ -1406,6 +1406,7 @@ package Snames is
 
    Name_Synchronous_Task_Control         : constant Name_Id := N + $;
    Name_Continue                         : constant Name_Id := N + $;
+   Name_Finally                          : constant Name_Id := N + $;
 
    --  Names used to implement iterators over predefined containers
 
@@ -1454,16 +1455,6 @@ package Snames is
    subtype Ada_2012_Reserved_Words is Name_Id
      range First_2012_Reserved_Word .. Last_2012_Reserved_Word;
 
-   --  GNAT extensions reserved words
-
-   First_GNAT_Extensions_Reserved_Word   : constant Name_Id := N + $;
-   Name_Finally                          : constant Name_Id := N + $;
-   Last_GNAT_Extensions_Reserved_Word    : constant Name_Id := N + $;
-
-   subtype GNAT_Extensions_Reserved_Words is Name_Id
-     range First_GNAT_Extensions_Reserved_Word ..
-       Last_GNAT_Extensions_Reserved_Word;
-
    --  Mark last defined name for consistency check in Snames body
 
    Last_Predefined_Name                  : constant Name_Id := N + $;
--- a/src/gcc/ada/sysdep.c
+++ b/src/gcc/ada/sysdep.c
@@ -394,7 +394,7 @@ getc_immediate_common (FILE *stream,
     || defined (__Lynx__) || defined (__FreeBSD__) || defined (__OpenBSD__) \
     || defined (__GLIBC__) || defined (__APPLE__) || defined (__DragonFly__) \
     || defined (__QNX__)
-  char c;
+  unsigned char c;
   int nread;
   int good_one = 0;
   int eof_ch = 4; /* Ctrl-D */
@@ -512,7 +512,7 @@ getc_immediate_common (FILE *stream,
   struct fd_set readFds;
   /* Timeout before select returns if nothing can be read.  */
   struct timeval timeOut;
-  char c;
+  unsigned char c;
   int fd = fileno (stream);
   int nread;
   int option;
--- a/src/gcc/algol68/ChangeLog
+++ b/src/gcc/algol68/ChangeLog
@@ -1,3 +1,10 @@
+2026-05-01  Peter Damianov  <peter0x44@disroot.org>
+
+	Backported from master:
+	2026-05-01  Peter Damianov  <peter0x44@disroot.org>
+
+	* Make-lang.in: Correct typo exeect -> exeext
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/algol68/Make-lang.in
+++ b/src/gcc/algol68/Make-lang.in
@@ -219,7 +219,7 @@ ga68.pod: algol68/ga68.texi
 algol68.srcextra:
 
 algol68.all.cross: ga68$(exeext)
-algol68.start.encap: ga68$(exeect)
+algol68.start.encap: ga68$(exeext)
 algol68.rest.encap:
 algol68.info: doc/ga68.info doc/ga68-internals.info doc/ga68-coding-guidelines.info
 algol68.dvi: doc/ga68.dvi doc/ga68-internals.dvi doc/ga68-coding-guidelines.dvi
--- a/src/gcc/c/ChangeLog
+++ b/src/gcc/c/ChangeLog
@@ -1,3 +1,10 @@
+2026-05-15  Andi Kleen  <ak@gcc.gnu.org>
+
+	PR c/124532
+	* c-parser.cc (struct attr_state): Add reset method.
+	(c_parser_compound_statement_nostart): Rename a to astate.
+	Reset state before iterating statements.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/c/c-parser.cc
+++ b/src/gcc/c/c-parser.cc
@@ -1795,6 +1795,8 @@ struct attr_state
 {
   /* True if we parsed a musttail attribute for return.  */
   bool musttail_p;
+
+  void reset () { musttail_p = false; }
 };
 
 static bool c_parser_nth_token_starts_std_attributes (c_parser *,
@@ -7648,7 +7650,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
   bool in_omp_loop_block
     = omp_for_parse_state ? omp_for_parse_state->want_nested_loop : false;
   tree sl = NULL_TREE;
-  attr_state a = {};
+  attr_state astate = {};
 
   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
     {
@@ -7740,6 +7742,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 	      sl = push_stmt_list ();
 	      parser->error = false;
 	      before_labels = get_before_labels ();
+	      astate.reset ();
 	      continue;
 	    }
 	  else if (want_nested_loop
@@ -7773,6 +7776,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 		}
 	      parser->error = false;
 	      before_labels = get_before_labels ();
+	      astate.reset ();
 	      continue;
 	    }
 	  else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
@@ -7784,6 +7788,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 	      /* FIXME:  Maybe issue a warning or something here?  */
 	      c_parser_consume_token (parser);
 	      before_labels = get_before_labels ();
+	      astate.reset ();
 	      continue;
 	    }
 	}
@@ -7795,7 +7800,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
       if (have_std_attrs)
 	{
 	  std_attrs = c_parser_std_attribute_specifier_sequence (parser);
-	  std_attrs = c_parser_handle_musttail (parser, std_attrs, a);
+	  std_attrs = c_parser_handle_musttail (parser, std_attrs, astate);
 	}
       if (c_parser_next_token_is_keyword (parser, RID_CASE)
 	  || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
@@ -7937,6 +7942,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
               error_at (loc, "%<else%> without a previous %<if%>");
               c_parser_consume_token (parser);
 	      before_labels = get_before_labels ();
+	      astate.reset ();
               continue;
             }
         }
@@ -7949,7 +7955,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 	  mark_valid_location_for_stdc_pragma (false);
 	  if (!omp_for_parse_state)
 	    c_parser_statement_after_labels (parser, NULL, before_labels,
-					     NULL, a);
+					     NULL, astate);
 	  else
 	    {
 	      /* In canonical loop nest form, nested loops can only appear
@@ -7966,6 +7972,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
 	}
 
       parser->error = false;
+      astate.reset ();
     }
   if (last_label)
     pedwarn_c11 (label_loc, OPT_Wfree_labels,
--- a/src/gcc/cfgrtl.cc
+++ b/src/gcc/cfgrtl.cc
@@ -559,8 +559,8 @@ update_bb_for_insn (basic_block bb)
 }
 
 
-/* Like active_insn_p, except keep the return value use or clobber around
-   even after reload.  */
+/* Return true if adding or removing instances of INSN might affect the
+   semantics of the RTL.  */
 
 static bool
 flow_active_insn_p (const rtx_insn *insn)
@@ -568,16 +568,29 @@ flow_active_insn_p (const rtx_insn *insn)
   if (active_insn_p (insn))
     return true;
 
-  /* A clobber of the function return value exists for buggy
-     programs that fail to return a value.  Its effect is to
-     keep the return value from being live across the entire
-     function.  If we allow it to be skipped, we introduce the
-     possibility for register lifetime confusion.
-     Similarly, keep a USE of the function return value, otherwise
-     the USE is dropped and we could fail to thread jump if USE
-     appears on some paths and not on others, see PR90257.  */
-  if ((GET_CODE (PATTERN (insn)) == CLOBBER
-       || GET_CODE (PATTERN (insn)) == USE)
+  /* We cannot add new clobbers to a path without first proving that
+     the clobbered thing is dead.
+
+     For example:
+
+	(code_label L1)
+	(clobber X)
+	(set (pc) (label_ref L2))
+
+     is a forwarder block in the sense that a jump to L1 can be replaced
+     with a jump to L2, although perhaps with some loss of dataflow precision.
+     However, any attempt to merge a jump to L1 with a jump to L2 would be an
+     asymmetric operation, in that the merged code must jump to L2 rather than
+     to L1.  Our current definition of "forwarder block" does not allow for
+     this distinction and so we need to take a conservatively correct
+     approach.  */
+  if (GET_CODE (PATTERN (insn)) == CLOBBER)
+    return true;
+
+  /* Keep a USE of the function return value, otherwise the USE is dropped and
+     we could fail to thread a jump if USE appears on some paths and not on
+     others, see PR90257.  */
+  if (GET_CODE (PATTERN (insn)) == USE
       && REG_P (XEXP (PATTERN (insn), 0))
       && REG_FUNCTION_VALUE_P (XEXP (PATTERN (insn), 0)))
     return true;
--- a/src/gcc/common/config/i386/cpuinfo.h
+++ b/src/gcc/common/config/i386/cpuinfo.h
@@ -349,6 +349,48 @@ get_amd_cpu (struct __processor_model *cpu_model,
   return cpu;
 }
 
+/* Get the specific type of HYGON CPU and return HYGON CPU name.  Return
+   NULL for unknown HYGON CPU.  */
+
+static inline const char *
+get_hygon_cpu (struct __processor_model *cpu_model,
+	       struct __processor_model2 *cpu_model2,
+	       unsigned int *cpu_features2 __attribute__((unused)))
+{
+  const char *cpu = NULL;
+  unsigned int family = cpu_model2->__cpu_family;
+  unsigned int model = cpu_model2->__cpu_model;
+
+  switch (family)
+    {
+    case 0x18:
+      cpu_model->__cpu_type = HYGONFAM18H;
+      if (model == 0x4)
+	{
+	  cpu = "c86-4g-m4";
+	  CHECK___builtin_cpu_is ("c86-4g-m4");
+	  cpu_model->__cpu_subtype = HYGONFAM18H_C86_4G_M4;
+	}
+      else if (model == 0x6)
+	{
+	  cpu = "c86-4g-m6";
+	  CHECK___builtin_cpu_is ("c86-4g-m6");
+	  cpu_model->__cpu_subtype = HYGONFAM18H_C86_4G_M6;
+	}
+      else if (model == 0x7)
+	{
+	  cpu = "c86-4g-m7";
+	  CHECK___builtin_cpu_is ("c86-4g-m7");
+	  cpu_model->__cpu_subtype = HYGONFAM18H_C86_4G_M7;
+	}
+      break;
+    default:
+      break;
+    }
+
+  return cpu;
+}
+
 /* Get the specific type of Intel CPU and return Intel CPU name.  Return
    NULL for unknown Intel CPU.  */
 
@@ -1259,6 +1301,21 @@ cpu_indicator_init (struct __processor_model *cpu_model,
     cpu_model->__cpu_vendor = VENDOR_CYRIX;
   else if (vendor == signature_NSC_ebx)
     cpu_model->__cpu_vendor = VENDOR_NSC;
+  else if (vendor == signature_HYGON_ebx)
+    {
+      /* Adjust model and family for HYGON CPUS.  */
+      if (family == 0x0f)
+	{
+	  family += extended_family;
+	  model += extended_model;
+	}
+      cpu_model2->__cpu_family = family;
+      cpu_model2->__cpu_model = model;
+
+      /* Get CPU type.  */
+      get_hygon_cpu (cpu_model, cpu_model2, cpu_features2);
+      cpu_model->__cpu_vendor = VENDOR_HYGON;
+    }
   else
     cpu_model->__cpu_vendor = VENDOR_OTHER;
 
--- a/src/gcc/common/config/i386/i386-common.cc
+++ b/src/gcc/common/config/i386/i386-common.cc
@@ -2205,7 +2205,10 @@ const char *const processor_names[] =
   "znver3",
   "znver4",
   "znver5",
-  "znver6"
+  "znver6",
+  "c86-4g-m4",
+  "c86-4g-m6",
+  "c86-4g-m7"
 };
 
 /* Guarantee that the array is aligned with enum processor_type.  */
@@ -2473,6 +2476,15 @@ const pta processor_alias_table[] =
   {"btver2", PROCESSOR_BTVER2, CPU_BTVER2,
     PTA_BTVER2,
     M_CPU_TYPE (AMD_BTVER2), P_PROC_BMI},
+  {"c86-4g-m4", PROCESSOR_C86_4G_M4, CPU_C86_4G_M4,
+    PTA_C86_4G_M4,
+    M_CPU_SUBTYPE (HYGONFAM18H_C86_4G_M4), P_PROC_AVX2},
+  {"c86-4g-m6", PROCESSOR_C86_4G_M6, CPU_C86_4G_M6,
+    PTA_C86_4G_M6,
+    M_CPU_SUBTYPE (HYGONFAM18H_C86_4G_M6), P_PROC_AVX2},
+  {"c86-4g-m7", PROCESSOR_C86_4G_M7, CPU_C86_4G_M7,
+    PTA_C86_4G_M7,
+    M_CPU_SUBTYPE (HYGONFAM18H_C86_4G_M7), P_PROC_AVX512F},
 
   {"generic", PROCESSOR_GENERIC, CPU_GENERIC,
     PTA_64BIT
@@ -2493,10 +2505,14 @@ const pta processor_alias_table[] =
     M_CPU_SUBTYPE (AMDFAM10H_SHANGHAI), P_NONE},
   {"istanbul", PROCESSOR_GENERIC, CPU_GENERIC, 0,
     M_CPU_SUBTYPE (AMDFAM10H_ISTANBUL), P_NONE},
+  {"hygon", PROCESSOR_GENERIC, CPU_GENERIC, 0,
+    M_VENDOR (VENDOR_HYGON), P_NONE},
+  {"hygonfam18h", PROCESSOR_GENERIC, CPU_GENERIC, 0,
+    M_CPU_TYPE (HYGONFAM18H), P_NONE},
 };
 
 /* NB: processor_alias_table stops at the "generic" entry.  */
-unsigned int const pta_size = ARRAY_SIZE (processor_alias_table) - 7;
+unsigned int const pta_size = ARRAY_SIZE (processor_alias_table) - 9;
 unsigned int const num_arch_names = ARRAY_SIZE (processor_alias_table);
 
 /* Provide valid option values for -march and -mtune options.  */
--- a/src/gcc/common/config/i386/i386-cpuinfo.h
+++ b/src/gcc/common/config/i386/i386-cpuinfo.h
@@ -30,6 +30,7 @@ enum processor_vendor
   VENDOR_INTEL = 1,
   VENDOR_AMD,
   VENDOR_ZHAOXIN,
+  VENDOR_HYGON,
   VENDOR_OTHER,
   VENDOR_CENTAUR,
   VENDOR_CYRIX,
@@ -62,6 +63,7 @@ enum processor_types
   INTEL_GRANDRIDGE,
   INTEL_CLEARWATERFOREST,
   AMDFAM1AH,
+  HYGONFAM18H,
   CPU_TYPE_MAX,
   BUILTIN_CPU_TYPE_MAX = CPU_TYPE_MAX
 };
@@ -108,6 +110,9 @@ enum processor_subtypes
   INTEL_COREI7_DIAMONDRAPIDS,
   INTEL_COREI7_NOVALAKE,
   AMDFAM1AH_ZNVER6,
+  HYGONFAM18H_C86_4G_M4,
+  HYGONFAM18H_C86_4G_M6,
+  HYGONFAM18H_C86_4G_M7,
   CPU_SUBTYPE_MAX
 };
 
--- a/src/gcc/config.gcc
+++ b/src/gcc/config.gcc
@@ -768,7 +768,7 @@ sapphirerapids alderlake rocketlake eden-x2 nano nano-1000 nano-2000 nano-3000 \
 nano-x2 eden-x4 nano-x4 lujiazui yongfeng shijidadao x86-64 x86-64-v2 \
 x86-64-v3 x86-64-v4 sierraforest graniterapids graniterapids-d grandridge \
 arrowlake arrowlake-s clearwaterforest pantherlake diamondrapids novalake \
-native"
+c86-4g-m4 c86-4g-m6 c86-4g-m7 native"
 
 # Additional x86 processors supported by --with-cpu=.  Each processor
 # MUST be separated by exactly one space.
@@ -4006,6 +4006,18 @@ case ${target} in
 	cpu=pentiumpro
 	arch_without_sse2=yes
 	;;
+      c86_4g_m4-*)
+	arch=c86-4g-m4
+	cpu=c86-4g-m4
+	;;
+      c86_4g_m6-*)
+	arch=c86-4g-m6
+	cpu=c86-4g-m6
+	;;
+      c86_4g_m7-*)
+	arch=c86-4g-m7
+	cpu=c86-4g-m7
+	;;
       *)
 	arch=pentiumpro
 	cpu=generic
@@ -4108,6 +4120,18 @@ case ${target} in
 	arch=corei7
 	cpu=corei7
 	;;
+      c86_4g_m4-*)
+	arch=c86-4g-m4
+	cpu=c86-4g-m4
+	;;
+      c86_4g_m6-*)
+	arch=c86-4g-m6
+	cpu=c86-4g-m6
+	;;
+      c86_4g_m7-*)
+	arch=c86-4g-m7
+	cpu=c86-4g-m7
+	;;
       *)
 	arch=x86-64
 	cpu=generic
--- a/src/gcc/config/aarch64/aarch64-early-ra.cc
+++ b/src/gcc/config/aarch64/aarch64-early-ra.cc
@@ -1520,7 +1520,15 @@ early_ra::get_allocno_subgroup (rtx reg)
       group->has_flexible_stride = ((flags & HAS_FLEXIBLE_STRIDE) != 0
 				    && (flags & HAS_FIXED_STRIDE) == 0);
 
-      group->fpr_size = (maybe_gt (fpr_bits, 128) ? FPR_Z
+      // SVE modes always occupy the full Z register, even for partial modes
+      // like VNx2SF whose mode size is only 64 bits.  Treating such modes
+      // as FPR_D would let partial_fpr_clobbers ignore the fact that
+      // V8-V15 are only partially callee-saved under AAPCS64 -- the high
+      // bits of the Z register are clobbered by calls.  Always classify
+      // SVE modes as FPR_Z so that V8-V15 are excluded as candidates for
+      // pseudos that are live across calls.
+      group->fpr_size = ((aarch64_sve_mode_p (GET_MODE (reg))
+			  || maybe_gt (fpr_bits, 128)) ? FPR_Z
 			 : maybe_gt (fpr_bits, 64) ? FPR_Q : FPR_D);
 
       entry = group;
--- a/src/gcc/config/aarch64/aarch64-passes.def
+++ b/src/gcc/config/aarch64/aarch64-passes.def
@@ -26,4 +26,4 @@ INSERT_PASS_BEFORE (pass_late_thread_prologue_and_epilogue, 1, pass_late_track_s
 INSERT_PASS_BEFORE (pass_shorten_branches, 1, pass_insert_bti);
 INSERT_PASS_BEFORE (pass_early_remat, 1, pass_ldp_fusion);
 INSERT_PASS_BEFORE (pass_peephole2, 1, pass_ldp_fusion);
-INSERT_PASS_BEFORE (pass_cleanup_barriers, 1, pass_narrow_gp_writes);
+INSERT_PASS_BEFORE (pass_free_cfg, 1, pass_narrow_gp_writes);
--- a/src/gcc/config/aarch64/aarch64.cc
+++ b/src/gcc/config/aarch64/aarch64.cc
@@ -2923,10 +2923,23 @@ aarch64_hard_regno_call_part_clobbered (unsigned int abi_id,
       && abi_id != ARM_PCS_SVE
       && abi_id != ARM_PCS_PRESERVE_NONE)
     {
-      poly_int64 per_register_size = GET_MODE_SIZE (mode);
-      unsigned int nregs = hard_regno_nregs (regno, mode);
-      if (nregs > 1)
-	per_register_size = exact_div (per_register_size, nregs);
+      poly_int64 per_register_size;
+      if (aarch64_sve_mode_p (mode))
+	/* SVE instructions operate on the full SVE register, even for
+	   partial modes like VNx2SF whose GET_MODE_SIZE is only 8 bytes
+	   under -msve-vector-bits=128.  The elements of such partial
+	   modes are strided across the register and can lie outside the
+	   callee-preserved low 64 bits.  Compare against the full SVE
+	   vector size so that V8-V15 are correctly recognised as
+	   partially clobbered for any SVE mode under AAPCS64/AAPCS_SIMD.  */
+	per_register_size = BYTES_PER_SVE_VECTOR;
+      else
+	{
+	  per_register_size = GET_MODE_SIZE (mode);
+	  unsigned int nregs = hard_regno_nregs (regno, mode);
+	  if (nregs > 1)
+	    per_register_size = exact_div (per_register_size, nregs);
+	}
       if (abi_id == ARM_PCS_SIMD || abi_id == ARM_PCS_TLSDESC)
 	return maybe_gt (per_register_size, 16);
       return maybe_gt (per_register_size, 8);
--- a/src/gcc/config/aarch64/tuning_models/generic.h
+++ b/src/gcc/config/aarch64/tuning_models/generic.h
@@ -129,7 +129,7 @@ static const struct cpu_branch_cost generic_branch_cost =
 {
   1,  /* Predictable.  */
   3,  /* Unpredictable.  */
-  6, /* br_mispredict_factor.  */
+  7, /* br_mispredict_factor.  */
 };
 
 /* Generic approximation modes.  */
--- a/src/gcc/config/aarch64/tuning_models/olympus.h
+++ b/src/gcc/config/aarch64/tuning_models/olympus.h
@@ -95,7 +95,7 @@ static sve_vec_cost olympus_sve_vector_cost =
 
 static aarch64_scalar_vec_issue_info olympus_scalar_issue_info =
 {
-  4, /* loads_stores_per_cycle  */
+  6, /* loads_stores_per_cycle  */
   2, /* stores_per_cycle  */
   8, /* general_ops_per_cycle  */
   0, /* fp_simd_load_general_ops  */
@@ -105,7 +105,7 @@ static aarch64_scalar_vec_issue_info olympus_scalar_issue_info =
 static aarch64_advsimd_vec_issue_info olympus_advsimd_issue_info =
 {
   {
-    3, /* loads_stores_per_cycle  */
+    6, /* loads_stores_per_cycle  */
     2, /* stores_per_cycle  */
     6, /* general_ops_per_cycle  */
     0, /* fp_simd_load_general_ops  */
@@ -120,7 +120,7 @@ static aarch64_sve_vec_issue_info olympus_sve_issue_info =
 {
   {
     {
-      3, /* loads_stores_per_cycle  */
+      6, /* loads_stores_per_cycle  */
       2, /* stores_per_cycle  */
       6, /* general_ops_per_cycle  */
       0, /* fp_simd_load_general_ops  */
--- a/src/gcc/config/arm/arm-mve-builtins-base.cc
+++ b/src/gcc/config/arm/arm-mve-builtins-base.cc
@@ -294,9 +294,12 @@ public:
     : m_to_int_mode (to_int_mode)
   {}
 
-  unsigned int call_properties (const function_instance &) const override
+  unsigned int call_properties (const function_instance &fi) const override
   {
-    return CP_WRITE_MEMORY;
+    if (fi.mode_suffix_id == MODE_wb)
+      return CP_WRITE_MEMORY | CP_READ_MEMORY;
+    else
+      return CP_WRITE_MEMORY;
   }
 
   machine_mode memory_vector_mode (const function_instance &fi) const override
@@ -480,6 +483,14 @@ public:
     return type_suffixes[suffix].vector_mode;
   }
 
+  unsigned int call_properties (const function_instance &fi) const override
+  {
+    if (fi.mode_suffix_id == MODE_wb)
+      return CP_WRITE_MEMORY | CP_READ_MEMORY;
+    else
+      return CP_READ_MEMORY;
+  }
+
   rtx expand (function_expander &e) const override
   {
     insn_code icode;
--- a/src/gcc/config/avr/avr-fixed.md
+++ b/src/gcc/config/avr/avr-fixed.md
@@ -43,9 +43,9 @@ (define_mode_iterator FIXED_A
    SQ USQ SA USA
    DQ UDQ DA UDA
    TA UTA
-   QI HI SI DI])
+   QI HI PSI SI DI])
 
-;; Same so that be can build cross products
+;; Same so that we can build cartesian products.
 
 (define_mode_iterator FIXED_B
   [QQ UQQ
@@ -53,7 +53,7 @@ (define_mode_iterator FIXED_B
    SQ USQ SA USA
    DQ UDQ DA UDA
    TA UTA
-   QI HI SI DI])
+   QI HI PSI SI DI])
 
 (define_insn_and_split "fract<FIXED_B:mode><FIXED_A:mode>2"
   [(set (match_operand:FIXED_A 0 "register_operand" "=r")
--- a/src/gcc/config/avr/avr.cc
+++ b/src/gcc/config/avr/avr.cc
@@ -249,9 +249,6 @@ bool avr_need_clear_bss_p = false;
 bool avr_need_copy_data_p = false;
 bool avr_has_rodata_p = false;
 
-/* To track if we satisfy __call_main from AVR-LibC.  */
-bool avr_no_call_main_p = false;
-
 /* Counts how often pass avr-fuse-add has been executed.  Is is kept in
    sync with cfun->machine->n_avr_fuse_add_executed and serves as an
    insn condition for shift insn splitters.  */
@@ -10544,7 +10541,7 @@ avr_out_fract (rtx_insn *insn, rtx operands[], bool intsigned, int *plen)
 	{
 	  avr_asm_len ("clr __tmp_reg__" CR_TAB
 		       "sbrc %1,0"       CR_TAB
-		       "dec __tmp_reg__", xop, plen, 1);
+		       "dec __tmp_reg__", xop, plen, 3);
 	  sn = src.regno;
 	  if (sn < s0)
 	    {
@@ -10559,7 +10556,7 @@ avr_out_fract (rtx_insn *insn, rtx operands[], bool intsigned, int *plen)
 	    avr_asm_len ("clt"                CR_TAB
 			 "bld __tmp_reg__,7"  CR_TAB
 			 "adc %0,__tmp_reg__",
-			 &all_regs_rtx[s0], plen, 1);
+			 &all_regs_rtx[s0], plen, 3);
 	  else
 	    avr_asm_len ("lsr __tmp_reg" CR_TAB
 			 "add %0,__tmp_reg__",
@@ -10758,8 +10755,8 @@ avr_out_fract (rtx_insn *insn, rtx operands[], bool intsigned, int *plen)
 	  xop[2] = all_regs_rtx[s0];
 	  if (!lsb_in_tmp_reg && !MAY_CLOBBER (s0))
 	    avr_asm_len ("mov __tmp_reg__,%2", xop, plen, 1);
-	  avr_asm_len ("tst %0" CR_TAB "brpl 0f",
-		       &all_regs_rtx[src.regno_msb], plen, 2);
+	  avr_asm_len ("tst %0" CR_TAB
+		       "brpl 0f", &all_regs_rtx[src.regno_msb], plen, 2);
 	  if (!lsb_in_tmp_reg)
 	    {
 	      unsigned sn = src.regno;
@@ -11906,7 +11903,9 @@ avr_insert_attributes (tree node, tree *attributes)
 	      *attributes = tree_cons (get_identifier ("section"),
 				       arg, *attributes);
 	    }
-	  avr_no_call_main_p = true;
+	  if (!lookup_attribute ("used", *attributes))
+	    *attributes = tree_cons (get_identifier ("used"),
+				     NULL_TREE, *attributes);
 	}
     } // -mno-call-main
 #endif // AVR-LibC
@@ -12467,15 +12466,6 @@ avr_file_end (void)
 
   if (avr_need_clear_bss_p)
     fputs (".global __do_clear_bss\n", asm_out_file);
-
-  /* Don't let __call_main call main() and exit().
-     Defining this symbol will keep the code from being pulled
-     in from lib<mcu>.a as requested by AVR-LibC's gcrt1.S.
-     We invoke main() by other means: putting it in .init9.  */
-
-  if (avr_no_call_main_p)
-    fputs (".global __call_main\n"
-	   "__call_main = 0\n", asm_out_file);
 }
 
 
--- a/src/gcc/config/avr/gen-avr-mmcu-specs.cc
+++ b/src/gcc/config/avr/gen-avr-mmcu-specs.cc
@@ -355,6 +355,8 @@ print_mcu (const avr_mcu_t *mcu, const McuInfo &mi)
 
   fprintf (f, "*link_relax:\n\t%s\n\n", LINK_RELAX_SPEC);
 
+  fprintf (f, "*link_no_call_main:\n\t%s\n\n", "%{mno-call-main: --defsym __call_main=0}");
+
   fprintf (f, "*link_arch:\n\t%s", link_arch_spec);
   if (mi.is_device
       && rodata_pm_offset)
--- a/src/gcc/config/avr/specs.h
+++ b/src/gcc/config/avr/specs.h
@@ -67,6 +67,7 @@ along with GCC; see the file COPYING3.  If not see
   "%(link_relax) "                              \
   "%(link_pmem_wrap) "                          \
   "%(link_rodata_in_ram) "                      \
+  "%(link_no_call_main) "                       \
   "%{shared:%eshared is not supported} "
 
 #undef  LIB_SPEC
new file mode 100644
--- /dev/null
+++ b/src/gcc/config/i386/c86-4g-m7.md
@@ -0,0 +1,2063 @@
+;; Copyright (C) 2026 Free Software Foundation, Inc.
+;;
+;; This file is part of GCC.
+;;
+;; GCC is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; GCC is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GCC; see the file COPYING3.  If not see
+;; <http://www.gnu.org/licenses/>.
+;;
+
+;; HYGON c86-4g-m7 Scheduling
+;; Modeling automatons for decoders, integer execution pipes,
+;; AGU pipes, branch, floating point execution, fp store units,
+;; integer and floating point dividers.  Split fpu1 and fpu3
+;; into their own automata to keep these units independent
+;; without increasing the main c86_4g_m7_fpu state space.
+(define_automaton "c86_4g_m7, c86_4g_m7_ieu, c86_4g_m7_agu, c86_4g_m7_fpu02, c86_4g_m7_fpu13, c86_4g_m7_idiv, c86_4g_m7_fdiv")
+
+;; Decoders unit has 4 decoders and all of them can decode fast path
+;; and vector type instructions.
+(define_cpu_unit "c86-4g-m7-decode0" "c86_4g_m7")
+(define_cpu_unit "c86-4g-m7-decode1" "c86_4g_m7")
+(define_cpu_unit "c86-4g-m7-decode2" "c86_4g_m7")
+(define_cpu_unit "c86-4g-m7-decode3" "c86_4g_m7")
+
+;; Currently blocking all decoders for vector path instructions as
+;; they are dispatched separetely as microcode sequence.
+(define_reservation "c86-4g-m7-vector" "c86-4g-m7-decode0+c86-4g-m7-decode1+c86-4g-m7-decode2+c86-4g-m7-decode3")
+
+;; Direct instructions can be issued to any of the four decoders.
+(define_reservation "c86-4g-m7-direct" "c86-4g-m7-decode0|c86-4g-m7-decode1|c86-4g-m7-decode2|c86-4g-m7-decode3")
+
+;; Fix me: Need to revisit this later to simulate fast path double behavior.
+(define_reservation "c86-4g-m7-double" "c86-4g-m7-direct")
+
+;; Integer unit 4 ALU pipes.
+(define_cpu_unit "c86-4g-m7-ieu0" "c86_4g_m7_ieu")
+(define_cpu_unit "c86-4g-m7-ieu1" "c86_4g_m7_ieu")
+(define_cpu_unit "c86-4g-m7-ieu2" "c86_4g_m7_ieu")
+(define_cpu_unit "c86-4g-m7-ieu3" "c86_4g_m7_ieu")
+
+;; One separated integer divider.
+(define_cpu_unit "c86-4g-m7-idiv" "c86_4g_m7_idiv")
+
+;; c86-4g-m7 has an additional branch unit.
+(define_cpu_unit "c86-4g-m7-bru0" "c86_4g_m7_ieu")
+(define_reservation "c86-4g-m7-ieu" "c86-4g-m7-ieu0|c86-4g-m7-ieu1|c86-4g-m7-ieu2|c86-4g-m7-ieu3")
+
+;; 3 AGU pipes in c86-4g-m7
+(define_cpu_unit "c86-4g-m7-agu0" "c86_4g_m7_agu")
+(define_cpu_unit "c86-4g-m7-agu1" "c86_4g_m7_agu")
+(define_cpu_unit "c86-4g-m7-agu2" "c86_4g_m7_agu")
+(define_reservation "c86-4g-m7-agu-reserve" "c86-4g-m7-agu0|c86-4g-m7-agu1|c86-4g-m7-agu2")
+
+;; Load is 4 cycles.  We do not model reservation of load unit.
+(define_reservation "c86-4g-m7-load" "c86-4g-m7-agu-reserve")
+(define_reservation "c86-4g-m7-store" "c86-4g-m7-agu-reserve")
+
+;; vectorpath (microcoded) instructions are single issue instructions.
+;; So, they occupy all the integer units.
+(define_reservation "c86-4g-m7-ivector" "c86-4g-m7-ieu0+c86-4g-m7-ieu1
+					 +c86-4g-m7-ieu2+c86-4g-m7-ieu3+c86-4g-m7-bru0
+					 +c86-4g-m7-agu0+c86-4g-m7-agu1+c86-4g-m7-agu2")
+
+;; Floating point unit 4 FP pipes.
+(define_cpu_unit "c86-4g-m7-fpu0" "c86_4g_m7_fpu02")
+(define_cpu_unit "c86-4g-m7-fpu1" "c86_4g_m7_fpu13")
+(define_cpu_unit "c86-4g-m7-fpu2" "c86_4g_m7_fpu02")
+(define_cpu_unit "c86-4g-m7-fpu3" "c86_4g_m7_fpu13")
+
+(define_reservation "c86-4g-m7-fpu" "c86-4g-m7-fpu0|c86-4g-m7-fpu1|c86-4g-m7-fpu2|c86-4g-m7-fpu3")
+(define_reservation "c86-4g-m7-fpu_0_1" "c86-4g-m7-fpu0|c86-4g-m7-fpu1")
+(define_reservation "c86-4g-m7-fpu_0_2" "c86-4g-m7-fpu0|c86-4g-m7-fpu2")
+(define_reservation "c86-4g-m7-fpu_0_2x2" "c86-4g-m7-fpu0*2|c86-4g-m7-fpu2*2")
+(define_reservation "c86-4g-m7-fpu_0_2x4" "c86-4g-m7-fpu0*4|c86-4g-m7-fpu2*4")
+(define_reservation "c86-4g-m7-fpu_0_3" "c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+(define_reservation "c86-4g-m7-fpu_1_3" "c86-4g-m7-fpu1|c86-4g-m7-fpu3")
+(define_reservation "c86-4g-m7-fpu_1_3x2" "c86-4g-m7-fpu1*2|c86-4g-m7-fpu3*2")
+(define_reservation "c86-4g-m7-fpu_1_3x3" "c86-4g-m7-fpu1*3|c86-4g-m7-fpu3*3")
+(define_reservation "c86-4g-m7-fpu_1_3x6" "c86-4g-m7-fpu1*6|c86-4g-m7-fpu3*6")
+(define_reservation "c86-4g-m7-fpux2" "c86-4g-m7-fpu0*2|c86-4g-m7-fpu1*2|c86-4g-m7-fpu2*2|c86-4g-m7-fpu3*2")
+(define_reservation "c86-4g-m7-fpux4" "c86-4g-m7-fpu0*4|c86-4g-m7-fpu1*4|c86-4g-m7-fpu2*4|c86-4g-m7-fpu3*4")
+(define_reservation "c86-4g-m7-fpux8" "c86-4g-m7-fpu0*8|c86-4g-m7-fpu1*8|c86-4g-m7-fpu2*8|c86-4g-m7-fpu3*8")
+(define_reservation "c86-4g-m7-fpux6" "c86-4g-m7-fpu0*6|c86-4g-m7-fpu1*6|c86-4g-m7-fpu2*6|c86-4g-m7-fpu3*6")
+(define_reservation "c86-4g-m7-fpux16" "c86-4g-m7-fpu0*16|c86-4g-m7-fpu1*16|c86-4g-m7-fpu2*16|c86-4g-m7-fpu3*16")
+(define_reservation "c86-4g-m7-fvector" "c86-4g-m7-fpu0+c86-4g-m7-fpu1
+					 +c86-4g-m7-fpu2+c86-4g-m7-fpu3
+					 +c86-4g-m7-agu0+c86-4g-m7-agu1+c86-4g-m7-agu2")
+
+;; Two FP dividers.
+(define_cpu_unit "c86-4g-m7-fdiv1" "c86_4g_m7_fdiv")
+(define_cpu_unit "c86-4g-m7-fdiv3" "c86_4g_m7_fdiv")
+
+(define_reservation "c86-4g-m7-fp1fdiv1x4" "(c86-4g-m7-fpu1+c86-4g-m7-fdiv1)*4")
+(define_reservation "c86-4g-m7-fp3fdiv3x4" "(c86-4g-m7-fpu3+c86-4g-m7-fdiv3)*4")
+(define_reservation "c86-4g-m7-fdiv13" "(c86-4g-m7-fdiv1+c86-4g-m7-fdiv3)")
+(define_reservation "c86-4g-m7-fp13div13" "(c86-4g-m7-fpu1+c86-4g-m7-fpu3+c86-4g-m7-fdiv1+c86-4g-m7-fdiv3)")
+(define_reservation "c86-4g-m7-fp13div13x4" "c86-4g-m7-fp13div13*4")
+(define_reservation "c86-4g-m7-fp1div1_fp3div3_x4x8" "(c86-4g-m7-fp1fdiv1x4,c86-4g-m7-fdiv1*8)|(c86-4g-m7-fp3fdiv3x4,c86-4g-m7-fdiv3*8)")
+(define_reservation "c86-4g-m7-fp1div1_fp3div3_x4x9" "(c86-4g-m7-fp1fdiv1x4,c86-4g-m7-fdiv1*9)|(c86-4g-m7-fp3fdiv3x4,c86-4g-m7-fdiv3*9)")
+(define_reservation "c86-4g-m7-fp1div1_fp3div3_x4x11" "(c86-4g-m7-fp1fdiv1x4,c86-4g-m7-fdiv1*11)|(c86-4g-m7-fp3fdiv3x4,c86-4g-m7-fdiv3*11)")
+(define_reservation "c86-4g-m7-fp1div1_fp3div3_x4x15" "(c86-4g-m7-fp1fdiv1x4,c86-4g-m7-fdiv1*15)|(c86-4g-m7-fp3fdiv3x4,c86-4g-m7-fdiv3*15)")
+(define_reservation "c86-4g-m7-fp1div1_fp3div3_x4x18" "(c86-4g-m7-fp1fdiv1x4,c86-4g-m7-fdiv1*18)|(c86-4g-m7-fp3fdiv3x4,c86-4g-m7-fdiv3*18)")
+
+;; IMOV/IMOVX
+(define_insn_reservation "c86_4g_m7_imov_xchg" 1
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imov")
+				  (and (eq_attr "c86_decode" "vector")
+				       (eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct")
+
+(define_insn_reservation "c86_4g_m7_imov_xchg_load" 5
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imov")
+				  (and (eq_attr "c86_decode" "vector")
+				       (eq_attr "memory" "!none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load")
+
+(define_insn_reservation "c86_4g_m7_imovx_cwde" 2
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imovx")
+				  (and (eq_attr "c86_decode" "double")
+				       (eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_imov" 1
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imov,imovx")
+				  (and (eq_attr "c86_decode" "direct")
+				       (eq_attr "memory" "none"))))
+	     "c86-4g-m7-direct,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_imov_load" 5
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imov,imovx")
+				  (and (eq_attr "c86_decode" "!vector")
+				       (eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_imov_store" 1
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imov,imovx")
+				  (and (eq_attr "c86_decode" "!vector")
+				       (eq_attr "memory" "store"))))
+			 "c86-4g-m7-direct,c86-4g-m7-store,c86-4g-m7-ieu")
+
+;; PUSH
+(define_insn_reservation "c86_4g_m7_push" 1
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "push,sse")
+				  (eq_attr "memory" "store")))
+			 "c86-4g-m7-direct,c86-4g-m7-store")
+
+(define_insn_reservation "c86_4g_m7_push_mem" 5
+			(and (eq_attr "cpu" "c86_4g_m7")
+				 (and (eq_attr "type" "push")
+				  (eq_attr "memory" "both")))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-store")
+
+;; POP
+(define_insn_reservation "c86_4g_m7_pop" 4
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "pop")
+				  (eq_attr "memory" "load")))
+			 "c86-4g-m7-direct,c86-4g-m7-load")
+
+(define_insn_reservation "c86_4g_m7_pop_mem" 5
+	    (and (eq_attr "cpu" "c86_4g_m7")
+		 (and (eq_attr "type" "pop")
+		  (eq_attr "memory" "both")))
+	     "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-store")
+
+;; IMUL/IMULX
+(define_insn_reservation "c86_4g_m7_imul" 3
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imul,imulx")
+				  (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu1")
+
+(define_insn_reservation "c86_4g_m7_imul_load" 7
+			(and (eq_attr "cpu" "c86_4g_m7")
+			     (and (eq_attr "type" "imul")
+				  (eq_attr "memory" "!none")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-ieu1")
+
+;; IDIV
+(define_insn_reservation "c86_4g_m7_idiv" 7
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "!QI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-double,c86-4g-m7-ieu3,c86-4g-m7-idiv*7")
+
+(define_insn_reservation "c86_4g_m7_idiv_QI" 6
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "QI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-double,c86-4g-m7-ieu3,c86-4g-m7-idiv*6")
+
+(define_insn_reservation "c86_4g_m7_idiv_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "!QI")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-ieu3,c86-4g-m7-idiv*7")
+
+(define_insn_reservation "c86_4g_m7_idiv_QI_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "QI")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-ieu3,c86-4g-m7-idiv*6")
+
+;; Integer/genaral Instructions
+(define_insn_reservation "c86_4g_m7_insn" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu,negnot,rotate1,ishift1,test,incdec,icmp,
+						    rotate,rotatex,ishift,ishiftx,icmov")
+				   (eq_attr "memory" "none,unknown")))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_insn_load" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu,incdec,icmp,test,ishift,
+						    ishiftx,icmov,rotate,rotatex")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_insn_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ishift1,rotate1,rotate,incdec,
+						    alu,icmov,ishift,negnot,alu1")
+				   (eq_attr "memory" "store")))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu,c86-4g-m7-store")
+
+(define_insn_reservation "c86_4g_m7_insn2_store" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "icmp")
+				   (eq_attr "memory" "store")))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu,c86-4g-m7-store")
+
+(define_insn_reservation "c86_4g_m7_insn_both" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu,negnot,rotate1,ishift1,incdec,rotate,
+						    rotatex,ishift,ishiftx,icmov")
+				   (eq_attr "memory" "both")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-ieu,c86-4g-m7-store")
+
+(define_insn_reservation "c86_4g_m7_setcc" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "setcc")
+				   (eq_attr "memory" "none,unknown")))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu0|c86-4g-m7-ieu3")
+
+(define_insn_reservation "c86_4g_m7_setcc_load" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "setcc")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-ieu0|c86-4g-m7-ieu3")
+
+(define_insn_reservation "c86_4g_m7_setcc_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "setcc")
+				   (eq_attr "memory" "store")))
+			 "c86-4g-m7-direct,c86-4g-m7-store,c86-4g-m7-ieu0|c86-4g-m7-ieu3")
+
+;; ALU1
+(define_insn_reservation "c86_4g_m7_alu1_double" 2
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu1")
+				   (and (eq_attr "c86_decode" "double")
+					(eq_attr "memory" "none,unknown"))))
+			 "c86-4g-m7-double,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_alu1_double_load" 6
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu1")
+				   (and (eq_attr "c86_decode" "double")
+					(eq_attr "memory" "both"))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-store,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_alu1_vector" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu1")
+				   (and (eq_attr "c86_decode" "vector")
+					(eq_attr "memory" "none,unknown"))))
+			 "c86-4g-m7-vector,c86-4g-m7-ivector*3")
+
+(define_insn_reservation "c86_4g_m7_alu1_vector_load" 7
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu1")
+				   (and (eq_attr "c86_decode" "vector")
+					(eq_attr "memory" "both"))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-store,c86-4g-m7-ivector*3")
+
+(define_insn_reservation "c86_4g_m7_alu1_direct" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu1")
+				   (and (eq_attr "c86_decode" "direct")
+					(eq_attr "memory" "none,unknown"))))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu")
+
+(define_insn_reservation "c86_4g_m7_alu1_direct_load" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "alu1")
+				   (and (eq_attr "c86_decode" "direct")
+					(eq_attr "memory" "both"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-store,c86-4g-m7-ieu")
+
+;; CALL/CALLV
+(define_insn_reservation "c86_4g_m7_call" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (eq_attr "type" "call,callv"))
+			 "c86-4g-m7-double,c86-4g-m7-ieu0|c86-4g-m7-bru0,c86-4g-m7-store")
+
+;; IBR
+(define_insn_reservation "c86_4g_m7_branch" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ibr")
+				   (eq_attr "memory" "none")))
+			  "c86-4g-m7-direct,c86-4g-m7-ieu0|c86-4g-m7-bru0")
+
+(define_insn_reservation "c86_4g_m7_branch_load" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ibr")
+				   (eq_attr "memory" "load")))
+			  "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-ieu0|c86-4g-m7-bru0")
+
+;; LEA
+(define_insn_reservation "c86_4g_m7_lea" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (eq_attr "type" "lea"))
+			 "c86-4g-m7-direct,c86-4g-m7-ieu")
+
+;; LEAVE
+(define_insn_reservation "c86_4g_m7_leave" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (eq_attr "type" "leave"))
+			 "c86-4g-m7-double,c86-4g-m7-ieu,c86-4g-m7-store")
+
+;; STR
+(define_insn_reservation "c86_4g_m7_str" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "str")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-vector,c86-4g-m7-ivector*3")
+
+(define_insn_reservation "c86_4g_m7_str_load" 7
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "str")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-ivector*3")
+
+
+(define_insn_reservation "c86_4g_m7_ieu_vector" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "other,multi")
+				   (and (eq_attr "unit" "!i387")
+				       (eq_attr "memory" "none,unknown"))))
+			 "c86-4g-m7-vector,c86-4g-m7-ivector*5")
+
+(define_insn_reservation "c86_4g_m7_ieu_vector_load" 9
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "other,multi")
+				   (and (eq_attr "unit" "!i387")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-ivector*5")
+
+;; SSEINS
+(define_insn_reservation "c86_4g_m7_sse_insertimm" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseins")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "length_immediate" "2"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_0_3,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_sse_insert" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseins")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "length_immediate" "!2"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1*2")
+
+;; FCMOV
+(define_insn_reservation "c86_4g_m7_fp_cmov" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (eq_attr "type" "fcmov"))
+			 "c86-4g-m7-vector,c86-4g-m7-fvector*3")
+
+;; FLD
+(define_insn_reservation "c86_4g_m7_fp_mov_direct_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1")
+
+;; FST
+(define_insn_reservation "c86_4g_m7_fp_mov_direct_store" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1,c86-4g-m7-store")
+
+;; FILD
+(define_insn_reservation "c86_4g_m7_fp_mov_double_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1")
+
+;; FIST
+(define_insn_reservation "c86_4g_m7_fp_mov_double_store" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu1,c86-4g-m7-store")
+
+(define_insn_reservation "c86_4g_m7_fp_mov_direct" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1")
+
+;; FSQRT
+(define_insn_reservation "c86_4g_m7_fp_sqrt" 22
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fpspc")
+				   (eq_attr "c86_attr" "sqrt")))
+			 "c86-4g-m7-direct,c86-4g-m7-fp1div1_fp3div3_x4x18")
+
+;; FPSPC
+(define_insn_reservation "c86_4g_m7_fp_spc_direct" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fpspc")
+				   (and (eq_attr "c86_decode" "direct")
+				    (and (eq_attr "c86_attr" "other")
+					 (eq_attr "memory" "store")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_fp_spc" 6
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fpspc")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-vector,c86-4g-m7-fvector*6")
+
+(define_insn_reservation "c86_4g_m7_fp_op_mul" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fop,fmul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_fp_op_mul_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fop,fmul")
+				   (and (eq_attr "fp_int_src" "false")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_fp_op_imul_load" 16
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fmul")
+				   (and (eq_attr "fp_int_src" "true")
+					(eq_attr "memory" "!none"))))
+			"c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu0,c86-4g-m7-fpu_0_2")
+
+;; FDIV
+(define_insn_reservation "c86_4g_m7_fp_div" 15
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fdiv")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-fp1div1_fp3div3_x4x11")
+
+(define_insn_reservation "c86_4g_m7_fp_div_load" 22
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fdiv")
+				   (and (eq_attr "fp_int_src" "false")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp1div1_fp3div3_x4x11")
+
+(define_insn_reservation "c86_4g_m7_fp_idiv_load" 26
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fdiv")
+				   (and (eq_attr "fp_int_src" "true")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu1*4,c86-4g-m7-fp1div1_fp3div3_x4x11")
+
+(define_insn_reservation "c86_4g_m7_fp_fsgn" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (eq_attr "type" "fsgn"))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+;; FCMP
+(define_insn_reservation "c86_4g_m7_fp_fcmp" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fcmp")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-double,c86-4g-m7-fpu0,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_fp_fcmp_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "fcmp")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu0,c86-4g-m7-fpu1")
+
+;; MMX
+(define_insn_reservation "c86_4g_m7_fp_mmx" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (eq_attr "type" "mmx"))
+			 "c86-4g-m7-direct")
+
+(define_insn_reservation "c86_4g_m7_mmx_add_cmp" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxadd,mmxcmp")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_mmx_add_cmp_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxadd,mmxcmp")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_mmx_cvt" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxcvt")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_mmx_cvt_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxcvt")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_mmx_shift" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxshft")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_mmx_shift_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxshft")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_mmx_shift_avg" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxshft")
+				   (and (eq_attr "c86_attr" "avg")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_mmx_shift_avg_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxshft")
+				   (and (eq_attr "c86_attr" "avg")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+;; SADBW
+(define_insn_reservation "c86_4g_m7_mmx_shift_sadbw" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxshft")
+				   (and (eq_attr "c86_attr" "sadbw")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0")
+
+(define_insn_reservation "c86_4g_m7_mmx_shift_sadbw_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxshft")
+				   (and (eq_attr "c86_attr" "sadbw")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0")
+
+(define_insn_reservation "c86_4g_m7_mmx_mov" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxmov")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_mmx_mov_store" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxmov")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-m7-direct,c86-4g-m7-store,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_mmx_mov_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxmov")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_mmx_mul" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxmul")
+				   (eq_attr "memory" "none")))
+			  "c86-4g-m7-direct,c86-4g-m7-fpu0")
+
+(define_insn_reservation "c86_4g_m7_mmx_mul_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mmxmul")
+				   (eq_attr "memory" "load")))
+			  "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0")
+
+;; PINSR
+(define_insn_reservation "c86_4g_m7_sse_pinsr_reg" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,mmxcvt")
+				   (and (eq_attr "c86_attr" "insr")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-ieu2,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_sse_pinsr_reg_load" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,mmxcvt")
+				   (and (eq_attr "c86_attr" "insr")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx_vpinsr_reg" 2
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insr")
+				     (and (eq_attr "prefix" "!orig")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_1_3x2")
+
+(define_insn_reservation "c86_4g_m7_avx_vpinsr_reg_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insr")
+				     (and (eq_attr "prefix" "!orig")
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+;; PERM
+(define_insn_reservation "c86_4g_m7_avx512_perm_xmm" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (ior (and (eq_attr "c86_attr" "perm2")
+						  (eq_attr "mode" "V4SF,V2DF,TI"))
+					     (and (eq_attr "c86_attr" "perm")
+						  (eq_attr "mode" "V8SF,V4DF,TI,OI")))
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_perm_xmm_opload" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (ior (and (eq_attr "c86_attr" "perm2")
+						  (eq_attr "mode" "V4SF,V2DF,TI"))
+					     (and (eq_attr "c86_attr" "perm")
+						  (eq_attr "mode" "V8SF,V4DF,TI,OI")))
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_permi2_ymm" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm2")
+				    (and (eq_attr "mode" "V8SF,V4DF,OI")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpux4")
+
+(define_insn_reservation "c86_4g_m7_avx512_permi2_zmm" 16
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm2")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpux16")
+
+(define_insn_reservation "c86_4g_m7_avx512_permi2_ymm_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm2")
+				    (and (eq_attr "mode" "V8SF,V4DF,OI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpux4")
+
+(define_insn_reservation "c86_4g_m7_avx512_permi2_zmm_load" 23
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm2")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpux16")
+
+(define_insn_reservation "c86_4g_m7_avx512_perm_zmm_imm" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				     (and (match_operand 2 "immediate_operand")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpux4")
+
+(define_insn_reservation "c86_4g_m7_avx512_perm_zmm_imm_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				     (and (match_operand 2 "immediate_operand")
+					  (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpux4")
+
+(define_insn_reservation "c86_4g_m7_avx512_perm_zmm_noimm" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				     (and (match_operand 2 "nonimmediate_operand")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpux8")
+
+(define_insn_reservation "c86_4g_m7_sse_perm_zmm_noimm_load" 15
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "perm")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				     (and (match_operand 2 "nonimmediate_operand")
+					 (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpux8")
+
+;; VINSERT
+(define_insn_reservation "c86_4g_m7_avx512_insertx_ymm" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1")
+				   (and (eq_attr "c86_attr" "insertx")
+				    (and (eq_attr "mode" "V8SF,V4DF,OI")
+				     (and (eq_attr "prefix" "evex")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2x2,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_insertx_ymem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1")
+				   (and (eq_attr "c86_attr" "insertx")
+				    (and (eq_attr "mode" "V8SF,V4DF,OI")
+				     (and (eq_attr "prefix" "evex")
+					  (eq_attr "memory" "load,both"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2x2,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_insertx_zxmm" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insertx")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				    (and (match_test "GET_MODE_SIZE (GET_MODE (operands[2]))==16")
+					 (match_operand 2 "register_operand"))))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_0_2x4,c86-4g-m7-fpu_0_2x4")
+
+(define_insn_reservation "c86_4g_m7_avx512_insertx_zxmem" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insertx")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				    (and (match_test "GET_MODE_SIZE (GET_MODE (operands[2]))==16")
+					  (match_operand 2 "memory_operand"))))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_0_2x4,c86-4g-m7-fpu_0_2x4")
+
+(define_insn_reservation "c86_4g_m7_avx512_insertx_zymm" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insertx")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				    (and (match_test "GET_MODE_SIZE (GET_MODE (operands[2]))==32")
+					  (match_operand 2 "register_operand"))))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_1_3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_insertx_zymem" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insertx")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				    (and (match_test "GET_MODE_SIZE (GET_MODE (operands[2]))==32")
+					  (match_operand 2 "memory_operand"))))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx_insertx_ymm" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1")
+				   (and (eq_attr "c86_attr" "insertx")
+				     (and (eq_attr "prefix" "!evex")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0*2")
+
+(define_insn_reservation "c86_4g_m7_avx_insertx_ymem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1")
+				   (and (eq_attr "c86_attr" "insertx")
+				     (and (eq_attr "prefix" "!evex")
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0*2")
+
+;; SHUF/MULTISHIFTQB
+(define_insn_reservation "c86_4g_m7_avx512_shuf_xymm" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "shufx")
+				     (and (not (eq_attr "mode" "V8DF,V16SF,XI"))
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_shuf_zmm" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "shufx")
+				     (and (eq_attr "mode" "V8DF,V16SF,XI")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_0_2x4")
+
+(define_insn_reservation "c86_4g_m7_avx512_shuf_xymem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "shufx")
+				     (and (not (eq_attr "mode" "V8DF,V16SF,XI"))
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_shuf_zmem" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "shufx")
+				     (and (eq_attr "mode" "V8DF,V16SF,XI")
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_0_2x4")
+
+;; SSELOGIC
+(define_insn_reservation "c86_4g_m7_sselogic_xymm" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1")
+				   (and (eq_attr "c86_attr" "sselogic")
+					 (eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_sselogic_xymm_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1")
+				   (and (eq_attr "c86_attr" "sselogic")
+					 (eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+;; CMPESTR
+(define_insn_reservation "c86_4g_m7_avx512_cmpestr" 6
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "cmpestr")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpux6")
+
+(define_insn_reservation "c86_4g_m7_avx512_cmpestr_load" 13
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "cmpestr")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpux6")
+
+;; SSELOG
+(define_insn_reservation "c86_4g_m7_avx512_log" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1,sseshuf,sseshuf1")
+				   (and (eq_attr "c86_attr" "other")
+					  (eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_log_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog,sselog1,sseshuf,sseshuf1")
+				   (and (eq_attr "c86_attr" "other")
+					 (eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+;; SSELOG1
+;; VDBPSADBW
+(define_insn_reservation "c86_4g_m7_avx512_vdbpsadbw_xymm" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "mode" "OI,TI")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_vdbpsadbw_xymem" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "mode" "OI,TI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_vdbpsadbw_zmm" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "mode" "XI")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_vdbpsadbw_zmem" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "mode" "XI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3x2")
+
+;; ABS
+(define_insn_reservation "c86_4g_m7_avx512_abs" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1,sse")
+				   (and (eq_attr "c86_attr" "abs")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx512_abs_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1,sse")
+				   (and (eq_attr "c86_attr" "abs")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "load,both")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+;; SIGN
+(define_insn_reservation "c86_4g_m7_avx_sign" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sign")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_avx_sign_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sign")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+
+;; BLEND/ABS/AES
+(define_insn_reservation "c86_4g_m7_avx_blend" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "abs,blend,aes")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_avx_blend_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "abs,blend,aes")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_avx512_aes" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1,ssecvt,sse")
+				   (and (eq_attr "c86_attr" "aes")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_aes_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1,ssecvt,sse")
+				   (and (eq_attr "c86_attr" "aes")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx_aes" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "aes")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0|c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_avx_aes_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "aes")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0|c86-4g-m7-fpu1")
+
+;; EXTR
+(define_insn_reservation "c86_4g_m7_extr" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1,sselog,mmxcvt")
+				   (and (eq_attr "c86_attr" "extr")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu1,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_extr_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sselog1,sselog,mmxcvt")
+				   (and (eq_attr "c86_attr" "extr")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-m7-double,c86-4g-m7-store,c86-4g-m7-fpu1,c86-4g-m7-fpu_0_1")
+
+;; SSECOMI
+(define_insn_reservation "c86_4g_m7_avx_ssecomi_comi" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecomi")
+				   (and (eq_attr "prefix_extra" "0")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecomi_comi_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecomi")
+				   (and (eq_attr "prefix_extra" "0")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecomi_test" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecomi")
+				   (and (eq_attr "prefix_extra" "1")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1|c86-4g-m7-fpu2")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecomi_test_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecomi")
+				   (and (eq_attr "prefix_extra" "1")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1|c86-4g-m7-fpu2")
+
+;; SSEIMUL
+(define_insn_reservation "c86_4g_m7_avx512_imul" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseimul")
+				   (and (eq_attr "prefix" "evex")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_imul_mem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseimul")
+				   (and (eq_attr "prefix" "evex")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx_imul" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseimul")
+				   (and (eq_attr "prefix" "!evex")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_avx_imul_mem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseimul")
+				   (and (eq_attr "prefix" "!evex")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+
+;; SSEMOV
+(define_insn_reservation "c86_4g_m7_avx512_mov_vmov" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov,sseiadd")
+				    (and (eq_attr "c86_attr" "other,blend,maxmin")
+					 (eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx512_mov_vmov_store" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "other")
+					 (eq_attr "memory" "store"))))
+			 "c86-4g-m7-direct,c86-4g-m7-store,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_avx512_mov_vmov_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov,sseiadd")
+				   (and (eq_attr "c86_attr" "other,blend,maxmin")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx512_vpmovx_y" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				    (and (eq_attr "prefix" "evex")
+				     (and (eq_attr "mode" "OI,V8SF,V4DF")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_vpmovx_y_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov,sselog1")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				    (and (eq_attr "prefix" "evex")
+				     (and (eq_attr "mode" "OI,V8SF,V4DF")
+					  (eq_attr "memory" "load,both"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_vpmovx_z" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				     (and (eq_attr "mode" "XI")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2x4")
+
+(define_insn_reservation "c86_4g_m7_avx512_vpmovx_z_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				     (and (eq_attr "mode" "XI")
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2x4")
+
+(define_insn_reservation "c86_4g_m7_avx512_vpmovx_x" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				    (and (eq_attr "prefix" "evex")
+				     (and (eq_attr "mode" "TI,SI")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_vpmovx_x_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				    (and (eq_attr "prefix" "evex")
+				     (and (eq_attr "mode" "TI,SI")
+					  (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx_vpmovx_xx" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1|c86-4g-m7-fpu2")
+
+(define_insn_reservation "c86_4g_m7_avx_vpmovx_xx_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "vpmovx")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "load,both")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1|c86-4g-m7-fpu2")
+
+;; EXPAND
+(define_insn_reservation "c86_4g_m7_avx512_expand" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "expand,compress")
+				    (and (not (eq_attr "mode" "XI,V16SF,V8DF"))
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu3,c86-4g-m7-fpu_0_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_expand_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "expand,compress")
+				    (and (not (eq_attr "mode" "XI,V16SF,V8DF"))
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu3,c86-4g-m7-fpu_0_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_expand_z" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "expand,compress")
+				    (and (eq_attr "mode" "XI,V16SF,V8DF")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu3,c86-4g-m7-fpu_0_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_expand_z_load" 17
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "expand,compress")
+				    (and (eq_attr "mode" "XI,V16SF,V8DF")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu3,c86-4g-m7-fpu_0_3")
+
+;; MOVNT
+(define_insn_reservation "c86_4g_m7_avx512_movnt_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "movnt")
+				   (and (eq_attr "mode" "XI,V16SF,V8DF")
+					(eq_attr "memory" "load")))))
+			 "c86-4g-m7-double,c86-4g-m7-load")
+
+(define_insn_reservation "c86_4g_m7_avx512_movnt_store" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "movnt")
+				    (and (eq_attr "mode" "XI,V16SF,V8DF")
+					 (eq_attr "memory" "store")))))
+			 "c86-4g-m7-direct,c86-4g-m7-store,c86-4g-m7-fpu1*2")
+
+(define_insn_reservation "c86_4g_m7_sse_movnt_store" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov,mmxmov")
+				   (and (eq_attr "c86_attr" "movnt")
+				    (and (not (eq_attr "mode" "XI,V16SF,V8DF"))
+					 (eq_attr "memory" "!none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-store,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_sse_movnt" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "movnt")
+				    (and (not (eq_attr "mode" "XI,V16SF,V8DF"))
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+;; BLENDV
+(define_insn_reservation "c86_4g_m7_avx512_blendv" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "blendv")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_avx512_blendv_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov")
+				   (and (eq_attr "c86_attr" "blendv")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_1")
+
+;; SSEMOV2
+(define_insn_reservation "c86_4g_m7_sse_mov2" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov2")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_sse_mov2_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemov2")
+				   (eq_attr "memory" "!none")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+;; SSEISHFT
+(define_insn_reservation "c86_4g_m7_avx512_sseishft_aligr" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseishft")
+				   (and (eq_attr "prefix_extra" "1")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseishft_aligr_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseishft")
+				   (and (eq_attr "prefix_extra" "1")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseishft_vshift" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseishft")
+				   (and (eq_attr "prefix_extra" "!1")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseishft_vshift_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseishft")
+				   (and (eq_attr "prefix_extra" "!1")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+
+;; SSEADD
+(define_insn_reservation "c86_4g_m7_avx512_sseadd_maxmin_xy" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sse")
+				   (and (eq_attr "c86_attr" "maxmin")
+				    (and (eq_attr "prefix" "evex")
+				      (and (eq_attr "memory" "none")
+					   (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseadd_maxmin_xy_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sse")
+				   (and (eq_attr "c86_attr" "maxmin")
+				    (and (eq_attr "prefix" "evex")
+				      (ior (eq_attr "memory" "load")
+					   (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx_sseadd_maxmin" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sse")
+				   (and (eq_attr "c86_attr" "maxmin")
+				    (and (eq_attr "prefix" "vex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_avx_sseadd_maxmin_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sse")
+				   (and (eq_attr "c86_attr" "maxmin")
+				    (and (eq_attr "prefix" "vex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_sse_sseadd_maxmin" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sse")
+				   (and (eq_attr "c86_attr" "maxmin")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu2|c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_sse_sseadd_maxmin_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sse")
+				   (and (eq_attr "c86_attr" "maxmin")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu2|c86-4g-m7-fpu3")
+
+;; SUB/ADD
+(define_insn_reservation "c86_4g_m7_avx512_sseadd_xy" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd")
+				   (and (eq_attr "c86_attr" "other")
+					  (eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseadd_xy_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd")
+				   (and (eq_attr "c86_attr" "other")
+					 (eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+;; HADD/HSUB
+(define_insn_reservation "c86_4g_m7_avx_sseadd_hplus" 7
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sseadd1")
+				   (and (eq_attr "c86_attr" "hplus")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-vector")
+
+(define_insn_reservation "c86_4g_m7_avx_sseadd_hplus_load" 14
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseadd,sseadd1")
+				   (and (eq_attr "c86_attr" "hplus")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-vector,c86-4g-m7-load")
+
+;; SSEIADD
+(define_insn_reservation "c86_4g_m7_avx512_sseiadd_madd" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "sadbw,madd")
+					(and (ior (eq_attr "prefix" "evex")
+						  (eq_attr "mode" "XI"))
+					     (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseiadd_madd_mem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "sadbw,madd")
+					(and (ior (eq_attr "prefix" "evex")
+						  (eq_attr "mode" "XI"))
+					     (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx_sseiadd_sadbw" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "prefix" "vex,maybe_evex")
+				     (and (eq_attr "mode" "TI,OI")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_avx_sseiadd_sadbw_mem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "prefix" "vex,maybe_evex")
+				     (and (eq_attr "mode" "TI,OI")
+					  (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_sse_sseiadd_sadbw" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_sse_sseiadd_sadbw_mem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "sadbw")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0|c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_sse_sseiadd_madd" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "madd")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu0")
+
+(define_insn_reservation "c86_4g_m7_sse_sseiadd_madd_mem" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "madd")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu0")
+
+;; AVG
+(define_insn_reservation "c86_4g_m7_avx512_sseiadd_avg" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "avg")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx512_sseiadd_avg_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "avg")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx_sseiadd_hplus" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd,sseiadd1")
+				   (and (eq_attr "c86_attr" "hplus")
+				    (and (eq_attr "prefix" "vex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector")
+
+(define_insn_reservation "c86_4g_m7_avx_sseiadd_hplus_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd,sseiadd1")
+				   (and (eq_attr "c86_attr" "hplus")
+				    (and (eq_attr "prefix" "vex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load")
+
+(define_insn_reservation "c86_4g_m7_sse_sseiadd_hplus" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd,sseiadd1")
+				   (and (eq_attr "c86_attr" "hplus")
+				    (and (eq_attr "prefix" "orig")
+				     (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpux2")
+
+(define_insn_reservation "c86_4g_m7_sse_sseiadd_hplus_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sseiadd,sseiadd1")
+				   (and (eq_attr "c86_attr" "hplus")
+				    (and (eq_attr "prefix" "orig")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpux2")
+
+;; SSEMUL
+(define_insn_reservation "c86_4g_m7_avx512_ssemul" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssemul_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemul")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+;; SSEDIV
+(define_insn_reservation "c86_4g_m7_avx512_ssediv_x" 13
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssediv")
+				   (and (eq_attr "mode" "SF,DF,V4SF,V2DF")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp1div1_fp3div3_x4x8")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssediv_xmem" 20
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssediv")
+				   (and (eq_attr "mode" "SF,DF,V4SF,V2DF")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp1div1_fp3div3_x4x8")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssediv_y" 13
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssediv")
+				   (and (eq_attr "mode" "V8SF,V4DF")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*8")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssediv_ymem" 20
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssediv")
+				   (and (eq_attr "mode" "V8SF,V4DF")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*8")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssediv_z" 24
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssediv")
+				   (and (eq_attr "mode" "V16SF,V8DF")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-double,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*20")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssediv_zmem" 31
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssediv")
+				   (and (eq_attr "mode" "V16SF,V8DF")
+					 (eq_attr "memory" "load"))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*20")
+
+;; SSECMP
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "mode" "V2DF,V4DF,V8SF,V4SF,SF,DF")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "mode" "V2DF,V4DF,V8SF,V4SF,SF,DF")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_z" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				     (and (eq_attr "c86_attr" "other")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_z_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				    (and (eq_attr "mode" "V16SF,V8DF,XI")
+				     (and (eq_attr "c86_attr" "other")
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_0_2,c86-4g-m7-fpu_1_3x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_vp" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "mode" "TI,OI")
+				     (and (eq_attr "c86_attr" "other")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_vp_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "mode" "TI,OI")
+				     (and (eq_attr "c86_attr" "other")
+					  (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_vp_z" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "mode" "XI")
+				     (and (eq_attr "c86_attr" "other,ptest")
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_vp_z_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "mode" "XI")
+				     (and (eq_attr "c86_attr" "other,ptest")
+					  (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu,c86-4g-m7-fpu_1_3x2")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecmp_vp" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "!evex")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecmp_vp_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				   (and (eq_attr "prefix" "!evex")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu")
+
+;; VPTEST
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_test" 6
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				    (and (eq_attr "mode" "TI,OI")
+				     (and (eq_attr "c86_attr" "ptest")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecmp_test_load" 13
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecmp")
+				    (and (eq_attr "mode" "TI,OI")
+				     (and (eq_attr "c86_attr" "ptest")
+					  (eq_attr "memory" "load")))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu1,c86-4g-m7-fpu_1_3")
+
+;; SSECVT
+(define_insn_reservation "c86_4g_m7_avx512_ssecvt_xy" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "c86_attr" "other")
+				    (and (eq_attr "prefix" "evex")
+				     (and (eq_attr "mode" "TI,V4SF,V2DF,OI,V8SF,V4DF")
+				      (and (not (ior (match_operand:V8DI 1 "register_operand")
+						     (match_operand:V8DF 1 "register_operand")))
+					   (eq_attr "memory" "none")))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecvt_xy_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "prefix" "evex")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (eq_attr "mode" "TI,V4SF,V2DF,OI,V8SF,V4DF")
+				      (and (not (ior (match_operand:V8DI 1 "register_operand")
+						     (match_operand:V8DF 1 "register_operand")))
+					   (eq_attr "memory" "!none")))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecvt_y_z" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "mode" "OI,V8SF,V4DF")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (ior (match_operand:V8DI 1 "register_operand")
+					       (match_operand:V8DF 1 "register_operand"))
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecvt_y_z_load" 15
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "mode" "OI,V8SF,V4DF")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (ior (match_operand:V8DI 1 "memory_operand")
+					       (match_operand:V8DF 1 "memory_operand"))
+					  (eq_attr "memory" "!none"))))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecvt_z" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "c86_attr" "other")
+				    (and (eq_attr "mode" "XI,V16SF,V8DF")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_ssecvt_z_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "c86_attr" "other")
+				    (and (eq_attr "mode" "XI,V16SF,V8DF")
+					 (eq_attr "memory" "!none")))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecvt" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "prefix" "!evex")
+				     (and (eq_attr "mmx_isa" "base")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu2|c86-4g-m7-fpu3")
+
+(define_insn_reservation "c86_4g_m7_avx_ssecvt_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "prefix" "!evex")
+				    (and (eq_attr "mmx_isa" "base")
+					 (eq_attr "memory" "!none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu2|c86-4g-m7-fpu3")
+
+;; CVTPI
+(define_insn_reservation "c86_4g_m7_sse_ssecvt_pspi" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "mode" "SF,DI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_sse_ssecvt_pspi_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "mode" "SF,DI")
+					 (eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu1")
+
+(define_insn_reservation "c86_4g_m7_sse_ssecvt_pi" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				    (and (not (eq_attr "mode" "SF,DI"))
+				     (and (eq_attr "mmx_isa" "native")
+					  (eq_attr "memory" "none")))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu1,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_sse_ssecvt_pi_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (not (eq_attr "mode" "SF,DI"))
+				    (and (eq_attr "mmx_isa" "native")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu1,c86-4g-m7-fpu_0_1")
+
+;; SSEMULADD
+(define_insn_reservation "c86_4g_m7_avx512_muladd" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemuladd")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_muladd_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemuladd")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_muladd_madd" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemuladd,sse")
+				   (and (eq_attr "c86_attr" "madd,rcp")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_muladd_madd_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "ssemuladd,sse")
+				   (and (eq_attr "c86_attr" "madd,rcp")
+				    (and (eq_attr "prefix" "evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+;; SSE
+(define_insn_reservation "c86_4g_m7_avx512_sse_range" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (eq_attr "length_immediate" "!1")
+				      (and (eq_attr "prefix" "evex")
+				       (and (eq_attr "c86_decode" "direct")
+					   (eq_attr "memory" "none")))))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_range_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (eq_attr "length_immediate" "!1")
+				      (and (eq_attr "c86_decode" "direct")
+				       (and (eq_attr "prefix" "evex")
+					    (eq_attr "memory" "load")))))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_conflict_x" 2
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_decode" "vector")
+				    (and (eq_attr "mode" "TI")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_1_3x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_conflict_x_load" 9
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_decode" "vector")
+				    (and (eq_attr "mode" "TI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_1_3x2")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_conflict_y" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_decode" "vector")
+				    (and (eq_attr "mode" "OI")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_1_3x3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_conflict_y_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_decode" "vector")
+				    (and (eq_attr "mode" "OI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_1_3x3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_conflict_z" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_decode" "vector")
+				    (and (eq_attr "mode" "XI")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_1_3x6")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_conflict_z_load" 15
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_decode" "vector")
+				    (and (eq_attr "mode" "XI")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_1_3x6")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_class" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_attr" "other")
+				    (and (eq_attr "length_immediate" "1")
+				     (and (not (eq_attr "mode" "V32HF,V16SF,V8DF"))
+					  (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu_1_3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_class_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (eq_attr "length_immediate" "1")
+				      (and (not (eq_attr "mode" "V32HF,V16SF,V8DF"))
+					   (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-double,c86-4g-m7-load,c86-4g-m7-fpu_1_3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_class_z" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (eq_attr "length_immediate" "1")
+				      (and (eq_attr "mode" "V32HF,V16SF,V8DF")
+					   (eq_attr "memory" "none"))))))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_1_3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_class_z_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				    (and (eq_attr "c86_attr" "other")
+				     (and (eq_attr "length_immediate" "1")
+				      (and (eq_attr "mode" "V32HF,V16SF,V8DF")
+					   (eq_attr "memory" "load"))))))
+			 "c86-4g-m7-vector,c86-4g-m7-load,c86-4g-m7-fpu_1_3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx_sse" 5
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_attr" "rcp,other")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_0_1")
+
+(define_insn_reservation "c86_4g_m7_avx_sse_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "c86_attr" "rcp,other")
+				    (and (eq_attr "prefix" "!evex")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fpu_0_1")
+
+;; SSE SQRT
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_sf_x" 14
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "SF,V4SF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp1div1_fp3div3_x4x9")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_sf_xload" 21
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "SF,V4SF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp1div1_fp3div3_x4x9")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_sf_y" 14
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V8SF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*9")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_sf_yload" 21
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V8SF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*9")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_sf_z" 26
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V16SF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*22")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_sf_zload" 33
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V16SF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*22")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_df_x" 20
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "DF,V2DF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp1div1_fp3div3_x4x15")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_df_xload" 27
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "DF,V2DF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp1div1_fp3div3_x4x15")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_df_y" 20
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V4DF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*15")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_df_yload" 27
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V4DF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*15")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_df_z" 38
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V8DF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "none")))))
+			 "c86-4g-m7-direct,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*34")
+
+(define_insn_reservation "c86_4g_m7_avx512_sse_sqrt_df_zload" 45
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "mode" "V8DF")
+				    (and (eq_attr "c86_attr" "sqrt")
+					 (eq_attr "memory" "load")))))
+			 "c86-4g-m7-direct,c86-4g-m7-load,c86-4g-m7-fp13div13x4,c86-4g-m7-fdiv13*34")
+
+;; MSKLOG/MSKMOV
+(define_insn_reservation "c86_4g_m7_avx512_msklog" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "msklog")
+				   (eq_attr "c86_decode" "direct")))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_msklog_vector" 4
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "msklog")
+				   (eq_attr "c86_decode" "vector")))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_mskmov_reg_k" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mskmov")
+				  (and (match_operand 0 "register_operand" "r")
+				       (eq_attr "memory" "none"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_mskmov_xy_k" 2
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mskmov")
+				   (ior (match_operand:V2DI 0 "register_operand" "v")
+					(match_operand:V4DI 0 "register_operand" "v"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_mskmov_z_k" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mskmov")
+				   (match_operand:V8DI 0 "register_operand" "v")))
+			 "c86-4g-m7-vector,c86-4g-m7-fpu3,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_mskmov_k_k" 1
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mskmov")
+				  (and (match_operand 0 "register_operand" "k")
+				       (match_operand 1 "register_operand" "k"))))
+			 "c86-4g-m7-direct,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_mskmov_k_reg" 3
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mskmov")
+				  (and (match_operand 0 "register_operand" "k")
+				       (match_operand 1 "register_operand" "r"))))
+			 "c86-4g-m7-double,c86-4g-m7-fpu1,c86-4g-m7-fpu_1_3")
+
+(define_insn_reservation "c86_4g_m7_avx512_mskmov_k_m" 8
+			 (and (eq_attr "cpu" "c86_4g_m7")
+			      (and (eq_attr "type" "mskmov")
+				  (and (match_operand 0 "register_operand" "k")
+				       (match_operand 1 "memory_operand"))))
+			 "c86-4g-m7-direct,c86-4g-m7-load")
new file mode 100644
--- /dev/null
+++ b/src/gcc/config/i386/c86-4g.md
@@ -0,0 +1,1214 @@
+;; Copyright (C) 2026 Free Software Foundation, Inc.
+;;
+;; This file is part of GCC.
+;;
+;; GCC is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; GCC is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GCC; see the file COPYING3.  If not see
+;; <http://www.gnu.org/licenses/>.
+;;
+
+
+(define_attr "c86_decode" "direct,vector,double"
+  (const_string "direct"))
+
+(define_attr "c86_attr" "other,abs,sqrt,maxmin,blend,blendv,rcp,movnt,avg,
+			       sign,sadbw,insr,perm2,perm,insertx,shufx,madd,
+			       compress,sselogic,cmpestr,extr,vpmovx,expand,aes,
+			       hplus,ptest"
+  (const_string "other"))
+
+;; HYGON Scheduling
+;; Modeling automatons for decoders, integer execution pipes,
+;; AGU pipes, floating point execution units, integer and
+;; floating point dividers.  Split fp1 into its own automaton
+;; to keep this unit independent without increasing the main
+;; c86_4g_fp state space.
+(define_automaton "c86_4g, c86_4g_ieu, c86_4g_fp024, c86_4g_fp1, c86_4g_agu, c86_4g_idiv, c86_4g_fdiv")
+
+;; Decoders unit has 4 decoders and all of them can decode fast path
+;; and vector type instructions.
+(define_cpu_unit "c86-4g-decode0" "c86_4g")
+(define_cpu_unit "c86-4g-decode1" "c86_4g")
+(define_cpu_unit "c86-4g-decode2" "c86_4g")
+(define_cpu_unit "c86-4g-decode3" "c86_4g")
+
+;; Currently blocking all decoders for vector path instructions as
+;; they are dispatched separetely as microcode sequence.
+;; Fix me: Need to revisit this.
+(define_reservation "c86-4g-vector" "c86-4g-decode0+c86-4g-decode1+c86-4g-decode2+c86-4g-decode3")
+
+;; Direct instructions can be issued to any of the four decoders.
+(define_reservation "c86-4g-direct" "c86-4g-decode0|c86-4g-decode1|c86-4g-decode2|c86-4g-decode3")
+
+;; Fix me: Need to revisit this later to simulate fast path double behavior.
+(define_reservation "c86-4g-double" "c86-4g-direct")
+
+;; Integer unit 4 ALU pipes.
+(define_cpu_unit "c86-4g-ieu0" "c86_4g_ieu")
+(define_cpu_unit "c86-4g-ieu1" "c86_4g_ieu")
+(define_cpu_unit "c86-4g-ieu2" "c86_4g_ieu")
+(define_cpu_unit "c86-4g-ieu3" "c86_4g_ieu")
+(define_reservation "c86-4g-ieu" "c86-4g-ieu0|c86-4g-ieu1|c86-4g-ieu2|c86-4g-ieu3")
+
+;; One separated integer divider.
+(define_cpu_unit "c86-4g-idiv" "c86_4g_idiv")
+
+;; 2 AGU pipes in c86_4g
+;; According to CPU diagram last AGU unit is used only for stores.
+(define_cpu_unit "c86-4g-agu0" "c86_4g_agu")
+(define_cpu_unit "c86-4g-agu1" "c86_4g_agu")
+(define_reservation "c86-4g-agu-reserve" "c86-4g-agu0|c86-4g-agu1")
+
+;; Load is 4 cycles.  We do not model reservation of load unit.
+;;(define_reservation "c86-4g-load" "c86-4g-agu-reserve, nothing, nothing, nothing")
+(define_reservation "c86-4g-load" "c86-4g-agu-reserve")
+(define_reservation "c86-4g-store" "c86-4g-agu-reserve")
+
+;; vectorpath (microcoded) instructions are single issue instructions.
+;; So, they occupy all the integer units.
+(define_reservation "c86-4g-ivector" "c86-4g-ieu0+c86-4g-ieu1
+				      +c86-4g-ieu2+c86-4g-ieu3
+				      +c86-4g-agu0+c86-4g-agu1")
+
+;; Floating point unit 4 FP pipes.
+(define_cpu_unit "c86-4g-fp0" "c86_4g_fp024")
+(define_cpu_unit "c86-4g-fp1" "c86_4g_fp1")
+(define_cpu_unit "c86-4g-fp2" "c86_4g_fp024")
+(define_cpu_unit "c86-4g-fp3" "c86_4g_fp024")
+
+(define_reservation "c86-4g-fpu" "c86-4g-fp0|c86-4g-fp1|c86-4g-fp2|c86-4g-fp3")
+
+(define_reservation "c86-4g-fvector" "c86-4g-fp0+c86-4g-fp1
+				      +c86-4g-fp2+c86-4g-fp3
+				      +c86-4g-agu0+c86-4g-agu1")
+
+;; One separated FP divider.
+(define_cpu_unit "c86-4g-fdiv" "c86_4g_fdiv")
+
+(define_reservation "c86-4g-fp1fdivx4" "(c86-4g-fp1+c86-4g-fdiv)*4")
+
+;; Call instruction
+(define_insn_reservation "c86_4g_call" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (eq_attr "type" "call,callv"))
+			 "c86-4g-double,c86-4g-store,c86-4g-ieu0+c86-4g-ieu3")
+
+;; General instructions
+(define_insn_reservation "c86_4g_push" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "push")
+				   (eq_attr "memory" "store")))
+			 "c86-4g-direct,c86-4g-store")
+
+(define_insn_reservation "c86_4g_push_load" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "push")
+				   (eq_attr "memory" "both")))
+			 "c86-4g-direct,c86-4g-load+c86-4g-store")
+
+(define_insn_reservation "c86_4g_pop" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "pop")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load")
+
+(define_insn_reservation "c86_4g_pop_mem" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "pop")
+				   (eq_attr "memory" "both")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-store")
+
+;; Leave
+(define_insn_reservation "c86_4g_leave" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (eq_attr "type" "leave"))
+			 "c86-4g-double,c86-4g-ieu+c86-4g-store")
+
+;; Integer Instructions or General instructions
+;; Multiplications
+;; Reg operands
+(define_insn_reservation "c86_4g_imul" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "imul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-ieu1")
+
+(define_insn_reservation "c86_4g_imul_mem" 7
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "imul")
+				   (eq_attr "memory" "!none")))
+			 "c86-4g-direct,c86-4g-load, c86-4g-ieu1")
+
+;; Divisions
+;; Reg operands
+(define_insn_reservation "c86_4g_idiv_DI" 41
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "DI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-ieu2,c86-4g-idiv*41")
+
+(define_insn_reservation "c86_4g_idiv_SI" 25
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "SI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-ieu2,c86-4g-idiv*25")
+
+(define_insn_reservation "c86_4g_idiv_HI" 17
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "HI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-ieu2,c86-4g-idiv*17")
+
+(define_insn_reservation "c86_4g_idiv_QI" 15
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "QI")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-ieu2,c86-4g-idiv*15")
+
+;; Mem operands
+(define_insn_reservation "c86_4g_idiv_mem_DI" 45
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "DI")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-ieu2,c86-4g-idiv*41")
+
+(define_insn_reservation "c86_4g_idiv_mem_SI" 29
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "SI")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-ieu2,c86-4g-idiv*25")
+
+(define_insn_reservation "c86_4g_idiv_mem_HI" 21
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "HI")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-ieu2,c86-4g-idiv*17")
+
+(define_insn_reservation "c86_4g_idiv_mem_QI" 19
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "idiv")
+				   (and (eq_attr "mode" "QI")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-ieu2,c86-4g-idiv*15")
+
+;; STR ISHIFT which are micro coded.
+;; Fix me: Latency need to be rechecked.
+(define_insn_reservation "c86_4g_str_ishift" 6
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "str,ishift")
+				   (eq_attr "memory" "both,store")))
+			 "c86-4g-vector,c86-4g-ivector")
+
+;; MOV - integer moves
+(define_insn_reservation "c86_4g_load_imov_double" 2
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "imovx")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-ieu")
+
+(define_insn_reservation "c86_4g_load_imov_direct" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "!double")
+				   (and (eq_attr "type" "imov,imovx")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-ieu")
+
+(define_insn_reservation "c86_4g_load_imov_double_store" 2
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "imovx")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-double,c86-4g-ieu,c86-4g-store")
+
+(define_insn_reservation "c86_4g_load_imov_direct_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "!double")
+				   (and (eq_attr "type" "imov,imovx")
+					(eq_attr "memory" "store"))))
+				   "c86-4g-direct,c86-4g-ieu,c86-4g-store")
+
+(define_insn_reservation "c86_4g_load_imov_double_load" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "imovx")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-ieu")
+
+(define_insn_reservation "c86_4g_load_imov_direct_load" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "!double")
+				   (and (eq_attr "type" "imov,imovx")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load")
+
+;; INTEGER/GENERAL instructions
+;; register/imm operands only: ALU, ICMP, NEG, NOT, ROTATE, ISHIFT, TEST
+(define_insn_reservation "c86_4g_insn" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "alu,icmp,negnot,rotate,rotate1,ishift,ishift1,test,setcc,incdec,icmov")
+				   (eq_attr "memory" "none,unknown")))
+			 "c86-4g-direct,c86-4g-ieu")
+
+(define_insn_reservation "c86_4g_insn_load" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "alu,icmp,negnot,rotate,rotate1,ishift,ishift1,test,setcc,incdec,icmov")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-ieu")
+
+;; FIXME: The instructions matched here has only two operands, which means memory type can only be none, load or both.
+;; Store memory type handling should never take effect here?
+(define_insn_reservation "c86_4g_insn_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "alu,icmp,negnot,rotate,rotate1,ishift1,test,setcc,incdec")
+				   (eq_attr "memory" "store")))
+			 "c86-4g-direct,c86-4g-ieu,c86-4g-store")
+
+(define_insn_reservation "c86_4g_insn_both" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "alu,icmp,negnot,rotate,rotate1,ishift1,test,setcc,incdec")
+				   (eq_attr "memory" "both")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-ieu,c86-4g-store")
+
+;; Special latency for multi type.
+(define_insn_reservation "c86_4g_fp_fcomp" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "memory" "none")
+				   (and (eq_attr "unit" "i387")
+					(eq_attr "type" "multi"))))
+			 "c86-4g-double,c86-4g-fp0|c86-4g-fp2")
+
+;; Fix me: Other vector type insns keeping latency 6 as of now.
+(define_insn_reservation "c86_4g_ieu_vector" 6
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "memory" "none")
+				   (and (eq_attr "unit" "!i387")
+					(eq_attr "type" "other,str,multi"))))
+			 "c86-4g-vector,c86-4g-ivector")
+
+;; ALU1 register operands.
+(define_insn_reservation "c86_4g_alu1_vector" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "vector")
+				   (and (eq_attr "type" "alu1")
+					(eq_attr "memory" "none,unknown"))))
+			 "c86-4g-vector,c86-4g-ivector")
+
+(define_insn_reservation "c86_4g_alu1_double" 2
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "alu1")
+					(eq_attr "memory" "none,unknown"))))
+			 "c86-4g-double,c86-4g-ieu")
+
+(define_insn_reservation "c86_4g_alu1_direct" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "alu1")
+					(eq_attr "memory" "none,unknown"))))
+			 "c86-4g-direct,c86-4g-ieu")
+
+;; Branches : Fix me need to model conditional branches.
+(define_insn_reservation "c86_4g_branch" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "ibr")
+					(eq_attr "memory" "none")))
+			  "c86-4g-direct")
+
+;; Indirect branches check latencies.
+(define_insn_reservation "c86_4g_indirect_branch_mem" 6
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "ibr")
+					(eq_attr "memory" "load")))
+			 "c86-4g-vector,c86-4g-ivector")
+
+;; LEA executes in ALU units with 1 cycle latency.
+(define_insn_reservation "c86_4g_lea" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (eq_attr "type" "lea"))
+			 "c86-4g-direct,c86-4g-ieu")
+
+;;  Floating point
+(define_insn_reservation "c86_4g_fp_cmov" 6
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (eq_attr "type" "fcmov"))
+			 "c86-4g-vector,c86-4g-fvector")
+
+
+(define_insn_reservation "c86_4g_fp_mov_direct_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_fp_mov_direct_store" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-direct,c86-4g-fp2|c86-4g-fp3,c86-4g-store")
+
+(define_insn_reservation "c86_4g_fp_mov_double" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_fp_mov_double_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "double")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_fp_mov_direct" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fmov")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp1")
+
+;; SQRT
+(define_insn_reservation "c86_4g_fp_sqrt" 22
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fpspc")
+				   (eq_attr "c86_attr" "sqrt")))
+			 "c86-4g-direct,c86-4g-fp1fdivx4,c86-4g-fdiv*18")
+
+(define_insn_reservation "c86_4g_sse_sqrt_sf" 14
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SF,V4SF,V8SF")
+				   (and (eq_attr "memory" "none,unknown")
+					(and (eq_attr "c86_attr" "sqrt")
+					     (eq_attr "type" "sse")))))
+			 "c86-4g-direct,c86-4g-fp1fdivx4,c86-4g-fdiv*10")
+
+(define_insn_reservation "c86_4g_sse_sqrt_sf_mem" 21
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SF,V4SF,V8SF")
+				   (and (eq_attr "memory" "load")
+					(and (eq_attr "c86_attr" "sqrt")
+					     (eq_attr "type" "sse")))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*10")
+
+(define_insn_reservation "c86_4g_sse_sqrt_df" 20
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "DF,V2DF,V4DF")
+				   (and (eq_attr "memory" "none,unknown")
+					(and (eq_attr "c86_attr" "sqrt")
+					     (eq_attr "type" "sse")))))
+			 "c86-4g-direct,c86-4g-fp1fdivx4,c86-4g-fdiv*16")
+
+(define_insn_reservation "c86_4g_sse_sqrt_df_mem" 27
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "DF,V2DF,V4DF")
+				   (and (eq_attr "memory" "load")
+					(and (eq_attr "c86_attr" "sqrt")
+					     (eq_attr "type" "sse")))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*16")
+
+;; RCP
+(define_insn_reservation "c86_4g_sse_rcp" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V4SF,V8SF,SF")
+				   (and (eq_attr "memory" "none")
+					(and (eq_attr "c86_attr" "rcp")
+					     (eq_attr "type" "sse")))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_rcp_mem" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V4SF,V8SF,SF")
+				   (and (eq_attr "memory" "load")
+					(and (eq_attr "c86_attr" "rcp")
+					     (eq_attr "type" "sse")))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+;; TODO: AGU?
+(define_insn_reservation "c86_4g_fp_spc_direct" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_decode" "direct")
+				   (and (eq_attr "type" "fpspc")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-direct,c86-4g-fp3")
+
+;; FABS
+(define_insn_reservation "c86_4g_fp_absneg" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (eq_attr "type" "fsgn"))
+			 "c86-4g-direct,c86-4g-fp1|c86-4g-fp3")
+
+;; FCMP
+(define_insn_reservation "c86_4g_fp_fcmp" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				  (and (eq_attr "memory" "none")
+				  (and (eq_attr "c86_decode" "double")
+				       (eq_attr "type" "fcmp"))))
+			 "c86-4g-double,c86-4g-fp0,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_fp_fcmp_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "memory" "load")
+				   (and (eq_attr "c86_decode" "double")
+					(eq_attr "type" "fcmp"))))
+			 "c86-4g-double,c86-4g-load, c86-4g-fp0,c86-4g-fp1")
+
+;;FADD FSUB FMUL
+(define_insn_reservation "c86_4g_fp_op_mul" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fop,fmul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_fp_op_mul_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fop,fmul")
+				   (and (eq_attr "fp_int_src" "false")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_fp_op_imul_load" 16
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fop,fmul")
+				   (and (eq_attr "fp_int_src" "true")
+					(eq_attr "memory" "load"))))
+			"c86-4g-double,c86-4g-load,c86-4g-fp0,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_fp_op_div" 15
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fdiv")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp1fdivx4,c86-4g-fdiv*11")
+
+(define_insn_reservation "c86_4g_fp_op_div_load" 22
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fdiv")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*11")
+
+(define_insn_reservation "c86_4g_fp_op_idiv_load" 26
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "fdiv")
+				   (and (eq_attr "fp_int_src" "true")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp1*4,c86-4g-fp1fdivx4,c86-4g-fdiv*11")
+
+;; MMX, SSE, SSEn.n, AVX, AVX2 instructions
+(define_insn_reservation "c86_4g_fp_insn" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (eq_attr "type" "mmx"))
+			 "c86-4g-direct,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_mmx_add" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxadd")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1|c86-4g-fp3")
+
+(define_insn_reservation "c86_4g_mmx_add_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxadd")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp1|c86-4g-fp3")
+
+(define_insn_reservation "c86_4g_mmx_hadd" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseadd1")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_mmx_hadd_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseadd1")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_mmx_cmp" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxcmp")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp3")
+
+(define_insn_reservation "c86_4g_mmx_cmp_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxcmp")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp3")
+
+(define_insn_reservation "c86_4g_mmx_cvt_pck_shuf" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxcvt,sseshuf,sseshuf1")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_mmx_cvt_pck_shuf_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxcvt,sseshuf,sseshuf1")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_mmx_shift" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxshft")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_mmx_move" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxmov")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_mmx_shift_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxshft")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_mmx_move_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxshft")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_mmx_move_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxshft,mmxmov")
+				   (eq_attr "memory" "store,both")))
+			  "c86-4g-direct,c86-4g-fp2,c86-4g-store")
+
+(define_insn_reservation "c86_4g_mmx_mul" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxmul")
+				   (eq_attr "memory" "none")))
+			  "c86-4g-direct,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_mmx_mul_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "mmxmul")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0")
+
+;; sseabs
+(define_insn_reservation "c86_4g_sse_abs" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_attr" "abs")
+				   (and (eq_attr "type" "sselog1")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_sse_pinsr_reg" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insr")
+					(and (match_operand 2 "register_operand")
+					     (eq_attr "memory" "none")))))
+			 "c86-4g-direct,c86-4g-ieu2,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_pinsr" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "insr")
+					(and (not (match_operand 2 "register_operand"))
+					     (eq_attr "memory" "none")))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_log" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_log_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_sign" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sign")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_sse_sign_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "sign")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fpu")
+
+
+(define_insn_reservation "c86_4g_sse_log1" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_log1_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sselog1")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "!none"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_extrq" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "prefix_data16" "1"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_movsdup" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sse")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "prefix" "vex"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_alignr" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "prefix_extra" "1"))
+			      (and (eq_attr "type" "sseishft")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_ishift" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "prefix_extra" "!1"))
+			      (and (eq_attr "type" "sseishft")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_ishift_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "prefix_extra" "!1"))
+			      (and (eq_attr "type" "sseishft")
+				   (eq_attr "memory" "!none")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_insertimm" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseins")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "length_immediate" "2"))))
+			 "c86-4g-direct,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sse_insert" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseins")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "length_immediate" "!2"))))
+			 "c86-4g-direct,c86-4g-fpu,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sse_comi" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SF,DF,V4SF,V2DF")
+				   (and (eq_attr "prefix" "!vex")
+					(and (eq_attr "prefix_extra" "0")
+					     (and (eq_attr "type" "ssecomi")
+						  (eq_attr "memory" "none"))))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_comi_load" 12
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "SF,DF,V4SF,V2DF"))
+			      (and (eq_attr "prefix_extra" "0")
+				   (and (eq_attr "type" "ssecomi")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_comi_double" 2
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V4SF,V2DF,TI"))
+			      (and (eq_attr "prefix" "vex")
+				   (and (eq_attr "prefix_extra" "0")
+					(and (eq_attr "type" "ssecomi")
+					     (eq_attr "memory" "none")))))
+			 "c86-4g-double,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_comi_double_load" 10
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V4SF,V2DF,TI"))
+			      (and (eq_attr "prefix" "vex")
+				   (and (eq_attr "prefix_extra" "0")
+					(and (eq_attr "type" "ssecomi")
+					     (eq_attr "memory" "load")))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp0|c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_test" 4
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "SF,DF,V4SF,V2DF,TI"))
+			      (and (eq_attr "prefix_extra" "1")
+				   (and (eq_attr "type" "ssecomi")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_test_load" 11
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "SF,DF,V4SF,V2DF,TI"))
+			      (and (eq_attr "prefix_extra" "1")
+				   (and (eq_attr "type" "ssecomi")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp1,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_avx256_test" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V8SF,V4DF,OI"))
+			      (and (eq_attr "prefix_extra" "1")
+				   (and (eq_attr "type" "ssecomi")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp1,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_avx256_test_load" 15
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V8SF,V4DF,OI"))
+			      (and (eq_attr "prefix_extra" "1")
+				   (and (eq_attr "type" "ssecomi")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp1,c86-4g-fp1")
+
+;; SSE moves
+;; Fix me:  Need to revist this again some of the moves may be restricted
+;; to some fpu pipes.
+
+;; movnt doesn't touch cache, so latency modeling has little impact.
+(define_insn_reservation "c86_4g_sse_movnt_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_attr" "movnt")
+				   (and (eq_attr "type" "ssemov,mmxmov,ssecvt")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load")
+
+(define_insn_reservation "c86_4g_sse_movnt_store" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "c86_attr" "movnt")
+				   (and (eq_attr "type" "ssemov,mmxmov,ssecvt")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-direct,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_sse_mov" 2
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SI")
+				   (and (eq_attr "isa" "avx")
+					(and (eq_attr "type" "ssemov")
+					     (eq_attr "memory" "none")))))
+			 "c86-4g-direct,c86-4g-ieu0")
+
+(define_insn_reservation "c86_4g_avx_mov" 2
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "TI")
+				   (and (eq_attr "isa" "avx")
+					(and (eq_attr "type" "ssemov")
+					     (and (match_operand:SI 1 "register_operand")
+						  (eq_attr "memory" "none"))))))
+			 "c86-4g-direct,c86-4g-ieu2")
+
+(define_insn_reservation "c86_4g_sseavx_mov" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "SF,DF,V4SF,V2DF,TI"))
+			      (and (eq_attr "prefix_extra" "0")
+				   (and (eq_attr "type" "ssemov")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_sseavx_blend" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "SF,DF,V4SF,V2DF"))
+			      (and (eq_attr "type" "ssemov,sselog1")
+				   (and (eq_attr "c86_attr" "blend,blendv")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sseavx_mov_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SF,DF,V4SF,V2DF,TI")
+				   (and (eq_attr "type" "ssemov")
+					(eq_attr "memory" "store"))))
+			"c86-4g-direct,c86-4g-fpu,c86-4g-store")
+
+(define_insn_reservation "c86_4g_sseavx_mov_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "SF,DF,V4SF,V2DF,TI"))
+			       (and (eq_attr "type" "ssemov")
+				    (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_avx256_mov" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF,V4DF,OI")
+				   (and (eq_attr "type" "ssemov")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_avx256_mov_store" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF,V4DF,OI")
+				   (and (eq_attr "type" "ssemov")
+					(eq_attr "memory" "store"))))
+			 "c86-4g-double,c86-4g-fpu,c86-4g-store")
+
+(define_insn_reservation "c86_4g_avx256_mov_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF,V4DF,OI")
+				   (and (eq_attr "type" "ssemov")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fpu")
+
+;; SSE max & min
+(define_insn_reservation "c86_4g_sse_maxmin" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "SF,DF,V4SF,V8SF,V2DF,V4DF,TI"))
+			      (and (eq_attr "type" "sseadd")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "c86_attr" "maxmin"))))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_maxmin_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "SF,DF,V4SF,V8SF,V2DF,V4DF,TI"))
+			      (and (eq_attr "type" "sseadd")
+				   (and (eq_attr "memory" "load")
+					(eq_attr "c86_attr" "maxmin"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_pmaxmin" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "TI,OI"))
+			      (and (eq_attr "type" "mmxadd,sseiadd")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "c86_attr" "maxmin"))))
+			 "c86-4g-direct,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_sse_pmaxmin_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "TI,OI"))
+			      (and (eq_attr "type" "mmxadd,sseiadd")
+				   (and (eq_attr "memory" "load")
+					(eq_attr "c86_attr" "maxmin"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fpu")
+
+;; SSE avg
+(define_insn_reservation "c86_4g_sse_avg" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "c86_attr" "avg"))
+			      (and (eq_attr "type" "sseiadd,mmxshft")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_sse_avg_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "c86_attr" "avg"))
+			      (and (eq_attr "type" "sseiadd,mmxshft")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp3")
+
+;;MMX sadbw
+(define_insn_reservation "c86_4g_sse_sadbw" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseiadd,mmxshft")
+				   (and (eq_attr "c86_attr" "sadbw")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sse_sadbw_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseiadd,mmxshft")
+				   (and (eq_attr "c86_attr" "sadbw")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0")
+
+;; SSE add
+(define_insn_reservation "c86_4g_sse_add" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseadd")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "c86_attr" "other"))))
+			 "c86-4g-direct,c86-4g-fp1|c86-4g-fp3")
+
+(define_insn_reservation "c86_4g_sse_add_load" 10
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseadd")
+				   (and (eq_attr "memory" "load")
+					(eq_attr "c86_attr" "!maxmin"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1|c86-4g-fp3")
+
+(define_insn_reservation "c86_4g_sse_fma" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "ssemuladd")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_fma_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "ssemuladd")
+				   (eq_attr "memory" "load")))
+			"c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_iadd" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseiadd")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fpu")
+
+(define_insn_reservation "c86_4g_sse_iadd_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "sseiadd")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fpu")
+
+;; SSE conversions.
+(define_insn_reservation "c86_4g_ssecvtsf_si_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SI")
+				   (and (eq_attr "type" "sseicvt")
+					(and (match_operand:SF 1 "memory_operand")
+					     (eq_attr "memory" "load")))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp3,c86-4g-ieu0")
+
+(define_insn_reservation "c86_4g_ssecvtdf_si" 5
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SI")
+				   (and (match_operand:DF 1 "register_operand")
+					(and (eq_attr "type" "sseicvt")
+					     (eq_attr "memory" "none")))))
+			 "c86-4g-double,c86-4g-fp3,c86-4g-ieu0")
+
+(define_insn_reservation "c86_4g_ssecvtdf_si_load" 12
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "SI")
+				   (and (eq_attr "type" "sseicvt")
+					(and (match_operand:DF 1 "memory_operand")
+					     (eq_attr "memory" "load")))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp3,c86-4g-ieu0")
+
+;; All other used ssecvt fp3 pipes
+;; Check: Need to revisit this again.
+;; Some SSE converts may use different pipe combinations.
+(define_insn_reservation "c86_4g_ssecvt" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-direct,c86-4g-fp1")
+
+(define_insn_reservation "c86_4g_ssecvt_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "type" "ssecvt")
+				   (and (eq_attr "c86_attr" "other")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1")
+
+;; SSE div
+(define_insn_reservation "c86_4g_ssediv_ss_ps" 10
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V4SF,SF"))
+			      (and (eq_attr "type" "ssediv")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp1fdivx4,c86-4g-fdiv*6")
+
+(define_insn_reservation "c86_4g_ssediv_ss_ps_load" 17
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V4SF,SF"))
+			      (and (eq_attr "type" "ssediv")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*6")
+
+(define_insn_reservation "c86_4g_ssediv_sd_pd" 13
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "V2DF,DF"))
+			      (and (eq_attr "type" "ssediv")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp1fdivx4,c86-4g-fdiv*9")
+
+(define_insn_reservation "c86_4g_ssediv_sd_pd_load" 20
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					       (eq_attr "mode" "V2DF,DF"))
+			      (and (eq_attr "type" "ssediv")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*9")
+
+
+(define_insn_reservation "c86_4g_ssediv_avx256_ps" 10
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "type" "ssediv"))))
+			 "c86-4g-double,c86-4g-fp1fdivx4,c86-4g-fdiv*6")
+
+(define_insn_reservation "c86_4g_ssediv_avx256_ps_load" 17
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF")
+				   (and (eq_attr "type" "ssediv")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*6")
+
+(define_insn_reservation "c86_4g_ssediv_avx256_pd" 13
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V4DF")
+				   (and (eq_attr "type" "ssediv")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-fp1fdivx4,c86-4g-fdiv*9")
+
+(define_insn_reservation "c86_4g_ssediv_avx256_pd_load" 20
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V4DF")
+				   (and (eq_attr "type" "ssediv")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp1fdivx4,c86-4g-fdiv*9")
+;; SSE MUL
+(define_insn_reservation "c86_4g_ssemul_ss_ps" 3
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "V8SF,V4SF,SF"))
+			      (and (eq_attr "type" "ssemul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_ssemul_ss_ps_load" 10
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "V8SF,V4SF,SF"))
+			      (and (eq_attr "type" "ssemul")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_ssemul_sd_pd" 4
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "V4DF,V2DF,DF"))
+			      (and (eq_attr "type" "ssemul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_ssemul_sd_pd_load" 11
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "V4DF,V2DF,DF"))
+			      (and (eq_attr "type" "ssemul")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+;;SSE imul
+(define_insn_reservation "c86_4g_sseimul" 3
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "TI"))
+			      (and (eq_attr "type" "sseimul")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sseimul_avx256" 4
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "OI")
+				   (and (eq_attr "type" "sseimul")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sseimul_load" 10
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "TI"))
+			      (and (eq_attr "type" "sseimul")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sseimul_avx256_load" 11
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "OI")
+				   (and (eq_attr "type" "sseimul")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sseimul_di" 3
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "DI")
+				   (and (eq_attr "memory" "none")
+					(eq_attr "type" "sseimul"))))
+			 "c86-4g-direct,c86-4g-fp0")
+
+(define_insn_reservation "c86_4g_sseimul_load_di" 10
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "DI")
+				   (and (eq_attr "type" "sseimul")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0")
+
+;; SSE compares
+(define_insn_reservation "c86_4g_sse_cmp" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					(eq_attr "mode" "SF,DF,V4SF,V2DF"))
+			       (and (eq_attr "type" "ssecmp")
+				    (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_cmp_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+					 (eq_attr "mode" "SF,DF,V4SF,V2DF"))
+			      (and (eq_attr "type" "ssecmp")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+
+(define_insn_reservation "c86_4g_sse_cmp_avx256" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF,V4DF")
+				   (and (eq_attr "type" "ssecmp")
+					(eq_attr "memory" "none"))))
+			"c86-4g-double,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_cmp_avx256_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "V8SF,V4DF")
+				   (and (eq_attr "type" "ssecmp")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fp0|c86-4g-fp2")
+
+(define_insn_reservation "c86_4g_sse_icmp" 1
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "QI,HI,SI,DI,TI"))
+			      (and (eq_attr "type" "ssecmp")
+				   (eq_attr "memory" "none")))
+			 "c86-4g-direct,c86-4g-fpu")
+
+
+(define_insn_reservation "c86_4g_sse_icmp_load" 8
+			 (and (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+				   (eq_attr "mode" "QI,HI,SI,DI,TI"))
+			      (and (eq_attr "type" "ssecmp")
+				   (eq_attr "memory" "load")))
+			 "c86-4g-direct,c86-4g-load,c86-4g-fpu")
+
+
+(define_insn_reservation "c86_4g_sse_icmp_avx256" 1
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "OI")
+				   (and (eq_attr "type" "ssecmp")
+					(eq_attr "memory" "none"))))
+			 "c86-4g-double,c86-4g-fpu")
+
+
+(define_insn_reservation "c86_4g_sse_icmp_avx256_load" 8
+			 (and (eq_attr "cpu" "c86_4g_m4,c86_4g_m6")
+			      (and (eq_attr "mode" "OI")
+				   (and (eq_attr "type" "ssecmp")
+					(eq_attr "memory" "load"))))
+			 "c86-4g-double,c86-4g-load,c86-4g-fpu")
--- a/src/gcc/config/i386/cpuid.h
+++ b/src/gcc/config/i386/cpuid.h
@@ -235,6 +235,10 @@
 #define signature_SHANGHAI_ecx	0x20206961
 #define signature_SHANGHAI_edx	0x68676e61
 
+#define signature_HYGON_ebx	0x6f677948
+#define signature_HYGON_ecx	0x656e6975
+#define signature_HYGON_edx	0x6e65476e
+
 #ifndef __x86_64__
 /* At least one cpu (Winchip 2) does not set %ebx and %ecx
    for cpuid leaf 1. Forcibly zero the two registers before
--- a/src/gcc/config/i386/driver-i386.cc
+++ b/src/gcc/config/i386/driver-i386.cc
@@ -501,6 +501,16 @@ const char *host_detect_local_cpu (int argc, const char **argv)
       else
 	processor = PROCESSOR_PENTIUM;
     }
+  else if (vendor == VENDOR_HYGON)
+    {
+      processor = PROCESSOR_GENERIC;
+      if (model == 4)
+	processor = PROCESSOR_C86_4G_M4;
+      else if (model == 6)
+	processor = PROCESSOR_C86_4G_M6;
+      else if (model >= 7)
+	processor = PROCESSOR_C86_4G_M7;
+    }
   else if (vendor == VENDOR_CENTAUR)
     {
       processor = PROCESSOR_GENERIC;
@@ -850,6 +860,15 @@ const char *host_detect_local_cpu (int argc, const char **argv)
     case PROCESSOR_SHIJIDADAO:
       cpu = "shijidadao";
       break;
+    case PROCESSOR_C86_4G_M4:
+      cpu = "c86-4g-m4";
+      break;
+    case PROCESSOR_C86_4G_M6:
+      cpu = "c86-4g-m6";
+      break;
+    case PROCESSOR_C86_4G_M7:
+      cpu = "c86-4g-m7";
+      break;
 
     default:
       /* Use something reasonable.  */
--- a/src/gcc/config/i386/i386-c.cc
+++ b/src/gcc/config/i386/i386-c.cc
@@ -303,7 +303,18 @@ ix86_target_macros_internal (HOST_WIDE_INT isa_flag,
       def_or_undef (parse_in, "__novalake");
       def_or_undef (parse_in, "__novalake__");
       break;
-
+    case PROCESSOR_C86_4G_M4:
+      def_or_undef (parse_in, "__c86_4g_m4");
+      def_or_undef (parse_in, "__c86_4g_m4__");
+      break;
+    case PROCESSOR_C86_4G_M6:
+      def_or_undef (parse_in, "__c86_4g_m6");
+      def_or_undef (parse_in, "__c86_4g_m6__");
+      break;
+    case PROCESSOR_C86_4G_M7:
+      def_or_undef (parse_in, "__c86_4g_m7");
+      def_or_undef (parse_in, "__c86_4g_m7__");
+      break;
     /* use PROCESSOR_max to not set/unset the arch macro.  */
     case PROCESSOR_max:
       break;
@@ -512,6 +523,15 @@ ix86_target_macros_internal (HOST_WIDE_INT isa_flag,
     case PROCESSOR_NOVALAKE:
       def_or_undef (parse_in, "__tune_novalake__");
       break;
+    case PROCESSOR_C86_4G_M4:
+      def_or_undef (parse_in, "__tune_c86_4g_m4__");
+      break;
+    case PROCESSOR_C86_4G_M6:
+      def_or_undef (parse_in, "__tune_c86_4g_m6__");
+      break;
+    case PROCESSOR_C86_4G_M7:
+      def_or_undef (parse_in, "__tune_c86_4g_m7__");
+      break;
     case PROCESSOR_INTEL:
     case PROCESSOR_GENERIC:
       break;
--- a/src/gcc/config/i386/i386-expand.cc
+++ b/src/gcc/config/i386/i386-expand.cc
@@ -10454,7 +10454,7 @@ ix86_expand_movmem (rtx operands[])
 {
   /* Since there are much less registers available in 32-bit mode, don't
      inline movmem in 32-bit mode.  */
-  if (!TARGET_64BIT)
+  if (!TARGET_64BIT || optimize_insn_for_size_p ())
     return false;
 
   rtx dst = operands[0];
@@ -10585,12 +10585,12 @@ ix86_expand_movmem (rtx operands[])
 				 more_8x_vec_label);
 
       rtx_code_label *last_4x_vec_label = nullptr;
-      if (min_size == 0 || min_size < 4 * move_max)
+      if (min_size == 0 || min_size <= 4 * move_max)
 	last_4x_vec_label = gen_label_rtx ();
 
-      /* Jump to LAST_4X_VEC_LABEL if size < 4 * MOVE_MAX.  */
+      /* Jump to LAST_4X_VEC_LABEL if size <= 4 * MOVE_MAX.  */
       if (last_4x_vec_label)
-	emit_cmp_and_jump_insns (count_exp, GEN_INT (4 * move_max), LTU,
+	emit_cmp_and_jump_insns (count_exp, GEN_INT (4 * move_max), LEU,
 				 nullptr, count_mode, 1,
 				 last_4x_vec_label);
 
@@ -15243,7 +15243,7 @@ ix86_expand_builtin (tree exp, rtx target, rtx subtarget,
 	else
 	  {
 	    if (INTVAL (op3) != 0)
-	      warning (0, "invalid forth argument to"
+	      warning (0, "invalid fourth argument to"
 			  " %<__builtin_ia32_prefetch%>; using zero");
 
 	    if (!address_operand (op0, VOIDmode))
--- a/src/gcc/config/i386/i386-options.cc
+++ b/src/gcc/config/i386/i386-options.cc
@@ -185,6 +185,10 @@ along with GCC; see the file COPYING3.  If not see
 #define m_ZNVER (m_ZNVER1 | m_ZNVER2 | m_ZNVER3 | m_ZNVER4 | m_ZNVER5 | m_ZNVER6)
 #define m_AMD_MULTIPLE (m_ATHLON_K8 | m_AMDFAM10 | m_BDVER | m_BTVER \
 			| m_ZNVER)
+#define m_C86_4G_M4 (HOST_WIDE_INT_1U<<PROCESSOR_C86_4G_M4)
+#define m_C86_4G_M6 (HOST_WIDE_INT_1U<<PROCESSOR_C86_4G_M6)
+#define m_C86_4G_M7 (HOST_WIDE_INT_1U<<PROCESSOR_C86_4G_M7)
+#define m_C86_4G (m_C86_4G_M4 | m_C86_4G_M6 | m_C86_4G_M7)
 
 #define m_GENERIC (HOST_WIDE_INT_1U<<PROCESSOR_GENERIC)
 
@@ -814,7 +818,10 @@ static const struct processor_costs *processor_cost_table[] =
   &znver3_cost,		/* PROCESSOR_ZNVER3.		*/
   &znver4_cost,		/* PROCESSOR_ZNVER4.		*/
   &znver5_cost,		/* PROCESSOR_ZNVER5.		*/
-  &znver5_cost		/* PROCESSOR_ZNVER6.		*/
+  &znver5_cost,		/* PROCESSOR_ZNVER6.		*/
+  &c86_4g_m4_cost,	/* PROCESSOR_C86_4G_M4.		*/
+  &c86_4g_m6_cost,	/* PROCESSOR_C86_4G_M6.		*/
+  &c86_4g_m7_cost	/* PROCESSOR_C86_4G_M7.		*/
 };
 
 /* Guarantee that the array is aligned with enum processor_type.  */
--- a/src/gcc/config/i386/i386.cc
+++ b/src/gcc/config/i386/i386.cc
@@ -6777,6 +6777,13 @@ ix86_save_reg (unsigned int regno, bool maybe_eh_return, bool ignore_outlined)
 {
   rtx reg;
 
+  /* Save and restore DRAP register between prologue and epilogue so
+     that stack pointer can be restored.  */
+  if (crtl->drap_reg
+      && regno == REGNO (crtl->drap_reg)
+      && !cfun->machine->no_drap_save_restore)
+    return true;
+
   switch (cfun->machine->call_saved_registers)
     {
     case TYPE_DEFAULT_CALL_SAVED_REGISTERS:
@@ -6852,11 +6859,6 @@ ix86_save_reg (unsigned int regno, bool maybe_eh_return, bool ignore_outlined)
 	return false;
     }
 
-  if (crtl->drap_reg
-      && regno == REGNO (crtl->drap_reg)
-      && !cfun->machine->no_drap_save_restore)
-    return true;
-
   return (df_regs_ever_live_p (regno)
 	  && !call_used_or_fixed_reg_p (regno)
 	  && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
@@ -7947,6 +7949,11 @@ find_drap_reg (void)
      registers.  */
   if (TARGET_64BIT)
     {
+      /* In preserve_none functions, any register can be used for DRAP,
+	 except AX, R12–R15, DI, SI (argument registers), SP, and BP.  */
+      if (cfun->machine->call_saved_registers == TYPE_PRESERVE_NONE)
+	return R11_REG;
+
       /* Use R13 for nested function or function need static chain.
 	 Since function with tail call may use any caller-saved
 	 registers in epilogue, DRAP must not use caller-saved
@@ -25822,7 +25829,10 @@ ix86_reassociation_width (unsigned int op, machine_mode mode)
       /* Znver1-4 Integer vector instructions execute in FP unit
 	 and can execute 3 additions and one multiplication per cycle.  */
       if ((ix86_tune == PROCESSOR_ZNVER1 || ix86_tune == PROCESSOR_ZNVER2
-	   || ix86_tune == PROCESSOR_ZNVER3 || ix86_tune == PROCESSOR_ZNVER4)
+	   || ix86_tune == PROCESSOR_ZNVER3 || ix86_tune == PROCESSOR_ZNVER4
+	   || ix86_tune == PROCESSOR_C86_4G_M4
+	   || ix86_tune == PROCESSOR_C86_4G_M6
+	   || ix86_tune == PROCESSOR_C86_4G_M7)
    	  && INTEGRAL_MODE_P (mode) && op != PLUS && op != MINUS)
 	return 1;
       /* Znver5 can do 2 integer multiplications per cycle with latency
--- a/src/gcc/config/i386/i386.h
+++ b/src/gcc/config/i386/i386.h
@@ -512,7 +512,8 @@ extern unsigned char ix86_tune_features[X86_TUNE_LAST];
 	ix86_tune_features[X86_TUNE_ALIGN_TIGHT_LOOPS]
 #define TARGET_SSE_REDUCTION_PREFER_PSHUF \
 	ix86_tune_features[X86_TUNE_SSE_REDUCTION_PREFER_PSHUF]
-
+#define TARGET_DISABLE_SETZUCC \
+	ix86_tune_features[X86_TUNE_DISABLE_SETZUCC]
 
 /* Feature tests against the various architecture variations.  */
 enum ix86_arch_indices {
@@ -2384,6 +2385,9 @@ enum processor_type
   PROCESSOR_ZNVER4,
   PROCESSOR_ZNVER5,
   PROCESSOR_ZNVER6,
+  PROCESSOR_C86_4G_M4,
+  PROCESSOR_C86_4G_M6,
+  PROCESSOR_C86_4G_M7,
   PROCESSOR_max
 };
 
@@ -2547,6 +2551,21 @@ constexpr wide_int_bitmask PTA_LUJIAZUI = PTA_64BIT | PTA_MMX | PTA_SSE
 constexpr wide_int_bitmask PTA_YONGFENG = PTA_LUJIAZUI | PTA_AVX | PTA_AVX2
   | PTA_F16C | PTA_FMA | PTA_SHA;
 
+constexpr wide_int_bitmask PTA_C86_4G_M4 = PTA_64BIT | PTA_MMX | PTA_SSE
+  | PTA_SSE2 | PTA_SSE3 | PTA_SSE4A | PTA_CX16 | PTA_ABM | PTA_SSSE3
+  | PTA_SSE4_1 | PTA_SSE4_2 | PTA_AES | PTA_PCLMUL | PTA_AVX | PTA_AVX2
+  | PTA_BMI | PTA_BMI2 | PTA_F16C | PTA_FMA | PTA_PRFCHW | PTA_FXSR | PTA_XSAVE
+  | PTA_XSAVEOPT | PTA_FSGSBASE | PTA_RDRND | PTA_MOVBE | PTA_MWAITX | PTA_ADX
+  | PTA_RDSEED | PTA_CLZERO | PTA_CLFLUSHOPT | PTA_XSAVEC | PTA_XSAVES
+  | PTA_SHA | PTA_LZCNT | PTA_POPCNT;
+constexpr wide_int_bitmask PTA_C86_4G_M6 = PTA_C86_4G_M4;
+constexpr wide_int_bitmask PTA_C86_4G_M7 = PTA_C86_4G_M4 | PTA_AVX512F
+  | PTA_AVX512DQ | PTA_AVX512IFMA | PTA_AVX512CD | PTA_AVX512BW | PTA_AVX512VL
+  | PTA_AVX512BF16 | PTA_AVX512VBMI | PTA_AVX512VBMI2 | PTA_GFNI
+  | PTA_AVX512VNNI | PTA_AVX512BITALG | PTA_AVX512VPOPCNTDQ
+  | PTA_AVX512VP2INTERSECT | PTA_VAES | PTA_AVXVNNI | PTA_VPCLMULQDQ
+  | PTA_WBNOINVD | PTA_CLWB;
+
 #ifndef GENERATOR_FILE
 
 #include "insn-attr-common.h"
--- a/src/gcc/config/i386/i386.md
+++ b/src/gcc/config/i386/i386.md
@@ -530,7 +530,7 @@ (define_constants
 (define_attr "cpu" "none,pentium,pentiumpro,geode,k6,athlon,k8,core2,nehalem,
 		    atom,slm,glm,haswell,generic,lujiazui,yongfeng,amdfam10,bdver1,
 		    bdver2,bdver3,bdver4,btver2,znver1,znver2,znver3,znver4,
-		    znver5,znver6"
+		    znver5,znver6,c86_4g_m4,c86_4g_m6,c86_4g_m7"
   (const (symbol_ref "ix86_schedule")))
 
 ;; A basic instruction type.  Refinements due to arguments to be
@@ -1427,6 +1427,8 @@ (define_mode_iterator PTR
 (include "haswell.md")
 (include "lujiazui.md")
 (include "yongfeng.md")
+(include "c86-4g.md")
+(include "c86-4g-m7.md")
 
 
 ;; Operand and operator predicates and constraints
@@ -2038,6 +2040,7 @@ (define_insn "*cmpi<unord>xf_i387"
    (set_attr "athlon_decode" "vector")
    (set_attr "amdfam10_decode" "direct")
    (set_attr "bdver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "znver1_decode" "double")])
 
 (define_insn "*cmpx<unord><MODEF:mode>"
@@ -2091,6 +2094,7 @@ (define_insn "*cmpi<unord><MODEF:mode>"
    (set_attr "amdfam10_decode" "direct")
    (set_attr "bdver1_decode" "double")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set (attr "enabled")
      (if_then_else
        (match_test ("SSE_FLOAT_MODE_P (<MODEF:MODE>mode) && TARGET_SSE_MATH"))
@@ -2482,6 +2486,7 @@ (define_insn "*movxi_internal_avx512f"
     }
 }
   [(set_attr "type" "sselog1,sselog1,ssemov,ssemov")
+   (set_attr "c86_attr" "sselogic,sselogic,*,*")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -2506,6 +2511,7 @@ (define_insn "*movoi_internal_avx"
 }
   [(set_attr "isa" "*,avx2,*,*")
    (set_attr "type" "sselog1,sselog1,ssemov,ssemov")
+   (set_attr "c86_attr" "sselogic,sselogic,*,*")
    (set_attr "prefix" "vex")
    (set_attr "mode" "OI")])
 
@@ -2548,6 +2554,10 @@ (define_insn "*movti_internal"
 	      (const_string "sselog1")
 	   ]
 	   (const_string "ssemov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "2,3")
+       (const_string "sselogic")
+       (const_string "*")))
    (set (attr "prefix")
      (if_then_else (eq_attr "type" "sselog1,ssemov")
        (const_string "maybe_vex")
@@ -2691,6 +2701,10 @@ (define_insn "*movdi_internal"
 	      (const_string "lea")
 	   ]
 	   (const_string "imov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "12")
+       (const_string "sselogic")
+       (const_string "*")))
    (set (attr "modrm")
      (if_then_else
        (and (eq_attr "alternative" "4") (eq_attr "type" "imov"))
@@ -2911,6 +2925,10 @@ (define_insn "*movsi_internal"
 	      (const_string "lea")
 	   ]
 	   (const_string "imov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "8")
+       (const_string "sselogic")
+       (const_string "*")))
    (set (attr "prefix")
      (if_then_else (eq_attr "type" "sselog1,ssemov")
        (const_string "maybe_vex")
@@ -3085,6 +3103,10 @@ (define_insn "*movhi_internal"
 	      (const_string "imovx")
 	   ]
 	   (const_string "imov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "11")
+       (const_string "sselogic")
+       (const_string "*")))
    (set (attr "prefix")
 	(cond [(eq_attr "alternative" "4,5,6,7,8")
 		 (const_string "vex")
@@ -3366,6 +3388,7 @@ (define_insn "swap<mode>"
    (set_attr "pent_pair" "np")
    (set_attr "athlon_decode" "vector")
    (set_attr "amdfam10_decode" "double")
+   (set_attr "c86_decode" "vector")
    (set_attr "bdver1_decode" "double")])
 
 (define_insn "*swap<mode>"
@@ -3391,6 +3414,7 @@ (define_insn "*swap<mode>"
    (set_attr "pent_pair" "np")
    (set_attr "athlon_decode" "vector")
    (set_attr "amdfam10_decode" "double")
+   (set_attr "c86_decode" "vector")
    (set_attr "bdver1_decode" "double")])
 
 (define_peephole2
@@ -4068,6 +4092,7 @@ (define_insn "*movtf_internal"
 }
   [(set_attr "isa" "*,*,*,x64,x64")
    (set_attr "type" "sselog1,ssemov,ssemov,multi,multi")
+   (set_attr "c86_attr" "sselogic,*,*,*,*")
    (set (attr "prefix")
      (if_then_else (eq_attr "type" "sselog1,ssemov")
        (const_string "maybe_vex")
@@ -4239,6 +4264,10 @@ (define_insn "*movdf_internal"
 		 (const_string "sselog1")
 	      ]
 	      (const_string "ssemov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "12,16")
+       (const_string "sselogic")
+       (const_string "*")))
    (set (attr "modrm")
      (if_then_else (eq_attr "alternative" "11")
        (const_string "0")
@@ -4411,6 +4440,10 @@ (define_insn "*movsf_internal"
 		 (const_string "mmxmov")
 	      ]
 	      (const_string "ssemov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "5")
+       (const_string "sselogic")
+       (const_string "*")))
    (set (attr "prefix")
      (if_then_else (eq_attr "type" "sselog1,ssemov")
        (const_string "maybe_vex")
@@ -4759,6 +4792,10 @@ (define_insn "*zero_extendsidi2"
 	      (const_string "mskmov")
 	   ]
 	   (const_string "imovx")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "10,11")
+       (const_string "vpmovx")
+       (const_string "*")))
    (set (attr "prefix_extra")
      (if_then_else (eq_attr "alternative" "10,11")
        (const_string "1")
@@ -5168,6 +5205,10 @@ (define_insn "extendhisi2"
      (if_then_else (eq_attr "prefix_0f" "0")
 	(const_string "double")
 	(const_string "direct")))
+   (set (attr "c86_decode")
+     (if_then_else (eq_attr "prefix_0f" "0")
+	(const_string "double")
+	(const_string "direct")))
    (set (attr "modrm")
      (if_then_else (eq_attr "prefix_0f" "0")
 	(const_string "0")
@@ -6075,6 +6116,7 @@ (define_insn "floathi<mode>2"
   [(set_attr "type" "fmov")
    (set_attr "mode" "<MODE>")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "fp_int_src" "true")])
 
 (define_insn "float<SWI48x:mode>xf2"
@@ -6085,6 +6127,7 @@ (define_insn "float<SWI48x:mode>xf2"
   [(set_attr "type" "fmov")
    (set_attr "mode" "XF")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "fp_int_src" "true")])
 
 (define_expand "float<SWI48x:mode><MODEF:mode>2"
@@ -6119,6 +6162,7 @@ (define_insn "*float<SWI48:mode><MODEF:mode>2"
    (set_attr "amdfam10_decode" "*,vector,double")
    (set_attr "bdver1_decode" "*,double,direct")
    (set_attr "znver1_decode" "double,*,*")
+   (set_attr "c86_decode" "double,*,*")
    (set_attr "fp_int_src" "true")
    (set (attr "enabled")
      (if_then_else
@@ -6157,6 +6201,7 @@ (define_insn "*floatdi<MODEF:mode>2_i387"
   [(set_attr "type" "fmov")
    (set_attr "mode" "<MODEF:MODE>")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "fp_int_src" "true")])
 
 ;; Try TARGET_USE_VECTOR_CONVERTS, but not so hard as to require extra memory
@@ -12727,6 +12772,7 @@ (define_split
    "reload_completed
     && GET_MODE (operands[2]) != QImode
     && (!REG_P (operands[2]) || ANY_QI_REG_P (operands[2]))
+    && !(MEM_P (operands[2]) && MEM_VOLATILE_P (operands[2]))
     && ((ix86_match_ccmode (insn, CCZmode)
 	 && !(INTVAL (operands[3]) & ~255))
 	|| (ix86_match_ccmode (insn, CCNOmode)
@@ -12929,6 +12975,7 @@ (define_insn_and_split "*anddi_1_btr"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "DI")])
 
 ;; Turn *anddi_1 into *andsi_1_zext if possible.
@@ -13964,6 +14011,7 @@ (define_insn_and_split "*iordi_1_bts"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "DI")])
 
 (define_insn_and_split "*xordi_1_btc"
@@ -13988,6 +14036,7 @@ (define_insn_and_split "*xordi_1_btc"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "DI")])
 
 ;; Optimize a ^ ((a ^ b) & mask) to (~mask & a) | (b & mask)
@@ -19167,6 +19216,7 @@ (define_insn "*<btsc><mode>"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "<MODE>")])
 
 ;; Avoid useless masking of count operand.
@@ -19235,6 +19285,7 @@ (define_insn "*btr<mode>"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "<MODE>")])
 
 ;; Avoid useless masking of count operand.
@@ -19376,6 +19427,7 @@ (define_insn "*btsq_imm"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "DI")])
 
 (define_insn "*btrq_imm"
@@ -19389,6 +19441,7 @@ (define_insn "*btrq_imm"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "DI")])
 
 (define_insn "*btcq_imm"
@@ -19402,6 +19455,7 @@ (define_insn "*btcq_imm"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "DI")])
 
 ;; Allow Nocona to avoid these instructions if a register is available.
@@ -19830,7 +19884,7 @@ (define_insn "*setcc_<mode>_zu"
   [(set (match_operand:SWI248 0 "register_operand" "=r")
 	(match_operator:SWI248 1 "ix86_comparison_operator"
 	  [(reg FLAGS_REG) (const_int 0)]))]
-  "TARGET_APX_ZU"
+  "TARGET_APX_ZU && !TARGET_DISABLE_SETZUCC"
   "setzu%C1\t%b0"
   [(set_attr "type" "setcc")])
 
@@ -19838,7 +19892,8 @@ (define_insn_and_split "*setcc_di_1"
   [(set (match_operand:DI 0 "register_operand" "=q")
 	(match_operator:DI 1 "ix86_comparison_operator"
 	  [(reg FLAGS_REG) (const_int 0)]))]
-  "!TARGET_APX_ZU && TARGET_64BIT && !TARGET_PARTIAL_REG_STALL"
+  "(!TARGET_APX_ZU || TARGET_DISABLE_SETZUCC)
+   && TARGET_64BIT && !TARGET_PARTIAL_REG_STALL"
   "#"
   "&& reload_completed"
   [(set (match_dup 2) (match_dup 1))
@@ -19871,7 +19926,7 @@ (define_insn_and_split "*setcc_<mode>_1_movzbl"
   [(set (match_operand:SWI24 0 "register_operand" "=q")
 	(match_operator:SWI24 1 "ix86_comparison_operator"
 	  [(reg FLAGS_REG) (const_int 0)]))]
-  "!TARGET_APX_ZU && !TARGET_PARTIAL_REG_STALL
+  "(!TARGET_APX_ZU || TARGET_DISABLE_SETZUCC) && !TARGET_PARTIAL_REG_STALL
    && (!TARGET_ZERO_EXTEND_WITH_AND || optimize_function_for_size_p (cfun))"
   "#"
   "&& reload_completed"
@@ -19890,7 +19945,8 @@ (define_insn "*setcc_qi"
   ""
 {
   if (REG_P (operands[0])
-      && TARGET_APX_ZU)
+      && TARGET_APX_ZU
+      && !TARGET_DISABLE_SETZUCC)
     return "setzu%C1\t%0";
   else
     return "set%C1\t%0";
@@ -19904,7 +19960,7 @@ (define_insn "*setcc_qi_slp"
 	  [(reg FLAGS_REG) (const_int 0)]))]
   ""
 {
-  if (TARGET_APX_ZU)
+  if (TARGET_APX_ZU && !TARGET_DISABLE_SETZUCC)
     return "setzu%C1\t%0";
   else
     return "set%C1\t%0";
@@ -21379,6 +21435,7 @@ (define_insn_and_split "*tzcnt<mode>_1"
    (set_attr "prefix_0f" "1")
    (set_attr "prefix_rep" "1")
    (set_attr "btver2_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "<MODE>")])
 
 ; False dependency happens when destination is only updated by tzcnt,
@@ -21398,6 +21455,7 @@ (define_insn "*tzcnt<mode>_1_falsedep"
    (set_attr "prefix_0f" "1")
    (set_attr "prefix_rep" "1")
    (set_attr "btver2_decode" "double")
+   (set_attr "c86_decode" "double")
    (set_attr "mode" "<MODE>")])
 
 (define_insn "*bsf<mode>_1"
@@ -21412,6 +21470,7 @@ (define_insn "*bsf<mode>_1"
    (set_attr "prefix_0f" "1")
    (set_attr "btver2_decode" "double")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "<MODE>")])
 
 (define_insn_and_split "ctz<mode>2"
@@ -21474,6 +21533,7 @@ (define_insn "*ctz<mode>2_falsedep"
     gcc_unreachable ();
 }
   [(set_attr "type" "alu1")
+   (set_attr "c86_decode" "double")
    (set_attr "prefix_0f" "1")
    (set_attr "prefix_rep" "1")
    (set_attr "mode" "<MODE>")])
@@ -21499,6 +21559,7 @@ (define_insn_and_split "*ctzsi2_zext"
      (clobber (reg:CC FLAGS_REG))])]
   "ix86_expand_clear (operands[0]);"
   [(set_attr "type" "alu1")
+   (set_attr "c86_decode" "double")
    (set_attr "prefix_0f" "1")
    (set_attr "prefix_rep" "1")
    (set_attr "mode" "SI")])
@@ -21519,6 +21580,7 @@ (define_insn "*ctzsi2_zext_falsedep"
   "TARGET_BMI && TARGET_64BIT"
   "tzcnt{l}\t{%1, %k0|%k0, %1}"
   [(set_attr "type" "alu1")
+   (set_attr "c86_decode" "double")
    (set_attr "prefix_0f" "1")
    (set_attr "prefix_rep" "1")
    (set_attr "mode" "SI")])
@@ -21596,6 +21658,7 @@ (define_insn "bsr_rex64"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "DI")])
 
 (define_insn "bsr_rex64_1"
@@ -21608,6 +21671,7 @@ (define_insn "bsr_rex64_1"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "DI")])
 
 (define_insn "bsr_rex64_1_zext"
@@ -21623,6 +21687,7 @@ (define_insn "bsr_rex64_1_zext"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "DI")])
 
 (define_insn "bsr"
@@ -21637,6 +21702,7 @@ (define_insn "bsr"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "SI")])
 
 (define_insn "bsr_1"
@@ -21649,6 +21715,7 @@ (define_insn "bsr_1"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "SI")])
 
 (define_insn "bsr_zext_1"
@@ -21663,6 +21730,7 @@ (define_insn "bsr_zext_1"
   [(set_attr "type" "alu1")
    (set_attr "prefix_0f" "1")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "SI")])
 
 ; As bsr is undefined behavior on zero and for other input
@@ -22980,6 +23048,7 @@ (define_insn "*bswaphi2_movbe"
    (set_attr "pent_pair" "np,*,*")
    (set_attr "athlon_decode" "vector,*,*")
    (set_attr "amdfam10_decode" "double,*,*")
+   (set_attr "c86_decode" "vector,*,*")
    (set_attr "bdver1_decode" "double,*,*")
    (set_attr "mode" "QI,HI,HI")])
 
@@ -22992,6 +23061,7 @@ (define_insn "*bswaphi2"
    (set_attr "pent_pair" "np")
    (set_attr "athlon_decode" "vector")
    (set_attr "amdfam10_decode" "double")
+   (set_attr "c86_decode" "vector")
    (set_attr "bdver1_decode" "double")
    (set_attr "mode" "QI")])
 
@@ -23016,6 +23086,7 @@ (define_insn "bswaphisi2_lowpart"
    (set_attr "pent_pair" "np")
    (set_attr "athlon_decode" "vector")
    (set_attr "amdfam10_decode" "double")
+   (set_attr "c86_decode" "vector")
    (set_attr "bdver1_decode" "double")
    (set_attr "mode" "QI")])
 
@@ -24096,6 +24167,7 @@ (define_insn "sqrtxf2"
   [(set_attr "type" "fpspc")
    (set_attr "mode" "XF")
    (set_attr "athlon_decode" "direct")
+   (set_attr "c86_attr" "sqrt")
    (set_attr "amdfam10_decode" "direct")
    (set_attr "bdver1_decode" "direct")])
 
@@ -24264,6 +24336,7 @@ (define_insn "fpremxf4_i387"
   "fprem"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "fmodxf3"
@@ -24336,6 +24409,7 @@ (define_insn "fprem1xf4_i387"
   "fprem1"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "remainderxf3"
@@ -24411,6 +24485,7 @@ (define_insn "<sincos>xf2"
   "f<sincos>"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "<sincos><mode>2"
@@ -24442,6 +24517,7 @@ (define_insn "sincosxf3"
   "fsincos"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "sincos<mode>3"
@@ -24475,6 +24551,7 @@ (define_insn "fptanxf4_i387"
   "fptan"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "tanxf2"
@@ -24517,6 +24594,7 @@ (define_insn "atan2xf3"
   "fpatan"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "atan2<mode>3"
@@ -24820,6 +24898,7 @@ (define_insn "fyl2xxf3_i387"
   "fyl2x"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "logxf2"
@@ -24917,6 +24996,7 @@ (define_insn "fyl2xp1xf3_i387"
   "fyl2xp1"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "log1pxf2"
@@ -24957,6 +25037,7 @@ (define_insn "fxtractxf3_i387"
   "fxtract"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "logbxf2"
@@ -25037,6 +25118,7 @@ (define_insn "*f2xm1xf2_i387"
   "f2xm1"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_insn "fscalexf4_i387"
@@ -25052,6 +25134,7 @@ (define_insn "fscalexf4_i387"
   "fscale"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "expNcorexf3"
@@ -25370,6 +25453,7 @@ (define_insn "rintxf2"
   "frndint"
   [(set_attr "type" "fpspc")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "XF")])
 
 (define_expand "rinthf2"
@@ -27188,6 +27272,7 @@ (define_insn "<code><mode>3"
    v<maxmin_float><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "prefix" "orig,vex")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "type" "sseadd")
    (set_attr "mode" "<MODE>")])
 
@@ -27232,6 +27317,7 @@ (define_insn "*ieee_s<ieee_maxmin><mode>3"
    v<ieee_maxmin><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "prefix" "orig,maybe_evex")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "type" "sseadd")
    (set_attr "mode" "<MODE>")])
 
@@ -29448,7 +29534,7 @@ (define_peephole2
 (define_peephole2
   [(parallel
     [(set (match_operand:SWI48 0 "register_operand")
-	  (mult:SWI48 (match_operand:SWI48 1 "register_operand")
+	  (mult:SWI48 (match_operand:SWI48 1 "index_reg_operand")
 		      (match_operand:SWI48 2 "const359_operand")))
      (clobber (reg:CC FLAGS_REG))])]
   "!TARGET_PARTIAL_REG_STALL
@@ -29461,7 +29547,7 @@ (define_peephole2
 
 (define_peephole2
   [(parallel
-    [(set (match_operand:SWI48 0 "register_operand")
+    [(set (match_operand:SWI48 0 "index_reg_operand")
 	  (mult:SWI48 (match_operand:SWI48 1 "nonimmediate_operand")
 		      (match_operand:SWI48 2 "const359_operand")))
      (clobber (reg:CC FLAGS_REG))])]
@@ -30188,7 +30274,7 @@ (define_insn "ptwrite<mode>"
   [(unspec_volatile [(match_operand:SWI48 0 "nonimmediate_operand" "rm")]
 		    UNSPECV_PTWRITE)]
   "TARGET_PTWRITE"
-  "ptwrite\t%0"
+  "ptwrite{<imodesuffix>|}\t%0"
   [(set_attr "type" "other")
    (set_attr "prefix_0f" "1")
    (set_attr "prefix_rep" "1")])
--- a/src/gcc/config/i386/mmx.md
+++ b/src/gcc/config/i386/mmx.md
@@ -664,6 +664,7 @@ (define_insn "sse_movntq"
   [(set_attr "isa" "*,x64")
    (set_attr "mmx_isa" "native,*")
    (set_attr "type" "mmxmov,ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "mode" "DI")])
 
 (define_expand "movq_<mode>_to_sse"
@@ -1324,6 +1325,7 @@ (define_insn "*mmx_blendps"
    vblendps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*")
    (set_attr "prefix_extra" "1")
@@ -1344,6 +1346,7 @@ (define_insn "mmx_blendvps"
    vblendvps\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blendv")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*")
    (set_attr "prefix_extra" "1")
@@ -3599,6 +3602,7 @@ (define_insn "*mmx_pmaddwd"
   [(set_attr "isa" "*,sse2_noavx,avx")
    (set_attr "mmx_isa" "native,*,*")
    (set_attr "type" "mmxmul,sseiadd,sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "mode" "DI,TI,TI")])
 
 (define_expand "mmx_pmulhrwv4hi3"
@@ -4346,6 +4350,7 @@ (define_insn "mmx_pblendvb_v8qi"
    vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blendv")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,orig,vex")
@@ -4422,6 +4427,7 @@ (define_insn "mmx_pblendvb_<mode>"
    vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blendv")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,orig,vex")
@@ -5040,6 +5046,7 @@ (define_insn "sse4_1_<code>v4qiv4hi2"
   "%vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -5072,6 +5079,7 @@ (define_insn "sse4_1_<code>v2hiv2si2"
   "%vpmov<extsuffix>wd\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -5104,6 +5112,7 @@ (define_insn "sse4_1_<code>v2qiv2si2"
   "%vpmov<extsuffix>bd\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -5130,6 +5139,7 @@ (define_insn "sse4_1_<code>v2qiv2hi2"
   "%vpmov<extsuffix>bw\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -5306,6 +5316,7 @@ (define_insn "*mmx_pinsrd"
    (set_attr "addr" "gpr16,*")
    (set_attr "prefix_extra" "1")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insr")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "TI")])
@@ -5345,6 +5356,7 @@ (define_insn "*mmx_pinsrw"
   [(set_attr "isa" "*,sse2_noavx,avx,sse4")
    (set_attr "mmx_isa" "native,*,*,*")
    (set_attr "type" "mmxcvt,sselog,sselog,sselog")
+   (set_attr "c86_attr" "insr")
    (set_attr "length_immediate" "1")
    (set_attr "mode" "DI,TI,TI,TI")])
 
@@ -5395,6 +5407,7 @@ (define_insn "*mmx_pinsrb"
 }
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insr")
    (set_attr "addr" "gpr16,*")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -5417,6 +5430,7 @@ (define_insn "*mmx_pextrw"
    (set_attr "addr" "*,*,gpr16,*")
    (set_attr "mmx_isa" "native,*,*,*")
    (set_attr "type" "mmxcvt,sselog1,sselog1,sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,maybe_vex,maybe_vex,maybe_evex")
    (set_attr "mode" "DI,TI,TI,TI")])
@@ -5452,6 +5466,7 @@ (define_insn "*mmx_pextrw<mode>"
    (set_attr "addr" "*,*,gpr16,*,*,*")
    (set_attr "mmx_isa" "native,*,*,*,*,*")
    (set_attr "type" "mmxcvt,sselog1,sselog1,sselog1,sseishft1,sseishft1")
+   (set_attr "c86_attr" "extr,extr,extr,extr,*,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,maybe_vex,maybe_vex,maybe_evex,orig,maybe_evex")
    (set_attr "mode" "DI,TI,TI,TI,TI,TI")])
@@ -5470,6 +5485,7 @@ (define_insn "*mmx_pextrw_zext"
   [(set_attr "isa" "*,sse2")
    (set_attr "mmx_isa" "native,*")
    (set_attr "type" "mmxcvt,sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,maybe_vex")
    (set_attr "mode" "DI,TI")])
@@ -5488,6 +5504,7 @@ (define_insn "*mmx_pextrb"
   [(set_attr "isa" "noavx,noavx,avx,avx")
    (set_attr "addr" "*,gpr16,*,*")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -5503,6 +5520,7 @@ (define_insn "*mmx_pextrb_zext"
   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -5629,6 +5647,7 @@ (define_insn "*mmx_pblendw64"
    vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,orig,vex")
@@ -5647,6 +5666,7 @@ (define_insn "*mmx_pblendw32"
    vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,orig,vex")
@@ -5829,6 +5849,7 @@ (define_insn "*vec_extractv2si_1"
 		      (const_string "*")))
    (set_attr "mmx_isa" "native,*,*,*,*,native,*,*")
    (set_attr "type" "mmxcvt,ssemov,ssemov,sseshuf1,sseshuf1,mmxmov,ssemov,imov")
+   (set_attr "c86_attr" "*,extr,extr,*,*,*,*,*")
    (set (attr "length_immediate")
      (if_then_else (eq_attr "alternative" "1,2,3,4")
 		   (const_string "1")
@@ -5856,6 +5877,7 @@ (define_insn "*vec_extractv2si_1_zext"
   "%vpextrd\t{$1, %1, %k0|%k0, %1, 1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -6010,6 +6032,7 @@ (define_insn "*pinsrw"
 }
   [(set_attr "isa" "noavx,avx,sse4")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insr")
    (set_attr "length_immediate" "1")
    (set_attr "mode" "TI")])
 
@@ -6062,6 +6085,7 @@ (define_insn "*pinsrb"
   [(set_attr "isa" "noavx,avx")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,vex")
@@ -6080,6 +6104,7 @@ (define_insn "*pextrw"
   [(set_attr "isa" "*,sse4_noavx,avx")
    (set_attr "addr" "*,gpr16,*")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
    (set_attr "mode" "TI")])
@@ -6113,6 +6138,7 @@ (define_insn "*pextrw<mode>"
   [(set_attr "isa" "*,sse4_noavx,avx,noavx,avx")
    (set_attr "addr" "*,gpr16,*,*,*")
    (set_attr "type" "sselog1,sselog1,sselog1,sseishft1,sseishft1")
+   (set_attr "c86_attr" "extr,extr,extr,*,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex,orig,maybe_evex,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -6126,6 +6152,7 @@ (define_insn "*pextrw_zext"
   "TARGET_SSE2"
   "%vpextrw\t{%2, %1, %k0|%k0, %1, %2}"
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
    (set_attr "mode" "TI")])
@@ -6144,6 +6171,7 @@ (define_insn "*pextrb"
   [(set_attr "isa" "noavx,noavx,avx,avx")
    (set_attr "addr" "*,gpr16,*,*")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -6159,6 +6187,7 @@ (define_insn "*pextrb_zext"
   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -6511,6 +6540,7 @@ (define_insn "*mmx_psadbw"
   [(set_attr "isa" "*,sse2_noavx,avx")
    (set_attr "mmx_isa" "native,*,*")
    (set_attr "type" "mmxshft,sseiadd,sseiadd")
+   (set_attr "c86_attr" "sadbw")
    (set_attr "mode" "DI,TI,TI")])
 
 (define_expand "reduc_<code>_scal_<mode>"
@@ -6890,6 +6920,7 @@ (define_insn "*mmx_maskmovq"
   "maskmovq\t{%2, %1|%1, %2}"
   [(set_attr "type" "mmxcvt")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "DI")])
 
 (define_int_iterator EMMS
--- a/src/gcc/config/i386/sse.md
+++ b/src/gcc/config/i386/sse.md
@@ -1794,6 +1794,11 @@ (define_insn "<avx512>_blendm<mode>"
     }
 }
   [(set_attr "type" "ssemov")
+   (set (attr "c86_attr")
+     (if_then_else (and (match_test "REG_P (operands[1])")
+			(match_test "REGNO (operands[1]) != REGNO (operands[0])"))
+       (const_string "blend")
+       (const_string "*")))
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -1808,6 +1813,7 @@ (define_insn "<avx512>_blendm<mode>"
     vmovdqu<ssescalarsize>\t{%2, %0%{%3%}%N1|%0%{%3%}%N1, %2}
     vpblendm<sseintmodesuffix>\t{%2, %1, %0%{%3%}|%0%{%3%}, %1, %2}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "*,blend")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -2034,6 +2040,7 @@ (define_insn "sse2_movnti<mode>"
   "TARGET_SSE2"
   "movnti\t{%1, %0|%0, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "prefix_data16" "0")
    (set_attr "mode" "<MODE>")])
 
@@ -2045,6 +2052,7 @@ (define_insn "<sse>_movnt<mode>"
   "TARGET_SSE"
   "%vmovnt<ssemodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "prefix" "maybe_vex")
    (set_attr "mode" "<MODE>")])
 
@@ -2060,6 +2068,7 @@ (define_insn "<sse2>_movnt<mode>"
        (match_test "TARGET_AVX")
      (const_string "*")
      (const_string "1")))
+   (set_attr "c86_attr" "movnt")
    (set_attr "prefix" "maybe_vex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -2359,6 +2368,7 @@ (define_insn "ktest<mode>"
   "ktest<mskmodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "mode" "<MODE>")
    (set_attr "type" "msklog")
+   (set_attr "c86_decode" "vector")
    (set_attr "prefix" "vex")])
 
 (define_insn "*kortest<mode>"
@@ -2371,6 +2381,7 @@ (define_insn "*kortest<mode>"
   "kortest<mskmodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "mode" "<MODE>")
    (set_attr "type" "msklog")
+   (set_attr "c86_decode" "vector")
    (set_attr "prefix" "vex")])
 
 (define_insn "kortest<mode>_ccc"
@@ -2939,6 +2950,7 @@ (define_insn "<sse>_rcp<mode>2"
    (set_attr "addr" "*,gpr16")
    (set_attr "atom_sse_attr" "rcp")
    (set_attr "btver2_sse_attr" "rcp")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "maybe_vex")
    (set_attr "mode" "<MODE>")])
 
@@ -2958,6 +2970,7 @@ (define_insn "sse_vmrcpv4sf2"
    (set_attr "addr" "*,gpr16")
    (set_attr "atom_sse_attr" "rcp")
    (set_attr "btver2_sse_attr" "rcp")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "SF")])
 
@@ -2978,6 +2991,7 @@ (define_insn "*sse_vmrcpv4sf2"
    (set_attr "addr" "*,gpr16")
    (set_attr "atom_sse_attr" "rcp")
    (set_attr "btver2_sse_attr" "rcp")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "SF")])
 
@@ -3027,6 +3041,7 @@ (define_insn "<mask_codefor>rcp14<mode><mask_name>"
   "TARGET_AVX512F"
   "vrcp14<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -3041,6 +3056,7 @@ (define_insn "srcp14<mode>"
   "TARGET_AVX512F"
   "vrcp14<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %<iptr>1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -3058,6 +3074,7 @@ (define_insn "srcp14<mode>_mask"
   "TARGET_AVX512F"
   "vrcp14<ssescalarmodesuffix>\t{%1, %2, %0%{%4%}%N3|%0%{%4%}%N3, %2, %<iptr>1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -3093,6 +3110,7 @@ (define_insn "<sse>_sqrt<mode>2<mask_name><round_name>"
    (set_attr "type" "sse")
    (set_attr "atom_sse_attr" "sqrt")
    (set_attr "btver2_sse_attr" "sqrt")
+   (set_attr "c86_attr" "sqrt")
    (set_attr "prefix" "maybe_vex")
    (set_attr "mode" "<MODE>")])
 
@@ -3112,6 +3130,7 @@ (define_insn "<sse>_vmsqrt<mode>2<mask_scalar_name><round_scalar_name>"
    (set_attr "atom_sse_attr" "sqrt")
    (set_attr "prefix" "<round_scalar_prefix>")
    (set_attr "btver2_sse_attr" "sqrt")
+   (set_attr "c86_attr" "sqrt")
    (set_attr "mode" "<ssescalarmode>")])
 
 (define_insn "*<sse>_vmsqrt<mode>2<mask_scalar_name><round_scalar_name>"
@@ -3131,6 +3150,7 @@ (define_insn "*<sse>_vmsqrt<mode>2<mask_scalar_name><round_scalar_name>"
    (set_attr "atom_sse_attr" "sqrt")
    (set_attr "prefix" "<round_scalar_prefix>")
    (set_attr "btver2_sse_attr" "sqrt")
+   (set_attr "c86_attr" "sqrt")
    (set_attr "mode" "<ssescalarmode>")])
 
 (define_expand "rsqrt<mode>2"
@@ -3181,6 +3201,7 @@ (define_insn "<mask_codefor>rsqrt14<mode><mask_name>"
   "TARGET_AVX512F"
   "vrsqrt14<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -3195,6 +3216,7 @@ (define_insn "rsqrt14<mode>"
   "TARGET_AVX512F"
   "vrsqrt14<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %<iptr>1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -3212,6 +3234,7 @@ (define_insn "rsqrt14_<mode>_mask"
   "TARGET_AVX512F"
   "vrsqrt14<ssescalarmodesuffix>\t{%1, %2, %0%{%4%}%N3|%0%{%4%}%N3, %2, %<iptr>1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "rcp")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -3336,6 +3359,7 @@ (define_insn "*<code><mode>3<mask_name><round_saeonly_name>"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd")
    (set_attr "btver2_sse_attr" "maxmin")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix" "<mask_prefix3>")
    (set_attr "mode" "<MODE>")])
 
@@ -3444,7 +3468,7 @@ (define_insn_and_split "*minmax<mode>3_4"
      u = UNSPEC_IEEE_MAX;
 
    rtx tmp = force_reg (<MODE>mode, operands[3]);
-   rtvec v = gen_rtvec (2, operands[2], tmp);
+   rtvec v = gen_rtvec (2, force_reg (<MODE>mode, operands[2]), tmp);
    operands[5] = gen_rtx_UNSPEC (<MODE>mode, v, u);
  })
 
@@ -3469,6 +3493,7 @@ (define_insn "ieee_<ieee_maxmin><mode>3<mask_name><round_saeonly_name>"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd")
    (set_attr "btver2_sse_attr" "maxmin")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix" "<mask_prefix3>")
    (set_attr "mode" "<MODE>")])
 
@@ -3493,6 +3518,7 @@ (define_insn "*ieee_<ieee_maxmin><mode>3"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd")
    (set_attr "btver2_sse_attr" "maxmin")
+   (set_attr "c86_attr" "maxmin")
    (set (attr "prefix")
      (cond [(eq_attr "alternative" "0")
 	      (const_string "orig")
@@ -3540,6 +3566,7 @@ (define_insn "*<sse>_vm<code><mode>3<mask_scalar_name><round_saeonly_scalar_name
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sse")
    (set_attr "btver2_sse_attr" "maxmin")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix" "<round_saeonly_scalar_prefix>")
    (set_attr "mode" "<ssescalarmode>")])
 
@@ -3736,6 +3763,7 @@ (define_insn "avx_h<insn>v4df3"
   "TARGET_AVX"
   "vh<plusminus_mnemonic>pd\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "prefix" "vex")
    (set_attr "mode" "V4DF")])
@@ -3781,6 +3809,7 @@ (define_insn "*sse3_haddv2df3"
   [(set_attr "isa" "noavx,avx")
    (set_attr "addr" "*,gpr16")
    (set_attr "type" "sseadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "V2DF")])
 
@@ -3803,6 +3832,7 @@ (define_insn "sse3_hsubv2df3"
    vhsubpd\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "*,gpr16")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "V2DF")])
@@ -3823,6 +3853,7 @@ (define_insn "*sse3_haddv2df3_low"
    vhaddpd\t{%1, %1, %0|%0, %1, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "V2DF")])
 
@@ -3841,6 +3872,7 @@ (define_insn "*sse3_hsubv2df3_low"
    vhsubpd\t{%1, %1, %0|%0, %1, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "V2DF")])
 
@@ -3884,6 +3916,7 @@ (define_insn "avx_h<insn>v8sf3"
   "TARGET_AVX"
   "vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "prefix" "vex")
    (set_attr "mode" "V8SF")])
@@ -3915,6 +3948,7 @@ (define_insn "sse3_h<insn>v4sf3"
    vh<plusminus_mnemonic>ps\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "*,gpr16")
    (set_attr "atom_unit" "complex")
    (set_attr "prefix" "orig,vex")
@@ -4253,6 +4287,7 @@ (define_insn "<mask_codefor>reducep<mode><mask_name><round_saeonly_name>"
   "TARGET_AVX512DQ || (VALID_AVX512FP16_REG_MODE (<MODE>mode))"
   "vreduce<ssemodesuffix>\t{%2, <round_saeonly_mask_op3>%1, %0<mask_operand3>|%0<mask_operand3>, %1<round_saeonly_mask_op3>, %2}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "aes")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -4269,6 +4304,7 @@ (define_insn "reduces<mode><mask_scalar_name><round_saeonly_scalar_name>"
   "TARGET_AVX512DQ || (VALID_AVX512FP16_REG_MODE (<MODE>mode))"
   "vreduce<ssescalarmodesuffix>\t{%3, <round_saeonly_scalar_mask_op4>%2, %1, %0<mask_scalar_operand4>|%0<mask_scalar_operand4>, %1, %<iptr>2<round_saeonly_scalar_mask_op4>, %3}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "aes")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<MODE>")])
 
@@ -4937,6 +4973,7 @@ (define_insn "*<avx512>_eq<mode>3<mask_scalar_merge_name>_1"
    vpcmpeq<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}
    vptestnm<ssemodesuffix>\t{%1, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %1}"
   [(set_attr "type" "ssecmp")
+   (set_attr "c86_attr" "*,ptest")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -5026,6 +5063,7 @@ (define_insn "*<avx512>_eq<mode>3<mask_scalar_merge_name>_1"
    vpcmpeq<ssemodesuffix>\t{%2, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %2}
    vptestnm<ssemodesuffix>\t{%1, %1, %0<mask_scalar_merge_operand3>|%0<mask_scalar_merge_operand3>, %1, %1}"
   [(set_attr "type" "ssecmp")
+   (set_attr "c86_attr" "*,ptest")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -5635,6 +5673,7 @@ (define_insn "<sse>_andnot<mode>3<mask_name>"
   [(set_attr "isa" "noavx,avx_noavx512f,avx512dq,avx512f")
    (set_attr "addr" "*,gpr16,*,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "orig,maybe_vex,evex,evex")
    (set (attr "mode")
 	(cond [(and (match_test "<mask_applied>")
@@ -5686,6 +5725,7 @@ (define_insn "<sse>_andnot<mode>3<mask_name>"
   return "";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "evex")
    (set (attr "mode")
         (if_then_else (match_test "TARGET_AVX512DQ")
@@ -5762,6 +5802,7 @@ (define_insn "*<code><mode>3<mask_name>"
 }
   [(set_attr "isa" "noavx,avx,avx512dq,avx512f")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "orig,maybe_evex,evex,evex")
    (set (attr "mode")
 	(cond [(and (match_test "<mask_applied>")
@@ -5809,6 +5850,7 @@ (define_insn "*<code><mode>3<mask_name>"
   return "";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "evex")
    (set (attr "mode")
         (if_then_else (match_test "TARGET_AVX512DQ")
@@ -5926,6 +5968,7 @@ (define_insn "*andnot<mode>3"
 }
   [(set_attr "isa" "noavx,avx,avx512vl,avx512f")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "orig,vex,evex,evex")
    (set (attr "mode")
 	(cond [(eq_attr "alternative" "2")
@@ -6056,6 +6099,7 @@ (define_insn "<code><mode>3"
 }
   [(set_attr "isa" "noavx,avx,avx512vl,avx512f")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "orig,vex,evex,evex")
    (set (attr "mode")
 	(cond [(eq_attr "alternative" "2")
@@ -6118,6 +6162,7 @@ (define_insn "*<code>tf3"
 }
   [(set_attr "isa" "noavx,avx,avx512vl,avx512f")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set (attr "prefix_data16")
      (if_then_else
        (and (eq_attr "alternative" "0")
@@ -8860,6 +8905,7 @@ (define_insn "sse_cvtsi2ss<rex64namesuffix><round_name>"
    (set_attr "bdver1_decode" "double,direct,*")
    (set_attr "btver2_decode" "double,double,double")
    (set_attr "znver1_decode" "double,double,double")
+   (set_attr "c86_decode" "double,double,double")
    (set (attr "length_vex")
 	(if_then_else
 	  (and (match_test "<MODE>mode == DImode")
@@ -9321,6 +9367,7 @@ (define_insn "sse2_cvtsi2sd"
    (set_attr "bdver1_decode" "double,direct,*")
    (set_attr "btver2_decode" "double,double,double")
    (set_attr "znver1_decode" "double,double,double")
+   (set_attr "c86_decode" "double,double,double")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "DF")])
 
@@ -12250,6 +12297,10 @@ (define_insn "vec_set<mode>_0"
 	      (const_string "ssemov2")
 	   ]
 	   (const_string "ssemov")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "9,10,11")
+		   (const_string "insr")
+		   (const_string "*")))
    (set (attr "addr")
      (if_then_else (eq_attr "alternative" "9,10")
 		   (const_string "gpr16")
@@ -12324,6 +12375,13 @@ (define_insn "@vec_set<mode>_0"
      (if_then_else (eq_attr "alternative" "0,1,2,3,6,7,10")
 		   (const_string "ssemov")
 		   (const_string "sselog")))
+   (set (attr "c86_attr")
+	(cond [(eq_attr "alternative" "6,7,10")
+		 (const_string "blend")
+	       (eq_attr "alternative" "4,5,8,9,11,12")
+		 (const_string "insr")
+	      ]
+	      (const_string "*")))
    (set (attr "prefix_data16")
      (if_then_else (eq_attr "alternative" "4,5")
 		   (const_string "1")
@@ -12692,6 +12750,7 @@ (define_insn_and_split "*sse4_1_extractps"
   [(set_attr "isa" "noavx,noavx,avx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*,*,*")
    (set_attr "type" "sselog,sselog,sselog,*,*")
+   (set_attr "c86_attr" "extr,extr,extr,*,*")
    (set_attr "prefix_data16" "1,1,1,*,*")
    (set_attr "prefix_extra" "1,1,1,*,*")
    (set_attr "length_immediate" "1,1,1,*,*")
@@ -13591,6 +13650,7 @@ (define_insn "*vec_extract<mode>"
   [(set_attr "isa" "*,sse4_noavx,avx,noavx,avx")
    (set_attr "addr" "*,gpr16,*,*,*")
    (set_attr "type" "sselog1,sselog1,sselog1,sseishft1,sseishft1")
+   (set_attr "c86_attr" "extr,extr,extr,other,other")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "TI")])
 
@@ -14381,6 +14441,7 @@ (define_insn "<mask_codefor><avx512>_align<mode><mask_name>"
   "TARGET_AVX512F"
   "valign<ssemodesuffix>\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}";
   [(set_attr "prefix" "evex")
+   (set_attr "c86_attr" "shufx")
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_mode_attr vec_extract_imm_predicate
@@ -16996,6 +17057,7 @@ (define_insn "avx512bw_pmaddwd512<mode><mask_name>"
    "TARGET_AVX512BW && <mask_mode512bit_condition>"
    "vpmaddwd\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}";
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -17067,6 +17129,7 @@ (define_insn "*avx2_pmaddwd"
   "TARGET_AVX2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
   "vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix" "vex")
    (set_attr "mode" "OI")])
 
@@ -17125,6 +17188,7 @@ (define_insn "*sse2_pmaddwd"
    vpmaddwd\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "atom_unit" "simul")
    (set_attr "prefix_data16" "1,*")
    (set_attr "prefix" "orig,vex")
@@ -17992,6 +18056,7 @@ (define_insn "*avx2_<code><mode>3"
   "TARGET_AVX2 && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
   "vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "vex")
    (set_attr "mode" "OI")])
@@ -18033,6 +18098,7 @@ (define_insn "*avx512f_<code><mode>3<mask_name>"
   "TARGET_AVX512F && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
   "vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -18044,6 +18110,7 @@ (define_insn "*avx512bw_<code><mode>3<mask_name>"
   "TARGET_AVX512BW && !(MEM_P (operands[1]) && MEM_P (operands[2]))"
   "vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -18142,6 +18209,7 @@ (define_insn "*sse4_1_<code><mode>3<mask_name>"
    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix_extra" "1")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "prefix" "orig,orig,vex")
@@ -18158,6 +18226,7 @@ (define_insn "*<code>v8hi3"
    vp<maxmin_int>w\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "addr" "gpr16,*")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "TI")])
@@ -18226,6 +18295,7 @@ (define_insn "*sse4_1_<code><mode>3<mask_name>"
    vp<maxmin_int><ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "prefix_extra" "1,1,*")
    (set_attr "prefix" "orig,orig,vex")
@@ -18243,6 +18313,7 @@ (define_insn "*<code>v16qi3"
   [(set_attr "isa" "noavx,avx")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "maxmin")
    (set_attr "prefix" "orig,vex")
    (set_attr "mode" "TI")])
 
@@ -18912,6 +18983,7 @@ (define_insn "*andnot<mode>3"
   [(set_attr "isa" "noavx,avx_noavx512f,avx512f,*,*")
    (set_attr "addr" "*,gpr16,*,*,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set (attr "prefix_data16")
      (if_then_else
        (and (eq_attr "alternative" "0")
@@ -19018,6 +19090,7 @@ (define_insn "*andnot<mode>3_mask"
   "TARGET_AVX512F"
   "vpandn<ssemodesuffix>\t{%2, %1, %0%{%4%}%N3|%0%{%4%}%N3, %1, %2}";
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -19142,6 +19215,7 @@ (define_insn "*<code><mode>3<mask_name>"
   [(set_attr "isa" "noavx,avx_noavx512f,avx512f")
    (set_attr "addr" "*,gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set (attr "prefix_data16")
      (if_then_else
        (and (eq_attr "alternative" "0")
@@ -19239,6 +19313,7 @@ (define_insn "*<code><mode>3"
   [(set_attr "isa" "noavx,avx_noavx512f,avx512f")
    (set_attr "addr" "*,gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set (attr "prefix_data16")
      (if_then_else
        (and (eq_attr "alternative" "0")
@@ -19275,6 +19350,7 @@ (define_insn "<code>v1ti3"
    (set_attr "prefix" "orig,vex,evex")
    (set_attr "prefix_data16" "1,*,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "sselogic")
    (set_attr "mode" "TI")])
 
 (define_expand "one_cmplv1ti2"
@@ -20250,6 +20326,7 @@ (define_insn "<sse2p4_1>_pinsr<ssemodesuffix>"
 }
   [(set_attr "isa" "noavx,noavx,avx,avx,<pinsr_evex_isa>,<pinsr_evex_isa>,avx2")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insr")
    (set (attr "addr")
 	(if_then_else (eq_attr "alternative" "0,1")
 		      (const_string "gpr16")
@@ -20363,6 +20440,7 @@ (define_insn "*<extract_type>_vinsert<shuffletype><extract_suf>_0"
     }
 }
   [(set_attr "type" "sselog,ssemov,ssemov")
+   (set_attr "c86_attr" "insertx,*,*")
    (set_attr "length_immediate" "1,0,0")
    (set_attr "prefix" "evex,vex,evex")
    (set_attr "mode" "<sseinsnmode>,<ssequarterinsnmode>,<ssequarterinsnmode>")])
@@ -20395,6 +20473,7 @@ (define_insn "<mask_codefor><extract_type>_vinsert<shuffletype><extract_suf>_1<m
   return "vinsert<shuffletype><extract_suf>\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -20433,6 +20512,7 @@ (define_insn "vec_set_lo_<mode><mask_name>"
   "TARGET_AVX512DQ"
   "vinsert<shuffletype>32x8\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x0}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -20450,6 +20530,7 @@ (define_insn "vec_set_hi_<mode><mask_name>"
   "TARGET_AVX512DQ"
   "vinsert<shuffletype>32x8\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x1}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -20465,6 +20546,7 @@ (define_insn "vec_set_lo_<mode><mask_name>"
   "TARGET_AVX512F"
   "vinsert<shuffletype>64x4\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x0}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
@@ -20480,6 +20562,7 @@ (define_insn "vec_set_hi_<mode><mask_name>"
   "TARGET_AVX512F"
   "vinsert<shuffletype>64x4\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x1}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
@@ -20529,6 +20612,7 @@ (define_insn "<mask_codefor>avx512dq_shuf_<shuffletype>64x2_1<mask_name>"
   return "vshuf<shuffletype>64x2\t{%3, %2, %1, %0<mask_operand7>|%0<mask_operand7>, %1, %2, %3}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "shufx")
    (set_attr "addr" "gpr16,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
@@ -20592,6 +20676,7 @@ (define_insn "avx512f_shuf_<shuffletype>64x2_1<mask_name>"
   return "vshuf<shuffletype>64x2\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "shufx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -20628,6 +20713,7 @@ (define_insn "*avx512f_shuf_<shuffletype>64x2_1<mask_name>_1"
   return "vshuf<shuffletype>64x2\t{%2, %1, %1, %0<mask_operand10>|%0<mask_operand10>, %1, %1, %2}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "shufx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -20691,6 +20777,7 @@ (define_insn "avx512vl_shuf_<shuffletype>32x4_1<mask_name>"
   return "vshuf<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand11>|%0<mask_operand11>, %1, %2, %3}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "shufx")
    (set_attr "addr" "gpr16,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
@@ -20778,6 +20865,7 @@ (define_insn "avx512f_shuf_<shuffletype>32x4_1<mask_name>"
   return "vshuf<shuffletype>32x4\t{%3, %2, %1, %0<mask_operand19>|%0<mask_operand19>, %1, %2, %3}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "shufx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -20830,6 +20918,7 @@ (define_insn "*avx512f_shuf_<shuffletype>32x4_1<mask_name>_1"
   return "vshuf<shuffletype>32x4\t{%2, %1, %1, %0<mask_operand18>|%0<mask_operand18>, %1, %1, %2}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "shufx")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -21434,6 +21523,7 @@ (define_insn "*vec_extract<mode>"
   [(set_attr "isa" "sse2_noavx,avx,sse4_noavx,avx")
    (set_attr "addr" "*,*,gpr16,*")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set (attr "prefix_extra")
      (if_then_else
        (eq (const_string "<MODE>mode") (const_string "V8HImode"))
@@ -21455,6 +21545,7 @@ (define_insn "*vec_extract<PEXTR_MODE12:mode>_zext"
   "%vpextr<PEXTR_MODE12:ssemodesuffix>\t{%2, %1, %k0|%k0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set (attr "prefix_extra")
      (if_then_else
        (eq (const_string "<PEXTR_MODE12:MODE>mode") (const_string "V8HImode"))
@@ -21475,6 +21566,7 @@ (define_insn "*vec_extractv16qi_zext"
   "%vpextrb\t{%2, %1, %k0|%k0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -21609,6 +21701,7 @@ (define_insn "*vec_extractv4si"
 }
   [(set_attr "isa" "noavx,avx,avx512dq,noavx,noavx,avx")
    (set_attr "type" "sselog1,sselog1,sselog1,sseishft1,sseishft1,sseishft1")
+   (set_attr "c86_attr" "extr,extr,*,*,*,*")
    (set (attr "addr")
 	(if_then_else (eq_attr "alternative" "0")
 		      (const_string "gpr16")
@@ -21631,6 +21724,7 @@ (define_insn "*vec_extractv4si_zext"
   "%vpextrd\t{%2, %1, %k0|%k0, %1, %2}"
   [(set_attr "isa" "noavx,avx,avx512dq")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "extr")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "maybe_vex")
@@ -21703,6 +21797,10 @@ (define_insn "*vec_extractv2di_1"
 	      (const_string "imov")
 	   ]
 	   (const_string "sselog1")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "0,1,2")
+		   (const_string "extr")
+		   (const_string "other")))
    (set (attr "addr")
 	(if_then_else (eq_attr "alternative" "0")
 		      (const_string "gpr16")
@@ -21868,6 +21966,10 @@ (define_insn "*vec_concatv2si_sse4_1"
 	      (const_string "mmxmov")
 	   ]
 	   (const_string "sselog")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "0,1,2,3")
+		   (const_string "insr")
+		   (const_string "other")))
    (set (attr "addr")
      (if_then_else (eq_attr "alternative" "0,1")
 		   (const_string "gpr16")
@@ -22026,6 +22128,10 @@ (define_insn "vec_concatv2di"
        (eq_attr "alternative" "0,1,2,3,4,5")
        (const_string "sselog")
        (const_string "ssemov2")))
+   (set (attr "c86_attr")
+     (if_then_else (eq_attr "alternative" "0,1,2,3")
+		   (const_string "insr")
+		   (const_string "other")))
    (set (attr "addr")
      (if_then_else (eq_attr "alternative" "0,1")
 		   (const_string "gpr16")
@@ -22245,6 +22351,7 @@ (define_insn "*<sse2_avx2>_uavg<mode>3<mask_name>"
    vpavg<ssemodesuffix>\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "avg")
    (set_attr "prefix_data16" "1,*")
    (set_attr "prefix" "orig,<mask_prefix>")
    (set_attr "mode" "<sseinsnmode>")])
@@ -22273,6 +22380,7 @@ (define_insn "*<sse2_avx2>_psadbw"
    vpsadbw\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "sadbw")
    (set_attr "atom_unit" "simul")
    (set_attr "prefix_data16" "1,*")
    (set_attr "prefix" "orig,maybe_evex")
@@ -22287,6 +22395,7 @@ (define_insn "<sse>_movmsk<ssemodesuffix><avxsizesuffix>"
   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "<MODE>")])
 
@@ -22300,6 +22409,7 @@ (define_insn "*<sse>_movmsk<ssemodesuffix><avxsizesuffix>_<u>ext"
   "%vmovmsk<ssemodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "<MODE>")])
 
@@ -22437,6 +22547,7 @@ (define_insn "<sse2_avx2>_pmovmskb"
   "%vpmovmskb\t{%1, %0|%0, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set (attr "prefix_data16")
      (if_then_else
        (match_test "TARGET_AVX")
@@ -22455,6 +22566,7 @@ (define_insn "*<sse2_avx2>_pmovmskb_zext"
   "%vpmovmskb\t{%1, %k0|%k0, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set (attr "prefix_data16")
      (if_then_else
        (match_test "TARGET_AVX")
@@ -22473,6 +22585,7 @@ (define_insn "*sse2_pmovmskb_ext"
   "%vpmovmskb\t{%1, %k0|%k0, %1}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set (attr "prefix_data16")
      (if_then_else
        (match_test "TARGET_AVX")
@@ -22822,6 +22935,7 @@ (define_insn "*sse2_maskmovdqu"
   return "%vmaskmovdqu\t{%2, %1|%1, %2}";
 }
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "prefix_data16" "1")
    (set (attr "length_address")
      (symbol_ref ("Pmode != word_mode")))
@@ -22830,6 +22944,7 @@ (define_insn "*sse2_maskmovdqu"
      (symbol_ref ("3 + REX_SSE_REGNO_P (REGNO (operands[2]))")))
    (set_attr "prefix" "maybe_vex")
    (set_attr "znver1_decode" "vector")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "TI")])
 
 (define_insn "sse_ldmxcsr"
@@ -22922,6 +23037,7 @@ (define_insn "avx2_ph<plusminus_mnemonic>wv16hi3"
   "TARGET_AVX2"
   "vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "vex")
@@ -22948,6 +23064,7 @@ (define_insn "ssse3_ph<plusminus_mnemonic>wv8hi3"
    vph<plusminus_mnemonic>w\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "atom_unit" "complex")
    (set_attr "prefix_extra" "1")
@@ -22989,6 +23106,7 @@ (define_insn_and_split "ssse3_ph<plusminus_mnemonic>wv4hi3"
 }
   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "atom_unit" "complex")
    (set_attr "prefix_extra" "1")
    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
@@ -23012,6 +23130,7 @@ (define_insn "avx2_ph<plusminus_mnemonic>dv8si3"
   "TARGET_AVX2"
   "vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "vex")
@@ -23036,6 +23155,7 @@ (define_insn "ssse3_ph<plusminus_mnemonic>dv4si3"
    vph<plusminus_mnemonic>d\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "atom_unit" "complex")
    (set_attr "prefix_data16" "1,*")
@@ -23076,6 +23196,7 @@ (define_insn_and_split "ssse3_ph<plusminus_mnemonic>dv2si3"
 }
   [(set_attr "mmx_isa" "native,sse_noavx,avx")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "hplus")
    (set_attr "addr" "gpr16")
    (set_attr "atom_unit" "complex")
    (set_attr "prefix_extra" "1")
@@ -23132,6 +23253,7 @@ (define_insn "avx2_pmaddubsw256"
   "TARGET_AVX2"
   "vpmaddubsw\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "vex")
    (set_attr "mode" "OI")])
@@ -23147,6 +23269,7 @@ (define_insn "avx512bw_pmaddubsw512<mode><mask_name>"
    "TARGET_AVX512BW"
    "vpmaddubsw\t{%2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2}";
   [(set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -23223,6 +23346,7 @@ (define_insn "ssse3_pmaddubsw128"
   [(set_attr "isa" "noavx,avx")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "atom_unit" "simul")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,vex")
@@ -23259,6 +23383,7 @@ (define_insn "ssse3_pmaddubsw"
   [(set_attr "isa" "*,noavx,avx")
    (set_attr "mmx_isa" "native,*,*")
    (set_attr "type" "sseiadd")
+   (set_attr "c86_attr" "madd")
    (set_attr "atom_unit" "simul")
    (set_attr "prefix_extra" "1")
    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
@@ -23298,9 +23423,9 @@ (define_expand "<ssse3_avx2>_pmulhrsw<mode>3"
 	      (lshiftrt:<ssedoublemode>
 		(mult:<ssedoublemode>
 		  (sign_extend:<ssedoublemode>
-		    (match_operand:PMULHRSW 1 "nonimmediate_operand"))
+		    (match_operand:PMULHRSW 1 "vector_operand"))
 		  (sign_extend:<ssedoublemode>
-		    (match_operand:PMULHRSW 2 "nonimmediate_operand")))
+		    (match_operand:PMULHRSW 2 "vector_operand")))
 		(const_int 14))
 	      (match_dup 3))
 	    (const_int 1))))]
@@ -23318,9 +23443,9 @@ (define_expand "smulhrs<mode>3"
 	      (lshiftrt:<ssedoublemode>
 		(mult:<ssedoublemode>
 		  (sign_extend:<ssedoublemode>
-		    (match_operand:VI2_AVX2_AVX512BW 1 "nonimmediate_operand"))
+		    (match_operand:VI2_AVX2_AVX512BW 1 "vector_operand"))
 		  (sign_extend:<ssedoublemode>
-		    (match_operand:VI2_AVX2_AVX512BW 2 "nonimmediate_operand")))
+		    (match_operand:VI2_AVX2_AVX512BW 2 "vector_operand")))
 		(const_int 14))
 	      (match_dup 3))
 	    (const_int 1))))]
@@ -23542,6 +23667,7 @@ (define_insn "<ssse3_avx2>_psign<mode>3"
    vpsign<ssemodesuffix>\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "sign")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,vex")
@@ -23561,6 +23687,7 @@ (define_insn "ssse3_psign<mode>3"
   [(set_attr "isa" "*,noavx,avx")
    (set_attr "mmx_isa" "native,*,*")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "sign")
    (set_attr "prefix_extra" "1")
    (set (attr "prefix_rex") (symbol_ref "x86_extended_reg_mentioned_p (insn)"))
    (set_attr "mode" "DI,TI,TI")])
@@ -23710,6 +23837,7 @@ (define_insn "*abs<mode>2"
    (set_attr "type" "sselog1")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_vex")
+   (set_attr "c86_attr" "abs")
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn "abs<mode>2_mask"
@@ -23722,6 +23850,7 @@ (define_insn "abs<mode>2_mask"
   "TARGET_AVX512F"
   "vpabs<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "abs")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -23735,6 +23864,7 @@ (define_insn "abs<mode>2_mask"
   "TARGET_AVX512BW"
   "vpabs<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "abs")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -23767,6 +23897,7 @@ (define_insn "sse4a_movnt<mode>"
   "TARGET_SSE4A"
   "movnt<ssemodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "mode" "<MODE>")])
 
 (define_insn "sse4a_vmmovnt<mode>"
@@ -23779,6 +23910,7 @@ (define_insn "sse4a_vmmovnt<mode>"
   "TARGET_SSE4A"
   "movnt<ssescalarmodesuffix>\t{%1, %0|%0, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "mode" "<ssescalarmode>")])
 
 (define_insn "sse4a_extrqi"
@@ -23855,6 +23987,7 @@ (define_insn "<sse4_1>_blend<ssemodesuffix><avxsizesuffix>"
    vblend<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "addr" "gpr16")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*")
@@ -23876,6 +24009,7 @@ (define_insn "<sse4_1>_blendv<ssemodesuffix><avxsizesuffix>"
    vblendv<ssemodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blendv")
    (set_attr "addr" "gpr16")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*")
@@ -23909,6 +24043,7 @@ (define_insn "sse4_1_blendv<ssemodesuffix>"
 }
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blendv")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*")
    (set_attr "prefix_extra" "1")
@@ -24114,6 +24249,7 @@ (define_insn "<sse4_1>_dp<ssemodesuffix><avxsizesuffix>"
    (set_attr "prefix" "orig,orig,vex")
    (set_attr "btver2_decode" "vector,vector,vector")
    (set_attr "znver1_decode" "vector,vector,vector")
+   (set_attr "c86_decode" "vector,vector,vector")
    (set_attr "mode" "<MODE>")])
 
 ;; Mode attribute used by `vmovntdqa' pattern
@@ -24129,6 +24265,7 @@ (define_insn "<vi8_sse4_1_avx2_avx512>_movntdqa"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "movnt")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -24153,6 +24290,7 @@ (define_insn "<sse4_1_avx2>_mpsadbw"
    (set_attr "prefix" "orig,orig,vex")
    (set_attr "btver2_decode" "vector,vector,vector")
    (set_attr "znver1_decode" "vector,vector,vector")
+   (set_attr "c86_decode" "vector,vector,vector")
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn "avx10_2_mpsadbw<mask_name>"
@@ -24212,6 +24350,7 @@ (define_insn "<sse4_1_avx2>_pblendvb"
    vpblendvb\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blendv")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "*,*,1")
@@ -24353,6 +24492,7 @@ (define_insn "sse4_1_pblend<ssemodesuffix>"
    vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -24425,6 +24565,7 @@ (define_insn "*avx2_pblend<ssemodesuffix>"
   return "vpblendw\t{%3, %2, %1, %0|%0, %1, %2, %3}";
 }
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -24440,6 +24581,7 @@ (define_insn "avx2_pblendd<mode>"
   "TARGET_AVX2"
   "vpblendd\t{%3, %2, %1, %0|%0, %1, %2, %3}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "blend")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -24466,6 +24608,7 @@ (define_insn "avx2_<code>v16qiv16hi2<mask_name>"
   "TARGET_AVX2 && <mask_avx512bw_condition> && <mask_avx512vl_condition>"
   "vpmov<extsuffix>bw\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -24520,6 +24663,7 @@ (define_insn "avx512bw_<code>v32qiv32hi2<mask_name>"
   "TARGET_AVX512BW"
   "vpmov<extsuffix>bw\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -24579,6 +24723,7 @@ (define_insn "sse4_1_<code>v8qiv8hi2<mask_name>"
   "%vpmov<extsuffix>bw\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -24595,6 +24740,7 @@ (define_insn "*sse4_1_<code>v8qiv8hi2<mask_name>_1"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -24741,6 +24887,7 @@ (define_insn "<mask_codefor>avx512f_<code>v16qiv16si2<mask_name>"
   "TARGET_AVX512F"
   "vpmov<extsuffix>bd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -24762,6 +24909,7 @@ (define_insn "avx2_<code>v8qiv8si2<mask_name>"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>bd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -24773,6 +24921,7 @@ (define_insn "*avx2_<code>v8qiv8si2<mask_name>_1"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "%vpmov<extsuffix>bd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -24850,6 +24999,7 @@ (define_insn "sse4_1_<code>v4qiv4si2<mask_name>"
   "%vpmov<extsuffix>bd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -24863,6 +25013,7 @@ (define_insn "*sse4_1_<code>v4qiv4si2<mask_name>_1"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -24940,6 +25091,7 @@ (define_insn "avx512f_<code>v16hiv16si2<mask_name>"
   "TARGET_AVX512F"
   "vpmov<extsuffix>wd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -24993,6 +25145,7 @@ (define_insn "avx2_<code>v8hiv8si2<mask_name>"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>wd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -25052,6 +25205,7 @@ (define_insn "sse4_1_<code>v4hiv4si2<mask_name>"
   "%vpmov<extsuffix>wd\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -25065,6 +25219,7 @@ (define_insn "*sse4_1_<code>v4hiv4si2<mask_name>_1"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -25209,6 +25364,7 @@ (define_insn "avx512f_<code>v8qiv8di2<mask_name>"
   "TARGET_AVX512F"
   "vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -25219,6 +25375,7 @@ (define_insn "*avx512f_<code>v8qiv8di2<mask_name>_1"
   "TARGET_AVX512F"
   "vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -25292,6 +25449,7 @@ (define_insn "avx2_<code>v4qiv4di2<mask_name>"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -25303,6 +25461,7 @@ (define_insn "*avx2_<code>v4qiv4di2<mask_name>_1"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -25383,6 +25542,7 @@ (define_insn "sse4_1_<code>v2qiv2di2<mask_name>"
   "%vpmov<extsuffix>bq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -25396,6 +25556,7 @@ (define_insn "*sse4_1_<code>v2qiv2di2<mask_name>_1"
   [(set_attr "isa" "noavx,avx")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "TI")])
@@ -25445,6 +25606,7 @@ (define_insn "avx512f_<code>v8hiv8di2<mask_name>"
   "TARGET_AVX512F"
   "vpmov<extsuffix>wq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -25464,6 +25626,7 @@ (define_insn "avx2_<code>v4hiv4di2<mask_name>"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>wq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -25475,6 +25638,7 @@ (define_insn "*avx2_<code>v4hiv4di2<mask_name>_1"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>wq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_evex")
    (set_attr "mode" "OI")])
@@ -25547,6 +25711,7 @@ (define_insn "sse4_1_<code>v2hiv2di2<mask_name>"
   "%vpmov<extsuffix>wq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -25560,6 +25725,7 @@ (define_insn "*sse4_1_<code>v2hiv2di2<mask_name>_1"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -25635,6 +25801,7 @@ (define_insn "avx512f_<code>v8siv8di2<mask_name>"
   "TARGET_AVX512F"
   "vpmov<extsuffix>dq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -25686,6 +25853,7 @@ (define_insn "avx2_<code>v4siv4di2<mask_name>"
   "TARGET_AVX2 && <mask_avx512vl_condition>"
   "vpmov<extsuffix>dq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix" "maybe_evex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "OI")])
@@ -25741,6 +25909,7 @@ (define_insn "sse4_1_<code>v2siv2di2<mask_name>"
   "%vpmov<extsuffix>dq\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -25754,6 +25923,7 @@ (define_insn "*sse4_1_<code>v2siv2di2<mask_name>_1"
   [(set_attr "isa" "noavx,noavx,avx")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "ssemov")
+   (set_attr "c86_attr" "vpmovx")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,orig,maybe_evex")
    (set_attr "mode" "TI")])
@@ -26206,6 +26376,7 @@ (define_insn "sse4_1_round<ssescalarmodesuffix>"
 }
   [(set_attr "isa" "noavx,noavx,noavx512f,avx512f")
    (set_attr "type" "ssecvt")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16,gpr16,gpr16,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*,*")
@@ -26243,6 +26414,7 @@ (define_insn "*sse4_1_round<ssescalarmodesuffix>"
 }
   [(set_attr "isa" "noavx,noavx,noavx512f,avx512f")
    (set_attr "type" "ssecvt")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16,gpr16,gpr16,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix_data16" "1,1,*,*")
@@ -26512,6 +26684,7 @@ (define_insn "sse4_2_pcmpestri"
   "TARGET_SSE4_2"
   "%vpcmpestri\t{%5, %3, %1|%1, %3, %5}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "cmpestr")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_vex")
@@ -26540,6 +26713,7 @@ (define_insn "sse4_2_pcmpestrm"
   "TARGET_SSE4_2"
   "%vpcmpestrm\t{%5, %3, %1|%1, %3, %5}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "cmpestr")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -26566,6 +26740,7 @@ (define_insn "sse4_2_pcmpestr_cconly"
    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}
    %vpcmpestri\t{%6, %4, %2|%2, %4, %6}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "cmpestr")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -26643,6 +26818,7 @@ (define_insn "sse4_2_pcmpistri"
   "TARGET_SSE4_2"
   "%vpcmpistri\t{%3, %2, %1|%1, %2, %3}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "cmpestr")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -26667,6 +26843,7 @@ (define_insn "sse4_2_pcmpistrm"
   "TARGET_SSE4_2"
   "%vpcmpistrm\t{%3, %2, %1|%1, %2, %3}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "cmpestr")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -26691,6 +26868,7 @@ (define_insn "sse4_2_pcmpistr_cconly"
    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}
    %vpcmpistri\t{%4, %3, %2|%2, %3, %4}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "cmpestr")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -26877,6 +27055,7 @@ (define_insn "xop_phadd<u>bw"
   "TARGET_XOP"
   "vphadd<u>bw\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -26909,6 +27088,7 @@ (define_insn "xop_phadd<u>bd"
   "TARGET_XOP"
   "vphadd<u>bd\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -26957,6 +27137,7 @@ (define_insn "xop_phadd<u>bq"
   "TARGET_XOP"
   "vphadd<u>bq\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -26977,6 +27158,7 @@ (define_insn "xop_phadd<u>wd"
   "TARGET_XOP"
   "vphadd<u>wd\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -27005,6 +27187,7 @@ (define_insn "xop_phadd<u>wq"
   "TARGET_XOP"
   "vphadd<u>wq\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -27023,6 +27206,7 @@ (define_insn "xop_phadd<u>dq"
   "TARGET_XOP"
   "vphadd<u>dq\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -27047,6 +27231,7 @@ (define_insn "xop_phsubbw"
   "TARGET_XOP"
   "vphsubbw\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -27067,6 +27252,7 @@ (define_insn "xop_phsubwd"
   "TARGET_XOP"
   "vphsubwd\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -27085,6 +27271,7 @@ (define_insn "xop_phsubdq"
   "TARGET_XOP"
   "vphsubdq\t{%1, %0|%0, %1}"
   [(set_attr "type" "sseiadd1")
+   (set_attr "c86_attr" "hplus")
    (set_attr "prefix" "vex")
    (set_attr "prefix_extra" "1")
    (set_attr "mode" "TI")])
@@ -27791,6 +27978,7 @@ (define_insn "aesenc"
    vaesenc\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx,vaes_avx512vl")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,maybe_evex,evex")
@@ -27809,6 +27997,7 @@ (define_insn "aesenclast"
    vaesenclast\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx,vaes_avx512vl")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,maybe_evex,evex")
@@ -27827,6 +28016,7 @@ (define_insn "aesdec"
    vaesdec\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "isa" "noavx,avx,vaes_avx512vl")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,maybe_evex,evex")
@@ -27846,6 +28036,7 @@ (define_insn "aesdeclast"
   [(set_attr "isa" "noavx,avx,vaes_avx512vl")
    (set_attr "addr" "gpr16,gpr16,*")
    (set_attr "type" "sselog1")
+   (set_attr "c86_attr" "aes")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "orig,maybe_evex,evex")
    (set_attr "btver2_decode" "double,double,double")
@@ -27858,6 +28049,7 @@ (define_insn "aesimc"
   "TARGET_AES"
   "%vaesimc\t{%1, %0|%0, %1}"
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "maybe_vex")
@@ -27871,6 +28063,7 @@ (define_insn "aeskeygenassist"
   "TARGET_AES"
   "%vaeskeygenassist\t{%2, %1, %0|%0, %1, %2}"
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "aes")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -27894,6 +28087,7 @@ (define_insn "pclmulqdq"
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "orig,vex,evex")
+   (set_attr "c86_decode" "*,vector,vector")
    (set_attr "mode" "TI")])
 
 (define_expand "avx_vzeroall"
@@ -28011,6 +28205,7 @@ (define_insn "<avx2_avx512>_permvar<mode><mask_name>"
   return "vperm<ssemodesuffix>\t{%1, %2, %0<mask_operand3>|%0<mask_operand3>, %2, %1}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm")
    (set_attr "prefix" "<mask_prefix2>")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28023,6 +28218,7 @@ (define_insn "<avx512>_permvar<mode><mask_name>"
   "TARGET_AVX512VBMI && <mask_mode512bit_condition>"
   "vperm<ssemodesuffix>\t{%1, %2, %0<mask_operand3>|%0<mask_operand3>, %2, %1}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm")
    (set_attr "prefix" "<mask_prefix2>")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28035,6 +28231,7 @@ (define_insn "<avx512>_permvar<mode><mask_name>"
   "TARGET_AVX512BW && <mask_mode512bit_condition>"
   "vpermw\t{%1, %2, %0<mask_operand3>|%0<mask_operand3>, %2, %1}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm")
    (set_attr "prefix" "<mask_prefix2>")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28253,6 +28450,7 @@ (define_insn "avx2_perm<mode>_1<mask_name>"
   return "vperm<ssemodesuffix>\t{%2, %1, %0<mask_operand6>|%0<mask_operand6>, %1, %2}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm")
    (set_attr "prefix" "<mask_prefix2>")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28328,6 +28526,7 @@ (define_insn "avx512f_perm<mode>_1<mask_name>"
   return "vperm<ssemodesuffix>\t{%2, %1, %0<mask_operand10>|%0<mask_operand10>, %1, %2}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm")
    (set_attr "prefix" "<mask_prefix2>")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28434,6 +28633,7 @@ (define_insn "<mask_codefor>avx512f_broadcast<mode><mask_name>"
    vshuf<shuffletype>32x4\t{$0x0, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x0}
    vbroadcast<shuffletype>32x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "shufx,*")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28446,6 +28646,7 @@ (define_insn "<mask_codefor>avx512f_broadcast<mode><mask_name>"
    vshuf<shuffletype>64x2\t{$0x44, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x44}
    vbroadcast<shuffletype>64x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "shufx,*")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28698,6 +28899,7 @@ (define_insn "avx_vbroadcastf128_<mode>"
    vinsert<shuffletype>32x4\t{$1, %1, %0, %0|%0, %0, %1, 1}"
   [(set_attr "isa" "noavx512vl,*,*,avx512dq,avx512dq,avx512vl,avx512vl")
    (set_attr "type" "ssemov,sselog1,sselog1,ssemov,sselog1,ssemov,sselog1")
+   (set_attr "c86_attr" "*,insertx,*,*,insertx,*,insertx")
    (set (attr "addr")
 	(if_then_else (eq_attr "alternative" "0")
 		      (const_string "gpr16")
@@ -28756,6 +28958,7 @@ (define_insn "<mask_codefor>avx512vl_broadcast<mode><mask_name>_1"
    vshuf<shuffletype>32x4\t{$0x0, %t1, %t1, %0<mask_operand2>|%0<mask_operand2>, %t1, %t1, 0x0}
    vbroadcast<shuffletype>32x4\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "shufx,*")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -28769,6 +28972,7 @@ (define_insn "<mask_codefor>avx512dq_broadcast<mode><mask_name>_1"
    vshuf<shuffletype>32x4\t{$0x44, %g1, %g1, %0<mask_operand2>|%0<mask_operand2>, %g1, %g1, 0x44}
    vbroadcast<shuffletype>32x8\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "shufx,*")
    (set_attr "length_immediate" "1,*")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -28786,6 +28990,7 @@ (define_insn "<mask_codefor>avx512dq_broadcast<mode><mask_name>_1"
    vshuf<shuffletype>64x2\t{$0x0, %<xtg_mode>1, %<xtg_mode>1, %0<mask_operand2>|%0<mask_operand2>, %<xtg_mode>1, %<xtg_mode>1, 0x0}
    vbroadcast<shuffletype>64x2\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "shufx,*")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -28883,6 +29088,7 @@ (define_insn "*<avx512>_vpermi2var<mode>3_mask"
   "TARGET_AVX512F"
   "vpermi2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm2")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28899,6 +29105,7 @@ (define_insn "*<avx512>_vpermi2var<mode>3_mask"
   "TARGET_AVX512F"
   "vpermi2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm2")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28928,6 +29135,7 @@ (define_insn "<avx512>_vpermt2var<mode>3<sd_maskz_name>"
    vpermt2<ssemodesuffix>\t{%3, %1, %0<sd_mask_op4>|%0<sd_mask_op4>, %1, %3}
    vpermi2<ssemodesuffix>\t{%3, %2, %0<sd_mask_op4>|%0<sd_mask_op4>, %2, %3}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm2")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -28959,6 +29167,7 @@ (define_insn "<avx512>_vpermt2var<mode>3_mask"
   "TARGET_AVX512F"
   "vpermt2<ssemodesuffix>\t{%3, %1, %0%{%4%}|%0%{%4%}, %1, %3}"
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "perm2")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -29037,6 +29246,7 @@ (define_insn "*avx_vperm2f128<mode>_nozero"
   return "vperm2<i128>\t{%3, %2, %1, %0|%0, %1, %2, %3}";
 }
   [(set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -29144,6 +29354,7 @@ (define_insn "vec_set_lo_<mode><mask_name>"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex")
@@ -29168,6 +29379,7 @@ (define_insn "vec_set_hi_<mode><mask_name>"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex")
@@ -29191,6 +29403,7 @@ (define_insn "vec_set_lo_<mode><mask_name>"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex")
@@ -29214,6 +29427,7 @@ (define_insn "vec_set_hi_<mode><mask_name>"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex")
@@ -29236,6 +29450,7 @@ (define_insn "vec_set_lo_<mode>"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex,evex")
@@ -29258,6 +29473,7 @@ (define_insn "vec_set_hi_<mode>"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16,*")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex,evex")
@@ -29283,6 +29499,7 @@ (define_insn "vec_set_lo_v32qi"
    vinserti32x4\t{$0x0, %2, %1, %0|%0, %1, %2, 0x0}"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "addr" "gpr16,*")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
@@ -29310,6 +29527,7 @@ (define_insn "vec_set_hi_v32qi"
   [(set_attr "isa" "noavx512vl,avx512vl")
    (set_attr "addr" "gpr16")
    (set_attr "type" "sselog")
+   (set_attr "c86_attr" "insertx")
    (set_attr "prefix_extra" "1")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "vex,evex")
@@ -29329,6 +29547,7 @@ (define_insn "<avx_avx2>_maskload<ssemodesuffix><avxsizesuffix>"
     return "vmaskmov<ssefltmodesuffix>\t{%1, %2, %0|%0, %2, %1}";
 }
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "blend")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "vex")
@@ -29350,6 +29569,7 @@ (define_insn "<avx_avx2>_maskstore<ssemodesuffix><avxsizesuffix>"
     return "vmaskmov<ssefltmodesuffix>\t{%2, %1, %0|%0, %1, %2}";
 }
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "blend")
    (set_attr "addr" "gpr16")
    (set_attr "prefix_extra" "1")
    (set_attr "prefix" "vex")
@@ -29745,6 +29965,7 @@ (define_insn "avx_vec_concat<mode>"
   [(set_attr "isa" "noavx512f,avx512f,*,*")
    (set_attr "addr" "gpr16,*,*,*")
    (set_attr "type" "sselog,sselog,ssemov,ssemov")
+   (set_attr "c86_attr" "insertx,insertx,*,*")
    (set_attr "prefix_extra" "1,1,*,*")
    (set_attr "length_immediate" "1,1,*,*")
    (set_attr "prefix" "maybe_evex")
@@ -30355,6 +30576,7 @@ (define_insn "<avx512>_compress<mode>_mask"
   "TARGET_AVX512F"
   "v<sseintprefix>compress<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "compress")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -30368,6 +30590,7 @@ (define_insn "compress<mode>_mask"
   "TARGET_AVX512VBMI2"
   "vpcompress<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "compress")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -30381,6 +30604,7 @@ (define_insn "<avx512>_compressstore<mode>_mask"
   "TARGET_AVX512F"
   "v<sseintprefix>compress<ssemodesuffix>\t{%1, %0%{%2%}|%0%{%2%}, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "compress")
    (set_attr "prefix" "evex")
    (set_attr "memory" "store")
    (set_attr "mode" "<sseinsnmode>")])
@@ -30395,6 +30619,7 @@ (define_insn "compressstore<mode>_mask"
   "TARGET_AVX512VBMI2"
   "vpcompress<ssemodesuffix>\t{%1, %0%{%2%}|%0%{%2%}, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "compress")
    (set_attr "prefix" "evex")
    (set_attr "memory" "store")
    (set_attr "mode" "<sseinsnmode>")])
@@ -30419,6 +30644,7 @@ (define_insn "expand<mode>_mask"
   "TARGET_AVX512F"
   "v<sseintprefix>expand<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "expand")
    (set_attr "prefix" "evex")
    (set_attr "memory" "none,load")
    (set_attr "mode" "<sseinsnmode>")])
@@ -30433,6 +30659,7 @@ (define_insn "expand<mode>_mask"
   "TARGET_AVX512VBMI2"
   "v<sseintprefix>expand<ssemodesuffix>\t{%1, %0%{%3%}%N2|%0%{%3%}%N2, %1}"
   [(set_attr "type" "ssemov")
+   (set_attr "c86_attr" "expand")
    (set_attr "prefix" "evex")
    (set_attr "memory" "none,load")
    (set_attr "mode" "<sseinsnmode>")])
@@ -30625,6 +30852,7 @@ (define_insn "<mask_codefor>avx512bw_dbpsadbw<mode><mask_name>"
    "TARGET_AVX512BW"
   "vdbpsadbw\t{%3, %2, %1, %0<mask_operand4>|%0<mask_operand4>, %1, %2, %3}"
   [(set_attr "type" "sselog1")
+   (set_attr "c86_attr" "sadbw")
    (set_attr "length_immediate" "1")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -30636,6 +30864,7 @@ (define_insn "clz<mode>2<mask_name>"
   "TARGET_AVX512CD"
   "vplzcnt<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "sse")
+   (set_attr "c86_attr" "abs")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -30648,6 +30877,7 @@ (define_insn "<mask_codefor>conflict<mode><mask_name>"
   "vpconflict<ssemodesuffix>\t{%1, %0<mask_operand2>|%0<mask_operand2>, %1}"
   [(set_attr "type" "sse")
    (set_attr "prefix" "evex")
+   (set_attr "c86_decode" "vector")
    (set_attr "mode" "<sseinsnmode>")])
 
 (define_insn "sha1msg1"
@@ -30910,6 +31140,7 @@ (define_insn "vpmadd52<vpmadd52type>v8di"
   "TARGET_AVX512IFMA"
   "vpmadd52<vpmadd52type>\t{%3, %2, %0|%0, %2, %3}"
   [(set_attr "type" "ssemuladd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix" "evex")
    (set_attr "mode" "XI")])
 
@@ -30926,6 +31157,7 @@ (define_insn "vpmadd52<vpmadd52type><mode>"
   vpmadd52<vpmadd52type>\t{%3, %2, %0|%0, %2, %3}"
   [(set_attr "isa" "avxifma,avx512ifmavl")
    (set_attr "type" "ssemuladd")
+   (set_attr "c86_attr" "madd")
    (set_attr "addr" "gpr16,*")
    (set_attr "prefix" "vex,evex")
    (set_attr "mode" "<sseinsnmode>")])
@@ -30943,6 +31175,7 @@ (define_insn "vpmadd52<vpmadd52type><mode>_maskz_1"
   "TARGET_AVX512IFMA"
   "vpmadd52<vpmadd52type>\t{%3, %2, %0%{%5%}%{z%}|%0%{%5%}%{z%}, %2, %3}"
   [(set_attr "type" "ssemuladd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -30959,6 +31192,7 @@ (define_insn "vpmadd52<vpmadd52type><mode>_mask"
   "TARGET_AVX512IFMA"
   "vpmadd52<vpmadd52type>\t{%3, %2, %0%{%4%}|%0%{%4%}, %2, %3}"
   [(set_attr "type" "ssemuladd")
+   (set_attr "c86_attr" "madd")
    (set_attr "prefix" "evex")
    (set_attr "mode" "<sseinsnmode>")])
 
@@ -31562,6 +31796,7 @@ (define_insn "vaesdec_<mode>"
 }
 [(set_attr "isa" "avx,vaes_avx512vl")
  (set_attr "type" "sselog1")
+ (set_attr "c86_attr" "aes")
  (set_attr "addr" "gpr16,*")
  (set_attr "mode" "TI")])
 
@@ -31580,6 +31815,7 @@ (define_insn "vaesdeclast_<mode>"
 }
 [(set_attr "isa" "avx,vaes_avx512vl")
  (set_attr "type" "sselog1")
+ (set_attr "c86_attr" "aes")
  (set_attr "addr" "gpr16,*")
  (set_attr "mode" "TI")])
 
@@ -31598,6 +31834,7 @@ (define_insn "vaesenc_<mode>"
 }
 [(set_attr "isa" "avx,vaes_avx512vl")
  (set_attr "type" "sselog1")
+ (set_attr "c86_attr" "aes")
  (set_attr "addr" "gpr16,*")
  (set_attr "mode" "TI")])
 
@@ -31616,6 +31853,7 @@ (define_insn "vaesenclast_<mode>"
 }
 [(set_attr "isa" "avx,vaes_avx512vl")
  (set_attr "type" "sselog1")
+ (set_attr "c86_attr" "aes")
  (set_attr "addr" "gpr16,*")
  (set_attr "mode" "TI")])
 
--- a/src/gcc/config/i386/x86-tune-costs.h
+++ b/src/gcc/config/i386/x86-tune-costs.h
@@ -4420,3 +4420,303 @@ struct processor_costs core_cost = {
   COSTS_N_INSNS (2),			/* Branch mispredict scale.  */
 };
 
+/*  C86_4G_M4 has optimized REP instruction for medium sized blocks, but for
+    very small blocks it is better to use loop.  For large blocks, libcall
+    can do nontemporary accesses and beat inline considerably.  */
+static stringop_algs c86_4g_m4_memcpy[2] = {
+  /* 32-bit tuning.  */
+  {libcall, {{6, loop, false},
+	     {14, unrolled_loop, false},
+	     {-1, libcall, false}}},
+  /* 64-bit tuning.  */
+  {libcall, {{16, loop, false},
+	     {128, rep_prefix_8_byte, false},
+	     {-1, libcall, false}}}};
+static stringop_algs c86_4g_m4_memset[2] = {
+  /* 32-bit tuning.  */
+  {libcall, {{8, loop, false},
+	     {24, unrolled_loop, false},
+	     {128, rep_prefix_4_byte, false},
+	     {-1, libcall, false}}},
+  /* 64-bit tuning.  */
+  {libcall, {{48, unrolled_loop, false},
+	     {128, rep_prefix_8_byte, false},
+	     {-1, libcall, false}}}};
+static const
+struct processor_costs c86_4g_m4_cost = {
+  {
+  /* Start of register allocator costs.  integer->integer move cost is 2.  */
+
+  /* reg-reg moves are done by renaming and thus they are even cheaper than
+     1 cycle.  Because reg-reg move cost is 2 and the following tables
+     correspond to doubles of latencies, we do not model this correctly.
+     It does not seem to make practical difference to bump prices up even
+     more.  */
+  6,					/* cost for loading QImode using
+					   movzbl.  */
+  {6, 6, 6},				/* cost of loading integer registers
+					   in QImode, HImode and SImode.
+					   Relative to reg-reg move (2).  */
+  {8, 8, 8},				/* cost of storing integer
+					   registers.  */
+  2,					/* cost of reg,reg fld/fst.  */
+  {6, 6, 16},				/* cost of loading fp registers
+					   in SFmode, DFmode and XFmode.  */
+  {8, 8, 16},				/* cost of storing fp registers
+					   in SFmode, DFmode and XFmode.  */
+  2,					/* cost of moving MMX register.  */
+  {6, 6},				/* cost of loading MMX registers
+					   in SImode and DImode.  */
+  {8, 8},				/* cost of storing MMX registers
+					   in SImode and DImode.  */
+  2, 3, 6,				/* cost of moving XMM,YMM,ZMM register.  */
+  {6, 6, 6, 12, 24},			/* cost of loading SSE registers
+					   in 32,64,128,256 and 512-bit.  */
+  {8, 8, 8, 16, 32},			/* cost of storing SSE registers
+					   in 32,64,128,256 and 512-bit.  */
+  6, 6,				/* SSE->integer and integer->SSE moves.  */
+  8, 8,				/* mask->integer and integer->mask moves */
+  {6, 6, 6},				/* cost of loading mask register
+					   in QImode, HImode, SImode.  */
+  {8, 8, 8},				/* cost if storing mask register
+					   in QImode, HImode, SImode.  */
+  2,					/* cost of moving mask register.  */
+  /* End of register allocator costs.  */
+  },
+
+  COSTS_N_INSNS (1),			/* cost of an add instruction.  */
+  COSTS_N_INSNS (1),			/* cost of a lea instruction.  */
+  COSTS_N_INSNS (1),			/* variable shift costs.  */
+  COSTS_N_INSNS (1),			/* constant shift costs.  */
+  {COSTS_N_INSNS (3),			/* cost of starting multiply for QI.  */
+   COSTS_N_INSNS (3),			/*				 HI.  */
+   COSTS_N_INSNS (3),			/*				 SI.  */
+   COSTS_N_INSNS (3),			/*				 DI.  */
+   COSTS_N_INSNS (3)},			/*			      other.  */
+  0,					/* cost of multiply per each bit
+					    set.  */
+   /* Depending on parameters, idiv can get faster on HYGON.  This is upper
+      bound.  */
+  {COSTS_N_INSNS (16),			/* cost of a divide/mod for QI.  */
+   COSTS_N_INSNS (22),			/*			    HI.  */
+   COSTS_N_INSNS (30),			/*			    SI.  */
+   COSTS_N_INSNS (45),			/*			    DI.  */
+   COSTS_N_INSNS (45)},			/*			    other.  */
+  COSTS_N_INSNS (1),			/* cost of movsx.  */
+  COSTS_N_INSNS (1),			/* cost of movzx.  */
+  8,					/* "large" insn.  */
+  9,					/* MOVE_RATIO.  */
+  6,					/* CLEAR_RATIO */
+  {6, 6, 6},				/* cost of loading integer registers
+					   in QImode, HImode and SImode.
+					   Relative to reg-reg move (2).  */
+  {8, 8, 8},				/* cost of storing integer
+					   registers.  */
+  {6, 6, 6, 12, 24},			/* cost of loading SSE register
+					   in 32bit, 64bit, 128bit, 256bit and 512bit */
+  {8, 8, 8, 16, 32},			/* cost of storing SSE register
+					   in 32bit, 64bit, 128bit, 256bit and 512bit */
+  {6, 6, 6, 12, 24},			/* cost of unaligned loads.  */
+  {8, 8, 8, 16, 32},			/* cost of unaligned stores.  */
+  2, 3, 6,				/* cost of moving XMM,YMM,ZMM register.  */
+  6,					/* cost of moving SSE register to integer.  */
+  6,					/* cost of moving integer register to SSE.  */
+
+  18, 8,				/* Gather load static, per_elt.  */
+  18, 10,				/* Gather store static, per_elt.  */
+  32,					/* size of l1 cache.  */
+  512,					/* size of l2 cache.  */
+  64,					/* size of prefetch block.  */
+  /* C86_4G_M4 processors never drop prefetches; if they cannot be performed
+     immediately, they are queued.  We set number of simultaneous prefetches
+     to a large constant to reflect this (it probably is not a good idea not
+     to limit number of prefetches at all, as their execution also takes some
+     time).  */
+  100,					/* number of parallel prefetches.  */
+  3,					/* Branch cost.  */
+  COSTS_N_INSNS (5),			/* cost of FADD and FSUB insns.  */
+  COSTS_N_INSNS (5),			/* cost of FMUL instruction.  */
+
+  COSTS_N_INSNS (15),			/* cost of FDIV instruction.  */
+  COSTS_N_INSNS (1),			/* cost of FABS instruction.  */
+  COSTS_N_INSNS (1),			/* cost of FCHS instruction.  */
+
+  COSTS_N_INSNS (10),			/* cost of FSQRT instruction.  */
+
+  COSTS_N_INSNS (1),			/* cost of cheap SSE instruction.  */
+  COSTS_N_INSNS (3),			/* cost of ADDSS/SD SUBSS/SD insns.  */
+  COSTS_N_INSNS (3),			/* cost of MULSS instruction.  */
+  COSTS_N_INSNS (4),			/* cost of MULSD instruction.  */
+  COSTS_N_INSNS (5),			/* cost of FMA SS instruction.  */
+  COSTS_N_INSNS (5),			/* cost of FMA SD instruction.  */
+  COSTS_N_INSNS (10),			/* cost of DIVSS instruction.  */
+
+  COSTS_N_INSNS (13),			/* cost of DIVSD instruction.  */
+  COSTS_N_INSNS (10),			/* cost of SQRTSS instruction.  */
+  COSTS_N_INSNS (15),			/* cost of SQRTSD instruction.  */
+
+  COSTS_N_INSNS (4),			/* cost of CVTSS2SD etc.  */
+  COSTS_N_INSNS (5),			/* cost of 256bit VCVTPS2PD etc.  */
+  COSTS_N_INSNS (10),			/* cost of 512bit VCVTPS2PD etc.  */
+  COSTS_N_INSNS (5),			/* cost of CVTSI2SS instruction.  */
+  COSTS_N_INSNS (5),			/* cost of CVT(T)SS2SI instruction.  */
+  COSTS_N_INSNS (5),			/* cost of CVTPI2PS instruction.  */
+  COSTS_N_INSNS (4),			/* cost of CVT(T)PS2PI instruction.  */
+
+  4, 4, 3, 6,				/* reassoc int, fp, vec_int, vec_fp.  */
+  {8, 1, 6},				/* latency times throughput of
+					   FMA/DOT_PROD_EXPR/SAD_EXPR,
+					   it's used to determine unroll
+					   factor in the vectorizer.  */
+  4,					/* Limit how much the autovectorizer
+					   may unroll a loop.  */
+  c86_4g_m4_memcpy,
+  c86_4g_m4_memset,
+  COSTS_N_INSNS (4),			/* cond_taken_branch_cost.  */
+  COSTS_N_INSNS (2),			/* cond_not_taken_branch_cost.  */
+  "16",					/* Loop alignment.  */
+  "16",					/* Jump alignment.  */
+  "0:0:8",				/* Label alignment.  */
+  "16",					/* Func alignment.  */
+  4,					/* Small unroll limit.  */
+  2,					/* Small unroll factor.  */
+  COSTS_N_INSNS (2),			/* Branch mispredict scale.  */
+};
+
+struct processor_costs c86_4g_m6_cost = c86_4g_m4_cost;
+
+struct processor_costs c86_4g_m7_cost = {
+  {
+  /* Start of register allocator costs.  integer->integer move cost is 2.  */
+
+  /* reg-reg moves are done by renaming and thus they are even cheaper than
+     1 cycle.  Because reg-reg move cost is 2 and following tables correspond
+     to doubles of latencies, we do not model this correctly.  It does not
+     seem to make practical difference to bump prices up even more.  */
+  6,					/* cost for loading QImode using
+					   movzbl.  */
+  {6, 6, 6},				/* cost of loading integer registers
+					   in QImode, HImode and SImode.
+					   Relative to reg-reg move (2).  */
+  {8, 8, 8},				/* cost of storing integer
+					   registers.  */
+  2,					/* cost of reg,reg fld/fst.  */
+  {14, 14, 17},				/* cost of loading fp registers
+					   in SFmode, DFmode and XFmode.  */
+  {12, 12, 16},				/* cost of storing fp registers
+					   in SFmode, DFmode and XFmode.  */
+  2,					/* cost of moving MMX register.  */
+  {6, 6},				/* cost of loading MMX registers
+					   in SImode and DImode.  */
+  {8, 8},				/* cost of storing MMX registers
+					   in SImode and DImode.  */
+  2, 2, 3,				/* cost of moving XMM,YMM,ZMM
+					   register.  */
+  {6, 6, 10, 10, 12},			/* cost of loading SSE registers
+					   in 32,64,128,256 and 512-bit.  */
+  {8, 8, 8, 12, 12},			/* cost of storing SSE registers
+					   in 32,64,128,256 and 512-bit.  */
+  6, 8,					/* SSE->integer and integer->SSE
+					   moves.  */
+  8, 8,					/* mask->integer and integer->mask moves */
+  {6, 6, 6},				/* cost of loading mask register
+					   in QImode, HImode, SImode.  */
+  {8, 8, 8},				/* cost if storing mask register
+					   in QImode, HImode, SImode.  */
+  2,					/* cost of moving mask register.  */
+  /* End of register allocator costs.  */
+  },
+
+  COSTS_N_INSNS (1),			/* cost of an add instruction.  */
+
+  COSTS_N_INSNS (1),			/* cost of a lea instruction.  */
+  COSTS_N_INSNS (1),			/* variable shift costs.  */
+  COSTS_N_INSNS (1),			/* constant shift costs.  */
+  {COSTS_N_INSNS (3),			/* cost of starting multiply for QI.  */
+   COSTS_N_INSNS (3),			/* 				 HI.  */
+   COSTS_N_INSNS (3),			/*				 SI.  */
+   COSTS_N_INSNS (3),			/*				 DI.  */
+   COSTS_N_INSNS (3)},			/*			other.  */
+  0,					/* cost of multiply per each bit
+					   set.  */
+  {COSTS_N_INSNS (15),			/* cost of a divide/mod for QI.  */
+   COSTS_N_INSNS (17),			/* 			    HI.  */
+   COSTS_N_INSNS (25),			/*			    SI.  */
+   COSTS_N_INSNS (41),			/*			    DI.  */
+   COSTS_N_INSNS (41)},			/*			    other.  */
+  COSTS_N_INSNS (1),			/* cost of movsx.  */
+  COSTS_N_INSNS (1),			/* cost of movzx.  */
+  8,					/* "large" insn.  */
+  9,					/* MOVE_RATIO.  */
+  6,					/* CLEAR_RATIO */
+  {6, 6, 6},				/* cost of loading integer registers
+					   in QImode, HImode and SImode.
+					   Relative to reg-reg move (2).  */
+  {8, 8, 8},				/* cost of storing integer
+					   registers.  */
+  {6, 6, 10, 10, 12},			/* cost of loading SSE registers
+					   in 32bit, 64bit, 128bit, 256bit and 512bit */
+  {8, 8, 8, 12, 12},			/* cost of storing SSE register
+					   in 32bit, 64bit, 128bit, 256bit and 512bit */
+  {6, 6, 10, 10, 12},			/* cost of unaligned loads.  */
+  {8, 8, 8, 12, 12},			/* cost of unaligned stores.  */
+  2, 2, 3,				/* cost of moving XMM,YMM,ZMM
+					   register.  */
+  6,					/* cost of moving SSE register to integer.  */
+  6,					/* cost of moving integer register to SSE.  */
+
+  14, 10,				/* Gather load static, per_elt.  */
+  14, 20,				/* Gather store static, per_elt.  */
+  32,					/* size of l1 cache.  */
+  512,					/* size of l2 cache.  */
+  64,					/* size of prefetch block.  */
+
+  100,					/* number of parallel prefetches.  */
+  3,					/* Branch cost.  */
+  COSTS_N_INSNS (5),			/* cost of FADD and FSUB insns.  */
+  COSTS_N_INSNS (5),			/* cost of FMUL instruction.  */
+
+  COSTS_N_INSNS (15),			/* cost of FDIV instruction.  */
+  COSTS_N_INSNS (1),			/* cost of FABS instruction.  */
+  COSTS_N_INSNS (1),			/* cost of FCHS instruction.  */
+
+  COSTS_N_INSNS (22),			/* cost of FSQRT instruction.  */
+
+  COSTS_N_INSNS (1),			/* cost of cheap SSE instruction.  */
+  COSTS_N_INSNS (3),			/* cost of ADDSS/SD SUBSS/SD insns.  */
+  COSTS_N_INSNS (3),			/* cost of MULSS instruction.  */
+  COSTS_N_INSNS (3),			/* cost of MULSD instruction.  */
+  COSTS_N_INSNS (4),			/* cost of FMA SS instruction.  */
+  COSTS_N_INSNS (4),			/* cost of FMA SD instruction.  */
+  COSTS_N_INSNS (13),			/* cost of DIVSS instruction.  */
+
+  COSTS_N_INSNS (10),			/* cost of DIVSD instruction.  */
+  COSTS_N_INSNS (14),			/* cost of SQRTSS instruction.  */
+  COSTS_N_INSNS (20),			/* cost of SQRTSD instruction.  */
+
+  COSTS_N_INSNS (4),			/* cost of CVTSS2SD etc.  */
+  COSTS_N_INSNS (5),			/* cost of 256bit VCVTPS2PD etc.  */
+  COSTS_N_INSNS (10),			/* cost of 512bit VCVTPS2PD etc.  */
+  COSTS_N_INSNS (5),			/* cost of CVTSI2SS instruction.  */
+  COSTS_N_INSNS (5),			/* cost of CVT(T)SS2SI instruction.  */
+  COSTS_N_INSNS (5),			/* cost of CVTPI2PS instruction.  */
+  COSTS_N_INSNS (4),			/* cost of CVT(T)PS2PI instruction.  */
+  4, 4, 3, 6,				/* reassoc int, fp, vec_int, vec_fp.  */
+  {8, 8, 6},				/* latency times throughput of
+					   FMA/DOT_PROD_EXPR/SAD_EXPR,
+					   it's used to determine unroll
+					   factor in the vectorizer.  */
+  4,					/* Limit how much the autovectorizer
+					   may unroll a loop.  */
+  c86_4g_m4_memcpy,
+  c86_4g_m4_memset,
+  COSTS_N_INSNS (4),			/* cond_taken_branch_cost.  */
+  COSTS_N_INSNS (2),			/* cond_not_taken_branch_cost.  */
+  "16",					/* Loop alignment.  */
+  "16",					/* Jump alignment.  */
+  "0:0:8",				/* Label alignment.  */
+  "16",					/* Func alignment.  */
+  4,					/* Small unroll limit.  */
+  2,					/* Small unroll factor.  */
+  COSTS_N_INSNS (2),			/* Branch mispredict scale.  */
+};
--- a/src/gcc/config/i386/x86-tune-sched.cc
+++ b/src/gcc/config/i386/x86-tune-sched.cc
@@ -91,6 +91,9 @@ ix86_issue_rate (void)
        is limits of the decoders.  */
     case PROCESSOR_ZNVER5:
     case PROCESSOR_ZNVER6:
+    case PROCESSOR_C86_4G_M4:
+    case PROCESSOR_C86_4G_M6:
+    case PROCESSOR_C86_4G_M7:
       return 4;
 
     case PROCESSOR_ICELAKE_CLIENT:
@@ -440,6 +443,9 @@ ix86_adjust_cost (rtx_insn *insn, int dep_type, rtx_insn *dep_insn, int cost,
     case PROCESSOR_ZNVER4:
     case PROCESSOR_ZNVER5:
     case PROCESSOR_ZNVER6:
+    case PROCESSOR_C86_4G_M4:
+    case PROCESSOR_C86_4G_M6:
+    case PROCESSOR_C86_4G_M7:
       /* Stack engine allows to execute push&pop instructions in parall.  */
       if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
 	  && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
--- a/src/gcc/config/i386/x86-tune.def
+++ b/src/gcc/config/i386/x86-tune.def
@@ -42,7 +42,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 DEF_TUNE (X86_TUNE_SCHEDULE, "schedule",
           m_PENT | m_LAKEMONT | m_PPRO | m_CORE_ALL | m_BONNELL | m_SILVERMONT
 	  | m_INTEL | m_K6_GEODE | m_AMD_MULTIPLE | m_ZHAOXIN | m_GOLDMONT
-	  | m_GOLDMONT_PLUS | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM
+	  | m_GOLDMONT_PLUS | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G
 	  | m_GENERIC)
 
 /* X86_TUNE_PARTIAL_REG_DEPENDENCY: Enable more register renaming
@@ -53,7 +53,7 @@ DEF_TUNE (X86_TUNE_PARTIAL_REG_DEPENDENCY, "partial_reg_dependency",
           m_P4_NOCONA | m_CORE2 | m_NEHALEM  | m_SANDYBRIDGE | m_CORE_AVX2
 	  | m_BONNELL | m_SILVERMONT | m_GOLDMONT | m_GOLDMONT_PLUS | m_INTEL
 	  | m_AMD_MULTIPLE | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID
-	  | m_CORE_ATOM | m_GENERIC)
+	  | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY: This knob promotes all store
    destinations to be 128bit to allow register renaming on 128bit SSE units,
@@ -64,7 +64,7 @@ DEF_TUNE (X86_TUNE_PARTIAL_REG_DEPENDENCY, "partial_reg_dependency",
 DEF_TUNE (X86_TUNE_SSE_PARTIAL_REG_DEPENDENCY, "sse_partial_reg_dependency",
           m_PPRO | m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_AMDFAM10
 	  | m_BDVER | m_ZNVER | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID
-	  | m_CORE_ATOM | m_GENERIC)
+	  | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_SSE_PARTIAL_REG_FP_CONVERTS_DEPENDENCY: This knob avoids
    partial write to the destination in scalar SSE conversion from FP
@@ -73,7 +73,7 @@ DEF_TUNE (X86_TUNE_SSE_PARTIAL_REG_FP_CONVERTS_DEPENDENCY,
 	  "sse_partial_reg_fp_converts_dependency",
 	  m_PPRO | m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_AMDFAM10
 	  | m_BDVER | m_ZNVER | m_ZHAOXIN | m_CORE_HYBRID | m_CORE_ATOM
-	  | m_GENERIC)
+	  | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_SSE_PARTIAL_REG_CONVERTS_DEPENDENCY: This knob avoids partial
    write to the destination in scalar SSE conversion from integer to FP.  */
@@ -81,7 +81,7 @@ DEF_TUNE (X86_TUNE_SSE_PARTIAL_REG_CONVERTS_DEPENDENCY,
 	  "sse_partial_reg_converts_dependency",
 	  m_PPRO | m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_AMDFAM10
 	  | m_BDVER | m_ZNVER | m_ZHAOXIN | m_CORE_HYBRID | m_CORE_ATOM
-	  | m_GENERIC)
+	  | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_DEST_FALSE_DEP_FOR_GLC: This knob inserts zero-idiom before
    several insns to break false dependency on the dest register for GLC
@@ -113,32 +113,33 @@ DEF_TUNE (X86_TUNE_MOVX, "movx",
           m_PPRO | m_P4_NOCONA | m_CORE2 | m_NEHALEM  | m_SANDYBRIDGE
 	  | m_BONNELL | m_SILVERMONT | m_GOLDMONT | m_INTEL
 	  | m_GOLDMONT_PLUS | m_GEODE | m_AMD_MULTIPLE | m_ZHAOXIN
-	  | m_CORE_AVX2 | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_CORE_AVX2 | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM
+	  | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_MEMORY_MISMATCH_STALL: Avoid partial stores that are followed by
    full sized loads.  */
 DEF_TUNE (X86_TUNE_MEMORY_MISMATCH_STALL, "memory_mismatch_stall",
           m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_SILVERMONT | m_INTEL
 	  | m_GOLDMONT | m_GOLDMONT_PLUS | m_AMD_MULTIPLE | m_ZHAOXIN
-	  | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_FUSE_CMP_AND_BRANCH_32: Fuse compare with a subsequent
    conditional jump instruction for 32 bit TARGET.  */
 DEF_TUNE (X86_TUNE_FUSE_CMP_AND_BRANCH_32, "fuse_cmp_and_branch_32",
-	  m_CORE_ALL | m_BDVER | m_ZNVER | m_ZHAOXIN | m_GENERIC)
+	  m_CORE_ALL | m_BDVER | m_ZNVER | m_ZHAOXIN | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_FUSE_CMP_AND_BRANCH_64: Fuse compare with a subsequent
    conditional jump instruction for TARGET_64BIT.  */
 DEF_TUNE (X86_TUNE_FUSE_CMP_AND_BRANCH_64, "fuse_cmp_and_branch_64",
 	  m_NEHALEM | m_SANDYBRIDGE | m_CORE_AVX2 | m_BDVER
-	  | m_ZNVER | m_ZHAOXIN | m_GENERIC)
+	  | m_ZNVER | m_ZHAOXIN | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_FUSE_CMP_AND_BRANCH_SOFLAGS: Fuse compare with a
    subsequent conditional jump instruction when the condition jump
    check sign flag (SF) or overflow flag (OF).  */
 DEF_TUNE (X86_TUNE_FUSE_CMP_AND_BRANCH_SOFLAGS, "fuse_cmp_and_branch_soflags",
 	  m_NEHALEM | m_SANDYBRIDGE | m_CORE_AVX2 | m_BDVER
-	  | m_ZNVER | m_ZHAOXIN | m_GENERIC)
+	  | m_ZNVER | m_ZHAOXIN | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_FUSE_ALU_AND_BRANCH: Fuse alu with a subsequent conditional
    jump instruction when the alu instruction produces the CCFLAG consumed by
@@ -201,14 +202,15 @@ DEF_TUNE (X86_TUNE_EPILOGUE_USING_MOVE, "epilogue_using_move",
 /* X86_TUNE_USE_LEAVE: Use "leave" instruction in epilogues where it fits.  */
 DEF_TUNE (X86_TUNE_USE_LEAVE, "use_leave",
 	  m_386 | m_CORE_ALL | m_K6_GEODE | m_AMD_MULTIPLE | m_ZHAOXIN
-	  | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_PUSH_MEMORY: Enable generation of "push mem" instructions.
    Some chips, like 486 and Pentium works faster with separate load
    and push instructions.  */
 DEF_TUNE (X86_TUNE_PUSH_MEMORY, "push_memory",
           m_386 | m_P4_NOCONA | m_CORE_ALL | m_K6_GEODE | m_AMD_MULTIPLE
-	  | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G
+	  | m_GENERIC)
 
 /* X86_TUNE_SINGLE_PUSH: Enable if single push insn is preferred
    over esp subtraction.  */
@@ -292,7 +294,7 @@ DEF_TUNE (X86_TUNE_INTEGER_DFMODE_MOVES, "integer_dfmode_moves",
           ~(m_PPRO | m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_SILVERMONT
 	    | m_INTEL | m_GEODE | m_AMD_MULTIPLE | m_ZHAOXIN | m_GOLDMONT
 	    | m_GOLDMONT_PLUS | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM
-	    | m_GENERIC))
+	    | m_C86_4G | m_GENERIC))
 
 /* X86_TUNE_OPT_AGU: Optimize for Address Generation Unit. This flag
    will impact LEA instruction selection. */
@@ -339,14 +341,14 @@ DEF_TUNE (X86_TUNE_PREFER_KNOWN_REP_MOVSB_STOSB,
 DEF_TUNE (X86_TUNE_MISALIGNED_MOVE_STRING_PRO_EPILOGUES,
 	  "misaligned_move_string_pro_epilogues",
 	  m_386 | m_486 | m_CORE_ALL | m_AMD_MULTIPLE | m_ZHAOXIN | m_TREMONT
-	  | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_USE_SAHF: Controls use of SAHF.  */
 DEF_TUNE (X86_TUNE_USE_SAHF, "use_sahf",
 	  m_PPRO | m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_SILVERMONT
 	  | m_INTEL | m_K6_GEODE | m_K8 | m_AMDFAM10 | m_BDVER | m_BTVER
 	  | m_ZNVER | m_ZHAOXIN | m_GOLDMONT | m_GOLDMONT_PLUS | m_TREMONT
-	  | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_USE_CLTD: Controls use of CLTD and CTQO instructions.  */
 DEF_TUNE (X86_TUNE_USE_CLTD, "use_cltd",
@@ -357,7 +359,7 @@ DEF_TUNE (X86_TUNE_USE_CLTD, "use_cltd",
 DEF_TUNE (X86_TUNE_USE_BT, "use_bt",
 	  m_CORE_ALL | m_BONNELL | m_SILVERMONT | m_INTEL | m_LAKEMONT
 	  | m_AMD_MULTIPLE | m_ZHAOXIN | m_GOLDMONT | m_GOLDMONT_PLUS
-	  | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_AVOID_FALSE_DEP_FOR_BMI: Avoid false dependency
    for bit-manipulation instructions.  */
@@ -391,7 +393,7 @@ DEF_TUNE (X86_TUNE_ONE_IF_CONV_INSN, "one_if_conv_insn",
 /* X86_TUNE_AVOID_MFENCE: Use lock prefixed instructions instead of mfence.  */
 DEF_TUNE (X86_TUNE_AVOID_MFENCE, "avoid_mfence",
 	 m_CORE_ALL | m_BDVER | m_ZNVER | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID
-	 | m_CORE_ATOM | m_GENERIC)
+	 | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_EXPAND_ABS: This enables a new abs pattern by
    generating instructions for abs (x) = (((signed) x >> (W-1) ^ x) -
@@ -399,6 +401,10 @@ DEF_TUNE (X86_TUNE_AVOID_MFENCE, "avoid_mfence",
 DEF_TUNE (X86_TUNE_EXPAND_ABS, "expand_abs",
 	  m_CORE_ALL | m_SILVERMONT | m_GOLDMONT | m_GOLDMONT_PLUS | m_ZHAOXIN)
 
+/* X86_TUNE_DISABLE_SETZUCC: Disable SETcc with ZU suffix. */
+DEF_TUNE (X86_TUNE_DISABLE_SETZUCC, "disable_setzucc",
+	  m_DIAMONDRAPIDS | m_NOVALAKE)
+
 /*****************************************************************************/
 /* 387 instruction selection tuning                                          */
 /*****************************************************************************/
@@ -415,10 +421,11 @@ DEF_TUNE (X86_TUNE_USE_SIMODE_FIOP, "use_simode_fiop",
           ~(m_PENT | m_LAKEMONT | m_PPRO | m_CORE_ALL | m_BONNELL
 	    | m_SILVERMONT | m_INTEL | m_AMD_MULTIPLE | m_ZHAOXIN | m_GOLDMONT
 	    | m_GOLDMONT_PLUS | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM
-	    | m_GENERIC))
+	    | m_C86_4G | m_GENERIC))
 
 /* X86_TUNE_USE_FFREEP: Use freep instruction instead of fstp.  */
-DEF_TUNE (X86_TUNE_USE_FFREEP, "use_ffreep", m_AMD_MULTIPLE | m_ZHAOXIN)
+DEF_TUNE (X86_TUNE_USE_FFREEP, "use_ffreep", m_AMD_MULTIPLE | m_ZHAOXIN
+	  | m_C86_4G)
 
 /* X86_TUNE_EXT_80387_CONSTANTS: Use fancy 80387 constants, such as PI.  */
 DEF_TUNE (X86_TUNE_EXT_80387_CONSTANTS, "ext_80387_constants",
@@ -442,30 +449,31 @@ DEF_TUNE (X86_TUNE_SSE_UNALIGNED_LOAD_OPTIMAL, "sse_unaligned_load_optimal",
 	  m_NEHALEM | m_SANDYBRIDGE | m_CORE_AVX2 | m_SILVERMONT | m_INTEL
 	  | m_GOLDMONT | m_GOLDMONT_PLUS | m_TREMONT | m_CORE_HYBRID
 	  | m_CORE_ATOM | m_AMDFAM10 | m_BDVER | m_BTVER | m_ZNVER | m_ZHAOXIN
-	  | m_GENERIC)
+	  | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL: Use movups for misaligned stores
    instead of a sequence loading registers by parts.  */
 DEF_TUNE (X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL, "sse_unaligned_store_optimal",
 	  m_NEHALEM | m_SANDYBRIDGE | m_CORE_AVX2 | m_SILVERMONT
 	  | m_INTEL | m_GOLDMONT | m_GOLDMONT_PLUS | m_TREMONT | m_CORE_HYBRID
-	  | m_CORE_ATOM | m_BDVER | m_ZNVER | m_ZHAOXIN | m_GENERIC)
+	  | m_CORE_ATOM | m_BDVER | m_ZNVER | m_ZHAOXIN | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL: Use packed single
    precision 128bit instructions instead of double where possible.   */
 DEF_TUNE (X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL, "sse_packed_single_insn_optimal",
-	  m_BDVER | m_ZNVER)
+	  m_BDVER | m_ZNVER | m_C86_4G)
 
 /* X86_TUNE_SSE_TYPELESS_STORES: Always movaps/movups for 128bit stores.   */
 DEF_TUNE (X86_TUNE_SSE_TYPELESS_STORES, "sse_typeless_stores",
 	  m_AMD_MULTIPLE | m_ZHAOXIN | m_CORE_ALL | m_TREMONT | m_CORE_HYBRID
-	  | m_CORE_ATOM | m_GENERIC)
+	  | m_CORE_ATOM | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_SSE_LOAD0_BY_PXOR: Always use pxor to load0 as opposed to
    xorps/xorpd and other variants.  */
 DEF_TUNE (X86_TUNE_SSE_LOAD0_BY_PXOR, "sse_load0_by_pxor",
 	  m_PPRO | m_P4_NOCONA | m_CORE_ALL | m_BDVER | m_BTVER | m_ZNVER
-	  | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM | m_GENERIC)
+	  | m_ZHAOXIN | m_TREMONT | m_CORE_HYBRID | m_CORE_ATOM
+	  | m_C86_4G | m_GENERIC)
 
 /* X86_TUNE_INTER_UNIT_MOVES_TO_VEC: Enable moves in from integer
    to SSE registers.  If disabled, the moves will be done by storing
@@ -530,47 +538,50 @@ DEF_TUNE (X86_TUNE_AVOID_4BYTE_PREFIXES, "avoid_4byte_prefixes",
 /* X86_TUNE_USE_GATHER_2PARTS: Use gather instructions for vectors with 2
    elements.  */
 DEF_TUNE (X86_TUNE_USE_GATHER_2PARTS, "use_gather_2parts",
-	  ~(m_ZNVER | m_CORE_HYBRID
-	    | m_YONGFENG | m_SHIJIDADAO | m_CORE_ATOM | m_GENERIC | m_GDS))
+	  ~(m_ZNVER | m_CORE_HYBRID | m_DIAMONDRAPIDS
+	    | m_YONGFENG | m_SHIJIDADAO | m_CORE_ATOM | m_GENERIC | m_GDS
+	    | m_C86_4G))
 
 /* X86_TUNE_USE_SCATTER_2PARTS: Use scater instructions for vectors with 2
    elements.  */
 DEF_TUNE (X86_TUNE_USE_SCATTER_2PARTS, "use_scatter_2parts",
-	  ~(m_ZNVER4 | m_ZNVER5 | m_ZNVER6))
+	  ~(m_ZNVER4 | m_ZNVER5 | m_ZNVER6 | m_C86_4G_M7))
+
 
 /* X86_TUNE_USE_GATHER_4PARTS: Use gather instructions for vectors with 4
    elements.  */
 DEF_TUNE (X86_TUNE_USE_GATHER_4PARTS, "use_gather_4parts",
-	  ~(m_ZNVER | m_CORE_HYBRID
-	    | m_YONGFENG | m_SHIJIDADAO | m_CORE_ATOM | m_GENERIC | m_GDS))
+	  ~(m_ZNVER | m_CORE_HYBRID | m_DIAMONDRAPIDS
+	    | m_YONGFENG | m_SHIJIDADAO | m_CORE_ATOM | m_GENERIC | m_GDS
+	    | m_C86_4G))
 
 /* X86_TUNE_USE_SCATTER_4PARTS: Use scater instructions for vectors with 4
    elements.  */
 DEF_TUNE (X86_TUNE_USE_SCATTER_4PARTS, "use_scatter_4parts",
-	  ~(m_ZNVER4 | m_ZNVER5 | m_ZNVER6))
+	  ~(m_ZNVER4 | m_ZNVER5 | m_ZNVER6 | m_C86_4G_M7))
 
 /* X86_TUNE_USE_GATHER: Use gather instructions for vectors with 8 or more
    elements.  */
 DEF_TUNE (X86_TUNE_USE_GATHER_8PARTS, "use_gather_8parts",
 	  ~(m_ZNVER | m_CORE_HYBRID | m_CORE_ATOM
-	    | m_YONGFENG | m_SHIJIDADAO | m_GENERIC | m_GDS))
+	    | m_YONGFENG | m_SHIJIDADAO | m_GENERIC | m_GDS | m_C86_4G))
 
 /* X86_TUNE_USE_SCATTER: Use scater instructions for vectors with 8 or more
    elements.  */
 DEF_TUNE (X86_TUNE_USE_SCATTER_8PARTS, "use_scatter_8parts",
-	  ~(m_ZNVER4 | m_ZNVER5 | m_ZNVER6))
+	  ~(m_ZNVER4 | m_ZNVER5 | m_ZNVER6 | m_C86_4G_M7))
 
 /* X86_TUNE_AVOID_128FMA_CHAINS: Avoid creating loops with tight 128bit or
    smaller FMA chain.  */
 DEF_TUNE (X86_TUNE_AVOID_128FMA_CHAINS, "avoid_fma_chains", m_ZNVER
-          | m_YONGFENG | m_SHIJIDADAO | m_GENERIC)
+	  | m_YONGFENG | m_SHIJIDADAO | m_GENERIC | m_C86_4G)
 
 /* X86_TUNE_AVOID_256FMA_CHAINS: Avoid creating loops with tight 256bit or
    smaller FMA chain.  */
 DEF_TUNE (X86_TUNE_AVOID_256FMA_CHAINS, "avoid_fma256_chains",
 	  m_ZNVER2 | m_ZNVER3 | m_ZNVER4 | m_ZNVER5  | m_ZNVER6 | m_CORE_HYBRID
 	  | m_SAPPHIRERAPIDS | m_GRANITERAPIDS | m_GRANITERAPIDS_D
-	  | m_DIAMONDRAPIDS | m_CORE_ATOM | m_GENERIC)
+	  | m_DIAMONDRAPIDS | m_CORE_ATOM | m_GENERIC | m_C86_4G)
 
 /* X86_TUNE_AVOID_512FMA_CHAINS: Avoid creating loops with tight 512bit or
    smaller FMA chain.  */
@@ -593,7 +604,7 @@ DEF_TUNE (X86_TUNE_SSE_MOVCC_USE_BLENDV,
 /* X86_TUNE_V4SI_REDUCTION_PREFER_SHUFD: Prefer pshuf to reduce V16QI,
    V8HI, V8HI, V4SI, V4FI, V2DI modes when lshr are costlier. */
 DEF_TUNE (X86_TUNE_SSE_REDUCTION_PREFER_PSHUF,
-   "sse_reduction_prefer_pshuf", m_ZNVER4 | m_ZNVER5)
+   "sse_reduction_prefer_pshuf", m_ZNVER4 | m_ZNVER5 | m_C86_4G_M7)
 
 /*****************************************************************************/
 /* AVX instruction selection tuning (some of SSE flags affects AVX, too)     */
@@ -628,29 +639,31 @@ DEF_TUNE (X86_TUNE_AVX256_AVOID_VEC_PERM,
 	 "avx256_avoid_vec_perm", m_CORE_ATOM)
 
 /* X86_TUNE_AVX256_SPLIT_REGS: if true, AVX512 ops are split into two AVX256 ops.  */
-DEF_TUNE (X86_TUNE_AVX512_SPLIT_REGS, "avx512_split_regs", m_ZNVER4)
+DEF_TUNE (X86_TUNE_AVX512_SPLIT_REGS, "avx512_split_regs", m_ZNVER4
+	  | m_C86_4G_M7)
 
 /* It's better to align MOVE_MAX with prefer_vector_width to reduce
    risk of STLF stalls(small store followed by big load.)  */
 /* X86_TUNE_AVX256_MOVE_BY_PIECES: Optimize move_by_pieces with 256-bit
    AVX instructions.  */
 DEF_TUNE (X86_TUNE_AVX256_MOVE_BY_PIECES, "avx256_move_by_pieces",
-	  m_CORE_HYBRID | m_CORE_AVX2 | m_ZNVER1 | m_ZNVER2 | m_ZNVER3)
+	  m_CORE_HYBRID | m_CORE_AVX2 | m_ZNVER1 | m_ZNVER2 | m_ZNVER3
+	  | m_C86_4G_M4 | m_C86_4G_M6)
 
 /* X86_TUNE_AVX512_MOVE_BY_PIECES: Optimize move_by_pieces with 512-bit
    AVX instructions.  */
 DEF_TUNE (X86_TUNE_AVX512_MOVE_BY_PIECES, "avx512_move_by_pieces",
-	   m_ZNVER4 | m_ZNVER5 | m_ZNVER6)
+	   m_ZNVER4 | m_ZNVER5 | m_ZNVER6 | m_C86_4G_M7)
 
 /* X86_TUNE_AVX512_TWO_EPILOGUES: Use two vector epilogues for 512-bit
    vectorized loops.  */
 DEF_TUNE (X86_TUNE_AVX512_TWO_EPILOGUES, "avx512_two_epilogues",
-	  m_ZNVER4 | m_ZNVER5)
+	  m_ZNVER4 | m_ZNVER5 | m_ZNVER6)
 
 /* X86_TUNE_AVX512_MAKED_EPILOGUES: Use two masked vector epilogues
    when fit.  */
 DEF_TUNE (X86_TUNE_AVX512_MASKED_EPILOGUES, "avx512_masked_epilogues",
-	  m_ZNVER4 | m_ZNVER5)
+	  m_ZNVER4 | m_ZNVER5 | m_ZNVER6 | m_C86_4G_M7)
 
 /*****************************************************************************/
 /*****************************************************************************/
@@ -792,4 +805,4 @@ DEF_TUNE (X86_TUNE_PROMOTE_QI_REGS, "promote_qi_regs", m_NONE)
 DEF_TUNE (X86_TUNE_SLOW_STC, "slow_stc", m_PENT4)
 
 /* X86_TUNE_USE_RCR: Controls use of rcr 1 instruction instead of shrd.  */
-DEF_TUNE (X86_TUNE_USE_RCR, "use_rcr", m_AMD_MULTIPLE)
+DEF_TUNE (X86_TUNE_USE_RCR, "use_rcr", m_AMD_MULTIPLE | m_C86_4G)
--- a/src/gcc/config/loongarch/constraints.md
+++ b/src/gcc/config/loongarch/constraints.md
@@ -370,3 +370,12 @@ (define_address_constraint "ZD"
    and offset that is suitable for use in instructions with the same
    addressing mode as @code{preld}."
    (match_test "loongarch_12bit_offset_address_p (op, mode)"))
+
+(define_constraint "ZE"
+  "A symbolic suitable as stack canary in the normal/medium code model."
+  (match_operand 0 "ssp_normal_operand"))
+
+(define_constraint "ZF"
+  "A symbolic suitable as stack canary, but in the extreme code model."
+  (and (match_operand 0 "ssp_operand")
+       (not (match_operand 0 "ssp_normal_operand"))))
--- a/src/gcc/config/loongarch/loongarch-protos.h
+++ b/src/gcc/config/loongarch/loongarch-protos.h
@@ -235,4 +235,5 @@ extern bool loongarch_parse_fmv_features (location_t, string_slice,
 extern void get_feature_mask_for_version (tree, loongarch_fmv_feature_mask *,
 					  auto_vec<unsigned int> *);
 extern int loongarch_compare_version_priority (tree, tree);
+extern void loongarch_output_asm_load_canary (rtx reg, rtx canary, rtx tmp);
 #endif /* ! GCC_LOONGARCH_PROTOS_H */
--- a/src/gcc/config/loongarch/loongarch.cc
+++ b/src/gcc/config/loongarch/loongarch.cc
@@ -5108,8 +5108,37 @@ loongarch_split_vector_move (rtx dest, rtx src)
   machine_mode mode = GET_MODE (dest);
   bool lsx_p = LSX_SUPPORTED_MODE_P (mode);
 
-  if (FP_REG_RTX_P (dest))
-    {
+  if (FP_REG_RTX_P (dest) && GP_REG_RTX_P (src))
+    {
+    /* Since the LoongArch architecture has not yet implemented vector
+       parameter passing, the following operations are required when
+       a function returns a vector type that needs to be passed to a
+       vector register.
+
+       As shown in the following instruction sequence:
+
+       (call_insn 5 6 12 2 (parallel [
+	     (set (reg:V2DI 4 $r4)
+		  (call (mem:SI (symbol_ref:DI ("bar"))
+				(const_int 0 [0])))
+		  (clobber (reg:SI 1 $r1)))]))
+       (insn 12 5 7 2 (set (reg:V2DI 32 $f0)
+			   (reg:V2DI 4 $r4)))
+
+       insn 12 will be split here as follows:
+       (insn 15 5 16 2 (set (reg:V2DI 32 $f0)
+			    (vec_merge:V2DI
+				(vec_duplicate:V2DI (reg:DI 4 $r4))
+				(reg:V2DI 32 $f0)
+				(const_int 1 [0x1]))))
+       (insn 16 15 7 2 (set (reg:V2DI 32 $f0)
+			    (vec_merge:V2DI
+				(vec_duplicate:V2DI (reg:DI 5 $r5 [+8 ]))
+				(reg:V2DI 32 $f0)
+				(const_int 2 [0x2]))))
+
+       This can be reproduced with the test case lsx-mov-2.c.
+     */
       gcc_assert (!MEM_P (src));
 
       rtx (*gen_vinsgr2vr_d) (rtx, rtx, rtx, rtx);
@@ -5138,8 +5167,12 @@ loongarch_split_vector_move (rtx dest, rtx src)
 					  GEN_INT (1 << index)));
 	}
     }
-  else if (FP_REG_RTX_P (src))
+  else if (FP_REG_RTX_P (src) && GP_REG_RTX_P (dest))
     {
+      /* Transfer vector data from vector registers to GPRs, generally
+	 for vector argument handling.
+	 This can be reproduced with the test case lsx-mov-1.c.
+       */
       gcc_assert (!MEM_P (dest));
 
       rtx (*gen_vpickve2gr_d) (rtx, rtx, rtx);
@@ -5166,7 +5199,7 @@ loongarch_split_vector_move (rtx dest, rtx src)
 	  emit_insn (gen_vpickve2gr_d (d, new_src, GEN_INT (index)));
 	}
     }
-  else
+  else if (GP_REG_RTX_P (src) && GP_REG_RTX_P (dest))
     {
       /* This part of the code is designed to handle the following situations:
 	 (set (reg:V2DI 4 $r4)
@@ -6722,7 +6755,9 @@ loongarch_print_operand (FILE *file, rtx op, int letter)
 
 
     case 'c':
-      if (CONST_INT_P (op))
+      if (SYMBOL_REF_P (op))
+	output_addr_const (asm_out_file, op);
+      else if (CONST_INT_P (op))
 	fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (op));
       else
 	output_operand_lossage ("unsupported operand for code '%c'", letter);
@@ -6935,12 +6970,14 @@ loongarch_print_operand (FILE *file, rtx op, int letter)
 	case E_V4SFmode:
 	case E_V8SImode:
 	case E_V8SFmode:
+	case E_SImode:
 	  fprintf (file, "w");
 	  break;
 	case E_V2DImode:
 	case E_V2DFmode:
 	case E_V4DImode:
 	case E_V4DFmode:
+	case E_DImode:
 	  fprintf (file, "d");
 	  break;
 	default:
@@ -12110,6 +12147,55 @@ loongarch_option_same_function_versions (string_slice str1, const_tree,
   return feature_mask1 == feature_mask2;
 }
 
+/* Output assembly to materialize the address of the stack canary value
+   into reg.  The third argument, tmp, should be and should only be
+   non-NULL if the extreme code model is effective for the canary.  If
+   the fourth arugment, load, is true, the canary value is loaded into
+   the register.
+
+   The assembly cannot be splitted due to security reason.  */
+void
+loongarch_output_asm_load_canary (rtx reg, rtx canary, rtx tmp)
+{
+  gcc_checking_assert (ssp_operand (canary, VOIDmode));
+  gcc_checking_assert ((!tmp) == ssp_normal_operand (canary, VOIDmode));
+  gcc_checking_assert (register_operand (reg, Pmode));
+
+  rtx op[] = {reg, canary, tmp};
+  bool got = (loongarch_classify_symbol (canary) == SYMBOL_GOT_DISP);
+  bool need_ld = false;
+
+  if (la_opt_explicit_relocs != EXPLICIT_RELOCS_ALWAYS)
+    {
+      if (got)
+	output_asm_insn (tmp ? "la.global\t%0,%2,%1" : "la.global\t%0,%1",
+			 op);
+      else
+	output_asm_insn (tmp ? "la.local\t%0,%2,%1" : "la.local\t%0,%1",
+			 op);
+
+      need_ld = true;
+    }
+  else
+    {
+      output_asm_insn ("pcalau12i\t%0,%r1", op);
+      if (!tmp)
+	output_asm_insn ("ld.%v0\t%0,%0,%L1", op);
+      else
+	{
+	  output_asm_insn ("addi.d\t%2,$r0,%L1", op);
+	  output_asm_insn ("lu32i.d\t%2,%R1", op);
+	  output_asm_insn ("lu52i.d\t%2,%2,%H1", op);
+	  output_asm_insn ("ldx.d\t%0,%0,%2", op);
+	}
+
+      need_ld = got;
+    }
+
+  if (need_ld)
+    output_asm_insn ("ld.%v0\t%0,%0,0", op);
+}
+
 /* Initialize the GCC target structure.  */
 #undef TARGET_ASM_ALIGNED_HI_OP
 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
--- a/src/gcc/config/loongarch/loongarch.h
+++ b/src/gcc/config/loongarch/loongarch.h
@@ -368,8 +368,7 @@ along with GCC; see the file COPYING3.  If not see
   ((unsigned int) ((int) (REGNO) - LASX_REG_FIRST) < LASX_REG_NUM)
 
 #define FP_REG_RTX_P(X) (REG_P (X) && FP_REG_P (REGNO (X)))
-#define LSX_REG_RTX_P(X) (REG_P (X) && LSX_REG_P (REGNO (X)))
-#define LASX_REG_RTX_P(X) (REG_P (X) && LASX_REG_P (REGNO (X)))
+#define GP_REG_RTX_P(X) (REG_P (X) && GP_REG_P (REGNO (X)))
 
 /* Select a register mode required for caller save of hard regno REGNO.  */
 #define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE) \
--- a/src/gcc/config/loongarch/loongarch.md
+++ b/src/gcc/config/loongarch/loongarch.md
@@ -83,6 +83,8 @@ (define_c_enum "unspec" [
   UNSPEC_LOAD_SYMBOL_OFFSET64
   UNSPEC_LA_PCREL_64_PART1
   UNSPEC_LA_PCREL_64_PART2
+
+  UNSPEC_SSP
 ])
 
 (define_c_enum "unspecv" [
@@ -3677,7 +3679,7 @@ (define_insn "*branch_equality<mode>_inverted"
 ;; QImode values so we can force zero-extension.
 (define_mode_iterator BR [(QI "TARGET_64BIT") SI (DI "TARGET_64BIT")])
 
-(define_expand "cbranch<mode>4"
+(define_expand "@cbranch<mode>4"
   [(set (pc)
 	(if_then_else (match_operator 0 "comparison_operator"
 			[(match_operand:BR 1 "register_operand")
@@ -4986,6 +4988,90 @@ (define_insn_and_rewrite "simple_store<mode>"
     operands[0] = loongarch_rewrite_mem_for_simple_ldst (operands[0]);
   })
 
+;; Set and check against stack canary without leaving it in a register.
+;; DO NOT ATTEMPT TO SPLIT THESE INSNS!  It's important for security reason
+;; that the canary value does not live beyond the life of this sequence.
+
+(define_insn "@stack_protect_combined_set_normal_<mode>"
+  [(set (match_operand:P 0 "memory_operand" "=m,ZC")
+        (unspec:P [(mem:P (match_operand:P 1 "ssp_normal_operand"))]
+		  UNSPEC_SSP))
+   (set (match_scratch:P 2 "=&r,&r") (const_int 0))]
+  ""
+{
+  loongarch_output_asm_load_canary (operands[2], operands[1], NULL_RTX);
+  output_asm_insn (which_alternative ? "stptr.d\t%2,%0" : "st.d\t%2,%0",
+		   operands);
+  return "ori\t%2,$r0,0";
+}
+  [(set_attr "type" "store")
+   (set_attr "length" "20")])
+
+(define_insn "@stack_protect_combined_set_extreme_<mode>"
+  [(set (match_operand:P 0 "memory_operand" "=m,ZC")
+        (unspec:P [(mem:P (match_operand:P 1 "ssp_operand"))] UNSPEC_SSP))
+   (set (match_scratch:P 2 "=&r,&r") (const_int 0))
+   (set (match_scratch:P 3 "=&r,&r") (const_int 0))]
+  ""
+{
+  loongarch_output_asm_load_canary (operands[2], operands[1], operands[3]);
+  output_asm_insn (which_alternative ? "stptr.d\t%2,%0" : "st.d\t%2,%0",
+		   operands);
+  return "ori\t%2,$r0,0\n\tori\t%3,$r0,0";
+}
+  [(set_attr "type" "store")
+   (set_attr "length" "36")])
+
+(define_insn "@stack_protect_combined_test_internal_<mode>"
+  [(set (match_operand:P 0 "register_operand" "=r,r,&r,&r")
+	(xor:P
+	  (match_operand:P 1 "memory_operand" "=m,ZC,m,ZC")
+	    (unspec:P
+	      [(mem:P (match_operand:P 2 "ssp_operand" "ZE,ZE,ZF,ZF"))]
+	      UNSPEC_SSP)))
+   (set (match_scratch:P 3 "=&r,&r,&r,&r") (const_int 0))]
+  ""
+{
+  rtx t = (which_alternative >= 2 ? operands[0] : NULL_RTX);
+  loongarch_output_asm_load_canary (operands[3], operands[2], t);
+  output_asm_insn ((which_alternative & 1) ? "ldptr.d\t%0,%1"
+					   : "ld.d\t%0,%1",
+		   operands);
+  return "xor\t%0,%0,%3\n\tori\t%3,$r0,0";
+}
+  [(set_attr "type" "load,load,load,load")
+   (set_attr "length" "24,24,36,36")])
+
+(define_expand "stack_protect_combined_set"
+  [(match_operand 0 "memory_operand")
+   (match_operand 1 "memory_operand")]
+  ""
+{
+  rtx canary = XEXP (operands[1], 0);
+  auto fn = (ssp_normal_operand (canary, VOIDmode)
+	     ? gen_stack_protect_combined_set_normal
+	     : gen_stack_protect_combined_set_extreme);
+
+  emit_insn (fn (Pmode, operands[0], canary));
+  DONE;
+})
+
+(define_expand "stack_protect_combined_test"
+  [(match_operand 0 "memory_operand")
+   (match_operand 1 "memory_operand")
+   (match_operand 2 "")]
+  ""
+{
+  rtx t = gen_reg_rtx (Pmode);
+  rtx canary = XEXP (operands[1], 0);
+  emit_insn (gen_stack_protect_combined_test_internal (Pmode, t,
+						       operands[0],
+						       canary));
+  rtx cond = gen_rtx_EQ (VOIDmode, t, const0_rtx);
+  emit_jump_insn (gen_cbranch4 (Pmode, cond, t, const0_rtx, operands[2]));
+  DONE;
+})
+
 ;; Synchronization instructions.
 
 (include "sync.md")
--- a/src/gcc/config/loongarch/predicates.md
+++ b/src/gcc/config/loongarch/predicates.md
@@ -610,6 +610,14 @@ (define_predicate "symbolic_off64_or_reg_operand"
  (ior (match_operand 0 "register_operand")
       (match_operand 0 "symbolic_off64_operand")))
 
+;; Currently stack canary must be the global symbol __stack_chk_guard.
+(define_predicate "ssp_operand" (match_code "symbol_ref"))
+
+;; If the stack canary is within the normal/medium code model.
+(define_predicate "ssp_normal_operand"
+  (and (match_operand 0 "ssp_operand")
+       (not (match_operand 0 "symbolic_off64_operand"))))
+
 (define_predicate "equality_operator"
   (match_code "eq,ne"))
 
--- a/src/gcc/config/loongarch/t-loongarch
+++ b/src/gcc/config/loongarch/t-loongarch
@@ -18,6 +18,7 @@
 
 
 GTM_H += loongarch-multilib.h
+TM_H += $(srcdir)/common/config/loongarch/cpu-features.h
 OPTIONS_H_EXTRA += $(srcdir)/config/loongarch/loongarch-def.h	    \
 		   $(srcdir)/config/loongarch/loongarch-def-array.h \
 		   $(srcdir)/config/loongarch/loongarch-tune.h	    \
--- a/src/gcc/config/mingw/winnt.cc
+++ b/src/gcc/config/mingw/winnt.cc
@@ -860,7 +860,9 @@ mingw_pe_file_end (void)
 			   "\t.p2align\t3, 0\n"
 	  		   "\t.globl\t%s\n"
 			   "\t.linkonce\tdiscard\n", oname, oname);
-	  fprintf (asm_out_file, "%s:\n\t.quad\t%s\n", oname, name);
+	  fprintf (asm_out_file, "%s:\n\t.quad\t", oname);
+	  ASM_OUTPUT_LABELREF (asm_out_file, name);
+	  fputc ('\n', asm_out_file);
 	}
     }
 }
--- a/src/gcc/config/mips/sync.md
+++ b/src/gcc/config/mips/sync.md
@@ -179,7 +179,7 @@ (define_insn "sync_old_<optab>_12"
 	(unspec_volatile:SI
           [(match_operand:SI 2 "register_operand" "d")
 	   (match_operand:SI 3 "register_operand" "d")
-	   (atomic_hiqi_op:SI (match_dup 0)
+	   (atomic_hiqi_op:SI (match_dup 1)
 			      (match_operand:SI 4 "reg_or_0_operand" "dJ"))]
 	  UNSPEC_SYNC_OLD_OP_12))
    (clobber (match_scratch:SI 5 "=&d"))]
@@ -220,7 +220,7 @@ (define_insn "sync_new_<optab>_12"
           [(match_operand:SI 1 "memory_operand" "+ZC")
 	   (match_operand:SI 2 "register_operand" "d")
 	   (match_operand:SI 3 "register_operand" "d")
-	   (atomic_hiqi_op:SI (match_dup 0)
+	   (atomic_hiqi_op:SI (match_dup 1)
 			      (match_operand:SI 4 "reg_or_0_operand" "dJ"))]
 	  UNSPEC_SYNC_NEW_OP_12))
    (set (match_dup 1)
@@ -228,7 +228,8 @@ (define_insn "sync_new_<optab>_12"
 	  [(match_dup 1)
 	   (match_dup 2)
 	   (match_dup 3)
-	   (match_dup 4)] UNSPEC_SYNC_NEW_OP_12))]
+	   (atomic_hiqi_op:SI (match_dup 1) (match_dup 4))]
+	  UNSPEC_SYNC_NEW_OP_12))]
   "GENERATE_LL_SC"
   { return mips_output_sync_loop (insn, operands); }
   [(set_attr "sync_insn1" "<insn>")
--- a/src/gcc/config/or1k/or1k.cc
+++ b/src/gcc/config/or1k/or1k.cc
@@ -1389,10 +1389,11 @@ or1k_trampoline_init (rtx m_tramp, tree fndecl, rtx chain)
 static bool
 or1k_hard_regno_mode_ok (unsigned int regno, machine_mode mode)
 {
-  /* For OpenRISC, GENERAL_REGS can hold anything, while
-     FLAG_REGS are really single bits within SP[SR].  */
+  /* For OpenRISC, GENERAL_REGS can hold anything, while FLAG_REGS are
+     really single bits within SP[SR].  Also allow condition flag register
+     in SImode to match or1k_can_change_mode_class.  */
   if (REGNO_REG_CLASS (regno) == FLAG_REGS)
-    return mode == BImode;
+    return mode == BImode || mode == SImode;
   return true;
 }
 
--- a/src/gcc/config/pa/pa.cc
+++ b/src/gcc/config/pa/pa.cc
@@ -10651,10 +10651,7 @@ static void
 pa_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
 {
   rtx fnaddr = XEXP (DECL_RTL (fndecl), 0);
-  rtx start_addr = gen_reg_rtx (Pmode);
-  rtx end_addr = gen_reg_rtx (Pmode);
-  rtx line_length = gen_reg_rtx (Pmode);
-  rtx r_tramp, tmp;
+  rtx start, end, r_tramp, tmp;
 
   emit_block_move (m_tramp, assemble_trampoline_template (),
 		   GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
@@ -10662,6 +10659,9 @@ pa_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
 
   if (!TARGET_64BIT)
     {
+      /* Start of trampoline code.  */
+      start = r_tramp;
+
       tmp = adjust_address (m_tramp, Pmode, 48);
       emit_move_insn (tmp, fnaddr);
       tmp = adjust_address (m_tramp, Pmode, 52);
@@ -10669,28 +10669,15 @@ pa_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
 
       /* Create a fat pointer for the trampoline.  */
       tmp = adjust_address (m_tramp, Pmode, 56);
-      emit_move_insn (tmp, r_tramp);
+      emit_move_insn (tmp, start);
       tmp = adjust_address (m_tramp, Pmode, 60);
       emit_move_insn (tmp, gen_rtx_REG (Pmode, 19));
-
-      /* fdc and fic only use registers for the address to flush,
-	 they do not accept integer displacements.  We align the
-	 start and end addresses to the beginning of their respective
-	 cache lines to minimize the number of lines flushed.  */
-      emit_insn (gen_andsi3 (start_addr, r_tramp,
-			     GEN_INT (-MIN_CACHELINE_SIZE)));
-      tmp = force_reg (Pmode, plus_constant (Pmode, r_tramp,
-					     TRAMPOLINE_CODE_SIZE-1));
-      emit_insn (gen_andsi3 (end_addr, tmp,
-			     GEN_INT (-MIN_CACHELINE_SIZE)));
-      emit_move_insn (line_length, GEN_INT (MIN_CACHELINE_SIZE));
-      emit_insn (gen_dcacheflushsi (start_addr, end_addr, line_length));
-      emit_insn (gen_icacheflushsi (start_addr, end_addr, line_length,
-				    gen_reg_rtx (Pmode),
-				    gen_reg_rtx (Pmode)));
     }
   else
     {
+      /* Start of trampoline code.  */
+      start = force_reg (Pmode, plus_constant (Pmode, r_tramp, 32));
+
       tmp = adjust_address (m_tramp, Pmode, 56);
       emit_move_insn (tmp, fnaddr);
       tmp = adjust_address (m_tramp, Pmode, 64);
@@ -10698,29 +10685,16 @@ pa_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
 
       /* Create a fat pointer for the trampoline.  */
       tmp = adjust_address (m_tramp, Pmode, 16);
-      emit_move_insn (tmp, force_reg (Pmode, plus_constant (Pmode,
-							    r_tramp, 32)));
+      emit_move_insn (tmp, start);
       tmp = adjust_address (m_tramp, Pmode, 24);
       emit_move_insn (tmp, gen_rtx_REG (Pmode, 27));
-
-      /* fdc and fic only use registers for the address to flush,
-	 they do not accept integer displacements.  We align the
-	 start and end addresses to the beginning of their respective
-	 cache lines to minimize the number of lines flushed.  */
-      tmp = force_reg (Pmode, plus_constant (Pmode, r_tramp, 32));
-      emit_insn (gen_anddi3 (start_addr, tmp,
-			     GEN_INT (-MIN_CACHELINE_SIZE)));
-      tmp = force_reg (Pmode, plus_constant (Pmode, tmp,
-					     TRAMPOLINE_CODE_SIZE - 1));
-      emit_insn (gen_anddi3 (end_addr, tmp,
-			     GEN_INT (-MIN_CACHELINE_SIZE)));
-      emit_move_insn (line_length, GEN_INT (MIN_CACHELINE_SIZE));
-      emit_insn (gen_dcacheflushdi (start_addr, end_addr, line_length));
-      emit_insn (gen_icacheflushdi (start_addr, end_addr, line_length,
-				    gen_reg_rtx (Pmode),
-				    gen_reg_rtx (Pmode)));
     }
 
+  end = force_reg (Pmode, plus_constant (Pmode, start, TRAMPOLINE_CODE_SIZE));
+
+  /* Flush trampoline.  */
+  emit_insn (gen_clear_cache (start, end));
+
 #ifdef HAVE_ENABLE_EXECUTE_STACK
   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
 		     LCT_NORMAL, VOIDmode, XEXP (m_tramp, 0), Pmode);
--- a/src/gcc/config/pa/pa.md
+++ b/src/gcc/config/pa/pa.md
@@ -9947,10 +9947,9 @@ (define_insn ""
   [(set_attr "type" "fpalu")
    (set_attr "length" "4")])
 
-;; The following two patterns are used by the trampoline code for nested
+;; The following four patterns are used by the trampoline code for nested
 ;; functions.  They flush the I and D cache lines from the start address
-;; (operand0) to the end address (operand1).  No lines are flushed if the
-;; end address is less than the start address (unsigned).
+;; (operand0) to the end address (operand1).
 ;;
 ;; Because the range of memory flushed is variable and the size of a MEM
 ;; can only be a CONST_INT, the patterns specify that they perform an
@@ -9959,9 +9958,9 @@ (define_insn ""
 ;; The address range for an icache flush must lie within a single
 ;; space on targets with non-equivalent space registers.
 ;;
-;; Operand 0 contains the start address.
+;; Operand 0 contains the line aligned start address.
 ;; Operand 1 contains the end address.
-;; Operand 2 contains the line length to use.
+;; Operand 2 contains the line size to use.
 (define_insn "dcacheflush<P:mode>"
   [(const_int 1)
    (unspec_volatile [(mem:BLK (scratch))] UNSPECV_DCACHE)
@@ -9970,11 +9969,11 @@ (define_insn "dcacheflush<P:mode>"
    (use (match_operand 2 "pmode_register_operand" "r"))
    (clobber (match_scratch:P 3 "=&0"))]
   ""
-  "cmpb,<dwc><<=,n %3,%1,.\;fdc,m %2(%3)\;sync"
+  "{comb|cmpb},<dwc><<,n %3,%1,.\;fdc,m %2(%3)\;sync"
   [(set_attr "type" "multi")
    (set_attr "length" "12")])
 
-(define_insn "icacheflush<P:mode>"
+(define_insn "icacheflush1<P:mode>"
   [(const_int 2)
    (unspec_volatile [(mem:BLK (scratch))] UNSPECV_ICACHE)
    (use (match_operand 0 "pmode_register_operand" "r"))
@@ -9984,24 +9983,86 @@ (define_insn "icacheflush<P:mode>"
    (clobber (match_operand 4 "pmode_register_operand" "=&r"))
    (clobber (match_scratch:P 5 "=&0"))]
   ""
-  "mfsp %%sr0,%4\;ldsid (%5),%3\;mtsp %3,%%sr0\;cmpb,<dwc><<=,n %5,%1,.\;fic,m %2(%%sr0,%5)\;sync\;mtsp %4,%%sr0\;nop\;nop\;nop\;nop\;nop\;nop"
+  "mfsp %%sr1,%4\;ldsid (%5),%3\;mtsp %3,%%sr1\;{comb|cmpb},<dwc><<,n %5,%1,.\;fic,m %2(%%sr1,%5)\;sync\;mtsp %4,%%sr1\;nop\;nop\;nop\;nop\;nop\;nop"
   [(set_attr "type" "multi")
    (set_attr "length" "52")])
 
+(define_insn "icacheflush2<P:mode>"
+  [(const_int 2)
+   (unspec_volatile [(mem:BLK (scratch))] UNSPECV_ICACHE)
+   (use (match_operand 0 "pmode_register_operand" "r"))
+   (use (match_operand 1 "pmode_register_operand" "r"))
+   (use (match_operand 2 "pmode_register_operand" "r"))
+   (clobber (match_scratch:P 3 "=&0"))]
+  "TARGET_PA_20"
+  "cmpb,<dwc><<,n %3,%1,.\;fic,m %2(%3)\;sync\;nop\;nop\;nop\;nop\;nop\;nop\;nop"
+  [(set_attr "type" "multi")
+   (set_attr "length" "40")])
+
+(define_insn "icacheflush3<P:mode>"
+  [(const_int 3)
+   (unspec_volatile [(mem:BLK (scratch))] UNSPECV_ICACHE)
+   (use (match_operand 0 "pmode_register_operand" "r"))
+   (use (match_operand 1 "pmode_register_operand" "r"))
+   (use (match_operand 2 "pmode_register_operand" "r"))
+   (clobber (match_scratch:P 3 "=&0"))]
+  "!TARGET_PA_20 && TARGET_NO_SPACE_REGS"
+  "comb,<dwc><<,n %3,%1,.\;fic,m %2(%%sr4,%3)\;sync\;nop\;nop\;nop\;nop\;nop\;nop\;nop"
+  [(set_attr "type" "multi")
+   (set_attr "length" "40")])
+
+;; clear_cache
+;;
+;; Note the data and instruction cache flushes need to be separated
+;; by a sync instruction (see page 7-151 in PA 2.0 architecture manual).
+;; Thus, we can't combine the flush operations in a single loop.
+
+;; Operand 0 contains the start address (inclusive).
+;; Operand 1 contains the end address (exclusive).
 (define_expand "clear_cache"
   [(match_operand 0 "pmode_register_operand")
    (match_operand 1 "pmode_register_operand")]
   ""
 {
-  rtx line_length = gen_reg_rtx (Pmode);
+  rtx start = gen_reg_rtx (Pmode);
+  rtx line_size = gen_reg_rtx (Pmode);
+  rtx lab = gen_label_rtx ();
+  rtx op0 = operands[0];
+  rtx op1 = operands[1];
+
+  /* Skip flush if op0 is greater than or equal to op1.  */
+  emit_cmp_and_jump_insns (op0, op1, GEU, NULL_RTX, Pmode, 0, lab);
+
+  /* Load cache line size.  */
+  emit_move_insn (line_size, GEN_INT (MIN_CACHELINE_SIZE));
 
-  emit_move_insn (line_length, GEN_INT (MIN_CACHELINE_SIZE));
   if (TARGET_64BIT)
-    emit_insn (gen_icacheflushdi (operands[0], operands[1], line_length,
-				  gen_reg_rtx (Pmode), gen_reg_rtx (Pmode)));
+    {
+      /* Align the start address.  */
+      emit_insn (gen_anddi3 (start, op0, GEN_INT (-MIN_CACHELINE_SIZE)));
+
+      /* Flush the cache.  */
+      emit_insn (gen_dcacheflushdi (start, op1, line_size));
+      emit_insn (gen_icacheflush2di (start, op1, line_size));
+    }
   else
-    emit_insn (gen_icacheflushsi (operands[0], operands[1], line_length,
-				  gen_reg_rtx (Pmode), gen_reg_rtx (Pmode)));
+    {
+      /* Align the start address.  */
+      emit_insn (gen_andsi3 (start, op0, GEN_INT (-MIN_CACHELINE_SIZE)));
+
+      /* Flush the cache.  */
+      emit_insn (gen_dcacheflushsi (start, op1, line_size));
+      if (TARGET_PA_20)
+	emit_insn (gen_icacheflush2si (start, op1, line_size));
+      else if (TARGET_NO_SPACE_REGS)
+	emit_insn (gen_icacheflush3si (start, op1, line_size));
+      else
+	emit_insn (gen_icacheflush1si (start, op1, line_size,
+				       gen_reg_rtx (Pmode),
+				       gen_reg_rtx (Pmode)));
+    }
+
+  emit_label (lab);
   DONE;
 })
 
--- a/src/gcc/config/riscv/riscv-v.cc
+++ b/src/gcc/config/riscv/riscv-v.cc
@@ -1600,135 +1600,39 @@ expand_const_vector_interleaved_stepped_npatterns (rtx target, rtx src,
     rtx_to_poly_int64 (builder->elt (builder->npatterns () + 1))
       - rtx_to_poly_int64 (base2);
 
-  /* For { 1, 0, 2, 0, ... , n - 1, 0 }, we can use larger EEW
-     integer vector mode to generate such vector efficiently.
-
-     E.g. EEW = 16, { 2, 0, 4, 0, ... }
-
-     can be interpreted into:
-
-     EEW = 32, { 2, 4, ... }.
-
-     Both the series1 and series2 may overflow before taking the IOR
-     to generate the final result.  However, only series1 matters
-     because the series2 will shift before IOR, thus the overflow
-     bits will never pollute the final result.
-
-     For now we forbid the negative steps and overflow, and they
-     will fall back to the default merge way to generate the
-     const_vector.  */
-
-  unsigned int new_smode_bitsize = builder->inner_bits_size () * 2;
-  scalar_int_mode new_smode;
-  machine_mode new_mode;
-  poly_uint64 new_nunits = exact_div (GET_MODE_NUNITS (builder->mode ()), 2);
-
-  poly_int64 base1_poly = rtx_to_poly_int64 (base1);
-  bool overflow_smode_p = false;
-
-  if (!step1.is_constant ())
-    overflow_smode_p = true;
-  else
+  rtx vid = gen_reg_rtx (mode);
+  expand_vec_series (vid, const0_rtx, const1_rtx);
+  /* Transform into { 0, 0, 1, 1, 2, 2, ... }.  */
+  rtx shifted_vid;
+  if (lra_in_progress)
     {
-      int elem_count = XVECLEN (src, 0);
-      uint64_t step1_val = step1.to_constant ();
-      int64_t base1_signed = base1_poly.to_constant ();
-      /* Reinterpret as type of inner bits size so we can properly check
-	 overflow.  */
-      uint64_t base1_val
-	= base1_signed & ((1ULL << builder->inner_bits_size ()) - 1);
-      uint64_t elem_val = base1_val + (elem_count - 1) * step1_val;
-
-      if ((elem_val >> builder->inner_bits_size ()) != 0)
-	overflow_smode_p = true;
-    }
-
-  if (known_ge (step1, 0) && known_ge (step2, 0)
-      && int_mode_for_size (new_smode_bitsize, 0).exists (&new_smode)
-      && get_vector_mode (new_smode, new_nunits).exists (&new_mode)
-      && !overflow_smode_p)
-    {
-      rtx tmp1 = gen_reg_rtx (new_mode);
-      base1 = gen_int_mode (base1_poly, new_smode);
-      expand_vec_series (tmp1, base1, gen_int_mode (step1, new_smode));
-
-      if (rtx_equal_p (base2, const0_rtx) && known_eq (step2, 0))
-	/* { 1, 0, 2, 0, ... }.  */
-	emit_move_insn (result, gen_lowpart (mode, tmp1));
-      else if (known_eq (step2, 0))
-	{
-	  /* { 1, 1, 2, 1, ... }.  */
-	  rtx scalar = expand_simple_binop (
-	    Xmode, ASHIFT, gen_int_mode (rtx_to_poly_int64 (base2), Xmode),
-	    gen_int_mode (builder->inner_bits_size (), Xmode), NULL_RTX, false,
-	    OPTAB_DIRECT);
-	  scalar = simplify_gen_subreg (new_smode, scalar, Xmode, 0);
-	  rtx tmp2 = gen_reg_rtx (new_mode);
-	  rtx ior_ops[] = {tmp2, tmp1, scalar};
-	  emit_vlmax_insn (code_for_pred_scalar (IOR, new_mode), BINARY_OP,
-			   ior_ops);
-	  emit_move_insn (result, gen_lowpart (mode, tmp2));
-	}
-      else
-	{
-	  /* { 1, 3, 2, 6, ... }.  */
-	  rtx tmp2 = gen_reg_rtx (new_mode);
-	  base2 = gen_int_mode (rtx_to_poly_int64 (base2), new_smode);
-	  expand_vec_series (tmp2, base2, gen_int_mode (step2, new_smode));
-	  rtx shifted_tmp2;
-	  rtx shift = gen_int_mode (builder->inner_bits_size (), Xmode);
-	  if (lra_in_progress)
-	    {
-	      shifted_tmp2 = gen_reg_rtx (new_mode);
-	      rtx shift_ops[] = {shifted_tmp2, tmp2, shift};
-	      emit_vlmax_insn (code_for_pred_scalar (ASHIFT, new_mode),
-			       BINARY_OP, shift_ops);
-	    }
-	  else
-	    shifted_tmp2 = expand_simple_binop (new_mode, ASHIFT, tmp2, shift,
-						NULL_RTX, false, OPTAB_DIRECT);
-	  rtx tmp3 = gen_reg_rtx (new_mode);
-	  rtx ior_ops[] = {tmp3, tmp1, shifted_tmp2};
-	  emit_vlmax_insn (code_for_pred (IOR, new_mode), BINARY_OP, ior_ops);
-	  emit_move_insn (result, gen_lowpart (mode, tmp3));
-	}
+      shifted_vid = gen_reg_rtx (mode);
+      rtx shift = gen_int_mode (1, Xmode);
+      rtx shift_ops[] = {shifted_vid, vid, shift};
+      emit_vlmax_insn (code_for_pred_scalar (LSHIFTRT, mode), BINARY_OP,
+		       shift_ops);
     }
   else
-    {
-      rtx vid = gen_reg_rtx (mode);
-      expand_vec_series (vid, const0_rtx, const1_rtx);
-      /* Transform into { 0, 0, 1, 1, 2, 2, ... }.  */
-      rtx shifted_vid;
-      if (lra_in_progress)
-	{
-	  shifted_vid = gen_reg_rtx (mode);
-	  rtx shift = gen_int_mode (1, Xmode);
-	  rtx shift_ops[] = {shifted_vid, vid, shift};
-	  emit_vlmax_insn (code_for_pred_scalar (LSHIFTRT, mode), BINARY_OP,
-			   shift_ops);
-	}
-      else
-	shifted_vid = expand_simple_binop (mode, LSHIFTRT, vid, const1_rtx,
-					   NULL_RTX, false, OPTAB_DIRECT);
-      rtx tmp1 = gen_reg_rtx (mode);
-      rtx tmp2 = gen_reg_rtx (mode);
-      expand_vec_series (tmp1, base1,
-			 gen_int_mode (step1, builder->inner_mode ()),
-			 shifted_vid);
-      expand_vec_series (tmp2, base2,
-			 gen_int_mode (step2, builder->inner_mode ()),
-			 shifted_vid);
-
-      /* Transform into { 0, 1, 0, 1, 0, 1, ... }.  */
-      rtx and_vid = gen_reg_rtx (mode);
-      rtx and_ops[] = {and_vid, vid, const1_rtx};
-      emit_vlmax_insn (code_for_pred_scalar (AND, mode), BINARY_OP, and_ops);
-      rtx mask = gen_reg_rtx (builder->mask_mode ());
-      expand_vec_cmp (mask, EQ, and_vid, CONST1_RTX (mode));
+    shifted_vid = expand_simple_binop (mode, LSHIFTRT, vid, const1_rtx,
+				       NULL_RTX, false, OPTAB_DIRECT);
+  rtx tmp1 = gen_reg_rtx (mode);
+  rtx tmp2 = gen_reg_rtx (mode);
+  expand_vec_series (tmp1, base1,
+		     gen_int_mode (step1, builder->inner_mode ()),
+		     shifted_vid);
+  expand_vec_series (tmp2, base2,
+		     gen_int_mode (step2, builder->inner_mode ()),
+		     shifted_vid);
+
+  /* Transform into { 0, 1, 0, 1, 0, 1, ... }.  */
+  rtx and_vid = gen_reg_rtx (mode);
+  rtx and_ops[] = {and_vid, vid, const1_rtx};
+  emit_vlmax_insn (code_for_pred_scalar (AND, mode), BINARY_OP, and_ops);
+  rtx mask = gen_reg_rtx (builder->mask_mode ());
+  expand_vec_cmp (mask, EQ, and_vid, CONST1_RTX (mode));
 
-      rtx ops[] = {result, tmp1, tmp2, mask};
-      emit_vlmax_insn (code_for_pred_merge (mode), MERGE_OP, ops);
-    }
+  rtx ops[] = {result, tmp1, tmp2, mask};
+  emit_vlmax_insn (code_for_pred_merge (mode), MERGE_OP, ops);
 
   if (result != target)
     emit_move_insn (target, result);
--- a/src/gcc/config/riscv/riscv.md
+++ b/src/gcc/config/riscv/riscv.md
@@ -4384,7 +4384,16 @@ (define_insn "stack_protect_set_<mode>"
 	 UNSPEC_SSP_SET))
    (set (match_scratch:GPR 2 "=&r") (const_int 0))]
   ""
-  "<load>\t%2, %1\;<store>\t%2, %0\;li\t%2, 0"
+  {
+    rtx moves[][2] = {
+      {operands[2], operands[1]},
+      {operands[0], operands[2]},
+    };
+    for (rtx *op: moves)
+      output_asm_insn (riscv_output_move (op[0], op[1]), op);
+
+    return "li\t%2, 0";
+  }
   [(set_attr "type" "multi")
    (set_attr "length" "12")])
 
@@ -4424,7 +4433,16 @@ (define_insn "stack_protect_test_<mode>"
 	 UNSPEC_SSP_TEST))
    (clobber (match_scratch:GPR 3 "=&r"))]
   ""
-  "<load>\t%3, %1\;<load>\t%0, %2\;xor\t%0, %3, %0\;li\t%3, 0"
+  {
+    rtx moves[][2] = {
+      {operands[3], operands[1]},
+      {operands[0], operands[2]},
+    };
+    for (rtx *op: moves)
+      output_asm_insn (riscv_output_move (op[0], op[1]), op);
+
+    return "xor\t%0, %3, %0\;li\t%3, 0";
+  }
   [(set_attr "type" "multi")
    (set_attr "length" "12")])
 
--- a/src/gcc/config/riscv/thead.cc
+++ b/src/gcc/config/riscv/thead.cc
@@ -678,7 +678,7 @@ th_memidx_classify_address_index (struct riscv_address_info *info, rtx x,
     {
       type = (GET_CODE (XEXP (offset, 0)) == SIGN_EXTEND)
 	     ? ADDRESS_REG_REG : ADDRESS_REG_UREG;
-      shift = exact_log2 (INTVAL (XEXP (x, 1)));
+      shift = exact_log2 (INTVAL (offset));
       offset = XEXP (XEXP (x, 0), 0);
     }
   /* (ashift:X (reg:X) (const_int shift)) */
--- a/src/gcc/config/rs6000/rs6000-c.cc
+++ b/src/gcc/config/rs6000/rs6000-c.cc
@@ -835,14 +835,40 @@ rs6000_builtin_type_compatible (tree parmtype, tree argtype)
   return lang_hooks.types_compatible_p (parmtype, argtype);
 }
 
-/* In addition to calling fold_convert for EXPR of type TYPE, also
+/* Return fold_convert (TYPE, EXPR) for C and convert (TYPE, EXPR)
+   for C++.  The latter is needed because resolve_overloaded_builtin
+   can be called when parsing templates too if they don't have type
+   dependent operands, but the nested trees might not be usable in
+   GENERIC folding.  */
+
+static tree
+c_fold_convert (tree type, tree expr)
+{
+  return c_dialect_cxx () ? convert (type, expr) : fold_convert (type, expr);
+}
+
+/* Similar wrapper for fold_build2_loc.  For C++ just call build2_loc.  */
+
+static tree
+c_fold_build2_loc (location_t loc, enum tree_code code, tree type, tree arg0,
+		   tree arg1)
+{
+  if (!c_dialect_cxx ())
+    return fold_build2_loc (loc, code, type, arg0, arg1);
+  else if (loc != UNKNOWN_LOCATION)
+    return build2_loc (loc, code, type, arg0, arg1);
+  else
+    return build2 (code, type, arg0, arg1);
+}
+
+/* In addition to calling c_fold_convert for EXPR of type TYPE, also
    call c_fully_fold to remove any C_MAYBE_CONST_EXPRs that could be
    hiding there (PR47197).  */
 
 static tree
 fully_fold_convert (tree type, tree expr)
 {
-  tree result = fold_convert (type, expr);
+  tree result = c_fold_convert (type, expr);
   bool maybe_const = true;
 
   if (!c_dialect_cxx ())
@@ -855,7 +881,7 @@ fully_fold_convert (tree type, tree expr)
    The overloaded builtin that matched the types and args is described
    by DESC.  The N arguments are given in ARGS, respectively.
 
-   Actually the only thing it does is calling fold_convert on ARGS, with
+   Actually the only thing it does is calling c_fold_convert on ARGS, with
    a small exception for vec_{all,any}_{ge,le} predicates. */
 
 static tree
@@ -891,8 +917,9 @@ altivec_build_resolved_builtin (tree *args, int n, tree fntype, tree ret_type,
       std::swap (args[1], args[2]);
       std::swap (arg_type[1], arg_type[2]);
 
-      args[0] = fold_build2 (BIT_XOR_EXPR, TREE_TYPE (args[0]), args[0],
-			     build_int_cst (NULL_TREE, 2));
+      args[0] = c_fold_build2_loc (UNKNOWN_LOCATION, BIT_XOR_EXPR,
+				   TREE_TYPE (args[0]), args[0],
+				   build_int_cst (NULL_TREE, 2));
     }
 
   for (int j = 0; j < n; j++)
@@ -923,7 +950,7 @@ altivec_build_resolved_builtin (tree *args, int n, tree fntype, tree ret_type,
     default:
       gcc_unreachable ();
     }
-  return fold_convert (ret_type, call);
+  return c_fold_convert (ret_type, call);
 }
 
 /* Enumeration of possible results from attempted overload resolution.
@@ -964,8 +991,8 @@ resolve_vec_mul (resolution *res, tree *args, tree *types, location_t loc)
     case E_TImode:
       /* For scalar types just use a multiply expression.  */
       *res = resolved;
-      return fold_build2_loc (loc, MULT_EXPR, types[0], args[0],
-			      fold_convert (types[0], args[1]));
+      return c_fold_build2_loc (loc, MULT_EXPR, types[0], args[0],
+				c_fold_convert (types[0], args[1]));
     case E_SFmode:
       {
 	/* For floats use the xvmulsp instruction directly.  */
@@ -1108,8 +1135,8 @@ resolve_vec_adde_sube (resolution *res, rs6000_gen_builtins fcode,
 							params);
 	tree const1 = build_int_cstu (TREE_TYPE (types[0]), 1);
 	tree ones_vector = build_vector_from_val (types[0], const1);
-	tree and_expr = fold_build2_loc (loc, BIT_AND_EXPR, types[0],
-					 args[2], ones_vector);
+	tree and_expr = c_fold_build2_loc (loc, BIT_AND_EXPR, types[0],
+					   args[2], ones_vector);
 	params = make_tree_vector ();
 	vec_safe_push (params, call);
 	vec_safe_push (params, and_expr);
@@ -1194,8 +1221,8 @@ resolve_vec_addec_subec (resolution *res, rs6000_gen_builtins fcode,
 							 params);
 	tree const1 = build_int_cstu (TREE_TYPE (types[0]), 1);
 	tree ones_vector = build_vector_from_val (types[0], const1);
-	tree and_expr = fold_build2_loc (loc, BIT_AND_EXPR, types[0],
-					 args[2], ones_vector);
+	tree and_expr = c_fold_build2_loc (loc, BIT_AND_EXPR, types[0],
+					   args[2], ones_vector);
 	params = make_tree_vector ();
 	vec_safe_push (params, call2);
 	vec_safe_push (params, and_expr);
@@ -1303,7 +1330,7 @@ resolve_vec_splats (resolution *res, rs6000_gen_builtins fcode,
       return error_mark_node;
     }
 
-  arg = save_expr (fold_convert (TREE_TYPE (type), arg));
+  arg = save_expr (c_fold_convert (TREE_TYPE (type), arg));
   vec<constructor_elt, va_gc> *vec;
   vec_alloc (vec, size);
 
@@ -1442,7 +1469,7 @@ resolve_vec_extract (resolution *res, vec<tree, va_gc> *arglist,
 	  tree result = build_call_expr (call, 2, arg1, arg2);
 	  /* Coerce the result to vector element type.  May be no-op.  */
 	  arg1_inner_type = TREE_TYPE (arg1_type);
-	  result = fold_convert (arg1_inner_type, result);
+	  result = c_fold_convert (arg1_inner_type, result);
 	  *res = resolved;
 	  return result;
 	}
@@ -1566,8 +1593,9 @@ resolve_vec_insert (resolution *res, vec<tree, va_gc> *arglist,
   if (TARGET_VSX)
     {
       stmt = build_array_ref (loc, stmt, arg2);
-      stmt = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg0), stmt,
-			  convert (TREE_TYPE (stmt), arg0));
+      stmt = c_fold_build2_loc (UNKNOWN_LOCATION, MODIFY_EXPR,
+				TREE_TYPE (arg0), stmt,
+				convert (TREE_TYPE (stmt), arg0));
       stmt = build2 (COMPOUND_EXPR, arg1_type, stmt, decl);
     }
   else
@@ -1791,7 +1819,7 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl,
 		     "const");
 	  type = build_qualified_type (TREE_TYPE (type), 0);
 	  type = build_pointer_type (type);
-	  arg = fold_convert (type, arg);
+	  arg = c_fold_convert (type, arg);
 	}
 
       /* For RS6000_OVLD_VEC_LXVL, convert any const * to its non constant
@@ -1802,7 +1830,7 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl,
 	{
 	  type = build_qualified_type (TREE_TYPE (type), 0);
 	  type = build_pointer_type (type);
-	  arg = fold_convert (type, arg);
+	  arg = c_fold_convert (type, arg);
 	}
 
       args[n] = arg;
--- a/src/gcc/config/s390/s390.cc
+++ b/src/gcc/config/s390/s390.cc
@@ -5038,6 +5038,10 @@ s390_secondary_reload (bool in_p, rtx x, reg_class_t rclass_i,
 	      __SECONDARY_RELOAD_CASE (V1DI, v1di);
 	      __SECONDARY_RELOAD_CASE (V2DI, v2di);
 	      __SECONDARY_RELOAD_CASE (V1TI, v1ti);
+	      __SECONDARY_RELOAD_CASE (V1HF, v1hf);
+	      __SECONDARY_RELOAD_CASE (V2HF, v2hf);
+	      __SECONDARY_RELOAD_CASE (V4HF, v4hf);
+	      __SECONDARY_RELOAD_CASE (V8HF, v8hf);
 	      __SECONDARY_RELOAD_CASE (V1SF, v1sf);
 	      __SECONDARY_RELOAD_CASE (V2SF, v2sf);
 	      __SECONDARY_RELOAD_CASE (V4SF, v4sf);
--- a/src/gcc/config/s390/s390.md
+++ b/src/gcc/config/s390/s390.md
@@ -748,7 +748,8 @@ (define_code_iterator any_extend [sign_extend zero_extend])
 
 (define_mode_iterator ALL [TI DI SI HI QI TF FPRX2 DF SF HF TD DD SD V1QI V2QI
 			   V4QI V8QI V16QI V1HI V2HI V4HI V8HI V1SI V2SI V4SI
-			   V1DI V2DI V1SF V2SF V4SF V1TI V1DF V2DF V1TF])
+			   V1DI V2DI V1HF V2HF V4HF V8HF V1SF V2SF V4SF
+			   V1TI V1DF V2DF V1TF])
 
 ;; These mode iterators allow floating point patterns to be generated from the
 ;; same template.
--- a/src/gcc/cp/ChangeLog
+++ b/src/gcc/cp/ChangeLog
@@ -1,3 +1,420 @@
+2026-06-10  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-21  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125284
+	PR c++/125333
+	* pt.cc (tsubst_decl) <case USING_DECL>: Copy targs before
+	modifying them.
+
+2026-06-10  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-06-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125498
+	* mangle.cc (write_reflection): Use DECL_PARM_INDEX for
+	computing the parameter index.
+
+2026-06-05  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-06-05  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125334
+	* module.cc (depset::hash::add_dependent_adl_entities):
+	Disable when inside a header unit.
+
+2026-06-05  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-06-05  Patrick Palka  <ppalka@redhat.com>
+
+	* module.cc (dep_adl_info::args): Initializer to nullptr
+	instead of immediately allocating.
+	(depset::hash::add_dependent_adl_entities): Exit early
+	for non-type-dependent calls and operator expressions.
+	Only allocate dep_adl_info::args if we're not exiting early.
+	Correct all-type-dependent args test.
+	* name-lookup.cc (name_lookup::preserve_state): Replace
+	propagation of tentative flag with assert that it's not
+	set.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-06-03  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125378
+	* tree.cc (build_min_non_dep_op_overload): Handle comparison
+	operator expressions rewritten from a <=> that contain an
+	integer promotion.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-06-03  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125490
+	* parser.cc (cp_parser_constraint_expression): Pass
+	no_toplevel_fold_p=false instead of =true to
+	cp_parser_binary_expression.
+
+2026-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125123
+	* parser.cc (cp_build_range_for_decls): If range_temp or begin
+	are static, set DECL_IGNORED_P on it.
+	* pt.cc (finish_expansion_stmt): Similarly for iter.
+	* decl.cc (cp_finish_decl): Call determine_local_discriminator
+	etc. also for DECL_ARTIFICIAL TREE_STATIC vars.
+
+2026-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125412
+	* reflect.cc (process_metafunction): If ht is error_operand_p,
+	set *non_constant_p and return NULL_TREE.
+
+2026-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-21  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125376
+	* coroutines.cc (register_local_var_uses): Ignore DECL_NAME for
+	name independent decls.
+
+2026-05-28  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-28  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125454
+	* typeck.cc (cp_build_array_ref): Don't recurse for array[array].
+
+2026-05-26  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-26  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125423
+	* pt.cc (tsubst_expr) <case REFLECT_EXPR>: Don't tsubst
+	REFLECT_BASEs.
+
+2026-05-23  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/125135
+	* pt.cc (check_non_deducible_conversions): Handle LOOKUP_DEFAULTED.
+
+2026-05-23  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-21  Jason Merrill  <jason@redhat.com>
+
+	PR c++/125384
+	PR c++/113563
+	* lambda.cc (build_capture_proxy): 'this' capture proxy is const.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125007
+	* cp-tree.h (maybe_update_function_parm): Declare.
+	* reflect.cc (maybe_update_function_parm): No longer static.
+	* error.cc (dump_expr) <case REFLECT_EXPR>: Improve printing
+	of various reflections.
+
+2026-05-15  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-15  Jason Merrill  <jason@redhat.com>
+
+	PR c++/125315
+	* constexpr.cc (init_subob_ctx): Allow both ctor and object
+	to be null for an empty subobject.
+
+2026-05-15  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-14  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124628
+	* reflect.cc (resolve_type_of_reflected_decl): New.
+	(get_reflection): Call resolve_type_of_reflected_decl instead
+	of mark_used.
+	(has_type): Call resolve_type_of_reflected_decl before
+	checking for an undeduced auto.
+	(eval_can_substitute): Likewise.  Also look through BASELINK.
+	(members_of_representable): Call resolve_type_of_reflected_decl
+	before checking for an undeduced auto.
+
+2026-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125184
+	* reflect.cc (check_out_of_consteval_use_r): Don't walk children of
+	USING_STMTs.
+
+2026-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125111
+	* reflect.cc (extract_ref): Throw instead of trying to build
+	arrays of functions, methods or arrays with NULL TYPE_DOMAIN.
+
+2026-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/124991
+	* cp-tree.h (struct lang_type): Document typeinfo_var member.
+	(get_classtype_typeinfo_var): New inline function.
+	(CLASSTYPE_TYPEINFO_VAR): Use it.
+	(set_classtype_typeinfo_var): New inline function.
+	(SET_CLASSTYPE_TYPEINFO_VAR): Define.
+	(get_anon_aggr_type_field): New inline function.
+	(ANON_AGGR_TYPE_FIELD): Use it.
+	(set_anon_aggr_type_field): New inline function.
+	(SET_ANON_AGGR_TYPE_FIELD): Define.
+	* decl.cc (fixup_anonymous_aggr): Use SET_ANON_AGGR_TYPE_FIELD
+	instead of ANON_AGGR_TYPE_FIELD.
+	* module.cc (trees_in::read_class_def): Use
+	SET_CLASSTYPE_TYPEINFO_VAR instead of setting
+	CLASSTYPE_TYPEINFO_VAR and do it even for ANON_AGGR_TYPE_P
+	types.  Use SET_ANON_AGGR_TYPE_FIELD instead of setting
+	ANON_AGGR_TYPE_FIELD.
+	* rtti.cc (get_tinfo_decl_direct): Use SET_CLASSTYPE_TYPEINFO_VAR
+	instead of setting CLASSTYPE_TYPEINFO_VAR.
+	* semantics.cc (finish_member_declaration): Use
+	SET_ANON_AGGR_TYPE_FIELD instead of setting ANON_AGGR_TYPE_FIELD.
+
+2026-05-13  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-13  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125280
+	* reflect.cc (consteval_only_p): Don't complete_type.
+	(consteval_only_p_walker::walk): Return false for
+	error_mark_node.
+
+2026-05-12  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-12  Jason Merrill  <jason@redhat.com>
+
+	PR c++/100903
+	* call.cc (build_over_call): Avoid -Wzero-as-null-pointer-constant
+	if the warning is disabled around the called function.
+
+2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-08  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/115181
+	PR c++/125043
+	PR c++/124979
+	* pt.cc (invalid_tparm_referent_p): Allow DECL_IGNORED_P in an
+	assert.
+
+2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125208
+	* reflect.cc (compare_reflections): Use == when comparing two
+	aliases.
+	* tree.cc (cp_tree_equal) <case REFLECT_EXPR>: Use
+	compare_reflections.
+
+2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124770
+	* decl.cc (wrapup_namespace_globals): Give the odr-used
+	inline variable error only when !DECL_INITIAL.
+
+2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125206
+	* tree.cc (strip_typedefs_expr) <case REFLECT_EXPR>: Always
+	return instead of recursing.
+
+2026-05-06  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-06  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125179
+	* reflect.cc: (consteval_only_type_r): Remove this cp_walk_tree
+	callback and replace with ...
+	(consteval_only_walker): ... this recursive memoized
+	implementation.
+	(consteval_only_p): Define in terms of consteval_only_walker.
+
+2026-05-06  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-05  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124957
+	* class.cc (check_tag): Set ABI_TAG_INHERITED on the TREE_LIST
+	of an inherited tag.  Adjust after ABI_TAG_IMPLICIT renaming.
+	* cp-tree.h (ABI_TAG_IMPLICIT): Rename to ...
+	(ABI_TAG_NOT_MANGLED): ... this.
+	(equal_abi_tags): Adjust forward declaration.
+	* mangle.cc (write_unqualified_name): Adjust equal_abi_tags call.
+	(sorted_abi_tags): New ignore_inherited_p parameter, for ignoring
+	ABI_TAG_INHERITED tags.  Adjust after ABI_TAG_INHERITED renaming.
+	(write_abi_tags): Adjust sorted_abi_tags call.
+	(equal_abi_tags): New ignore_inherited_p parameter.  Pass it to
+	sorted_abi_tags.
+	* module.cc (trees_in::check_abi_tags): Pass
+	ignore_inherited_p=true to equal_abi_tags iff there's a
+	mangled-ness mismatch.
+
+2026-05-01  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-01  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125115
+	* module.cc (trees_in::is_matching_decl): Turn e_type into a
+	reference and use it instead of TREE_TYPE (e_inner).  Always
+	use build_exception_variant to propagate an already-instantiated
+	noexcept.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-04-23  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124926
+	* pt.cc (tsubst_qualified_id): Rename name_lookup_p parameter to
+	reflecting_p.  Check !reflecting_p instead of name_lookup_p.  Do
+	not give the "instantiation yields a type" error when reflecting_p
+	is true.
+	(tsubst_expr) <case REFLECT_EXPR>: Adjust the call to
+	tsubst_qualified_id.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-04-23  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124989
+	* pt.cc (tsubst_splice_expr): Turn off access checking for the
+	build_offset_ref call.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-04-28  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124756
+	* reflect.cc (get_reflection): Give an error when taking the
+	reflection of a block-scope extern.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125096
+	* pt.cc (tsubst_splice_scope): Don't return early for
+	dependent_splice_p.  Propagate cv-qualifiers from the
+	SPLICE_SCOPE to the result.
+	* reflect.cc (valid_splice_scope_p): Accept SPLICE_SCOPE.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-29  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125035
+	* module.cc (merge_key): Add iobj_p and xobj_p bits.
+	(trees_out::key_mergeable) <case MK_named>: Set and stream
+	merge_key's iobj_p and xobj_p bits.
+	(check_mergeable_decl) <case FUNCTION_DECL>: Compare merge_key's
+	iobj_p and xobj_p bits with that of the given function.
+	(trees_in::key_mergeable): Stream merge_key's iobj_p and xobj_p
+	bits.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-29  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124582
+	PR c++/123810
+	* module.cc (check_mergeable_decl) <case TYPE_DECL>: Handle
+	merging a typedef to an unnamed type with the -freflection
+	representation.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-27  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124953
+	* module.cc (trees_in::tree_node) <tt_nttp_var>: Push the result
+	of get_template_parm_object to post_load_decls.
+	(post_load_processing): Call cp_finish_decl on any not yet
+	completed NTTP objects.
+	* pt.cc (get_template_parm_object): Don't call cp_finish_decl
+	when !check_init.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-23  Patrick Palka  <ppalka@redhat.com>
+
+	* module.cc (trees_out::core_vals) <case PTRMEM_CST>:
+	Stream PTRMEM_CST_LOCATION.
+	<case TRAIT_EXPR>: Stream TRAIT_EXPR_LOCATION.
+	(trees_in::core_vals): As in trees_out::core_vals.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-23  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124981
+	* module.cc (trees_in::core_vals) <case PTRMEM_CST>: Use RTU
+	instead of RT to stream PTRMEM_CST_MEMBER.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-29  Jakub Jelinek  <jakub@redhat.com>
+
+	* reflect.cc (compare_reflection): For REFLECT_BASE use lhs == rhs rather
+	than cp_tree_equal.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/cp/call.cc
+++ b/src/gcc/cp/call.cc
@@ -10715,10 +10715,18 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
              func(NULL);
            }
       */
-      bool const conversion_warning = !(null_node_p (current_arg)
-					&& DECL_TEMPLATE_INFO (fn)
-					&& cand->template_decl
-					&& !cand->explicit_targs);
+      bool conversion_warning = !(null_node_p (current_arg)
+				  && DECL_TEMPLATE_INFO (fn)
+				  && cand->template_decl
+				  && !cand->explicit_targs);
+
+      /* Also don't warn about (x <=> y) < 0 (c++/100903).  */
+      if (conversion_warning
+	  && integer_zerop (current_arg)
+	  && warn_zero_as_null_pointer_constant
+	  && !warning_enabled_at (DECL_SOURCE_LOCATION (fn),
+				  OPT_Wzero_as_null_pointer_constant))
+	conversion_warning = false;
 
       tsubst_flags_t const arg_complain
 	= conversion_warning ? complain : complain & ~tf_warning;
--- a/src/gcc/cp/class.cc
+++ b/src/gcc/cp/class.cc
@@ -1711,11 +1711,12 @@ check_tag (tree tag, tree id, tree *tp, abi_tag_data *p)
 	  /* Don't inherit this tag multiple times.  */
 	  IDENTIFIER_MARKED (id) = true;
 
+	  ABI_TAG_INHERITED (p->tags) = true;
 	  if (TYPE_P (p->t))
 	    {
 	      /* Tags inherited from type template arguments are only used
 		 to avoid warnings.  */
-	      ABI_TAG_IMPLICIT (p->tags) = true;
+	      ABI_TAG_NOT_MANGLED (p->tags) = true;
 	      return;
 	    }
 	  /* For functions and variables we want to warn, too.  */
--- a/src/gcc/cp/constexpr.cc
+++ b/src/gcc/cp/constexpr.cc
@@ -6703,7 +6703,12 @@ init_subob_ctx (const constexpr_ctx *ctx, constexpr_ctx &new_ctx,
   else if (ctx->object)
     ctxtype = TREE_TYPE (ctx->object);
   else
-    gcc_unreachable ();
+    {
+      /* This can happen if the enclosing object is also an empty subobject
+	 (c++/125315).  */
+      gcc_checking_assert (is_empty_class (type));
+      return;
+    }
 
   if (VECTOR_TYPE_P (type)
       && VECTOR_TYPE_P (ctxtype)
--- a/src/gcc/cp/coroutines.cc
+++ b/src/gcc/cp/coroutines.cc
@@ -4403,6 +4403,8 @@ register_local_var_uses (tree *stmt, int *do_subtree, void *d)
 	 identify them in the coroutine frame.  */
       tree lvname = DECL_NAME (lvar);
       char *buf = NULL;
+      if (name_independent_decl_p (lvar))
+	lvname = NULL_TREE;
 
       /* The outermost bind scope contains the artificial variables that
 	 we inject to implement the coro state machine.  We want to be able
--- a/src/gcc/cp/cp-tree.h
+++ b/src/gcc/cp/cp-tree.h
@@ -429,7 +429,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
       TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
       TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
       ATTR_IS_DEPENDENT (in the TREE_LIST for an attribute)
-      ABI_TAG_IMPLICIT (in the TREE_LIST for the argument of abi_tag)
+      ABI_TAG_NOT_MANGLED (in the TREE_LIST for the argument of abi_tag)
       LAMBDA_CAPTURE_EXPLICIT_P (in a TREE_LIST in LAMBDA_EXPR_CAPTURE_LIST)
       PARENTHESIZED_LIST_P (in the TREE_LIST for a parameter-declaration-list)
       CONSTRUCTOR_IS_DIRECT_INIT (in CONSTRUCTOR)
@@ -480,6 +480,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
       BASELINK_FUNCTIONS_MAYBE_INCOMPLETE_P (in BASELINK)
       BIND_EXPR_VEC_DTOR (in BIND_EXPR)
       ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (in ATOMIC_CONSTR)
+      ABI_TAG_INHERITED (in the TREE_LIST for the argument of abi_tag)
       STATIC_INIT_DECOMP_BASE_P (in the TREE_LIST for {static,tls}_aggregates)
       MUST_NOT_THROW_THROW_P (in MUST_NOT_THROW_EXPR)
       LAMBDA_EXPR_CONST_QUAL_P (in LAMBDA_EXPR)
@@ -2682,6 +2683,9 @@ struct GTY(()) lang_type {
   tree primary_base;
   vec<tree_pair_s, va_gc> *vcall_indices;
   tree vtables;
+  /* CLASSTYPE_TYPEINFO_VAR and/or ANON_AGGR_TYPE_FIELD.  If both,
+     this is a TREE_LIST with the former as TREE_VALUE and the latter
+     as TREE_PURPOSE.  */
   tree typeinfo_var;
   vec<tree, va_gc> *vbases;
   tree as_base;
@@ -3075,11 +3079,44 @@ struct GTY(()) lang_type {
 #define CLASSTYPE_VTABLES(NODE) \
   (LANG_TYPE_CLASS_CHECK (NODE)->vtables)
 
+/* Helper for CLASSTYPE_TYPEINFO_VAR.  */
+
+inline tree
+get_classtype_typeinfo_var (tree typeinfo_var)
+{
+  if (typeinfo_var == NULL_TREE)
+    return NULL_TREE;
+  if (TREE_CODE (typeinfo_var) == TREE_LIST)
+    return TREE_VALUE (typeinfo_var);
+  if (VAR_P (typeinfo_var))
+    return typeinfo_var;
+  return NULL_TREE;
+}
+
 /* The std::type_info variable representing this class, or NULL if no
    such variable has been created.  This field is only set for the
    TYPE_MAIN_VARIANT of the class.  */
 #define CLASSTYPE_TYPEINFO_VAR(NODE) \
-  (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
+  get_classtype_typeinfo_var (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
+
+/* Helper for SET_CLASSTYPE_TYPEINFO_VAR.  */
+
+inline tree &
+set_classtype_typeinfo_var (tree &typeinfo_var)
+{
+  if (typeinfo_var == NULL_TREE)
+    return typeinfo_var;
+  if (TREE_CODE (typeinfo_var) == FIELD_DECL)
+    typeinfo_var = build_tree_list (typeinfo_var, NULL_TREE);
+  if (TREE_CODE (typeinfo_var) == TREE_LIST)
+    return TREE_VALUE (typeinfo_var);
+  return typeinfo_var;
+}
+
+/* Setter for that.  */
+#define SET_CLASSTYPE_TYPEINFO_VAR(NODE, VAR) \
+  (set_classtype_typeinfo_var (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) \
+   = (VAR))
 
 /* Accessor macros for the BINFO_VIRTUALS list.  */
 
@@ -3962,8 +3999,14 @@ struct GTY(()) lang_decl {
 #define ATTR_IS_DEPENDENT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
 
 /* In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag
-   was inherited from a template parameter, not explicitly indicated.  */
-#define ABI_TAG_IMPLICIT(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
+   was inherited from a template parameter, not explicitly indicated.
+   These are not mangled because they're already represented in the mangling
+   of the template argument.  */
+#define ABI_TAG_NOT_MANGLED(NODE) TREE_LANG_FLAG_0 (TREE_LIST_CHECK (NODE))
+
+/* In a TREE_LIST in the argument of attribute abi_tag, indicates that the tag
+ * was added by check_abi_tags, not explicitly specified.  */
+#define ABI_TAG_INHERITED(NODE) TREE_LANG_FLAG_1 (TREE_LIST_CHECK (NODE))
 
 /* In a TREE_LIST for a parameter-declaration-list, indicates that all the
    parameters in the list have declarators enclosed in ().  */
@@ -5407,9 +5450,42 @@ get_vec_init_expr (tree t)
 #define ANON_UNION_TYPE_P(NODE) \
   (TREE_CODE (NODE) == UNION_TYPE && ANON_AGGR_TYPE_P (NODE))
 
+/* Helper for ANON_AGGR_TYPE_FIELD.  */
+
+inline tree
+get_anon_aggr_type_field (tree typeinfo_var)
+{
+  if (typeinfo_var == NULL_TREE)
+    return NULL_TREE;
+  if (TREE_CODE (typeinfo_var) == TREE_LIST)
+    return TREE_PURPOSE (typeinfo_var);
+  if (TREE_CODE (typeinfo_var) == FIELD_DECL)
+    return typeinfo_var;
+  return NULL_TREE;
+}
+
 /* For an ANON_AGGR_TYPE_P the single FIELD_DECL it is used with.  */
 #define ANON_AGGR_TYPE_FIELD(NODE) \
-  (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
+  get_anon_aggr_type_field (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var)
+
+/* Helper for SET_ANON_AGGR_TYPE_FIELD.  */
+
+inline tree &
+set_anon_aggr_type_field (tree &typeinfo_var)
+{
+  if (typeinfo_var == NULL_TREE)
+    return typeinfo_var;
+  if (VAR_P (typeinfo_var))
+    typeinfo_var = build_tree_list (NULL_TREE, typeinfo_var);
+  if (TREE_CODE (typeinfo_var) == TREE_LIST)
+    return TREE_PURPOSE (typeinfo_var);
+  return typeinfo_var;
+}
+
+/* Setter for that.  */
+#define SET_ANON_AGGR_TYPE_FIELD(NODE, FIELD) \
+  (set_anon_aggr_type_field (LANG_TYPE_CLASS_CHECK (NODE)->typeinfo_var) \
+   = (FIELD))
 
 /* Define fields and accessors for nodes representing declared names.  */
 
@@ -9114,7 +9190,7 @@ extern void mangle_module_substitution		(int);
 extern int mangle_module_component		(tree id, bool partition);
 extern tree mangle_module_global_init		(int);
 extern unsigned HOST_WIDE_INT range_expr_nelts	(tree);
-extern bool equal_abi_tags			(tree, tree);
+extern bool equal_abi_tags			(tree, tree, bool);
 
 /* in dump.cc */
 extern bool cp_dump_tree			(void *, tree);
@@ -9432,6 +9508,7 @@ extern void coro_set_ramp_function		(tree, tree);
 
 /* In reflect.cc */
 extern void init_reflection ();
+extern tree maybe_update_function_parm (tree);
 extern bool metafunction_p (tree) ATTRIBUTE_PURE;
 extern tree direct_base_derived (tree) ATTRIBUTE_PURE;
 extern tree process_metafunction (const constexpr_ctx *, tree, tree,
--- a/src/gcc/cp/decl.cc
+++ b/src/gcc/cp/decl.cc
@@ -1023,6 +1023,10 @@ wrapup_namespace_globals ()
 
 	  if (VAR_P (decl)
 	      && DECL_EXTERNAL (decl)
+	      /* We mark consteval-only variables DECL_EXTERNAL, but
+		  extern constexpr inline std::meta::info i{};
+		 is a definition (the extern is redundant).  */
+	      && !DECL_INITIAL (decl)
 	      && DECL_INLINE_VAR_P (decl)
 	      && DECL_ODR_USED (decl))
 	    error_at (DECL_SOURCE_LOCATION (decl),
@@ -6200,7 +6204,7 @@ fixup_anonymous_aggr (tree t)
   vec_safe_truncate (vec, store);
 
   /* Wipe RTTI info.  */
-  CLASSTYPE_TYPEINFO_VAR (t) = NULL_TREE;
+  SET_CLASSTYPE_TYPEINFO_VAR (t, NULL_TREE);
 
   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
      assignment operators (because they cannot have these methods themselves).
@@ -9883,9 +9887,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
 	 require a guard variable, and since the mangled name of the
 	 guard variable will depend on the mangled name of this
 	 variable.  */
-      if (DECL_FUNCTION_SCOPE_P (decl)
-	  && TREE_STATIC (decl)
-	  && !DECL_ARTIFICIAL (decl))
+      if (DECL_FUNCTION_SCOPE_P (decl) && TREE_STATIC (decl))
 	{
 	  /* The variable holding an anonymous union will have had its
 	     discriminator set in finish_anon_union, after which it's
--- a/src/gcc/cp/error.cc
+++ b/src/gcc/cp/error.cc
@@ -3331,21 +3331,156 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags)
 
     case REFLECT_EXPR:
       {
-	pp_string (pp, "^^");
 	tree h = REFLECT_EXPR_HANDLE (t);
-	if (DECL_P (h))
-	  dump_decl (pp, h, flags);
-	else if (TYPE_P (h))
-	  dump_type (pp, h, flags);
-	else if (TREE_CODE (h) == TREE_VEC)
+	bool any;
+	switch (REFLECT_EXPR_KIND (t))
 	  {
-	    pp_format_decoder (pp) = cp_printer;
-	    pp->set_format_postprocessor
-	      (std::make_unique<cxx_format_postprocessor> ());
-	    dump_data_member_spec (pp, h);
+	  case REFLECT_ANNOTATION:
+	    pp_string (pp, "^^[[=");
+	    pp->set_padding (pp_none);
+	    dump_expr (pp, TREE_VALUE (TREE_VALUE (h)), flags);
+	    pp_string (pp, "]]");
+	    break;
+	  case REFLECT_DATA_MEMBER_SPEC:
+	    pp_cxx_ws_string (pp, "data_member_spec");
+	    pp_string (pp, "(^^");
+	    pp->set_padding (pp_none);
+	    dump_type (pp, TREE_VEC_ELT (h, 0), flags);
+	    pp_string (pp, ",{");
+	    any = false;
+	    if (TREE_VEC_ELT (h, 1))
+	      {
+		pp_string (pp, ".name=");
+		pp_doublequote (pp);
+		pp->set_padding (pp_none);
+		dump_decl (pp, TREE_VEC_ELT (h, 1), flags);
+		pp_doublequote (pp);
+		any = true;
+	      }
+	    if (TREE_VEC_ELT (h, 2))
+	      {
+		if (any)
+		  pp_comma (pp);
+		pp_string (pp, ".alignment=");
+		pp->set_padding (pp_none);
+		dump_expr (pp, TREE_VEC_ELT (h, 2), flags);
+		any = true;
+	      }
+	    if (TREE_VEC_ELT (h, 3))
+	      {
+		if (any)
+		  pp_comma (pp);
+		pp_string (pp, ".bit_width=");
+		pp->set_padding (pp_none);
+		dump_expr (pp, TREE_VEC_ELT (h, 3), flags);
+		any = true;
+	      }
+	    if (TREE_VEC_ELT (h, 4) && !integer_zerop (TREE_VEC_ELT (h, 4)))
+	      {
+		if (any)
+		  pp_comma (pp);
+		pp_string (pp, ".no_unique_address=");
+		pp->set_padding (pp_none);
+		dump_expr (pp, TREE_VEC_ELT (h, 4), flags);
+		any = true;
+	      }
+	    if (TREE_VEC_LENGTH (h) > 5)
+	      {
+		if (any)
+		  pp_comma (pp);
+		pp_string (pp, ".annotations={");
+		pp->set_padding (pp_none);
+		for (int i = 5; i < TREE_VEC_LENGTH (h); ++i)
+		  {
+		    dump_expr (pp, TREE_VEC_ELT (h, i), flags);
+		    if (i != TREE_VEC_LENGTH (h) - 1)
+		      pp_comma (pp);
+		    pp->set_padding (pp_none);
+		  }
+		pp_right_brace (pp);
+	      }
+	    pp_string (pp, "})");
+	    break;
+	  case REFLECT_BASE:
+	    {
+	      pp_cxx_ws_string (pp, "bases_of");
+	      pp_string (pp, "(^^");
+	      pp->set_padding (pp_none);
+	      tree d = direct_base_derived (h);
+	      dump_type (pp, d, flags);
+	      pp_string (pp, ",std::meta::access_context::unchecked())[");
+	      pp->set_padding (pp_none);
+	      tree binfo = TYPE_BINFO (d), base_binfo;
+	      for (unsigned i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo);
+		   i++)
+		if (base_binfo == h)
+		  {
+		    pp_wide_integer (pp, i);
+		    break;
+		  }
+	      pp_string (pp, "] {aka ");
+	      pp->set_padding (pp_none);
+	      dump_type (pp, BINFO_TYPE (h), flags);
+	      pp_right_brace (pp);
+	      break;
+	    }
+	  case REFLECT_PARM:
+	    {
+	      pp_cxx_ws_string (pp, "parameters_of");
+	      pp_string (pp, "(^^");
+	      pp->set_padding (pp_none);
+	      h = maybe_update_function_parm (h);
+	      dump_decl (pp, DECL_CONTEXT (h), flags);
+	      pp_string (pp, ")[");
+	      pp->set_padding (pp_none);
+	      unsigned int i = 0;
+	      for (tree arg = FUNCTION_FIRST_USER_PARM (DECL_CONTEXT (h));
+		   arg; arg = DECL_CHAIN (arg), ++i)
+		if (arg == h)
+		  {
+		    pp_wide_integer (pp, i);
+		    break;
+		  }
+	      pp_right_bracket (pp);
+	      if (MULTIPLE_NAMES_PARM_P (h))
+		break;
+	      if (DECL_NAME (h))
+		h = DECL_NAME (h);
+	      else if (tree opn = lookup_attribute ("old parm name",
+						    DECL_ATTRIBUTES (h)))
+		h = TREE_VALUE (TREE_VALUE (opn));
+	      else
+		break;
+	      pp_string (pp, " {aka ");
+	      dump_decl (pp, h, flags);
+	      pp_right_brace (pp);
+	      break;
+	    }
+	  case REFLECT_OBJECT:
+	    pp_cxx_ws_string (pp, "std::meta::reflect_object");
+	    pp_left_paren (pp);
+	    pp->set_padding (pp_none);
+	    dump_expr (pp, h, flags);
+	    pp_right_paren (pp);
+	    break;
+	  case REFLECT_VALUE:
+	    pp_cxx_ws_string (pp, "std::meta::reflect_constant");
+	    pp_left_paren (pp);
+	    pp->set_padding (pp_none);
+	    dump_expr (pp, h, flags);
+	    pp_right_paren (pp);
+	    break;
+	  default:
+	    pp_string (pp, "^^");
+	    pp->set_padding (pp_none);
+	    if (DECL_P (h))
+	      dump_decl (pp, h, flags);
+	    else if (TYPE_P (h))
+	      dump_type (pp, h, flags);
+	    else
+	      dump_expr (pp, h, flags);
+	    break;
 	  }
-	else
-	  dump_expr (pp, h, flags);
 	break;
       }
 
--- a/src/gcc/cp/lambda.cc
+++ b/src/gcc/cp/lambda.cc
@@ -450,7 +450,7 @@ build_capture_proxy (tree member, tree init, bool early_p)
        constness of the closure doesn't matter just like it doesn't matter to
        other by-ref capture.  It's simpler to handle this special case here
        than in lambda_proxy_type.  */
-    type = TREE_TYPE (member);
+    type = cp_build_qualified_type (TREE_TYPE (member), TYPE_QUAL_CONST);
   else
     {
       type = lambda_proxy_type (object);
--- a/src/gcc/cp/mangle.cc
+++ b/src/gcc/cp/mangle.cc
@@ -1645,7 +1645,7 @@ write_unqualified_name (tree decl)
 
 	  if (!G.need_abi_warning
 	      && abi_warn_or_compat_version_crosses (11)
-	      && !equal_abi_tags (dtags, mtags))
+	      && !equal_abi_tags (dtags, mtags, /*ignore_inherited_p=*/false))
 	    G.need_abi_warning = 1;
 
 	  if (!abi_version_at_least (10))
@@ -1709,13 +1709,14 @@ tree_string_cmp (const void *p1, const void *p2)
 /* Return the TREE_LIST of TAGS as a sorted VEC.  */
 
 static vec<tree, va_gc> *
-sorted_abi_tags (tree tags)
+sorted_abi_tags (tree tags, bool ignore_inherited_p)
 {
   vec<tree, va_gc> * vec = make_tree_vector();
 
   for (tree t = tags; t; t = TREE_CHAIN (t))
     {
-      if (ABI_TAG_IMPLICIT (t))
+      if (ABI_TAG_NOT_MANGLED (t)
+	  || (ignore_inherited_p && ABI_TAG_INHERITED (t)))
 	continue;
       tree str = TREE_VALUE (t);
       vec_safe_push (vec, str);
@@ -1735,7 +1736,7 @@ write_abi_tags (tree tags)
   if (tags == NULL_TREE)
     return;
 
-  vec<tree, va_gc> * vec = sorted_abi_tags (tags);
+  vec<tree, va_gc> * vec = sorted_abi_tags (tags, /*ignore_inherited_p=*/false);
 
   unsigned i; tree str;
   FOR_EACH_VEC_ELT (*vec, i, str)
@@ -1751,10 +1752,10 @@ write_abi_tags (tree tags)
 /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent.  */
 
 bool
-equal_abi_tags (tree t1, tree t2)
+equal_abi_tags (tree t1, tree t2, bool ignore_inherited_p)
 {
-  releasing_vec v1 = sorted_abi_tags (t1);
-  releasing_vec v2 = sorted_abi_tags (t2);
+  releasing_vec v1 = sorted_abi_tags (t1, ignore_inherited_p);
+  releasing_vec v2 = sorted_abi_tags (t2, ignore_inherited_p);
 
   unsigned len1 = v1->length();
   if (len1 != v2->length())
@@ -4219,13 +4220,8 @@ write_reflection (tree refl)
   else if (strcmp (prefix, "pa") == 0)
     {
       tree fn = DECL_CONTEXT (arg);
-      tree args = FUNCTION_FIRST_USER_PARM (fn);
-      int idx = 0;
-      while (arg != args)
-	{
-	  args = DECL_CHAIN (args);
-	  ++idx;
-	}
+      /* DECL_PARM_INDEX is 1-based but here we want a 0-based index.  */
+      const int idx = DECL_PARM_INDEX (arg) - 1;
       write_compact_number (idx);
       write_encoding (fn);
     }
--- a/src/gcc/cp/module.cc
+++ b/src/gcc/cp/module.cc
@@ -2645,7 +2645,7 @@ public:
       /* If not ERROR_MARK, a rewrite candidate for this operator.  */
       tree_code rewrite = ERROR_MARK;
       /* Argument list for the call.  */
-      vec<tree, va_gc>* args = make_tree_vector ();
+      vec<tree, va_gc>* args = nullptr;
     };
     vec<dep_adl_info> dep_adl_entity_list;
 
@@ -2970,6 +2970,8 @@ static char const *const merge_kind_name[MK_hwm] =
 struct merge_key {
   cp_ref_qualifier ref_q : 2;
   unsigned coro_disc : 2;  /* Discriminator for coroutine transforms.  */
+  unsigned iobj_p : 1;
+  unsigned xobj_p : 1;
   unsigned index;
 
   tree ret;  /* Return type, if appropriate.  */
@@ -2978,7 +2980,7 @@ struct merge_key {
   tree constraints;  /* Constraints.  */
 
   merge_key ()
-    :ref_q (REF_QUAL_NONE), coro_disc (0), index (0),
+    :ref_q (REF_QUAL_NONE), coro_disc (0), iobj_p (0), xobj_p (0), index (0),
      ret (NULL_TREE), args (NULL_TREE),
      constraints (NULL_TREE)
   {
@@ -6872,6 +6874,8 @@ trees_out::core_vals (tree t)
 
     case PTRMEM_CST:
       WT (((lang_tree_node *)t)->ptrmem.member);
+      if (state)
+	state->write_location (*this, ((lang_tree_node *)t)->ptrmem.locus);
       break;
 
     case STATIC_ASSERT:
@@ -6933,6 +6937,9 @@ trees_out::core_vals (tree t)
     case TRAIT_EXPR:
       WT (((lang_tree_node *)t)->trait_expression.type1);
       WT (((lang_tree_node *)t)->trait_expression.type2);
+      if (state)
+	state->write_location
+	  (*this, ((lang_tree_node *)t)->trait_expression.locus);
       if (streaming_p ())
 	WU (((lang_tree_node *)t)->trait_expression.kind);
       break;
@@ -7443,7 +7450,8 @@ trees_in::core_vals (tree t)
       break;
 
     case PTRMEM_CST:
-      RT (((lang_tree_node *)t)->ptrmem.member);
+      RTU (((lang_tree_node *)t)->ptrmem.member);
+      ((lang_tree_node *)t)->ptrmem.locus = state->read_location (*this);
       break;
 
     case STATIC_ASSERT:
@@ -7493,6 +7501,8 @@ trees_in::core_vals (tree t)
     case TRAIT_EXPR:
       RT (((lang_tree_node *)t)->trait_expression.type1);
       RT (((lang_tree_node *)t)->trait_expression.type2);
+      ((lang_tree_node *)t)->trait_expression.locus
+	= state->read_location (*this);
       RUC (cp_trait_kind, ((lang_tree_node *)t)->trait_expression.kind);
       break;
 
@@ -10864,6 +10874,7 @@ trees_in::tree_node (bool is_use)
 	    int tag = insert (res);
 	    dump (dumper::TREE)
 	      && dump ("Created nttp object:%d %N", tag, name);
+	    vec_safe_push (post_load_decls, res);
 	  }
       }
       break;
@@ -11889,6 +11900,8 @@ trees_out::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
 
 	      key.ref_q = type_memfn_rqual (fn_type);
 	      key.coro_disc = get_coroutine_discriminator (inner);
+	      key.iobj_p = DECL_IOBJ_MEMBER_FUNCTION_P (inner);
+	      key.xobj_p = DECL_XOBJ_MEMBER_FUNCTION_P (inner);
 	      key.args = TYPE_ARG_TYPES (fn_type);
 
 	      if (tree reqs = get_constraints (inner))
@@ -12026,11 +12039,13 @@ trees_out::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
       if (streaming_p ())
 	{
 	  /* Check we have enough bits for the index.  */
-	  gcc_checking_assert (key.index < (1u << (sizeof (unsigned) * 8 - 4)));
+	  gcc_checking_assert (key.index < (1u << (sizeof (unsigned) * 8 - 6)));
 
 	  unsigned code = ((key.ref_q << 0)
 			   | (key.coro_disc << 2)
-			   | (key.index << 4));
+			   | (key.iobj_p << 4)
+			   | (key.xobj_p << 5)
+			   | (key.index << 6));
 	  u (code);
 	}
 
@@ -12109,6 +12124,8 @@ check_mergeable_decl (merge_kind mk, tree decl, tree ovl, merge_key const &key)
 	    if ((!key.ret
 		 || same_type_p (key.ret, fndecl_declared_return_type (m_inner)))
 		&& type_memfn_rqual (m_type) == key.ref_q
+		&& key.iobj_p == DECL_IOBJ_MEMBER_FUNCTION_P (m_inner)
+		&& key.xobj_p == DECL_XOBJ_MEMBER_FUNCTION_P (m_inner)
 		&& compparms (key.args, TYPE_ARG_TYPES (m_type))
 		&& get_coroutine_discriminator (m_inner) == key.coro_disc
 		/* Reject if old is a "C" builtin and new is not "C".
@@ -12150,6 +12167,20 @@ check_mergeable_decl (merge_kind mk, tree decl, tree ovl, merge_key const &key)
 			   == key.ret))
 		found = match;
 	    }
+	  /* With -freflection, typedef struct { } A is now represented the same
+	     as typedef struct A_ { } A except the TYPE_DECL for A_ is invisible
+	     to name lookup, so we won't be able to find and match it directly.
+	     But we will find the in-TU A (m_inner), through which we can obtain
+	     the in-TU A_ when d_inner is the streamed-in A_.  */
+	  else if (flag_reflection
+		   && TYPE_DECL_WAS_UNNAMED (d_inner)
+		   && DECL_ORIGINAL_TYPE (m_inner))
+	    {
+	      tree orig = TYPE_NAME (DECL_ORIGINAL_TYPE (m_inner));
+	      if (TYPE_DECL_WAS_UNNAMED (orig)
+		  && DECL_NAME (orig) == DECL_NAME (d_inner))
+		found = orig;
+	    }
 	  break;
 
 	default:
@@ -12234,7 +12265,9 @@ trees_in::key_mergeable (int tag, merge_kind mk, tree decl, tree inner,
       unsigned code = u ();
       key.ref_q = cp_ref_qualifier ((code >> 0) & 3);
       key.coro_disc = (code >> 2) & 3;
-      key.index = code >> 4;
+      key.iobj_p = (code >> 4) & 1;
+      key.xobj_p = (code >> 5) & 1;
+      key.index = code >> 6;
 
       if (mk == MK_enum)
 	key.ret = tree_node ();
@@ -12509,8 +12542,13 @@ trees_in::check_abi_tags (tree existing, tree decl, tree &eattr, tree &dattr)
       if (dtags)
 	dtags = TREE_VALUE (dtags);
 
-      /* We only error if mangling wouldn't consider the tags equivalent.  */
-      if (!equal_abi_tags (etags, dtags))
+      /* We only error if mangling wouldn't consider the tags equivalent.
+	 Since tags might have been inherited during mangling, ignore
+	 inherited tags if there's a mangled-ness mismatch.  */
+      bool ignore_inherited_p
+	= (DECL_ASSEMBLER_NAME_SET_P (STRIP_TEMPLATE (existing))
+	   != DECL_ASSEMBLER_NAME_SET_P (STRIP_TEMPLATE (decl)));
+      if (!equal_abi_tags (etags, dtags, ignore_inherited_p))
 	{
 	  auto_diagnostic_group d;
 	  if (dtags)
@@ -12588,7 +12626,7 @@ trees_in::is_matching_decl (tree existing, tree decl, bool is_typedef)
 	  goto mismatch;
 	}
 
-      tree e_type = TREE_TYPE (e_inner);
+      tree& e_type = TREE_TYPE (e_inner);
       tree d_type = TREE_TYPE (d_inner);
 
       for (tree e_args = TYPE_ARG_TYPES (e_type),
@@ -12627,18 +12665,13 @@ trees_in::is_matching_decl (tree existing, tree decl, bool is_typedef)
 	      dump (dumper::MERGE)
 		&& dump ("Propagating instantiated noexcept to %N", existing);
 	      gcc_checking_assert (existing == e_inner);
-	      TREE_TYPE (existing) = d_type;
+	      e_type = build_exception_variant (e_type, d_spec);
 
 	      /* Propagate to existing clones.  */
 	      tree clone;
 	      FOR_EACH_CLONE (clone, existing)
-		{
-		  if (TREE_TYPE (clone) == e_type)
-		    TREE_TYPE (clone) = d_type;
-		  else
-		    TREE_TYPE (clone)
-		      = build_exception_variant (TREE_TYPE (clone), d_spec);
-		}
+		TREE_TYPE (clone)
+		  = build_exception_variant (TREE_TYPE (clone), d_spec);
 	    }
 	}
       else if (!DECL_MAYBE_DELETED (d_inner)
@@ -12661,7 +12694,7 @@ trees_in::is_matching_decl (tree existing, tree decl, bool is_typedef)
 	  gcc_checking_assert (existing == e_inner);
 	  FNDECL_USED_AUTO (existing) = true;
 	  DECL_SAVED_AUTO_RETURN_TYPE (existing) = TREE_TYPE (e_type);
-	  TREE_TYPE (existing) = change_return_type (TREE_TYPE (d_type), e_type);
+	  e_type = change_return_type (TREE_TYPE (d_type), e_type);
 	}
       else if (d_undeduced && !e_undeduced)
 	/* EXISTING was deduced, leave it alone.  */;
@@ -13702,9 +13735,8 @@ trees_in::read_class_def (tree defn, tree maybe_template)
 		{
 		  CLASSTYPE_BEFRIENDING_CLASSES (type_dup)
 		    = CLASSTYPE_BEFRIENDING_CLASSES (type);
-		  if (!ANON_AGGR_TYPE_P (type))
-		    CLASSTYPE_TYPEINFO_VAR (type_dup)
-		      = CLASSTYPE_TYPEINFO_VAR (type);
+		  SET_CLASSTYPE_TYPEINFO_VAR (type_dup,
+					      CLASSTYPE_TYPEINFO_VAR (type));
 		}
 	      for (tree v = type; v; v = TYPE_NEXT_VARIANT (v))
 		TYPE_LANG_SPECIFIC (v) = ls;
@@ -13745,7 +13777,7 @@ trees_in::read_class_def (tree defn, tree maybe_template)
 		       to the as-base FIELD_DECL copy.  */
 		    gcc_checking_assert (ANON_AGGR_TYPE_FIELD (anon_type));
 		  else
-		    ANON_AGGR_TYPE_FIELD (anon_type) = decl;
+		    SET_ANON_AGGR_TYPE_FIELD (anon_type, decl);
 		}
 
 	      if (TREE_CODE (decl) == USING_DECL
@@ -15222,14 +15254,22 @@ void
 depset::hash::add_dependent_adl_entities (tree expr)
 {
   gcc_checking_assert (!is_key_order ());
+
+  /* This is not needed for header units where everything is
+     visible to name lookup, nothing is discarded.  */
+  if (header_module_p ())
+    return;
+
   if (TREE_CODE (current->get_entity ()) != TEMPLATE_DECL)
     return;
 
   dep_adl_info info;
+  auto_vec<tree, 3> args;
   switch (TREE_CODE (expr))
     {
     case CALL_EXPR:
-      if (!KOENIG_LOOKUP_P (expr))
+      if (!KOENIG_LOOKUP_P (expr)
+	  || !type_dependent_expression_p_push (expr))
 	return;
       info.name = CALL_EXPR_FN (expr);
       if (!info.name)
@@ -15241,7 +15281,7 @@ depset::hash::add_dependent_adl_entities (tree expr)
       if (!identifier_p (info.name))
 	info.name = OVL_NAME (info.name);
       for (int ix = 0; ix < call_expr_nargs (expr); ix++)
-	vec_safe_push (info.args, CALL_EXPR_ARG (expr, ix));
+	args.safe_push (CALL_EXPR_ARG (expr, ix));
       break;
 
     case LE_EXPR:
@@ -15278,10 +15318,12 @@ depset::hash::add_dependent_adl_entities (tree expr)
     case TRUTH_ANDIF_EXPR:
     case TRUTH_ORIF_EXPR:
     overloadable_expr:
+      if (!type_dependent_expression_p_push (expr))
+	return;
       info.name = ovl_op_identifier (TREE_CODE (expr));
       gcc_checking_assert (tree_operand_length (expr) == 2);
-      vec_safe_push (info.args, TREE_OPERAND (expr, 0));
-      vec_safe_push (info.args, TREE_OPERAND (expr, 1));
+      args.safe_push (TREE_OPERAND (expr, 0));
+      args.safe_push (TREE_OPERAND (expr, 1));
       break;
 
     default:
@@ -15290,11 +15332,21 @@ depset::hash::add_dependent_adl_entities (tree expr)
 
   /* If all arguments are type-dependent we don't need to do
      anything further, we won't find new entities.  */
-  processing_template_decl_sentinel ptds;
-  ++processing_template_decl;
-  if (!any_type_dependent_arguments_p (info.args))
+  bool all_type_dependent = true;
+  for (tree arg : args)
+    if (!type_dependent_expression_p_push (arg))
+      {
+	all_type_dependent = false;
+	break;
+      }
+  if (all_type_dependent)
     return;
 
+  gcc_checking_assert (!info.args);
+  info.args = make_tree_vector ();
+  for (tree arg : args)
+    vec_safe_push (info.args, arg);
+
   /* We need to defer name lookup until after walking, otherwise
      we get confused by stray TREE_VISITEDs.  */
   dep_adl_entity_list.safe_push (info);
@@ -20510,6 +20562,17 @@ post_load_processing ()
 
       dump () && dump ("Post-load processing of %N", decl);
 
+      if (VAR_P (decl) && DECL_NTTP_OBJECT_P (decl))
+	{
+	  if (!DECL_SIZE (decl))
+	    {
+	      push_to_top_level ();
+	      cp_finish_decl (decl, DECL_INITIAL (decl), false, NULL_TREE, 0);
+	      pop_from_top_level ();
+	    }
+	  continue;
+	}
+
       gcc_checking_assert (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl));
       expand_or_defer_fn (decl);
       /* As in module_state::read_cluster.  */
--- a/src/gcc/cp/name-lookup.cc
+++ b/src/gcc/cp/name-lookup.cc
@@ -580,7 +580,8 @@ name_lookup::preserve_state ()
 	    }
 	}
 
-      tentative = previous->tentative;
+      /* We deliberately avoid instantiation during tentative ADL.  */
+      gcc_checking_assert (!previous->tentative);
 
       /* Unmark the outer partial lookup.  */
       if (previous->deduping)
--- a/src/gcc/cp/parser.cc
+++ b/src/gcc/cp/parser.cc
@@ -16063,6 +16063,7 @@ cp_build_range_for_decls (location_t loc, tree range_expr, tree *end_p,
 		  DECL_INTERFACE_KNOWN (range_temp) = 1;
 		  DECL_DECLARED_CONSTEXPR_P (range_temp) = 1;
 		  TREE_READONLY (range_temp) = 1;
+		  DECL_IGNORED_P (range_temp) = 1;
 		}
 	    }
 	  else
@@ -16092,6 +16093,7 @@ cp_build_range_for_decls (location_t loc, tree range_expr, tree *end_p,
       TREE_STATIC (begin) = 1;
       DECL_DECLARED_CONSTEXPR_P (begin) = 1;
       TREE_READONLY (begin) = 1;
+      DECL_IGNORED_P (begin) = 1;
     }
   pushdecl (begin);
   cp_finish_decl (begin, begin_expr,
@@ -34723,7 +34725,7 @@ cp_parser_constraint_expression (cp_parser *parser)
 {
   processing_constraint_expression_sentinel parsing_constraint;
   ++processing_template_decl;
-  cp_expr expr = cp_parser_binary_expression (parser, false, true,
+  cp_expr expr = cp_parser_binary_expression (parser, false, false,
 					      PREC_NOT_OPERATOR, NULL);
   --processing_template_decl;
   if (check_for_bare_parameter_packs (expr))
--- a/src/gcc/cp/pt.cc
+++ b/src/gcc/cp/pt.cc
@@ -7439,18 +7439,22 @@ invalid_tparm_referent_p (tree type, tree expr, tsubst_flags_t complain)
 			"because %qD has no linkage", expr, type, decl);
 	    return true;
 	  }
-	/* C++17: For a non-type template-parameter of reference or pointer
-	   type, the value of the constant expression shall not refer to (or
-	   for a pointer type, shall not be the address of):
-	   * a subobject (4.5),
-	   * a temporary object (15.2),
-	   * a string literal (5.13.5),
-	   * the result of a typeid expression (8.2.8), or
-	   * a predefined __func__ variable (11.4.1).  */
+	/* For a constant template parameter of reference or pointer type,
+	   or for each non-static data member of reference or pointer type
+	   in a constant template parameter of class type or subobject thereof,
+	   the reference or pointer value shall not refer or point to
+	   (respectively):
+	   -- a temporary object,
+	   -- a string literal object,
+	   -- the result of a typeid expression,
+	   -- a predefined __func__ variable, or
+	   -- a subobject of one of the above.  */
 	else if (VAR_P (decl) && DECL_ARTIFICIAL (decl)
 		 && !DECL_NTTP_OBJECT_P (decl))
 	  {
-	    gcc_checking_assert (DECL_TINFO_P (decl) || DECL_FNAME_P (decl));
+	    gcc_checking_assert (DECL_TINFO_P (decl)
+				 || DECL_FNAME_P (decl)
+				 || DECL_IGNORED_P (decl));
 	    if (complain & tf_error)
 	      error ("the address of %qD is not a valid template argument",
 		     decl);
@@ -7582,6 +7586,9 @@ get_template_parm_object (tree expr, tree name, bool check_init/*=true*/)
       /* FIXME setting TREE_CONSTANT on refs breaks the back end.  */
       if (!TYPE_REF_P (type))
 	TREE_CONSTANT (decl) = true;
+      pushdecl_top_level (decl);
+      /* The caller must call cp_finish_decl to complete its processing.  */
+      return decl;
     }
 
   pushdecl_top_level_and_finish (decl, expr);
@@ -16079,6 +16086,7 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain,
 		  r = error_mark_node;
 		  break;
 		}
+	      name = copy_node (name);
 	      for (tree& elt : tree_vec_range (name))
 		elt = make_conv_op_name (elt);
 	      variadic_p = true;
@@ -16899,18 +16907,19 @@ tsubst_splice_scope (tree t, tree args, tsubst_flags_t complain, tree in_decl)
   tree r = tsubst (SPLICE_SCOPE_EXPR (t), args, complain, in_decl);
   if (r == error_mark_node)
     return r;
+  const bool type_p = SPLICE_SCOPE_TYPE_P (t);
   if (dependent_splice_p (r))
-    return make_splice_scope (r, SPLICE_SCOPE_TYPE_P (t));
-  if (SPLICE_SCOPE_TYPE_P (t) && ctad_template_p (r))
+    r = make_splice_scope (r, type_p);
+  else if (type_p && ctad_template_p (r))
     r = make_template_placeholder (r);
-  if (SPLICE_SCOPE_TYPE_P (t)
+  if (type_p
       ? !valid_splice_type_p (r)
       : !valid_splice_scope_p (r))
     {
       if (complain & tf_error)
 	{
 	  const location_t loc = EXPR_LOCATION (SPLICE_SCOPE_EXPR (t));
-	  if (SPLICE_SCOPE_TYPE_P (t))
+	  if (type_p)
 	    error_at (loc, "%qE is not usable in a splice type", r);
 	  else
 	    error_at (loc, "%qE is not usable in a splice scope", r);
@@ -16918,6 +16927,10 @@ tsubst_splice_scope (tree t, tree args, tsubst_flags_t complain, tree in_decl)
       return error_mark_node;
     }
 
+  if (type_p)
+    r = cp_build_qualified_type (r, cp_type_quals (t) | cp_type_quals (r),
+				 complain | tf_ignore_bad_quals);
+
   return r;
 }
 
@@ -16957,12 +16970,14 @@ tsubst_splice_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 
   if (SPLICE_EXPR_ADDRESS_P (t))
     {
+      push_deferring_access_checks (dk_no_check);
       if (BASELINK_P (op))
 	op = build_offset_ref (BINFO_TYPE (BASELINK_ACCESS_BINFO (op)), op,
 			       /*address_p=*/true, complain);
       else if (DECL_NONSTATIC_MEMBER_P (op))
 	op = build_offset_ref (DECL_CONTEXT (op), op,
 			       /*address_p=*/true, complain);
+      pop_deferring_access_checks ();
     }
 
   if (outer_automatic_var_p (op))
@@ -18238,12 +18253,12 @@ tsubst_baselink (tree baselink, tree object_type,
    true if the qualified-id will be a postfix-expression in-and-of
    itself; false if more of the postfix-expression follows the
    QUALIFIED_ID.  ADDRESS_P is true if the qualified-id is the operand
-   of "&".  NAME_LOOKUP_P is true if we intend to perform name lookup.  */
+   of "&".  REFLECTING_P is true if this SCOPE_REF is an operand of ^^.  */
 
 static tree
 tsubst_qualified_id (tree qualified_id, tree args,
 		     tsubst_flags_t complain, tree in_decl,
-		     bool done, bool address_p, bool name_lookup_p = true)
+		     bool done, bool address_p, bool reflecting_p = false)
 {
   tree expr;
   tree scope;
@@ -18322,7 +18337,9 @@ tsubst_qualified_id (tree qualified_id, tree args,
       else
 	expr = lookup_qualified_name (scope, expr, LOOK_want::NORMAL, false);
       if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
-		     ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
+		     ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL
+	  /* For ^^T::X, we'll take both types and non-types.  */
+	  && !reflecting_p)
 	{
 	  if (complain & tf_error)
 	    {
@@ -18368,7 +18385,7 @@ tsubst_qualified_id (tree qualified_id, tree args,
 				 expr, input_location);
   /* For ^^S::mem, we do not want to create the dummy object that
      finish_non_static_data_member would give us.  */
-  else if (TYPE_P (scope) && name_lookup_p)
+  else if (TYPE_P (scope) && !reflecting_p)
     {
       expr = (adjust_result_of_qualified_name_lookup
 	      (expr, scope, current_nonlambda_class_type ()));
@@ -23352,10 +23369,13 @@ tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 	     instantiated entities and so no need to tsubst the annotation
 	     attribute and we rely on pointer equality of that.  */
 	  ;
+	else if (kind == REFLECT_BASE)
+	  /* Don't substitute; class_bases_of is never called for a dependent
+	     type.  */;
 	else if (TREE_CODE (h) == SCOPE_REF)
 	  h = tsubst_qualified_id (h, args, complain, in_decl,
 				   /*done=*/true, /*address_p=*/false,
-				   /*name_lookup_p=*/false);
+				   /*reflecting_p=*/true);
 	else
 	  {
 	    /* [expr.reflect] The id-expression of a reflect-expression is
@@ -23900,6 +23920,16 @@ check_non_deducible_conversions (tree parms, const tree *args, unsigned nargs,
 	  conversion **conv_p = convs ? &convs[ia+offset] : NULL;
 	  int lflags = conv_flags (ia, nargs, fn, arg, flags);
 
+	  /* As in add_function_candidate, don't consider conversion to an
+	     unrelated type when LOOKUP_DEFAULTED.  */
+	  if ((flags & LOOKUP_DEFAULTED)
+	      && ia == 0
+	      && (DECL_CONSTRUCTOR_P (fn)
+		  || DECL_ASSIGNMENT_OPERATOR_P (fn))
+	      && !reference_related_p (non_reference (parm),
+				       DECL_CONTEXT (fn)))
+	    return 1;
+
 	  if (check_non_deducible_conversion (parm, arg, strict, lflags,
 					      conv_p, explain_p, noninst_only_p))
 	    return 1;
@@ -33667,6 +33697,7 @@ finish_expansion_stmt (tree expansion_stmt, tree args,
 	      TREE_STATIC (iter) = 1;
 	      DECL_DECLARED_CONSTEXPR_P (iter) = 1;
 	      TREE_READONLY (iter) = 1;
+	      DECL_IGNORED_P (iter) = 1;
 	    }
 	  pushdecl (iter);
 	  cp_finish_decl (iter, iter_init, /*is_constant_init*/false,
--- a/src/gcc/cp/reflect.cc
+++ b/src/gcc/cp/reflect.cc
@@ -74,6 +74,19 @@ init_reflection ()
   pop_namespace ();
 }
 
+/* Ensure the type of DECL is fully resolved by performing return
+   type deduction and deferred noexcept instantiation.  */
+
+static void
+resolve_type_of_reflected_decl (tree decl)
+{
+  /* Quietly calling mark_used in an unevaluated context will perform
+     all necessary checks and instantiations while suppressing constraint
+     unsatisfaction and deletedness diagnostics.  */
+  cp_unevaluated u;
+  mark_used (decl, tf_none);
+}
+
 /* Create a REFLECT_EXPR expression of kind KIND around T.  */
 
 static tree
@@ -210,8 +223,7 @@ get_reflection (location_t loc, tree t, reflect_kind kind/*=REFLECT_UNDEF*/)
       t = resolve_nondeduced_context_or_error (t, tf_warning_or_error);
       /* The argument could have a deduced return type, so we need to
 	 instantiate it now to find out its type.  */
-      if (!mark_used (t))
-	return error_mark_node;
+      resolve_type_of_reflected_decl (t);
       /* Avoid -Wunused-but-set* warnings when a variable or parameter
 	 is just set and reflected.  */
       if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
@@ -238,9 +250,14 @@ get_reflection (location_t loc, tree t, reflect_kind kind/*=REFLECT_UNDEF*/)
 	t = dtor;
     }
 
-  /* Look through block scope externs.  */
+  /* Block-scope externs are invalid here as per the proposed resolution
+     of CWG 3065.  */
   if (VAR_OR_FUNCTION_DECL_P (t) && DECL_LOCAL_DECL_P (t))
-    t = DECL_LOCAL_DECL_ALIAS (t);
+    {
+      error_at (loc, "cannot take the reflection of a block-scope extern %qE",
+		t);
+      return error_mark_node;
+    }
 
   if (t == error_mark_node)
     return error_mark_node;
@@ -278,7 +295,7 @@ maybe_strip_typedefs (tree t)
    DECL_ARGUMENTS (DECL_CONTEXT (parm)) chain.  Return corresponding
    PARM_DECL which is in the chain.  */
 
-static tree
+tree
 maybe_update_function_parm (tree parm)
 {
   if (!OLD_PARM_DECL_P (parm))
@@ -2534,6 +2551,7 @@ has_type (tree r, reflect_kind kind)
     {
       if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
 	return false;
+      resolve_type_of_reflected_decl (r);
       if (undeduced_auto_decl (r))
 	return false;
       return true;
@@ -5532,6 +5550,8 @@ eval_can_substitute (location_t loc, const constexpr_ctx *ctx,
       if (fn == error_mark_node)
 	return boolean_false_node;
       fn = resolve_nondeduced_context_or_error (fn, tf_none);
+      fn = MAYBE_BASELINK_FUNCTIONS (fn);
+      resolve_type_of_reflected_decl (fn);
       if (fn == error_mark_node || undeduced_auto_decl (fn))
 	return boolean_false_node;
       return boolean_true_node;
@@ -6759,8 +6779,12 @@ members_of_representable_p (tree c, tree r)
 	  || TREE_CODE (r) == FIELD_DECL
 	  || TREE_CODE (r) == NAMESPACE_DECL)
 	return true;
-      if (VAR_OR_FUNCTION_DECL_P (r) && !undeduced_auto_decl (r))
-	return true;
+      if (VAR_OR_FUNCTION_DECL_P (r))
+	{
+	  resolve_type_of_reflected_decl (r);
+	  if (!undeduced_auto_decl (r))
+	    return true;
+	}
     }
   return false;
 }
@@ -7453,6 +7477,10 @@ extract_ref (location_t loc, const constexpr_ctx *ctx, tree T, tree r,
     {
       if (TYPE_REF_P (type))
 	type = TREE_TYPE (type);
+      if (FUNC_OR_METHOD_TYPE_P (type)
+	  || (TREE_CODE (type) == ARRAY_TYPE
+	      && TYPE_DOMAIN (type) == NULL_TREE))
+	return error_mark_node;
       type = build_cplus_array_type (type, NULL_TREE);
       return build_pointer_type (type);
     };
@@ -7462,7 +7490,11 @@ extract_ref (location_t loc, const constexpr_ctx *ctx, tree T, tree r,
     {
       /* The wording is saying that U is the type of r.  */
       tree U = TREE_TYPE (r);
-      if (is_convertible (adjust_type (U), adjust_type (T))
+      tree adju = adjust_type (U);
+      tree adjt = adjust_type (T);
+      if (adju != error_mark_node
+	  && adjt != error_mark_node
+	  && is_convertible (adju, adjt)
 	  && (!var_p || is_constant_expression (r)))
 	{
 	  if (TYPE_REF_P (TREE_TYPE (r)))
@@ -7851,6 +7883,11 @@ process_metafunction (const constexpr_ctx *ctx, tree fun, tree call,
 	if (*jump_target || *non_constant_p)
 	  return NULL_TREE;
 	ht = REFLECT_EXPR_HANDLE (info);
+	if (error_operand_p (ht))
+	  {
+	    *non_constant_p = true;
+	    return NULL_TREE;
+	  }
 	if (METAFN_KIND_ARG (minfo, argno) == METAFN_KIND_ARG_TINFO
 	    && eval_is_type (ht) != boolean_true_node)
 	  return throw_exception_nontype (loc, ctx, fun, non_constant_p,
@@ -8561,47 +8598,26 @@ splice (tree refl)
   return refl;
 }
 
-/* A walker for consteval_only_p.  It cannot be a lambda, because we
-   have to call this recursively, sigh.  */
+/* A cache of the known boolean result of consteval_only_p_walker::walk
+   for class types.  */
 
-static tree
-consteval_only_type_r (tree *tp, int *walk_subtrees, void *data)
-{
-  tree t = *tp;
-  /* Types can contain themselves recursively, hence this.  */
-  auto visited = static_cast<hash_set<tree> *>(data);
+static GTY((cache)) type_tree_cache_map *consteval_only_class_cache;
 
-  if (!TYPE_P (t))
-    return NULL_TREE;
-
-  if (REFLECTION_TYPE_P (t))
-    return t;
-
-  if (typedef_variant_p (t))
-    /* Tell cp_walk_subtrees to look through typedefs.  */
-    *walk_subtrees = 2;
-
-  if (RECORD_OR_UNION_TYPE_P (t))
-    {
-      /* Don't walk template arguments; A<info>::type isn't a consteval-only
-	 type.  */
-      *walk_subtrees = 0;
-      /* So we have to walk the fields manually.  */
-      for (tree member = TYPE_FIELDS (t);
-	   member; member = DECL_CHAIN (member))
-	if (TREE_CODE (member) == FIELD_DECL)
-	  if (tree r = cp_walk_tree (&TREE_TYPE (member),
-				     consteval_only_type_r, visited, visited))
-	    return r;
-    }
+struct consteval_only_p_walker
+{
+  /* The set of class types we've seen.  */
+  hash_set<tree> class_seen;
+  /* The number of class types we're recursively inside.  */
+  int class_depth = 0;
+  /* True if we've optimistically assumed an already-seen
+     consteval-unknown class type is not consteval.  */
+  bool optimistic_p = false;
 
-  return NULL_TREE;
-}
+  tristate walk (tree);
+};
 
-/* True if T is a consteval-only type as per [basic.types.general]:
-   "A type is consteval-only if it is either std::meta::info or a type
-   compounded from a consteval-only type", or something that has
-   a consteval-only type.  */
+/* True if T is a consteval-only type as per [basic.types.general]/12,
+   or is a declaration with such a type, or a TREE_VEC thereof.  */
 
 bool
 consteval_only_p (tree t)
@@ -8612,7 +8628,7 @@ consteval_only_p (tree t)
   if (!TYPE_P (t))
     t = TREE_TYPE (t);
 
-  if (!t)
+  if (!t || t == error_mark_node)
     return false;
 
   if (TREE_CODE (t) == TREE_VEC)
@@ -8627,16 +8643,86 @@ consteval_only_p (tree t)
   if (dependent_type_p (t))
     return false;
 
-  /* We need the complete type otherwise we'd have no fields for class
-     templates and thus come up with zilch for things like
-       template<typename T>
-       struct X : T { };
-     which could be consteval-only, depending on T.  */
-  t = complete_type (t);
+  consteval_only_p_walker walker;
+  return walker.walk (t).is_true ();
+}
+
+/* Recursive workhorse of consteval_only_p.  Returns true if T is definitely
+   consteval-only, false if it's definitely not, and unknown if we saw an
+   incomplete type and therefore don't know.  */
+
+tristate
+consteval_only_p_walker::walk (tree t)
+{
+  if (t == error_mark_node)
+    return false;
+
+  t = TYPE_MAIN_VARIANT (t);
+
+  if (REFLECTION_TYPE_P (t))
+    return true;
+  else if (INDIRECT_TYPE_P (t))
+    return walk (TREE_TYPE (t));
+  else if (TREE_CODE (t) == ARRAY_TYPE)
+    return walk (TREE_TYPE (t));
+  else if (FUNC_OR_METHOD_TYPE_P (t))
+    {
+      tristate r = walk (TREE_TYPE (t));
+      for (tree parm = TYPE_ARG_TYPES (t);
+	   parm != NULL_TREE && parm != void_list_node;
+	   parm = TREE_CHAIN (parm))
+	{
+	  if (r.is_true ())
+	    break;
+	  r = r || walk (TREE_VALUE (parm));
+	}
+      return r;
+    }
+  else if (RECORD_OR_UNION_TYPE_P (t))
+    {
+      if (tree *slot = hash_map_safe_get (consteval_only_class_cache, t))
+	return *slot == boolean_true_node;
+
+      if (!COMPLETE_TYPE_P (t) && LAMBDA_TYPE_P (t))
+	/* Defer until we've definitely gone through prune_lambda_captures.  */
+	return tristate::unknown ();
 
-  /* Classes with std::meta::info members are also consteval-only.  */
-  hash_set<tree> visited;
-  return !!cp_walk_tree (&t, consteval_only_type_r, &visited, &visited);
+      if (class_seen.add (t))
+	{
+	  /* Optimistically assume this already seen consteval-unknown class is
+	     not consteval-only, for sake of mutually recursive classes.  */
+	  optimistic_p = true;
+	  return false;
+	}
+      ++class_depth;
+
+      tristate r = COMPLETE_TYPE_P (t) ? false : tristate::unknown ();
+      for (tree member = TYPE_FIELDS (t); member; member = DECL_CHAIN (member))
+	if (TREE_CODE (member) == FIELD_DECL)
+	  {
+	    r = r || walk (TREE_TYPE (member));
+	    if (r.is_true ())
+	      break;
+	  }
+
+      if (r.is_true ())
+	hash_map_safe_put<hm_ggc> (consteval_only_class_cache,
+				   t, boolean_true_node);
+      else if (r.is_false ()
+	       /* The optimistic assumption above is at odds with caching
+		  'false' results for a nested class type.  */
+	       && (class_depth == 1 || !optimistic_p))
+	hash_map_safe_put<hm_ggc> (consteval_only_class_cache,
+				   t, boolean_false_node);
+
+      --class_depth;
+      return r;
+    }
+  else if (TYPE_PTRMEM_P (t))
+    return (walk (TYPE_PTRMEM_CLASS_TYPE (t))
+	    || walk (TYPE_PTRMEM_POINTED_TO_TYPE (t)));
+  else
+    return false;
 }
 
 /* A walker for check_out_of_consteval_use_r.  It cannot be a lambda, because
@@ -8655,6 +8741,8 @@ check_out_of_consteval_use_r (tree *tp, int *walk_subtrees, void *pset)
       || TREE_CODE (t) == INIT_EXPR
       /* And don't recurse on DECL_EXPRs.  */
       || TREE_CODE (t) == DECL_EXPR
+      /* Neither into USING_STMT.  */
+      || TREE_CODE (t) == USING_STMT
       /* Blocks can appear in the TREE_VEC operand of OpenMP
 	 depend/affinity/map/to/from OMP_CLAUSEs when using iterators.  */
       || TREE_CODE (t) == BLOCK)
@@ -8872,11 +8960,16 @@ compare_reflections (tree lhs, tree rhs)
     }
   else if (lkind == REFLECT_ANNOTATION)
     return TREE_VALUE (lhs) == TREE_VALUE (rhs);
+  else if (lkind == REFLECT_BASE)
+    return lhs == rhs;
   else if (TYPE_P (lhs) && TYPE_P (rhs))
     {
-      /* Given "using A = int;", "^^int != ^^A" should hold.  */
-      if (typedef_variant_p (lhs) != typedef_variant_p (rhs))
-	return false;
+      /* Given
+	  using A = int;
+	  using B = int;
+	 ^^int != ^^A and ^^A != ^^B.  */
+      if (typedef_variant_p (lhs) || typedef_variant_p (rhs))
+	return lhs == rhs;
       /* This is for comparing function types.  E.g.,
 	  auto fn() -> int; type_of(^^fn) == ^^auto()->int;  */
       return same_type_p (lhs, rhs);
@@ -8910,7 +9003,8 @@ valid_splice_scope_p (const_tree t)
 {
   return (CLASS_TYPE_P (t)
 	  || TREE_CODE (t) == ENUMERAL_TYPE
-	  || TREE_CODE (t) == NAMESPACE_DECL);
+	  || TREE_CODE (t) == NAMESPACE_DECL
+	  || TREE_CODE (t) == SPLICE_SCOPE);
 }
 
 /* Return true if T is a valid result of the splice in a class member access,
--- a/src/gcc/cp/rtti.cc
+++ b/src/gcc/cp/rtti.cc
@@ -490,7 +490,7 @@ get_tinfo_decl_direct (tree type, tree name, int pseudo_ix)
 
       d = pushdecl_top_level_and_finish (d, NULL_TREE);
       if (CLASS_TYPE_P (type))
-	CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
+	SET_CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type), d);
 
       /* Add decl to the global array of tinfo decls.  */
       vec_safe_push (unemitted_tinfo_decls, d);
--- a/src/gcc/cp/semantics.cc
+++ b/src/gcc/cp/semantics.cc
@@ -4284,7 +4284,7 @@ finish_member_declaration (tree decl)
       && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
     {
       gcc_assert (!ANON_AGGR_TYPE_FIELD (TYPE_MAIN_VARIANT (TREE_TYPE (decl))));
-      ANON_AGGR_TYPE_FIELD (TYPE_MAIN_VARIANT (TREE_TYPE (decl))) = decl;
+      SET_ANON_AGGR_TYPE_FIELD (TYPE_MAIN_VARIANT (TREE_TYPE (decl)), decl);
     }
 
   if (TREE_CODE (decl) == USING_DECL)
--- a/src/gcc/cp/tree.cc
+++ b/src/gcc/cp/tree.cc
@@ -2153,12 +2153,9 @@ strip_typedefs_expr (tree t, bool *remove_attributes, unsigned int flags)
 
     case LAMBDA_EXPR:
     case STMT_EXPR:
-      return t;
-
+    /* ^^alias represents the alias itself, not the underlying type.  */
     case REFLECT_EXPR:
-      /* ^^alias represents the alias itself, not the underlying type.  */
-      if (TYPE_P (REFLECT_EXPR_HANDLE (t)))
-	return t;
+      return t;
 
     default:
       break;
@@ -3856,6 +3853,15 @@ build_min_non_dep_op_overload (enum tree_code op,
 	  tree spaceship_non_dep = (TREE_CODE (non_dep) == CALL_EXPR
 				    ? CALL_EXPR_ARG (non_dep, reversed ? 1 : 0)
 				    : TREE_OPERAND (non_dep, reversed ? 1 : 0));
+
+	  tree int_promotion = NULL_TREE;
+	  if (TREE_CODE (spaceship_non_dep) == NOP_EXPR)
+	    {
+	      gcc_checking_assert (TREE_CODE (non_dep) != CALL_EXPR);
+	      int_promotion = TREE_TYPE (spaceship_non_dep);
+	      spaceship_non_dep = TREE_OPERAND (spaceship_non_dep, 0);
+	    }
+
 	  gcc_checking_assert (TREE_CODE (spaceship_non_dep) == CALL_EXPR);
 	  tree spaceship_op0 = va_arg (p, tree);
 	  tree spaceship_op1 = va_arg (p, tree);
@@ -3878,6 +3884,8 @@ build_min_non_dep_op_overload (enum tree_code op,
 	    {
 	      gcc_checking_assert (COMPARISON_CLASS_P (non_dep)
 				   || TREE_CODE (non_dep) == SPACESHIP_EXPR);
+	      if (int_promotion)
+		op0 = build_nop (int_promotion, op0);
 	      if (reversed)
 		std::swap (op0, op1);
 	      return build_min_non_dep (TREE_CODE (non_dep), non_dep, op0, op1);
@@ -4515,20 +4523,7 @@ cp_tree_equal (tree t1, tree t2)
       return true;
 
     case REFLECT_EXPR:
-      {
-	if (REFLECT_EXPR_KIND (t1) != REFLECT_EXPR_KIND (t2))
-	  return false;
-	tree h1 = REFLECT_EXPR_HANDLE (t1);
-	tree h2 = REFLECT_EXPR_HANDLE (t2);
-	if (!cp_tree_equal (h1, h2))
-	  return false;
-	/* ^^alias represents the alias itself, not the underlying type.  */
-	if (TYPE_P (h1)
-	    && (typedef_variant_p (h1) || typedef_variant_p (h2))
-	    && TYPE_NAME (h1) != TYPE_NAME (h2))
-	  return false;
-	return true;
-      }
+      return compare_reflections (t1, t2);
 
     default:
       break;
--- a/src/gcc/cp/typeck.cc
+++ b/src/gcc/cp/typeck.cc
@@ -4162,7 +4162,8 @@ cp_build_array_ref (location_t loc, tree array, tree idx,
     return error_mark_node;
 
   /* 0[array] */
-  if (TREE_CODE (TREE_TYPE (idx)) == ARRAY_TYPE)
+  if (TREE_CODE (TREE_TYPE (idx)) == ARRAY_TYPE
+      && TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE)
     {
       std::swap (array, idx);
 
--- a/src/gcc/d/ChangeLog
+++ b/src/gcc/d/ChangeLog
@@ -1,3 +1,15 @@
+2026-05-05  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	Backported from master:
+	2026-05-05  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	PR d/125089
+	* types.cc (finish_aggregate_mode): Explicitly set TYPE_MODE of
+	non-POD types here.
+	(finish_aggregate_type): Propagate TREE_ADDRESSABLE to all variants.
+	(TypeVisitor::visit (TypeStruct *)): Set TREE_ADDRESSABLE before
+	visiting struct members.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/d/types.cc
+++ b/src/gcc/d/types.cc
@@ -593,7 +593,12 @@ finish_aggregate_mode (tree type)
 	return;
     }
 
-  compute_record_mode (type);
+  /* Force mode of non-trivially copyable structs to be BLKmode, preventing it
+     from being returned in a register.  */
+  if (TREE_ADDRESSABLE (type))
+    SET_TYPE_MODE (type, BLKmode);
+  else
+    compute_record_mode (type);
 
   /* Propagate computed mode to all variants of this aggregate type.  */
   for (tree t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
@@ -715,6 +720,7 @@ finish_aggregate_type (unsigned structsize, unsigned alignsize, tree type)
       TYPE_PACKED (t) = TYPE_PACKED (type);
       SET_TYPE_ALIGN (t, TYPE_ALIGN (type));
       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (type);
+      TREE_ADDRESSABLE (t) = TREE_ADDRESSABLE (type);
     }
 
   /* Complete any other forward-referenced fields of this aggregate type.  */
@@ -1236,6 +1242,12 @@ public:
     TYPE_LANG_SPECIFIC (t->ctype) = build_lang_type (t);
     TYPE_CXX_ODR_P (t->ctype) = 1;
 
+    /* For structs with a user defined postblit, copy constructor, or a
+       destructor, also set TREE_ADDRESSABLE on the type and all variants.
+       This will make the struct be passed around by reference.  */
+    if (!dmd::isPOD (t->sym))
+      TREE_ADDRESSABLE (t->ctype) = 1;
+
     if (t->sym->members)
       {
 	/* Must set up the overall size and alignment before determining
@@ -1257,18 +1269,6 @@ public:
 	build_type_decl (t->ctype, t->sym);
 	apply_user_attributes (t->sym, t->ctype);
       }
-
-    /* For structs with a user defined postblit, copy constructor, or a
-       destructor, also set TREE_ADDRESSABLE on the type and all variants.
-       This will make the struct be passed around by reference.  */
-    if (!dmd::isPOD (t->sym))
-      {
-	for (tree tv = t->ctype; tv != NULL_TREE; tv = TYPE_NEXT_VARIANT (tv))
-	  {
-	    TREE_ADDRESSABLE (tv) = 1;
-	    SET_TYPE_MODE (tv, BLKmode);
-	  }
-      }
   }
 
   /* Build a class type.  Whereas structs are value types, classes are
--- a/src/gcc/fortran/ChangeLog
+++ b/src/gcc/fortran/ChangeLog
@@ -1,3 +1,139 @@
+2026-06-09  Paul Thomas  <pault@gcc.gnu.org>
+
+	Backported from master:
+	2026-06-09  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/125669
+	* decl.cc (gfc_get_pdt_instance): If the bound expressions for
+	and array component, of the length expression for a character
+	component, gave simplified to a constant, do not set attributes
+	pdt_array and pdt_string respectively.
+
+2026-06-08  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-06-06  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/125606
+	* trans-intrinsic.cc (gfc_conv_intrinsic_loc): When the argument
+	of LOC() is not scalar or known to be simply contiguous, simply
+	take the address of the argument array's first element.
+
+2026-06-01  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-05-29  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/125393
+	* interface.cc (get_expr_storage_size): Additionally return
+	character length.
+	(gfc_compare_actual_formal): When the formal is a scalar character
+	variable, use character lengths, not array storage size for check.
+
+2026-05-30  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-30  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/105582
+	* trans-decl.cc (get_proc_pointer_decl): Add FL_LABEL check to
+	route BLOCK-construct procedure pointers to gfc_add_decl_to_function
+	rather than gfc_add_decl_to_parent_function.
+
+2026-05-23  Paul Thomas  <pault@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-23  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/125391
+	* trans.cc (gfc_assignment_finalizer_call): For finalization of
+	allocatable and pointer lhs before assignment, gfc_conv_expr
+	should be used with se.descriptor_only. This avoids implicit of
+	set_factored_descriptor_value by gfc_conv_expr_descriptor.
+
+2026-05-22  Tobias Burnus  <tburnus@baylibre.com>
+
+	Backported from master:
+	2026-05-22  Tobias Burnus  <tburnus@baylibre.com>
+
+	* dump-parse-tree.cc: Fix comment typo.
+	* gfortran.texi: Fix typo.
+	* intrinsic.texi: Likewise.
+	* invoke.texi: Likewise.
+
+2026-05-22  Tobias Burnus  <tburnus@baylibre.com>
+
+	Backported from master:
+	2026-05-22  Tobias Burnus  <tburnus@baylibre.com>
+
+	PR fortran/125416
+	* invoke.texi (fcoarray): Document 'shared'.
+
+2026-05-21  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-20  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/106546
+	* frontend-passes.cc (create_var): Set attr->automatic on
+	new symbol.
+	(create_do_loop): Likewise on iteration variable.
+
+2026-05-20  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-19  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/115260
+	* trans-expr.cc (gfc_conv_subref_array_arg): Pass false to
+	dealloc argument of gfc_trans_scalar_assign if we are
+	converting a g77-style argument.
+
+2026-05-19  Andre Vehreschild  <vehre@gcc.gnu.org>
+
+	Backported from master:
+	2026-04-29  Andre Vehreschild  <vehre@gcc.gnu.org>
+
+	PR fortran/125021
+	* coarray.cc (check_add_new_comp_handle_array): Prefix internal
+	symbols by two underscores.
+	(create_get_callback): Same.
+	(create_allocated_callback): Same.
+	(create_send_callback): Same.
+
+2026-05-13  Mikael Morin  <mikael@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-07  Mikael Morin  <mikael@gcc.gnu.org>
+
+	PR fortran/125192
+	PR fortran/125198
+	* trans-array.cc (gfc_conv_expr_descriptor): Add bounds checking
+	code to the outermost loop's preliminary block.
+
+2026-05-13  Mikael Morin  <mikael@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-07  Mikael Morin  <mikael@gcc.gnu.org>
+
+	* trans-array.cc (trans_array_bound_check): Replace references
+	to SE->PRE with references to the new argument BLOCK.  Remove
+	argument SE.
+	(array_bound_check_elemental): Likewise.  Update caller.
+	(conv_array_index_offset): Update caller.
+	(gfc_conv_expr_descriptor): Update caller.
+
+2026-05-13  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-05-08  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/111952
+	PR fortran/125059
+	* trans-decl.cc (gfc_finish_var_decl): Remove bogus code forcing
+	a DT variable with DTIO as static.
+	* trans-io.cc (gfc_build_io_library_fndecls): Fix fnspec attribute.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/fortran/coarray.cc
+++ b/src/gcc/fortran/coarray.cc
@@ -620,7 +620,7 @@ check_add_new_comp_handle_array (gfc_expr *e, gfc_symbol *type,
 	  c->expr2->ref->u.ar.codimen = 1;
 	  c->expr2->ref->u.ar.dimen_type[0] = DIMEN_ELEMENT;
 	  caller_image
-	    = gfc_find_symtree_in_proc ("caller_image", add_data->ns);
+	    = gfc_find_symtree_in_proc ("__caller_image", add_data->ns);
 	  gcc_assert (caller_image);
 	  c->expr2->ref->u.ar.start[0] = gfc_get_variable_expr (caller_image);
 	  c->expr2->ref->u.ar.start[0]->where = e->where;
@@ -866,16 +866,16 @@ create_get_callback (gfc_expr *expr)
   (*argptr)->sym = nsym;                                                       \
   argptr = &(*argptr)->next
 
-  name = xasprintf ("add_data_%s_%s_%d", mname, tname, caf_sym_cnt);
+  name = xasprintf ("__add_data_%s_%s_%d", mname, tname, caf_sym_cnt);
   ADD_ARG (name, get_data, BT_DERIVED, 0, INTENT_IN);
   gfc_commit_symbol (get_data);
   free (name);
 
-  ADD_ARG ("caller_image", caller_image, BT_INTEGER, gfc_default_integer_kind,
+  ADD_ARG ("__caller_image", caller_image, BT_INTEGER, gfc_default_integer_kind,
 	   INTENT_IN);
   gfc_commit_symbol (caller_image);
 
-  ADD_ARG ("buffer", buffer, expr->ts.type, expr->ts.kind, INTENT_INOUT);
+  ADD_ARG ("__buffer", buffer, expr->ts.type, expr->ts.kind, INTENT_INOUT);
   buffer->ts = expr->ts;
   if (expr_rank)
     {
@@ -915,7 +915,7 @@ create_get_callback (gfc_expr *expr)
     }
   gfc_commit_symbol (buffer);
 
-  ADD_ARG ("free_buffer", free_buffer, BT_LOGICAL, gfc_default_logical_kind,
+  ADD_ARG ("__free_buffer", free_buffer, BT_LOGICAL, gfc_default_logical_kind,
 	   INTENT_OUT);
   gfc_commit_symbol (free_buffer);
 
@@ -1115,15 +1115,16 @@ create_allocated_callback (gfc_expr *expr)
   (*argptr)->sym = nsym;                                                       \
   argptr = &(*argptr)->next
 
-  name = xasprintf ("add_data_%s_%s_%d", mname, tname, ++caf_sym_cnt);
+  name = xasprintf ("__add_data_%s_%s_%d", mname, tname, ++caf_sym_cnt);
   ADD_ARG (name, add_data, BT_DERIVED, 0, INTENT_IN);
   gfc_commit_symbol (add_data);
   free (name);
-  ADD_ARG ("caller_image", caller_image, BT_INTEGER, gfc_default_integer_kind,
+  ADD_ARG ("__caller_image", caller_image, BT_INTEGER, gfc_default_integer_kind,
 	   INTENT_IN);
   gfc_commit_symbol (caller_image);
 
-  ADD_ARG ("result", result, BT_LOGICAL, gfc_default_logical_kind, INTENT_OUT);
+  ADD_ARG ("__result", result, BT_LOGICAL, gfc_default_logical_kind,
+	   INTENT_OUT);
   gfc_commit_symbol (result);
 
   // ADD_ARG (expr->symtree->name, base, BT_VOID, INTENT_IN);
@@ -1260,12 +1261,12 @@ create_send_callback (gfc_expr *expr, gfc_expr *rhs)
   (*argptr)->sym = nsym;                                                       \
   argptr = &(*argptr)->next
 
-  name = xasprintf ("add_send_data_%s_%s_%d", mname, tname, caf_sym_cnt);
+  name = xasprintf ("__add_send_data_%s_%s_%d", mname, tname, caf_sym_cnt);
   ADD_ARG (name, send_data, BT_DERIVED, 0, INTENT_IN);
   gfc_commit_symbol (send_data);
   free (name);
 
-  ADD_ARG ("caller_image", caller_image, BT_INTEGER, gfc_default_integer_kind,
+  ADD_ARG ("__caller_image", caller_image, BT_INTEGER, gfc_default_integer_kind,
 	   INTENT_IN);
   gfc_commit_symbol (caller_image);
 
@@ -1279,7 +1280,7 @@ create_send_callback (gfc_expr *expr, gfc_expr *rhs)
   argptr = &(*argptr)->next;
   gfc_commit_symbol (base);
 
-  ADD_ARG ("buffer", buffer, rhs->ts.type, rhs->ts.kind, INTENT_IN);
+  ADD_ARG ("__buffer", buffer, rhs->ts.type, rhs->ts.kind, INTENT_IN);
   buffer->ts = rhs->ts;
   if (rhs->rank)
     {
--- a/src/gcc/fortran/decl.cc
+++ b/src/gcc/fortran/decl.cc
@@ -4472,6 +4472,7 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym,
       if (c1->as && c1->as->type == AS_EXPLICIT)
 	{
 	  bool pdt_array = false;
+	  bool all_constant = true;
 
 	  /* Are the bounds of the array parameterized?  */
 	  for (i = 0; i < c1->as->rank; i++)
@@ -4494,15 +4495,19 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym,
 		gfc_replace_expr (c2->as->lower[i], e);
 	      else
 		gfc_free_expr (e);
+	      if (c2->as->lower[i]->expr_type != EXPR_CONSTANT)
+		all_constant = false;
 	      e = gfc_copy_expr (c1->as->upper[i]);
 	      gfc_insert_kind_parameter_exprs (e);
 	      if (gfc_simplify_expr (e, 1))
 		gfc_replace_expr (c2->as->upper[i], e);
 	      else
 		gfc_free_expr (e);
+	      if (c2->as->upper[i]->expr_type != EXPR_CONSTANT)
+		all_constant = false;
 	    }
 
-	  c2->attr.pdt_array = 1;
+	  c2->attr.pdt_array = all_constant ? 0 : 1;
 	  if (c1->initializer)
 	    {
 	      c2->initializer = gfc_copy_expr (c1->initializer);
@@ -4523,7 +4528,8 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym,
 	    gfc_replace_expr (c2->ts.u.cl->length, e);
 	  else
 	    gfc_free_expr (e);
-	  c2->attr.pdt_string = 1;
+	  if (c2->ts.u.cl->length->expr_type != EXPR_CONSTANT)
+	    c2->attr.pdt_string = 1;
 	}
 
       /* Recurse into this function for PDT components.  */
--- a/src/gcc/fortran/dump-parse-tree.cc
+++ b/src/gcc/fortran/dump-parse-tree.cc
@@ -4120,8 +4120,8 @@ gfc_dump_parse_tree (gfc_namespace *ns, FILE *file)
   show_namespace (ns);
 }
 
-/* This part writes BIND(C) prototypes and declatations, and prototypes
-   for EXTERNAL preocedures, for use in a C programs.  */
+/* This part writes BIND(C) prototypes and declarations, and prototypes
+   for EXTERNAL procedures, for use in a C programs.  */
 
 static void write_interop_decl (gfc_symbol *);
 static void write_proc (gfc_symbol *, bool);
--- a/src/gcc/fortran/frontend-passes.cc
+++ b/src/gcc/fortran/frontend-passes.cc
@@ -849,6 +849,7 @@ create_var (gfc_expr * e, const char *vname)
   symbol->attr.referenced = 1;
   symbol->attr.dimension = e->rank > 0;
   symbol->attr.fe_temp = 1;
+  symbol->attr.automatic = 1;
   gfc_commit_symbol (symbol);
 
   result = gfc_get_expr ();
@@ -3808,6 +3809,7 @@ create_do_loop (gfc_expr *start, gfc_expr *end, gfc_expr *step, locus *where,
   symbol->attr.referenced = 1;
   symbol->attr.dimension = 0;
   symbol->attr.fe_temp = 1;
+  symbol->attr.automatic = 1;
   gfc_commit_symbol (symbol);
 
   i = gfc_get_expr ();
--- a/src/gcc/fortran/interface.cc
+++ b/src/gcc/fortran/interface.cc
@@ -3085,7 +3085,7 @@ get_sym_storage_size (gfc_symbol *sym, bool *size_known)
    units of the actual argument up to the end of the array.  */
 
 static unsigned long
-get_expr_storage_size (gfc_expr *e, bool *size_known)
+get_expr_storage_size (gfc_expr *e, bool *size_known, long int *charlen)
 {
   int i;
   long int strlen, elements;
@@ -3094,6 +3094,7 @@ get_expr_storage_size (gfc_expr *e, bool *size_known)
   gfc_ref *ref;
 
   *size_known = false;
+  *charlen = -1;
 
   if (e == NULL)
     return 0;
@@ -3109,6 +3110,7 @@ get_expr_storage_size (gfc_expr *e, bool *size_known)
 	strlen = e->value.character.length;
       else
 	return 0;
+      *charlen = strlen;
     }
   else
     strlen = 1; /* Length per element.  */
@@ -3365,6 +3367,7 @@ gfc_compare_actual_formal (gfc_actual_arglist **ap, gfc_formal_arglist *formal,
   gfc_formal_arglist *f;
   int i, n, na;
   unsigned long actual_size, formal_size;
+  long int charlen;
   bool full_array = false;
   gfc_array_ref *actual_arr_ref;
   gfc_array_spec *fas, *aas;
@@ -3681,9 +3684,17 @@ gfc_compare_actual_formal (gfc_actual_arglist **ap, gfc_formal_arglist *formal,
       if (a->expr->expr_type == EXPR_NULL && a->expr->ts.type == BT_UNKNOWN)
 	goto skip_size_check;
 
-      actual_size = get_expr_storage_size (a->expr, &actual_size_known);
+      actual_size = get_expr_storage_size (a->expr, &actual_size_known, &charlen);
       formal_size = get_sym_storage_size (f->sym, &formal_size_known);
 
+      /* If the formal is a scalar character variable, use the charlen of the
+	 actual.  */
+      if (actual_size_known && formal_size_known && charlen >= 0
+	  && a->expr->ts.type == BT_CHARACTER
+	  && f->sym->attr.flavor != FL_PROCEDURE
+	  && !f->sym->attr.dimension)
+	actual_size = charlen;
+
       if (actual_size_known && formal_size_known
 	  && actual_size != formal_size
 	  && a->expr->ts.type == BT_CHARACTER
--- a/src/gcc/fortran/trans-array.cc
+++ b/src/gcc/fortran/trans-array.cc
@@ -3910,7 +3910,7 @@ abridged_ref_name (gfc_expr * expr, gfc_array_ref * ar)
 /* Generate code to perform an array index bound check.  */
 
 static tree
-trans_array_bound_check (gfc_se * se, gfc_ss *ss, tree index, int n,
+trans_array_bound_check (stmtblock_t *block, gfc_ss *ss, tree index, int n,
 			 locus * where, bool check_upper,
 			 const char *compname = NULL)
 {
@@ -3927,7 +3927,7 @@ trans_array_bound_check (gfc_se * se, gfc_ss *ss, tree index, int n,
 
   descriptor = ss->info->data.array.descriptor;
 
-  index = gfc_evaluate_now (index, &se->pre);
+  index = gfc_evaluate_now (index, block);
 
   /* We find a name for the error message.  */
   name = ss->info->expr->symtree->n.sym->name;
@@ -3961,13 +3961,13 @@ trans_array_bound_check (gfc_se * se, gfc_ss *ss, tree index, int n,
 
       fault = fold_build2_loc (input_location, LT_EXPR, logical_type_node,
 			       index, tmp_lo);
-      gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
+      gfc_trans_runtime_check (true, false, fault, block, where, msg,
 			       fold_convert (long_integer_type_node, index),
 			       fold_convert (long_integer_type_node, tmp_lo),
 			       fold_convert (long_integer_type_node, tmp_up));
       fault = fold_build2_loc (input_location, GT_EXPR, logical_type_node,
 			       index, tmp_up);
-      gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
+      gfc_trans_runtime_check (true, false, fault, block, where, msg,
 			       fold_convert (long_integer_type_node, index),
 			       fold_convert (long_integer_type_node, tmp_lo),
 			       fold_convert (long_integer_type_node, tmp_up));
@@ -3986,7 +3986,7 @@ trans_array_bound_check (gfc_se * se, gfc_ss *ss, tree index, int n,
 
       fault = fold_build2_loc (input_location, LT_EXPR, logical_type_node,
 			       index, tmp_lo);
-      gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
+      gfc_trans_runtime_check (true, false, fault, block, where, msg,
 			       fold_convert (long_integer_type_node, index),
 			       fold_convert (long_integer_type_node, tmp_lo));
       free (msg);
@@ -4023,7 +4023,7 @@ gfc_expr_contains_impure_fcn (gfc_expr *e)
 /* Generate code for bounds checking for elemental dimensions.  */
 
 static void
-array_bound_check_elemental (gfc_se * se, gfc_ss * ss, gfc_expr * expr)
+array_bound_check_elemental (stmtblock_t *block, gfc_ss * ss, gfc_expr * expr)
 {
   gfc_array_ref *ar;
   gfc_ref *ref;
@@ -4052,8 +4052,8 @@ array_bound_check_elemental (gfc_se * se, gfc_ss * ss, gfc_expr * expr)
 		      gfc_init_se (&indexse, NULL);
 		      gfc_conv_expr_type (&indexse, ar->start[dim],
 					  gfc_array_index_type);
-		      gfc_add_block_to_block (&se->pre, &indexse.pre);
-		      trans_array_bound_check (se, ss, indexse.expr, dim,
+		      gfc_add_block_to_block (block, &indexse.pre);
+		      trans_array_bound_check (block, ss, indexse.expr, dim,
 					       &ar->where,
 					       ar->as->type != AS_ASSUMED_SIZE
 					       || dim < ar->dimen - 1,
@@ -4098,7 +4098,7 @@ conv_array_index_offset (gfc_se * se, gfc_ss * ss, int dim, int i,
 	  /* We've already translated this value outside the loop.  */
 	  index = info->subscript[dim]->info->data.scalar.value;
 
-	  index = trans_array_bound_check (se, ss, index, dim, &ar->where,
+	  index = trans_array_bound_check (&se->pre, ss, index, dim, &ar->where,
 					   ar->as->type != AS_ASSUMED_SIZE
 					   || dim < ar->dimen - 1);
 	  break;
@@ -4127,7 +4127,7 @@ conv_array_index_offset (gfc_se * se, gfc_ss * ss, int dim, int i,
 	  index = fold_convert (gfc_array_index_type, index);
 
 	  /* Do any bounds checking on the final info->descriptor index.  */
-	  index = trans_array_bound_check (se, ss, index, dim, &ar->where,
+	  index = trans_array_bound_check (&se->pre, ss, index, dim, &ar->where,
 					   ar->as->type != AS_ASSUMED_SIZE
 					   || dim < ar->dimen - 1);
 	  break;
@@ -8652,7 +8652,7 @@ gfc_conv_expr_descriptor (gfc_se *se, gfc_expr *expr)
 
   /* Add bounds-checking for elemental dimensions.  */
   if ((gfc_option.rtcheck & GFC_RTCHECK_BOUNDS) && !expr->no_bounds_check)
-    array_bound_check_elemental (se, ss, expr);
+    array_bound_check_elemental (&outermost_loop (&loop)->pre, ss, expr);
 
   if (need_tmp)
     {
--- a/src/gcc/fortran/trans-decl.cc
+++ b/src/gcc/fortran/trans-decl.cc
@@ -756,16 +756,6 @@ gfc_finish_var_decl (tree decl, gfc_symbol * sym)
 		&& sym->attr.codimension && !sym->attr.allocatable)))
     TREE_STATIC (decl) = 1;
 
-  /* If derived-type variables with DTIO procedures are not made static
-     some bits of code referencing them get optimized away.
-     TODO Understand why this is so and fix it.  */
-  if (!sym->attr.use_assoc
-      && ((sym->ts.type == BT_DERIVED
-           && sym->ts.u.derived->attr.has_dtio_procs)
-	  || (sym->ts.type == BT_CLASS
-	      && CLASS_DATA (sym)->ts.u.derived->attr.has_dtio_procs)))
-    TREE_STATIC (decl) = 1;
-
   /* Treat asynchronous variables the same as volatile, for now.  */
   if (sym->attr.volatile_ || sym->attr.asynchronous)
     {
@@ -2222,7 +2212,12 @@ get_proc_pointer_decl (gfc_symbol *sym)
 
   if ((sym->ns->proc_name
       && sym->ns->proc_name->backend_decl == current_function_decl)
-      || sym->attr.contained)
+      || sym->attr.contained
+      || (sym->ns->proc_name
+	  && sym->ns->proc_name->attr.flavor == FL_LABEL))
+    /* The last condition handles BLOCK constructs: the proc_name has
+       FL_LABEL flavor and its backend_decl is not set, but the proc pointer
+       belongs to the enclosing function (current_function_decl).  */
     gfc_add_decl_to_function (decl);
   else if (sym->ns->proc_name->attr.flavor != FL_MODULE)
     gfc_add_decl_to_parent_function (decl);
--- a/src/gcc/fortran/trans-expr.cc
+++ b/src/gcc/fortran/trans-expr.cc
@@ -5724,7 +5724,9 @@ gfc_conv_subref_array_arg (gfc_se *se, gfc_expr * expr, int g77,
 
   gcc_assert (lse.ss == gfc_ss_terminator);
 
-  tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts, false, true);
+  /* Do not do deallocations when we are looking at a g77-style argument.  */
+
+  tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts, false, !g77);
   gfc_add_expr_to_block (&body, tmp);
 
   /* Generate the copying loops.  */
--- a/src/gcc/fortran/trans-intrinsic.cc
+++ b/src/gcc/fortran/trans-intrinsic.cc
@@ -9828,9 +9828,15 @@ gfc_conv_intrinsic_loc (gfc_se * se, gfc_expr * expr)
 	gfc_add_data_component (arg_expr);
       gfc_conv_expr_reference (se, arg_expr);
     }
-  else
+  else if (gfc_is_simply_contiguous (arg_expr, false, false))
     gfc_conv_array_parameter (se, arg_expr, true, NULL, NULL, NULL);
+  else
+    {
+      gfc_conv_expr_descriptor (se, arg_expr);
+      se->expr = gfc_conv_descriptor_data_get (se->expr);
+    }
   se->expr = convert (gfc_get_int_type (gfc_index_integer_kind), se->expr);
+  se->expr = gfc_evaluate_now (se->expr, &se->pre);
 
   /* Create a temporary variable for loc return value.  Without this,
      we get an error an ICE in gcc/expr.cc(expand_expr_addr_expr_1).  */
--- a/src/gcc/fortran/trans-io.cc
+++ b/src/gcc/fortran/trans-io.cc
@@ -416,7 +416,7 @@ gfc_build_io_library_fndecls (void)
 	integer_type_node, gfc_charlen_type_node);
 
   iocall[IOCALL_X_DERIVED] = gfc_build_library_function_decl_with_spec (
-	get_identifier (PREFIX("transfer_derived")), ". w r ",
+	get_identifier (PREFIX("transfer_derived")), ". w w ",
 	void_type_node, 2, dt_parm_type, pvoid_type_node);
 
   /* Library entry points */
--- a/src/gcc/fortran/trans.cc
+++ b/src/gcc/fortran/trans.cc
@@ -1570,7 +1570,10 @@ gfc_assignment_finalizer_call (gfc_se *lse, gfc_expr *expr1, bool init_flag)
 	  gfc_init_se (&se, NULL);
 	  if (expr1->rank)
 	    {
-	      gfc_conv_expr_descriptor (&se, expr1);
+	      /* Avoid calling trans-array.cc(set_factored_descriptor_value) by
+		 not using gfc_conv_expr_descriptor.  */
+	      se.descriptor_only = 1;
+	      gfc_conv_expr (&se, expr1);
 	      ptr = gfc_conv_descriptor_data_get (se.expr);
 	    }
 	  else
--- a/src/gcc/gimple-fold.cc
+++ b/src/gcc/gimple-fold.cc
@@ -6850,14 +6850,12 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree),
       gimple_seq seq = NULL;
       gimple_match_op res_op;
       if (gimple_simplify (stmt, &res_op, inplace ? NULL : &seq,
-			   valueize, valueize))
-	{
-	  if (replace_stmt_with_simplification (gsi, &res_op, &seq, inplace,
-						dce_worklist))
-	    changed = true;
-	  else
-	    gimple_seq_discard (seq);
-	}
+			   valueize, valueize)
+	  && replace_stmt_with_simplification (gsi, &res_op, &seq, inplace,
+					       dce_worklist))
+	changed = true;
+      else
+	gimple_seq_discard (seq);
     }
 
   stmt = gsi_stmt (*gsi);
--- a/src/gcc/gimple-lower-bitint.cc
+++ b/src/gcc/gimple-lower-bitint.cc
@@ -4485,6 +4485,70 @@ bitint_large_huge::finish_arith_overflow (tree var, tree obj, tree type,
 	    obj_nelts >>= 1;
 	  atype = build_array_type_nelts (m_limb_type, obj_nelts);
 	}
+      if (bitint_extended && (var || obj))
+	{
+	  unsigned prec = TYPE_PRECISION (type);
+	  unsigned prec_limbs = CEIL (prec, limb_prec);
+	  bool ext_ms_limb
+	    = (bitint_extended == bitint_ext_full
+	       && abi_limb_prec > limb_prec
+	       && (CEIL (prec, abi_limb_prec) * abi_limb_prec
+		   > CEIL (prec, limb_prec) * limb_prec));
+	  /* For .{ADD,SUB}_OVERFLOW the partial limb if any is
+	     already extended in lower_addsub_overflow.  */
+	  if ((code == MULT_EXPR && (prec % limb_prec) != 0)
+	      || (ext_ms_limb && !TYPE_UNSIGNED (type)))
+	    {
+	      tree plm1idx = size_int (bitint_big_endian
+				       ? nelts - obj_nelts : prec_limbs - 1);
+	      tree plm1type
+		= limb_access_type (type, bitint_big_endian
+					  ? size_zero_node : plm1idx);
+	      tree l = limb_access (bitint_big_endian ? NULL_TREE : type,
+				    var ? var : obj, plm1idx, true);
+	      tree rhs = make_ssa_name (TREE_TYPE (l));
+	      g = gimple_build_assign (rhs, l);
+	      insert_before (g);
+	      if (code == MULT_EXPR && (prec % limb_prec) != 0)
+		{
+		  if (!useless_type_conversion_p (plm1type, TREE_TYPE (rhs)))
+		    rhs = add_cast (plm1type, rhs);
+		  if (!useless_type_conversion_p (TREE_TYPE (l),
+						  TREE_TYPE (rhs)))
+		    rhs = add_cast (TREE_TYPE (l), rhs);
+		  l = limb_access (bitint_big_endian ? NULL_TREE : type,
+				   var ? var : obj, plm1idx, true);
+		  g = gimple_build_assign (l, rhs);
+		  insert_before (g);
+		}
+	      if (ext_ms_limb && !TYPE_UNSIGNED (type))
+		{
+		  rhs = add_cast (signed_type_for (m_limb_type), rhs);
+		  tree lpm1 = build_int_cst (unsigned_type_node,
+					     limb_prec - 1);
+		  tree v = make_ssa_name (TREE_TYPE (rhs));
+		  g = gimple_build_assign (v, RSHIFT_EXPR, rhs, lpm1);
+		  insert_before (g);
+		  unsigned int i
+		    = CEIL (prec, abi_limb_prec) * abi_limb_prec / limb_prec;
+		  v = add_cast (m_limb_type, v);
+		  g = gimple_build_assign (limb_access (type, var ? var : obj,
+							size_int (i - 1),
+							true), v);
+		  insert_before (g);
+		  ext_ms_limb = false;
+		}
+	    }
+	  if (ext_ms_limb)
+	    {
+	      unsigned int i
+		= CEIL (prec, abi_limb_prec) * abi_limb_prec / limb_prec;
+	      g = gimple_build_assign (limb_access (type, var ? var : obj,
+						    size_int (i - 1), true),
+				       build_zero_cst (m_limb_type));
+	      insert_before (g);
+	    }
+	}
       if (var && obj)
 	{
 	  tree v1, v2;
@@ -4673,7 +4737,7 @@ bitint_large_huge::lower_addsub_overflow (tree obj, gimple *stmt)
   int prec0 = range_to_prec (arg0, stmt);
   int prec1 = range_to_prec (arg1, stmt);
   /* If PREC0 >= 0 && PREC1 >= 0 and CODE is not MINUS_EXPR, PREC2 is
-     the be minimum unsigned precision of any possible operation's
+     the minimum unsigned precision of any possible operation's
      result, otherwise it is minimum signed precision.
      Some examples:
      If PREC0 or PREC1 is 8, it means that argument is [0, 0xff],
@@ -5149,6 +5213,12 @@ bitint_large_huge::lower_addsub_overflow (tree obj, gimple *stmt)
 		    }
 		}
 	      tree l = limb_access (type, var ? var : obj, idxl, true);
+	      if (bitint_extended && tree_fits_uhwi_p (idxl))
+		{
+		  tree atype = limb_access_type (type, idxl);
+		  if (!useless_type_conversion_p (atype, TREE_TYPE (rhs)))
+		    rhs = add_cast (atype, rhs);
+		}
 	      if (!useless_type_conversion_p (TREE_TYPE (l), TREE_TYPE (rhs)))
 		rhs = add_cast (TREE_TYPE (l), rhs);
 	      g = gimple_build_assign (l, rhs);
--- a/src/gcc/glimits.h
+++ b/src/gcc/glimits.h
@@ -162,7 +162,9 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #  define BITINT_MAXWIDTH __BITINT_MAXWIDTH__
 # endif
 
-# define __STDC_VERSION_LIMITS_H__	202311L
+# ifndef __STDC_VERSION_LIMITS_H__
+#  define __STDC_VERSION_LIMITS_H__	202311L
+# endif
 #endif
 
 #endif /* _LIMITS_H___ */
--- a/src/gcc/m2/ChangeLog
+++ b/src/gcc/m2/ChangeLog
@@ -1,3 +1,12 @@
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/125348
+	* gm2-compiler/M2GenGCC.mod (PerformLastForIterator): Fix diagnostic
+	typo, intemediate -> intermediate.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/m2/gm2-compiler/M2GenGCC.mod
+++ b/src/gcc/m2/gm2-compiler/M2GenGCC.mod
@@ -566,7 +566,7 @@ BEGIN
          IF TreeOverflow (incrtree)
          THEN
             MetaErrorT0 (lastpos,
-                         'the intemediate calculation for the last iterator value in the {%kFOR} loop has caused an overflow') ;
+                         'the intermediate calculation for the last iterator value in the {%kFOR} loop has caused an overflow') ;
             NoChange := FALSE ;
             SubQuad (quad) ;
             success := FALSE
@@ -585,7 +585,7 @@ BEGIN
          IF TreeOverflow (incrtree)
          THEN
             MetaErrorT0 (lastpos,
-                         'the intemediate calculation for the last iterator value in the {%kFOR} loop has caused an overflow') ;
+                         'the intermediate calculation for the last iterator value in the {%kFOR} loop has caused an overflow') ;
             NoChange := FALSE ;
             SubQuad (quad) ;
             success := FALSE
--- a/src/gcc/match.pd
+++ b/src/gcc/match.pd
@@ -5734,9 +5734,9 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   (view_convert (BIT_FIELD_REF@0 @1 @2 @3))
   (if (is_gimple_reg_type (type)
        && (!INTEGRAL_TYPE_P (type)
-	   || !INTEGRAL_TYPE_P (TREE_TYPE (@0))
-	   || (type_has_mode_precision_p (type)
-	       && type_has_mode_precision_p (TREE_TYPE (@0)))))
+	   || type_has_mode_precision_p (type))
+       && (!INTEGRAL_TYPE_P (TREE_TYPE (@0))
+	   || type_has_mode_precision_p (TREE_TYPE (@0))))
    (BIT_FIELD_REF:type @1 @2 @3)))
 
 /* For integral conversions with the same precision or pointer
--- a/src/gcc/po/ChangeLog
+++ b/src/gcc/po/ChangeLog
@@ -1,3 +1,17 @@
+2026-05-18  Joseph Myers  <josmyers@redhat.com>
+
+	* sv.po: Update.
+
+2026-05-05  Joseph Myers  <josmyers@redhat.com>
+
+	* de.po: Update.
+
+2026-05-01  Joseph Myers  <josmyers@redhat.com>
+
+	* be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po,
+	ja.po, ka.po, nl.po, ru.po, sr.po, sv.po, tr.po, uk.po, vi.po,
+	zh_CN.po, zh_TW.po: Update.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/gcc/po/be.po
+++ b/src/gcc/po/be.po
@@ -6,7 +6,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 3.1\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2002-05-17 15:54+0200\n"
 "Last-Translator: Ales Nyakhaychyk <nyakhaychyk@i18n.linux.by>\n"
 "Language-Team: Belarusian <i18n@tut.by>\n"
@@ -1293,12 +1293,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr ""
@@ -2135,13 +2135,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2602,7 +2602,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr ""
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr ""
@@ -2677,7 +2677,7 @@ msgstr ""
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2714,7 +2714,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr ""
@@ -2824,7 +2824,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2870,7 +2870,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5171,7 +5171,7 @@ msgstr ""
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5528,7 +5528,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5839,213 +5839,218 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, fuzzy, no-c-format
 #| msgid "Optimize for 3900"
 msgid "Optimize for CPU."
 msgstr "Аптымізаваць для 3900"
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Генерыраваць код для дадзенага ЦП"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, no-c-format
 msgid "This option is deprecated."
 msgstr ""
@@ -11452,7 +11457,7 @@ msgstr ""
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18405,82 +18410,82 @@ msgstr ""
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 msgid "argument must be passed by copying"
 msgstr ""
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 msgid "volatile function type"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "In function"
 msgid "nested function"
 msgstr "У функцыі"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr ""
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support %s"
 msgid "frontend does not support sibling call"
 msgstr "%s не падтрымлівае %s"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 msgid "variable size arguments"
 msgstr ""
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr ""
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr ""
 
@@ -18601,12 +18606,12 @@ msgstr ""
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr ""
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19898,11 +19903,11 @@ msgstr ""
 msgid "this is the insn:"
 msgstr ""
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 msgid "unable to reload address in "
 msgstr ""
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr ""
 
@@ -20128,7 +20133,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr ""
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr ""
@@ -20542,20 +20547,20 @@ msgstr "Нерэчаісны выбар \"%s\""
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "Нерэчаісны выбар \"%s\""
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid string constant `%E'"
 msgid "invalid vector constant"
@@ -20605,71 +20610,71 @@ msgstr "Нерэчаісны выбар \"%s\""
 msgid "invalid address mode"
 msgstr "нерэчаісны адрас"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 msgid "postincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr ""
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20686,13 +20691,13 @@ msgid "invalid %%r value"
 msgstr "нерэчаіснае значэньне %%r"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "нерэчаіснае значэньне %%R"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "нерэчаіснае значэньне %%N"
@@ -20707,7 +20712,7 @@ msgstr "нерэчаіснае значэньне %%P"
 msgid "invalid %%h value"
 msgstr "нерэчаіснае значэньне %%h"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "нерэчаіснае значэньне %%L"
@@ -20722,7 +20727,7 @@ msgstr "нерэчаіснае значэньне %%m"
 msgid "invalid %%M value"
 msgstr "нерэчаіснае значэньне %%M"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "нерэчаіснае значэньне %%U"
@@ -21069,7 +21074,7 @@ msgstr "непадтрымліваемая версія"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21317,130 +21322,130 @@ msgstr "`%E' - нерэчаісная нязьменная тыпу string"
 msgid "Expected register or constant integer."
 msgstr ""
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr ""
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of register '%s'"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of asm flag output"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "нерэчаісны %%-код"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "нерэчаісны %%-код"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr ""
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr ""
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr ""
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr ""
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr ""
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr ""
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr ""
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr ""
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr ""
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, fuzzy, c-format
 msgid "invalid operand code '%c'"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, fuzzy, c-format
 #| msgid "invalid %%c operand"
 msgid "invalid constraints for operand"
 msgstr "нерэчаісны %%c аперанд"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 msgid "invalid vector immediate"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 #, fuzzy
 msgid "unknown insn mode"
 msgstr "невядомы рэжым машыны \"%s\""
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21526,9 +21531,9 @@ msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, fuzzy, c-format
 #| msgid "invalid use of `%D'"
 msgid "invalid use of '%%%c'"
@@ -21598,7 +21603,7 @@ msgid "insn contains an invalid address !"
 msgstr "нерэчаісны адрас"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "нерэчаісны адрас"
 
@@ -21674,7 +21679,7 @@ msgstr "Нерэчаісны выбар %s"
 msgid "invalid %%H value"
 msgstr "нерэчаіснае значэньне %%H"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, fuzzy, c-format
 #| msgid "invalid %%Q value"
 msgid "invalid %%d value"
@@ -21732,34 +21737,34 @@ msgstr "нераспазнаны адрас"
 msgid "unsupported memory expression:"
 msgstr "непадтрымліваемая версія"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%c operand"
 msgid "invalid vector operand"
 msgstr "нерэчаісны %%c аперанд"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid register name for `%s'"
 msgid "invalid register number for 'N' modifier"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr ""
@@ -21819,7 +21824,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "дрэннае %%Q значэнне"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, fuzzy, c-format
 msgid "invalid %%D value"
 msgstr "дрэннае %%Q значэнне"
@@ -21860,7 +21865,7 @@ msgstr ""
 msgid "invalid %%k value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr ""
@@ -21891,17 +21896,17 @@ msgstr ""
 msgid "invalid %%u value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "нерэчаіснае значэньне %%V"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, fuzzy, c-format
 #| msgid "invalid %%x/X value"
 msgid "invalid %%x value"
@@ -22116,27 +22121,27 @@ msgstr "нерэчаісны %%-код"
 msgid "floating-point constant not a valid immediate operand"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, fuzzy, c-format
 msgid "'B' operand is not constant"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, fuzzy, c-format
 msgid "'o' operand is not constant"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 msgid "'h' operand is not SImode register"
 msgstr "Не выкарыстоўваць рэгістра sb"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr ""
@@ -22194,26 +22199,26 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr ""
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "нерэчаісная маска"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, fuzzy, c-format
 #| msgid "invalid %%x/X value"
 msgid "invalid %%t/%%b value"
 msgstr "нерэчаіснае значэньне %%x/X"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 #, fuzzy
 msgid "no register in address"
 msgstr "невядомая назва рэгістра: %s"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr ""
 
@@ -22245,7 +22250,7 @@ msgstr ""
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr ""
 
@@ -22270,8 +22275,8 @@ msgstr ""
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr ""
@@ -22299,7 +22304,7 @@ msgstr ""
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr ""
@@ -22307,7 +22312,7 @@ msgstr ""
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr ""
@@ -22327,13 +22332,13 @@ msgstr ""
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr ""
@@ -22342,7 +22347,7 @@ msgstr ""
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22359,13 +22364,13 @@ msgstr ""
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr ""
@@ -22375,7 +22380,7 @@ msgstr ""
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr ""
@@ -22385,18 +22390,18 @@ msgid "expected %<.%>"
 msgstr ""
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr ""
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr ""
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr ""
@@ -22406,45 +22411,45 @@ msgstr ""
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr ""
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr ""
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr ""
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr ""
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr ""
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr ""
@@ -22469,7 +22474,7 @@ msgstr ""
 msgid "  after user-defined conversion:"
 msgstr ""
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] ""
@@ -22578,7 +22583,7 @@ msgstr "невыкарыстаемы параметр \"%s\""
 msgid "<statement>"
 msgstr ""
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr ""
@@ -22605,276 +22610,314 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 #, fuzzy
 #| msgid "parse error"
 msgid "<expression error>"
 msgstr "граматычная памылка"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr ""
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-msgid "array element not a constant integer"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
 msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr ""
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+msgid "array element not a constant integer"
+msgstr ""
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 msgid "reflection does not have template arguments"
 msgstr ""
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a function or function type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 msgid "operators argument is not a valid operator"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not have a type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr ""
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr ""
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr ""
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 msgid "reflection not suitable for alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 msgid "alignment_of on function type"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr ""
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr ""
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr ""
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr ""
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 msgid "invalid argument to can_substitute"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 msgid "type is not object or reference type"
 msgstr ""
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 msgid "name is not a valid identifier"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr ""
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 #, fuzzy
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "бітавае поле \"%s\" мае нерэчаісны тып"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 msgid "both alignment and bit_width specified"
 msgstr ""
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr ""
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr ""
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr ""
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "size of array is negative"
 msgid "alignment is negative"
 msgstr "адмоўны памер масіва "
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "function does not return string type"
+msgid "reflection does not have non-array object type"
+msgstr "функцыя не вяртае тып string"
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr ""
+
+#: cp/reflect.cc:6526
+msgid "current scope does not represent a class nor a member function"
+msgstr ""
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr ""
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr ""
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 msgid "not a complete class type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "virtual functions cannot be friends"
 msgid "value cannot be extracted"
@@ -22925,54 +22968,54 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr ""
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr ""
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr ""
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr ""
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr ""
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr ""
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 #| msgid "too many arguments to function"
 msgid "in argument to unary !"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -22989,59 +23032,59 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr ""
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 msgid "BOZ literal constant"
 msgstr ""
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr ""
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 msgid "Procedure unexpected as argument"
 msgstr ""
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr ""
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -23111,7 +23154,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr ""
 
@@ -23120,17 +23163,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -23315,11 +23358,11 @@ msgstr ""
 msgid "implied END DO"
 msgstr ""
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr ""
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr ""
 
@@ -23327,145 +23370,145 @@ msgstr ""
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 #| msgid "no arguments"
 msgid "allocatable argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 #| msgid "no arguments"
 msgid "asynchronous argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 #| msgid "no arguments"
 msgid "optional argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "no arguments"
 msgid "pointer argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 #| msgid "no arguments"
 msgid "target argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 #| msgid "no arguments"
 msgid "value argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 #| msgid "no arguments"
 msgid "assumed-rank argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 #| msgid "no arguments"
 msgid "coarray argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "няма аргументаў"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr ""
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -23474,31 +23517,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -23561,27 +23604,27 @@ msgstr ""
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23679,7 +23722,7 @@ msgid "expected boolean type"
 msgstr ""
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr ""
@@ -23747,7 +23790,7 @@ msgstr "няма аргументаў"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments"
@@ -24175,7 +24218,7 @@ msgstr ""
 msgid "target OS does not support unaligned accesses"
 msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай"
@@ -24419,13 +24462,13 @@ msgstr ""
 msgid "Global declarative %s for %s"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24590,13 +24633,13 @@ msgstr ""
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown escape sequence '\\%c'"
 msgid "unknown autovec preference %qs"
 msgstr "невядомая ESC-паслядоўнасць '\\%c'"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr ""
@@ -25049,8 +25092,8 @@ msgstr ""
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
@@ -25068,7 +25111,7 @@ msgstr "\"%s\" атрыбут ігнарыруецца"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr ""
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments specified for %qE attribute"
@@ -25079,7 +25122,7 @@ msgstr "памылковая колькасьць аргументаў, зада
 msgid "expected %i or more, found %i"
 msgstr ""
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr ""
@@ -25162,12 +25205,12 @@ msgstr ""
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25284,135 +25327,135 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "location is after end of function"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr ""
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "can't open output file `%s'"
 msgid "cannot open profile file %s"
 msgstr "немагчыма адчыніць файл уводу `%s'"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr ""
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr ""
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read function profile from %s"
 msgstr "немагчыма знайсьці файл для кляса %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read module profile from %s"
@@ -25423,7 +25466,7 @@ msgstr "немагчыма знайсьці файл для кляса %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr ""
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr ""
@@ -25531,7 +25574,7 @@ msgstr "вельмі шмат аргументаў у функцыі \"%s\""
 msgid "illegal argument 0 to %qs"
 msgstr "аргумент для \"%s\" прапушчан"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
@@ -25612,12 +25655,12 @@ msgstr ""
 msgid "cannot tail-call: %s"
 msgstr "немагчыма знайсьці кляс `%s'"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr ""
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr ""
@@ -26283,343 +26326,343 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr ""
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr ""
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "аргумент для \"%s\" прапушчан"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr ""
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr ""
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 #| msgid "label `%s' used but not defined"
 msgid "local symbols must be defined"
 msgstr "адмеціна `%s' выкарыстоўвываецца, але ня вызначана"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr ""
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr ""
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr ""
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr ""
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr ""
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr ""
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr ""
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr ""
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr ""
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, fuzzy, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr ""
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr ""
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to `-%s' is missing"
 msgid "%s: section %s.%d is missing"
@@ -27406,17 +27449,17 @@ msgstr ""
 msgid "impossible constraint in %<asm%>"
 msgstr "немагчымы апэратар '%s'"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr ""
@@ -28108,7 +28151,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -28148,7 +28191,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 msgid "%qD defined here"
 msgstr "YYDEBUG не вызначан."
@@ -28168,24 +28211,24 @@ msgstr ""
 msgid "function may return address of local variable"
 msgstr ""
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr ""
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -29076,7 +29119,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr ""
@@ -29146,210 +29189,210 @@ msgstr ""
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for `%s'"
 msgid "invalid memory model %qs for %qD"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for `%s'"
 msgid "invalid memory model %wi for %qD"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for `%s'"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array `%s' is negative"
 msgid "argument %i value %s is negative"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "call to %qD here"
 msgstr "выклікана адсюль"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "cannot create temporary file"
 msgid "unnamed temporary defined here"
 msgstr "немагчыма стварыць часовы файл"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr ""
@@ -30155,346 +30198,346 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr ""
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, fuzzy, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "невыкарыстаемы параметр \"%s\""
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr ""
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr ""
@@ -30514,7 +30557,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr ""
@@ -30746,12 +30789,12 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr "Не выкарыстоўваць рэгістра sb"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr ""
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -31123,7 +31166,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -32531,22 +32574,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr ""
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -33498,171 +33541,171 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr "Нераспазнаны выбар \"%s\""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr ""
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr ""
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%f operand"
 msgid "invalid %qs offset operator"
 msgstr "нерэчаісны %%f аперанд"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%d operand"
 msgid "invalid address operand in %qs"
 msgstr "нерэчаісны %%d аперанд"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%f operand"
 msgid "invalid offset operand in %qs"
 msgstr "нерэчаісны %%f аперанд"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr ""
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr ""
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%m value"
 msgid "invalid expression for min lvalue"
 msgstr "нерэчаіснае значэньне %%m"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "Нерэчаісная спецыфікацыя! Памылка ў cc."
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -33673,602 +33716,602 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr ""
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr ""
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr ""
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, fuzzy, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr ""
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr ""
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr ""
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr ""
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr ""
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "прапушчан ініцыялізатар"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr ""
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr ""
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr ""
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr ""
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr ""
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for `%s'"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr ""
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr ""
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "нерэчаісны %%-код"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%Q value"
 msgid "invalid %<PHI%> result"
 msgstr "дрэннае %%Q значэнне"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr ""
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%Q value"
 msgid "invalid %<PHI%> argument"
 msgstr "дрэннае %%Q значэнне"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr ""
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr ""
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr ""
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe is not supported"
 msgid "case labels not sorted: "
 msgstr "-pipe не падтрымліваецца"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing field '%s' in '%s'"
 msgid "missing edge %i->%i"
 msgstr "прапушчана поле '%s' у '%s'"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr ""
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr ""
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr ""
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr ""
@@ -34448,12 +34491,12 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr ""
@@ -34966,7 +35009,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -35387,12 +35430,12 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
@@ -35400,16 +35443,16 @@ msgstr ""
 msgid "previous declaration of %qD"
 msgstr "папярэдняе абвяшчэньне `%D'"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: tree.cc:15804
+#: tree.cc:15824
 msgid "%qD conflicts for version %qB"
 msgstr ""
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "conflicts with previous declaration `%#D'"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -35490,7 +35533,7 @@ msgstr "не магу ініцыялізаваць сяброўскую функ
 msgid "no initializers are allowed in section %qs"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr ""
@@ -35635,7 +35678,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr ""
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
@@ -35680,55 +35723,55 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for `%#D' has type `%T'"
 msgid "%qE attribute argument has type %qT"
 msgstr "звычайны аргумэнт для `%#D' мае тып `%T'"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for `%#D' has type `%T'"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "звычайны аргумэнт для `%#D' мае тып `%T'"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr ""
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr ""
@@ -35743,12 +35786,12 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr ""
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr ""
@@ -35961,12 +36004,12 @@ msgstr ""
 msgid "mode %qs applied to inappropriate type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, fuzzy, gcc-internal-format
 #| msgid "section attributes are not supported for this target"
 msgid "section attribute not allowed for %q+D"
@@ -35977,19 +36020,19 @@ msgstr "атрыбуты секцыі не падтрымліваюцца для
 msgid "section attribute argument not a string constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr ""
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, fuzzy, gcc-internal-format
 #| msgid "section of `%s' conflicts with previous declaration"
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
@@ -36075,7 +36118,7 @@ msgstr ""
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
@@ -36121,12 +36164,12 @@ msgstr "\"%s\" атрыбут ігнарыруецца"
 msgid "%qE attribute is only applicable on functions"
 msgstr "\"%s\" звычайна функцыя"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "\"%s\" звычайна функцыя"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "\"%s\" атрыбут ігнарыруецца"
@@ -36136,12 +36179,12 @@ msgstr "\"%s\" атрыбут ігнарыруецца"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -36232,23 +36275,23 @@ msgstr ""
 msgid "visibility argument not a string"
 msgstr "аргумент для \"%s\" прапушчан"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr ""
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -36265,7 +36308,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "\"%s\" звычайна функцыя"
@@ -36336,7 +36379,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "\"%s\" атрыбут ігнарыруецца"
@@ -36413,7 +36456,7 @@ msgstr ""
 msgid "%qE argument is not a function"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr ""
@@ -36480,7 +36523,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr ""
@@ -36642,15 +36685,15 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
@@ -36920,7 +36963,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr ""
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of %<restrict%>"
@@ -37093,8 +37136,8 @@ msgstr "не хапае аргументаў у функцыі"
 msgid "missing sentinel in function call"
 msgstr ""
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -38125,7 +38168,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr ""
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -38180,7 +38223,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr ""
@@ -38196,17 +38239,17 @@ msgstr ""
 msgid "%qE is not initialized"
 msgstr "прапушчан ініцыялізатар"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 msgid "missing increment expression"
 msgstr "аргумент для \"%s\" прапушчан"
@@ -38216,7 +38259,7 @@ msgstr "аргумент для \"%s\" прапушчан"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "нерэчаісны ініцыялізатар"
@@ -38311,19 +38354,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD is not a function argument"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -38333,8 +38376,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr ""
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr ""
@@ -38855,7 +38898,7 @@ msgstr ""
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr ""
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr ""
@@ -38930,8 +38973,8 @@ msgstr ""
 msgid "wrong type argument to %s"
 msgstr "не хапае аргументаў у функцыі"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -39424,17 +39467,17 @@ msgstr "нехапае аргументаў у функцыі \"%s\""
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr ""
@@ -39706,7 +39749,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] ""
 msgstr[1] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -40648,7 +40691,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -41289,7 +41332,7 @@ msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
@@ -41336,7 +41379,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -41387,7 +41430,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -41480,19 +41523,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "\"%s\" звычайна функцыя"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41538,210 +41581,210 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%Q value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "дрэннае %%Q значэнне"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "Нераспазнаны выбар \"%s\""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "невядомая назва рэгістра: %s\n"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "%s не падтрымлівае %s"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "-pipe не падтрымліваецца"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41749,196 +41792,196 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function multiversioning not supported"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported version"
 msgid "unsupported simdlen %wd"
 msgstr "непадтрымліваемая версія"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "YYDEBUG не вызначан."
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -42128,12 +42171,12 @@ msgstr "аргумент `__builtin_args_info' павінен быць канс
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -42268,22 +42311,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "памер \"%s\" больш чам %d байт"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr ""
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr ""
@@ -42822,12 +42865,12 @@ msgstr "-pipe не падтрымліваецца"
 msgid "%<-fPIE%> is not supported"
 msgstr "-pipe не падтрымліваецца"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr ""
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "%qs function cannot have arguments"
@@ -42838,7 +42881,7 @@ msgstr "віртуальныя функцыі не могуць быць сяб
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "%qs function cannot return a value"
@@ -43171,7 +43214,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "invalid argument to built-in function"
@@ -43492,7 +43535,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -43664,169 +43707,169 @@ msgstr "аргумент `__builtin_args_info' павінен быць канс
 msgid "parameter to builtin not valid: %s"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, fuzzy, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "Нерэчаісны выбар %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%r value"
 msgid "invalid third argument"
 msgstr "нерэчаіснае значэньне %%r"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
@@ -44223,8 +44266,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
@@ -44468,7 +44511,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -44493,12 +44536,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -44508,128 +44551,128 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr ""
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr ""
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr ""
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr ""
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr ""
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -44681,7 +44724,7 @@ msgstr ""
 msgid "argument %qd is not a constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr ""
@@ -44691,7 +44734,7 @@ msgstr ""
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr ""
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr ""
@@ -44846,48 +44889,48 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай"
@@ -45651,7 +45694,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr ""
@@ -45879,82 +45922,82 @@ msgstr "немагчыма зачыніць уваходзячы файл %s"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
@@ -46184,323 +46227,323 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "нераспазнаны выбар \"-%s\""
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr ""
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr ""
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr ""
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C89 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C89 не падтрымлівае комлексныя тыпы"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr ""
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for `%s'"
 msgid "%qs is not a valid base register in %qs"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr ""
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -47511,22 +47554,22 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, fuzzy, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr ""
@@ -47748,32 +47791,32 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47860,7 +47903,7 @@ msgstr ""
 msgid "%qs attribute only applies to variadic functions"
 msgstr "\"%s\" звычайна функцыя"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored"
@@ -47947,8 +47990,8 @@ msgstr ""
 msgid "could not get size of source file"
 msgstr "не магу знайсці крыніцу %s\n"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr ""
@@ -48439,7 +48482,7 @@ msgstr ""
 msgid "%qE defined as wrong kind of tag"
 msgstr ""
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr ""
@@ -48592,7 +48635,7 @@ msgstr "ISO C89 не падтрымлівае \"long long\""
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C89 не падтрымлівае \"long long\""
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr ""
@@ -48603,7 +48646,7 @@ msgstr ""
 msgid "%q+D is usually a function"
 msgstr "`%s' - звычайна функцыя"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 #| msgid "no previous declaration for `%s'"
 msgid "no previous declaration for %qD"
@@ -48682,7 +48725,7 @@ msgstr ""
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -48887,7 +48930,7 @@ msgstr ""
 msgid "storage class specified for unnamed parameter"
 msgstr ""
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr ""
@@ -49068,7 +49111,7 @@ msgstr ""
 msgid "function definition has qualified void return type"
 msgstr "функцыя не вяртае тып string"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr ""
@@ -49197,7 +49240,7 @@ msgstr ""
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr ""
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, fuzzy, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "тып параметра \"%s\" не аб'яўлены"
@@ -49413,7 +49456,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr ""
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr ""
@@ -49480,7 +49523,7 @@ msgstr ""
 msgid "struct has no members"
 msgstr ""
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr ""
@@ -49548,7 +49591,7 @@ msgstr "абвяшчэньне `%#D'"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr ""
@@ -49603,7 +49646,7 @@ msgstr ""
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr ""
@@ -49759,12 +49802,12 @@ msgstr ""
 msgid "argument %qD doesn%'t match prototype"
 msgstr ""
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr ""
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "parameter %qD set but not used"
@@ -49848,7 +49891,7 @@ msgstr ""
 msgid "two or more data types in declaration specifiers"
 msgstr ""
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, fuzzy, gcc-internal-format
 #| msgid "`long long long' is too long for GCC"
 msgid "%<long long long%> is too long for GCC"
@@ -49960,7 +50003,7 @@ msgstr "ISO C89 не падтрымлівае комлексныя тыпы"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай"
@@ -50125,12 +50168,12 @@ msgstr ""
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -50190,37 +50233,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr ""
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr ""
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr ""
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr ""
@@ -50240,7 +50283,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr ""
@@ -50251,7 +50294,7 @@ msgstr ""
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C не дазваляе пусты ізыходны файл"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -50299,8 +50342,8 @@ msgid "unknown type name %qE"
 msgstr "невядомая назва рэгістра: %s"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declaration specifiers"
@@ -50337,7 +50380,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "\"%s\" атрыбут ігнарыруецца"
@@ -50353,12 +50396,12 @@ msgstr "атрыбуты секцыі не падтрымліваюцца для
 msgid "unexpected attribute"
 msgstr ""
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr ""
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr ""
@@ -50401,7 +50444,7 @@ msgstr ""
 msgid "%qs may only be used with a single declarator"
 msgstr ""
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr ""
@@ -50435,7 +50478,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "\"%s\" звычайна функцыя"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr ""
@@ -50466,7 +50509,7 @@ msgstr ""
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr ""
@@ -50522,8 +50565,8 @@ msgstr ""
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr ""
@@ -50556,12 +50599,12 @@ msgstr "нявернае выкарыстанне \"restict\""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr ""
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50642,22 +50685,22 @@ msgstr ""
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr ""
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr ""
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr ""
@@ -50667,7 +50710,7 @@ msgstr ""
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C89 не падтрымлівае \"long long\""
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr ""
@@ -50698,17 +50741,17 @@ msgstr ""
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr ""
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -50718,44 +50761,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
@@ -50787,7 +50830,7 @@ msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 msgid "expected %<}%> before %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -50802,7 +50845,7 @@ msgstr ""
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr ""
@@ -50837,30 +50880,30 @@ msgstr "ISO C89 не падтрымлівае \"long long\""
 msgid "declaration in the controlling expression must have an initializer"
 msgstr ""
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declaration"
 msgstr "пустое абвяшчэньне"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "пустое цела ў else-выражэнні"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "пустое цела ў else-выражэнні"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -50880,12 +50923,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -50900,8 +50943,8 @@ msgstr ""
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "паўтарэнне \"volatile\""
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -50923,12 +50966,12 @@ msgstr "ISO C не дазваляе пусты ізыходны файл"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr ""
@@ -51107,7 +51150,7 @@ msgstr "ISO C не падтрымлівае комлексныя цэлалік
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr ""
@@ -51122,12 +51165,12 @@ msgstr ""
 msgid "ISO C forbids braced-groups within expressions"
 msgstr ""
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr ""
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -51275,7 +51318,7 @@ msgstr "аргумент `__builtin_args_info' павінен быць канс
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
@@ -51318,7 +51361,7 @@ msgstr ""
 msgid "rotate count is negative"
 msgstr "адмоўны памер масіва "
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -51430,7 +51473,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -51470,12 +51513,12 @@ msgstr ""
 msgid "no type or storage class may be specified here,"
 msgstr ""
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 msgid "missing property attribute"
 msgstr "прапушчан ініцыялізатар"
@@ -51485,57 +51528,57 @@ msgstr "прапушчан ініцыялізатар"
 msgid "unknown property attribute %<%s%s%>"
 msgstr ""
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr ""
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr ""
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -51545,12 +51588,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr ""
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr ""
@@ -51560,11 +51603,11 @@ msgstr ""
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %qs clauses"
@@ -51580,59 +51623,59 @@ msgstr ""
 msgid "%qD is not a variable"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "\"%s\" звычайна функцыя"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr ""
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr ""
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr ""
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<if%> clauses"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr ""
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -51655,22 +51698,22 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr ""
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr ""
@@ -51680,101 +51723,101 @@ msgstr ""
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr ""
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many %<static%> arguments"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "unexpected argument"
 msgstr "няма аргументаў"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr ""
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr ""
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr ""
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr ""
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%-code"
 msgid "invalid schedule kind"
@@ -51785,39 +51828,39 @@ msgstr "нерэчаісны %%-код"
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr ""
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `%s'"
 msgid "duplicate %qs modifier"
 msgstr "паўтарэньне `%s'"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -51832,22 +51875,22 @@ msgstr ""
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr ""
@@ -51857,7 +51900,7 @@ msgstr ""
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51872,319 +51915,319 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr ""
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%d operand"
 msgid "invalid depend kind"
 msgstr "нерэчаісны %%d аперанд"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid doacross kind"
 msgstr "нерэчаісная маска"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid map kind"
 msgstr "нерэчаісная маска"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr ""
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr ""
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "Нерэчаісны выбар %s"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr ""
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "невядомая назва рэгістра: %s"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr ""
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr ""
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr ""
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 #| msgid "complex invalid for `%s'"
 msgid "%qs is not valid for %qs"
 msgstr "complex нерэчаісны для \"%s\""
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr ""
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr ""
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr ""
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -52199,7 +52242,7 @@ msgstr ""
 msgid "expected function name"
 msgstr ""
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD does not refer to a function"
@@ -52210,22 +52253,22 @@ msgstr "`%D' - гэта ня функцыя,"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr ""
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -52251,7 +52294,7 @@ msgstr ""
 msgid "modified here"
 msgstr "'O' мадыфікатар"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -52286,111 +52329,111 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr ""
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many atomic clauses"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr ""
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr ""
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr ""
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr ""
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr ""
@@ -52400,27 +52443,27 @@ msgstr ""
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr ""
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr ""
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr ""
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -52430,32 +52473,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr ""
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr ""
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 msgid "for statement expected"
 msgstr "вельмі шмат аргументаў у функцыі"
@@ -52463,68 +52506,68 @@ msgstr "вельмі шмат аргументаў у функцыі"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, gcc-internal-format
 msgid "loop nest expected"
 msgstr ""
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr ""
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr ""
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr ""
@@ -52534,7 +52577,7 @@ msgstr ""
 msgid "expected a function name"
 msgstr ""
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, gcc-internal-format
 msgid "expected target-function call"
 msgstr ""
@@ -52544,47 +52587,47 @@ msgstr ""
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr ""
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -52599,57 +52642,57 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr ""
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr ""
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr ""
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr ""
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr ""
@@ -52660,28 +52703,28 @@ msgstr ""
 msgid "variant %qD is not a function"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<match%> clauses"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -52691,7 +52734,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr ""
@@ -52701,17 +52744,17 @@ msgstr ""
 msgid "%<need_device_addr%> is not valid for C"
 msgstr ""
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr ""
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr ""
@@ -52731,12 +52774,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr ""
@@ -52746,7 +52789,7 @@ msgstr ""
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "\"%s\" мае незавершаны тып"
@@ -52756,7 +52799,7 @@ msgstr "\"%s\" мае незавершаны тып"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -52771,84 +52814,84 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr ""
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr ""
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr ""
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr ""
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr ""
@@ -52873,12 +52916,12 @@ msgstr ""
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr ""
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, gcc-internal-format
 msgid "unexpected clause"
 msgstr ""
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "Missing class name"
 msgid "missing %<map%> clause"
@@ -52939,32 +52982,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr ""
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -52979,161 +53022,161 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr ""
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr ""
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr ""
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr ""
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr ""
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "невядомая назва рэгістра: %s\n"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr ""
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "невядомая назва рэгістра: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr ""
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -53143,7 +53186,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -53159,7 +53202,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr ""
@@ -53190,168 +53233,168 @@ msgstr "нявернае выкарыстанне \"restict\""
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "\"%s\" звычайна функцыя"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr ""
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr ""
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr ""
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr ""
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr ""
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr ""
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr ""
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%s' is negative"
 msgid "array subscript is negative"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr ""
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, fuzzy, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr ""
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr ""
@@ -53359,1867 +53402,1867 @@ msgstr ""
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr ""
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr ""
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr ""
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function `%s'"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "вельмі шмат аргумэнтаў у функцыі `%s'"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function `%s'"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "вельмі шмат аргумэнтаў у функцыі `%s'"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function `%s'"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "вельмі шмат аргумэнтаў у функцыі `%s'"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr ""
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr ""
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr ""
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr ""
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr ""
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr ""
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C89 does not support complex types"
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C89 не падтрымлівае комлексныя тыпы"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "не хапае аргументаў у функцыі"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr ""
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support `++' and `--' on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C не падтрымлівае \"++\" і \"--\" для тыпу complex"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, fuzzy, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "не хапае аргументаў у функцыі"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr ""
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr ""
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "не магу атрымаць адрас бітавага поля \"%s\""
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "не магу атрымаць адрас бітавага поля \"%s\""
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr ""
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr ""
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr ""
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr ""
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr ""
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr ""
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr ""
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr ""
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr ""
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr ""
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr ""
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr ""
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, fuzzy, gcc-internal-format
 #| msgid "initialization"
 msgid "(near initialization for %qs)"
 msgstr "ініцыялізацыя"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr ""
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 msgid "expected %e but argument is of type %e"
 msgstr ""
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr ""
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 msgid "%e declared here"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "converting from `%T' to `%T'"
 msgid "implicit conversion from %qT to %qT"
 msgstr "пераўтварэньне з `%T' у `%T'"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr ""
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 msgid "returning %e from a function with incompatible return type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr ""
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr ""
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr ""
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr ""
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr ""
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr ""
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr ""
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr ""
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr ""
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "прапушчан ініцыялізатар"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, fuzzy, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "excess elements in %qT initializer"
 msgstr "прапушчан ініцыялізатар"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr ""
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids `goto *expr;'"
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C не падтрымлівае \"goto *expr;\""
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "функцыя не вяртае тып string"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr ""
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "function returns address of label"
 msgstr "ISO C не дазваляе пусты ізыходны файл"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, gcc-internal-format
 msgid "function returns address of nested function referencing local context"
 msgstr ""
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr ""
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr ""
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr ""
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr ""
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr ""
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr ""
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr ""
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr ""
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr ""
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr ""
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr ""
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr ""
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr ""
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "бітавае поле \"%s\" мае нерэчаісны тып"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr ""
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr ""
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported version"
 msgid "unsupported map expression %qE"
 msgstr "непадтрымліваемая версія"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr ""
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr ""
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr ""
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -55493,253 +55536,248 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr ""
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr ""
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr ""
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr ""
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr ""
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr ""
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55748,72 +55786,82 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr ""
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr ""
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr ""
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55823,13 +55871,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "вельмі шмат уваходзячых файлаў"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr ""
@@ -55844,62 +55892,62 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr ""
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr ""
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr ""
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling `%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s: кампілюецца \"%s\"\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling `%s'\n"
 msgid "failed compiling %s"
@@ -56340,7 +56388,7 @@ msgstr "немагчымы апэратар '%s'"
 msgid "%q#D is private within this context"
 msgstr ""
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 msgid "declared private here"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
@@ -56350,7 +56398,7 @@ msgstr "\"%s\" не абвешчан (першае выкарыстанне ў 
 msgid "%q#D is protected within this context"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "declared protected here"
@@ -56677,7 +56725,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr ""
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr ""
 
@@ -56696,7 +56744,7 @@ msgstr ""
 msgid "call to non-function %qD"
 msgstr ""
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -57295,7 +57343,7 @@ msgstr ""
 msgid "next member %q#D declared here"
 msgstr ""
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of `%#T'"
 msgid "redefinition of %q#T"
@@ -57306,7 +57354,7 @@ msgstr "папярэдняе вызначэньне `%#T'"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -57438,7 +57486,7 @@ msgstr ""
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -57489,7 +57537,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -57524,848 +57572,848 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr ""
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr ""
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s не падтрымлівае %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr ""
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %qs call"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr ""
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr ""
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "can't initialize friend function `%s'"
 msgid "call to internal function %qE"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr ""
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%s' is initialized"
 msgid "virtual table pointer is used uninitialized"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr ""
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr ""
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr ""
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr ""
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr ""
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr ""
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr ""
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr ""
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "прапушчан ініцыялізатар"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "прапушчан ініцыялізатар"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr ""
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, gcc-internal-format
 msgid "%qT object created here"
 msgstr ""
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "allocated here"
 msgstr "выклікана адсюль"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "%qD used in its own initializer"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%q#D is not const"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr ""
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "use of %qD"
 msgstr "нерэчаіснае выкарыстаньне `%D'"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr ""
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr ""
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr ""
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr ""
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr ""
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr ""
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr ""
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr ""
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr ""
@@ -58500,354 +58548,354 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr ""
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr ""
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr ""
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr ""
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr ""
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr ""
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr ""
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an aggregate"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an array"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr ""
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qT is not a function"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr ""
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr ""
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr ""
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr ""
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr ""
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qT is not a union"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr ""
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3358
-#, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr ""
+#: cp/constraint.cc:3363
+#, fuzzy, gcc-internal-format
+msgid "%qT is not a structural type"
+msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr ""
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr ""
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr ""
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr ""
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 msgid "invalid constraints"
 msgstr "Нерэчаісны выбар %s"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr ""
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr ""
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -58878,50 +58926,50 @@ msgstr ""
 msgid "previous declaration with fewer contracts here"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "parameter declared here"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "declaration adds contracts to %q#D"
 msgstr "абвяшчэньне шаблёну `%#D'"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, gcc-internal-format
 msgid "first declared here"
 msgstr ""
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -58993,7 +59041,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr ""
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr ""
@@ -59065,84 +59113,84 @@ msgstr ""
 msgid "awaitable type %qT is not a structure"
 msgstr ""
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr ""
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr ""
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `%s'"
 msgid "duplicate info for %qE"
 msgstr "паўтарэньне `%s'"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr ""
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -59167,68 +59215,73 @@ msgstr ""
 msgid "%qs used outside of constant expressions"
 msgstr ""
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr ""
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr ""
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -59270,7 +59323,7 @@ msgstr ""
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr ""
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr ""
@@ -59664,7 +59717,7 @@ msgstr "папярэдняе абвяшчэньне `%D'"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "гэта папярэдняе абвяшчэньне"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration `%D'"
 msgid "previous declaration %qD"
@@ -59892,13 +59945,13 @@ msgstr "нехапае аргументаў у функцыі \"%s\""
 msgid "previous specification in %q#D here"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with previous declaration `%#D'"
 msgid "conflicting exporting for declaration %qD"
 msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr ""
@@ -60108,7 +60161,7 @@ msgstr "ініцыялізацыя"
 msgid "  enters %<template for%> statement"
 msgstr ""
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr ""
@@ -60153,2449 +60206,2459 @@ msgstr ""
 msgid "template parameters do not match template %qD"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr ""
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr ""
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr ""
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr ""
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr ""
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr ""
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr ""
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr ""
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr ""
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr ""
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored"
 msgid "attribute ignored"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr ""
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr ""
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr ""
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr ""
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "пустое абвяшчэнне"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, fuzzy, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr ""
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, fuzzy, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr ""
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr ""
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr ""
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr ""
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, fuzzy, gcc-internal-format
 #| msgid "array size missing in `%D'"
 msgid "array size missing in %qD"
 msgstr "прапушчан памер масіва ў `%D'"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, fuzzy, gcc-internal-format
 #| msgid "zero-size array `%D'"
 msgid "zero-size array %qD"
 msgstr "нулявы памер масіва `%D'"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr ""
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr ""
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr ""
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr ""
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, fuzzy, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr ""
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr ""
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr ""
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer for %q#D"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, fuzzy, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, fuzzy, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr ""
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, fuzzy, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr ""
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr ""
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr ""
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr ""
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr ""
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "Не магу знайсці дэкларацыю інтэрфейса для \"%s\""
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "%<declare variant%> on deleted %qD"
 msgstr "абвяшчэньне шаблёну `%#D'"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr ""
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr ""
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "вяртаемы тып \"%s\" не \"int\""
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr ""
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, fuzzy, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr ""
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr ""
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr ""
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, gcc-internal-format
 msgid "lambda declared here"
 msgstr ""
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr ""
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, gcc-internal-format
 msgid "in base class of %qT"
 msgstr ""
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr ""
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr ""
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr ""
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr ""
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr ""
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr ""
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr ""
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 #| msgid "array size missing in `%D'"
 msgid "array size missing in %qT"
 msgstr "прапушчан памер масіва ў `%D'"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 #| msgid "zero-size array `%D'"
 msgid "zero-size array %qT"
 msgstr "нулявы памер масіва `%D'"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr ""
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr ""
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr ""
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr ""
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr ""
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr ""
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr ""
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr ""
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "-pipe не падтрымліваецца."
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr ""
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, fuzzy, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "ініцыялізацыя"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr ""
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr ""
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr ""
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr ""
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr ""
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr ""
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid "  from here"
 msgid "  declared here"
 msgstr " адсюль"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr ""
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr ""
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr ""
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, fuzzy, gcc-internal-format
 #| msgid "`main' must return `int'"
 msgid "%<::main%> must return %<int%>"
 msgstr "`main' павінна вяртаць `int'"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr ""
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr ""
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "ініцыялізацыя"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr ""
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr ""
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr ""
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "-pipe не падтрымліваецца."
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr ""
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr ""
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr ""
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr ""
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' has non-integer type"
 msgid "size of array %qD has non-integral type %qT"
 msgstr "памер масіва `%D' не цэлалікавы тып"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr ""
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D'"
 msgid "declaration of %qD as array of void"
 msgstr "абвяшчэньне `%#D'"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr ""
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr ""
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr ""
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr ""
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr ""
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr ""
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr ""
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr ""
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not at beginning of declaration"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 msgid "%e and %e specified together"
 msgstr ""
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr ""
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D'"
 msgid "declaration of %qE as non-member"
 msgstr "абвяшчэньне `%#D'"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr ""
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D'"
 msgid "declaration of %qD as %<typedef%>"
 msgstr "абвяшчэньне `%#D'"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D'"
 msgid "declaration of %qD as parameter"
 msgstr "абвяшчэньне `%#D'"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not at beginning of declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, fuzzy, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "пустое абвяшчэнне"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain `complex' meaning `double complex'"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C не падтрымлівае просты \"complex\" у значэнні \"double complex\""
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_saveregs not supported by this target"
 msgid "%<__int%d%> is not supported by this target"
 msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support `long long'"
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ не падтрымлівае \"long long\""
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr ""
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr ""
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr ""
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr ""
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, fuzzy, gcc-internal-format
 #| msgid "complex invalid for `%s'"
 msgid "complex invalid for %qs"
 msgstr "complex нерэчаісны для \"%s\""
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr ""
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid declaration"
 msgid "%<virtual%> outside class declaration"
 msgstr "Нерэчаіснае абвяшчэнне"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr ""
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate label declaration `%s'"
 msgid "multiple storage classes in declaration of %qs"
 msgstr "паўторнае абвяшчэньне адмеціны `%s'"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr ""
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr ""
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr ""
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr ""
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr ""
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' undeclared (first use in this function)"
 msgid "%qs declared as function returning a function"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr ""
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr ""
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr ""
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr ""
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr ""
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "Не магу знайсці файл для класа %s."
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr ""
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr ""
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr ""
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr ""
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate label declaration `%s'"
 msgid "%<explicit%> outside class declaration"
 msgstr "паўторнае абвяшчэньне адмеціны `%s'"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr ""
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, fuzzy, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, fuzzy, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr ""
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr ""
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr ""
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, fuzzy, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr ""
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr ""
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr ""
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "Не магу знайсці дэкларацыю пратакола для \"%s\""
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr ""
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr ""
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `::'"
 msgid "invalid use of %<::%>"
 msgstr "нерэчаіснае выкарыстаньне `::'"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr ""
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "declaration of %qD as member of %qT"
 msgstr "абвяшчэньне шаблёну `%#D'"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "[cannot find %s]"
 msgid "%qD cannot be %qs"
 msgstr "[нельга знайсці %s]"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr ""
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, fuzzy, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr ""
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr ""
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr ""
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr ""
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "can't initialize friend function `%s'"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr ""
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr ""
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr ""
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr ""
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr ""
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr ""
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr ""
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr ""
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr ""
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr ""
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr ""
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr ""
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr ""
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr ""
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr ""
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "%qD must have no arguments"
 msgstr "няма аргументаў"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr ""
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr ""
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr ""
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, fuzzy, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr ""
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 #| msgid "this is a previous declaration"
 msgid "%qD has a previous declaration here"
 msgstr "гэта папярэдняе абвяшчэньне"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr ""
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "this is a previous declaration"
 msgid "%qT has a previous declaration here"
 msgstr "гэта папярэдняе абвяшчэньне"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr ""
@@ -62607,101 +62670,101 @@ msgstr ""
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, fuzzy, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr ""
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, fuzzy, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "redeclaration of %qT as a non-template"
 msgstr "абвяшчэньне шаблёну `%#D'"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr ""
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr ""
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, fuzzy, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "паўтарэнне \"restrict\""
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "папярэдняе вызначэньне"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr ""
@@ -62710,88 +62773,93 @@ msgstr ""
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr ""
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr ""
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr ""
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr ""
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr ""
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of `%#T'"
 msgid "multiple definition of %q#T"
 msgstr "папярэдняе вызначэньне `%#T'"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, fuzzy, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "вяртаемы тып \"%s\" не \"int\""
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr ""
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr ""
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr ""
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr ""
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, fuzzy, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "не знойдзен клас \"%s\""
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr ""
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "\"%s\" - гэта не пачатак дэкларацыі"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -63225,346 +63293,346 @@ msgstr ""
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr ""
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "In file included from %s:%d"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "У файле уключаным з %s:%d"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr ""
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "In copy constructor %qD"
 msgstr "У канструкцыі"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "In constructor %qD"
 msgstr "У канструкцыі"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "In destructor %qD"
 msgstr "У канструкцыі"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 #| msgid "In function"
 msgid "In lambda function"
 msgstr "У функцыі"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "у функцыі \"%s\":"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 msgid "In member function %qD"
 msgstr "у функцыі \"%s\":"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function"
 msgid "In function %qD"
 msgstr "У функцыі"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, gcc-internal-format
 msgid "but %qE is a type"
 msgstr ""
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr ""
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr ""
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "невыкарыстаемы параметр \"%s\""
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "but %qE is a function"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr ""
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr ""
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr ""
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr ""
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr ""
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr ""
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "ініцыялізацыя"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr ""
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "required from here\n"
 msgstr "выклікана адсюль"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr ""
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr ""
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "няма аргументаў"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "няма аргументаў"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, fuzzy, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr ""
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr ""
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr ""
@@ -63785,7 +63853,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -63902,7 +63970,7 @@ msgstr ""
 msgid "type %qT is not a direct base of %qT"
 msgstr ""
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class type"
@@ -64094,43 +64162,43 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr ""
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' has an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
@@ -64165,83 +64233,91 @@ msgstr "\"%s\" мае незавершаны тып"
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr ""
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter `%s'"
 msgid "invalid %<#pragma %s%>"
 msgstr "нерэчаісны парамэтр `%s'"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr ""
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr ""
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, fuzzy, gcc-internal-format
 msgid "%qD not defined"
 msgstr "YYDEBUG не вызначан."
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -64251,64 +64327,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -64692,7 +64761,7 @@ msgstr "няма папярэдняга аб'яўлення для \"%s\""
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with previous declaration `%#D'"
 msgid "conflicting type for imported declaration %#qD"
@@ -64710,429 +64779,429 @@ msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with previous declaration `%#D'"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with previous declaration `%#D'"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with previous declaration `%#D'"
 msgid "conflicting imported declaration %q#D"
 msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration `%D'"
 msgid "existing declaration %#qD"
 msgstr "у абвяшчэньні  `%D'"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, gcc-internal-format
 msgid "existing default declared here"
 msgstr ""
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr ""
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition here"
 msgid "existing definition %qD"
 msgstr "папярэдняе вызначэньне"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr ""
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr ""
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr ""
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr ""
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr ""
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr ""
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr ""
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr ""
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr ""
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr ""
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr ""
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr ""
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr ""
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr ""
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr ""
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr ""
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr ""
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr ""
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of `%D'"
 msgid "previously declared in module %qs"
 msgstr "папярэдняе абвяшчэньне `%D'"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of `%D'"
 msgid "previously declared in global module"
 msgstr "папярэдняе абвяшчэньне `%D'"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr ""
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr ""
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr ""
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, gcc-internal-format
 msgid "module declared here"
 msgstr ""
@@ -65144,110 +65213,110 @@ msgstr ""
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr ""
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr ""
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr ""
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown compiled module interface: %s"
 msgstr "невядомая назва рэгістра: %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr ""
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for `%s'"
 msgid "invalid header name %qs"
 msgstr "нерэчаісная назва рэгістра `%s'"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "Нерэчаісны выбар %s"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing to %s"
 msgid "writing CMI %qs"
 msgstr "памылка запісу ў %s"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr ""
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown header kind %qs"
@@ -65263,7 +65332,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
@@ -65310,264 +65379,274 @@ msgstr "абвяшчэньне `%#D'"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr ""
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr ""
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr ""
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr ""
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr ""
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "%s: Not a directory"
 msgid "%qT is not a direct base of %qT"
 msgstr "%s: не дырэкторыя"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "using-declaration may not name namespace %qD"
 msgstr "абвяшчэньне шаблёну `%#D'"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "дэструктару неабходны \"%#D\""
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, fuzzy, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr ""
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored"
 msgid "%qD attribute directive ignored"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr ""
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr ""
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr ""
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr ""
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr ""
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "нерэчаісны ініцыялізатар"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr ""
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, fuzzy, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "previous definition here"
 msgid "reachable %s definition here"
 msgstr "папярэдняе вызначэньне"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -65597,7 +65676,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -65642,7 +65721,7 @@ msgstr ""
 msgid "request for member %qE in non-class type %qT"
 msgstr ""
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr ""
@@ -65712,7 +65791,7 @@ msgstr "Не магу знайсці дэкларацыю інтэрфейса 
 msgid "%qE is not a class template"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "\"%s\" мае незавершаны тып"
@@ -66024,1708 +66103,1718 @@ msgstr ""
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr ""
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "\"%s\" звычайна функцыя"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe is not supported"
 msgid "fixed-point types not supported in C++"
 msgstr "-pipe не падтрымліваецца"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr ""
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr ""
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr ""
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr ""
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr ""
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr ""
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr ""
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr ""
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr ""
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr ""
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, gcc-internal-format
 msgid "selected function declared here"
 msgstr ""
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr ""
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "invalid use of %qD"
 msgstr "нерэчаіснае выкарыстаньне `%D'"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr ""
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr ""
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr ""
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr ""
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr ""
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr ""
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr ""
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr ""
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr ""
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr ""
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr ""
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr ""
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr ""
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr ""
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr ""
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr ""
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr ""
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "default argument specified for lambda parameter"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, gcc-internal-format
+msgid "%q#E declared here"
+msgstr ""
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr ""
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected labeled-statement"
 msgstr "пустое цела ў else-выражэнні"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr ""
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr ""
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected selection-statement"
 msgstr "пустое цела ў else-выражэнні"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr ""
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "condition declares a function"
 msgstr "не хапае аргументаў у функцыі"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr ""
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "expected initializer"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr ""
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr ""
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected iteration-statement"
 msgstr "пустое цела ў else-выражэнні"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr ""
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr ""
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr ""
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr ""
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr ""
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr ""
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr ""
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr ""
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr ""
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr ""
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr ""
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr ""
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr ""
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "ініцыялізацыя"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr ""
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, fuzzy, gcc-internal-format
 #| msgid "multiple declarations `%T' and `%T'"
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "неаднолькавае абвяшчэньне `%T' і `%T'"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "empty structured binding declaration"
 msgstr "пустое абвяшчэньне"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr ""
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr ""
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr ""
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, fuzzy, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr ""
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "Нерэчаісная спецыфікацыя! Памылка ў cc."
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr ""
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr ""
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr ""
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "прапушчан ініцыялізатар"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr ""
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr ""
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 #| msgid "unregistered operator %s"
 msgid "expected operator"
 msgstr "нераспазнаны аператар %s"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr ""
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr ""
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr ""
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr ""
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr ""
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr ""
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr ""
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr ""
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr ""
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr ""
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr ""
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr ""
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr ""
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "%qE does not constrain a type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr ""
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr ""
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr ""
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr ""
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr ""
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr ""
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr ""
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr ""
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr ""
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr ""
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids an empty source file"
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C не дазваляе пусты ізыходны файл"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr ""
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD is not a namespace-name"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr ""
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr ""
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr ""
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr ""
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, fuzzy, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr ""
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr ""
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr ""
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "паўтарэнне \"volatile\""
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr ""
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr ""
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr ""
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr ""
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr ""
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr ""
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr ""
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, fuzzy, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr ""
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr ""
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, fuzzy, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr ""
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "\"%s\" мае незавершаны тып"
@@ -67734,281 +67823,281 @@ msgstr "\"%s\" мае незавершаны тып"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "нерэчаісны абвяшчальнік"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid declaration"
 msgid "qualified-id in declaration"
 msgstr "Нерэчаіснае абвяшчэнне"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declarator"
 msgstr "пустое абвяшчэньне"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr ""
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr ""
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr ""
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `volatile'"
 msgid "duplicate cv-qualifier"
 msgstr "паўтарэнне \"volatile\""
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr ""
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `volatile'"
 msgid "duplicate virt-specifier"
 msgstr "паўтарэнне \"volatile\""
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "невыкарыстаемы параметр \"%s\""
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr ""
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%T'"
 msgid "invalid use of %qT"
 msgstr "нерэчаіснае выкарыстаньне `%T'"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr ""
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr ""
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr ""
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr ""
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr ""
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr ""
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, fuzzy, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr "прапушчан прабел пасля нумара \"%.*s\""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr ""
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr ""
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr ""
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr ""
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr ""
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `%s'"
 msgid "duplicate %qD specifier"
 msgstr "паўтарэньне `%s'"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr ""
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr ""
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, fuzzy, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "Нерэчаіснае абвяшчэнне"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr ""
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, fuzzy, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "ініцыялізацыя"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr ""
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of `%#T'"
 msgid "previous definition of %q#T"
@@ -68017,268 +68106,268 @@ msgstr "папярэдняе вызначэньне `%#T'"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr ""
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr ""
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "бітавае поле \"%s\" мае нерэчаісны тып"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr ""
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr ""
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr ""
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr ""
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr ""
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr ""
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr ""
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on %qs"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr ""
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr ""
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr ""
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr ""
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "Нерэчаіснае абвяшчэнне"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, fuzzy, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "невыкарыстаемы параметр \"%s\""
@@ -68287,439 +68376,439 @@ msgstr "невыкарыстаемы параметр \"%s\""
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr ""
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, fuzzy, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "-pipe не падтрымліваецца."
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr ""
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "ініцыялізацыя"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "пустое абвяшчэнне"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr ""
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "ініцыялізацыя"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr ""
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr ""
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr ""
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support `long long'"
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ не падтрымлівае \"long long\""
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr ""
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `%s'"
 msgid "duplicate %qD"
 msgstr "паўтарэньне `%s'"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `%s'"
 msgid "duplicate %qs"
 msgstr "паўтарэньне `%s'"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr ""
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr ""
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr ""
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr ""
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr ""
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr ""
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 #| msgid "unregistered operator %s"
 msgid "expected %<operator%>"
 msgstr "нераспазнаны аператар %s"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr ""
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr ""
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr ""
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr ""
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr ""
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr ""
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr ""
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr ""
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr ""
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr ""
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr ""
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr ""
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr ""
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr ""
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr ""
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr ""
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr ""
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr ""
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr ""
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr ""
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr ""
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr ""
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr ""
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr ""
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr ""
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, fuzzy, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr ""
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr ""
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mode for gen_tst_reg"
 msgid "invalid type for instance variable"
 msgstr "нерэчаісны рэжым для gen_tst_reg"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr ""
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid type for property"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr ""
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr ""
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr ""
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr ""
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid reduction-identifier"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr ""
@@ -68728,175 +68817,175 @@ msgstr ""
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr ""
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr ""
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr ""
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD is not a C pointer"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr ""
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr ""
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr ""
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr ""
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr ""
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr ""
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr ""
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr ""
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr ""
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr ""
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr ""
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -69378,498 +69467,503 @@ msgstr ""
 msgid "redeclaration of %qD with different constraints"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr ""
+
+#: cp/pt.cc:6461
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, fuzzy, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "пустое абвяшчэнне"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "нявернае выкарыстанне \"restict\""
 msgstr[1] "нявернае выкарыстанне \"restict\""
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "няма папярэдняга аб'яўлення для \"%s\""
 msgstr[1] "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, fuzzy, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "невыкарыстаемы параметр \"%s\""
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr ""
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr ""
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr ""
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr ""
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "невыкарыстаемы параметр \"%s\""
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr ""
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr ""
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr ""
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr ""
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr ""
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr ""
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr ""
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for `%#D' has type `%T'"
 msgid "in template argument for type %qT"
 msgstr "звычайны аргумэнт для `%#D' мае тып `%T'"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr ""
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr ""
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr ""
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr ""
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr ""
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr ""
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr ""
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of destructor %qE as a type"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr ""
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr ""
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr ""
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr ""
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 msgid "provided for %qD"
 msgstr "дэструктару неабходны \"%#D\""
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr ""
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr ""
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, fuzzy, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "пустое абвяшчэнне"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr ""
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr ""
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr ""
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr ""
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr ""
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr ""
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr ""
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr ""
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find `nm'"
 msgid "cannot index an empty pack"
 msgstr "нельга знайсці \"nm\""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr ""
@@ -69887,125 +69981,125 @@ msgstr ""
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter type `%T'"
 msgid "invalid parameter type %qT"
 msgstr "нерэчаісны тып парамэтра `%T'"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration `%D'"
 msgid "in declaration %q+D"
 msgstr "у абвяшчэньні  `%D'"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function returning an array"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, fuzzy, gcc-internal-format
 msgid "function returning a function"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr ""
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr ""
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr ""
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr ""
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr ""
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr ""
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr ""
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr ""
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, fuzzy, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "\"%s\" звычайна функцыя"
@@ -70013,209 +70107,209 @@ msgstr "\"%s\" звычайна функцыя"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr ""
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr ""
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr ""
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr ""
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr ""
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr ""
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr ""
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for `%#D' has type `%T'"
 msgid "template argument for %qD uses local type %qT"
 msgstr "звычайны аргумэнт для `%#D' мае тып `%T'"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr ""
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, fuzzy, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr ""
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr ""
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr ""
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr ""
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr ""
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr ""
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr ""
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "паўторнае абвяшчэнне меткі \"%s\""
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr ""
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr ""
@@ -70227,513 +70321,568 @@ msgstr ""
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr ""
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr ""
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "\"%s\" - гэта не пачатак дэкларацыі"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "a concept cannot be constrained"
 msgstr "віртуальныя функцыі не могуць быць сяброўскімі"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr ""
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr ""
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr ""
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr ""
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr ""
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "ініцыялізацыя"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr ""
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr ""
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr ""
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr ""
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr ""
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr ""
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr ""
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr ""
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:476
 #, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr ""
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr ""
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, gcc-internal-format
 msgid "couldn%'t look up %qs"
 msgstr ""
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr ""
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr ""
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr ""
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr ""
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr ""
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr ""
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr ""
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "аргумент для \"%s\" прапушчан"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "невядомы рэжым машыны \"%s\""
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr ""
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr ""
+
+#: cp/reflect.cc:8540
+#, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr ""
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr ""
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr ""
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr ""
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr ""
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr ""
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr ""
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "\"%s\" звычайна функцыя"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -71067,584 +71216,584 @@ msgstr "нявернае выкарыстанне \"restict\""
 msgid "invalid base-class specification"
 msgstr "Нерэчаісная спецыфікацыя! Памылка ў cc."
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr ""
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr ""
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr ""
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments"
 msgstr "параметр \"%s\" ініцыялізаваны"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr ""
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr ""
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr ""
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "памер масіва \"%s\" адмоўны"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr ""
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr ""
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr ""
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr ""
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr ""
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr ""
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr ""
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr ""
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr ""
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr ""
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr ""
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr ""
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr ""
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr ""
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr ""
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr ""
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr ""
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr ""
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr ""
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr ""
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr ""
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr ""
@@ -71652,347 +71801,347 @@ msgstr ""
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr ""
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr ""
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid " declared here"
 msgstr "выклікана адсюль"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "Выкарыстоўваць апаратную \"плаваючую кропку\""
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr ""
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr ""
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr ""
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr ""
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "Клас \"%s\" ужо існуе"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD is not public"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr ""
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr ""
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr ""
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr ""
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr ""
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr ""
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr ""
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr ""
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr ""
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr ""
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "сімвальная канстанта вельмі доўгая"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr ""
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr ""
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr ""
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr ""
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "annotation applied to a label"
 msgstr "\"%s\" атрыбут ігнарыруецца"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter `%s'"
 msgid "annotation on void parameter"
 msgstr "нерэчаісны парамэтр `%s'"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "функцыя не вяртае тып string"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr ""
@@ -72192,804 +72341,809 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr ""
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr ""
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr ""
+
+#: cp/typeck.cc:3781
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD is not a member template function"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr ""
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr ""
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr ""
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr ""
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "\"%s\" звычайна функцыя"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "вельмі шмат аргументаў у функцыі \"%s\""
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments to member function %q#D"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to member function %q#D"
 msgstr "не хапае аргументаў у функцыі"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments to function %q#D"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to function %q#D"
 msgstr "не хапае аргументаў у функцыі"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "вельмі шмат аргументаў у функцыі \"%s\""
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "не хапае аргументаў у функцыі"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, fuzzy, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, fuzzy, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr ""
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr ""
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr ""
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr ""
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr ""
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr ""
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "ISO C не дазваляе пусты ізыходны файл"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C не дазваляе пусты ізыходны файл"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, fuzzy, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "не магу атрымаць адрас бітавага поля \"%s\""
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids an empty source file"
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C не дазваляе пусты ізыходны файл"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr ""
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr ""
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr ""
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr ""
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr ""
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr ""
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr ""
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "вяртаемы тып \"%s\" не \"int\""
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from `%T' to `%T'"
 msgid "converting from %qH to %qI"
 msgstr "пераўтварэньне з `%T' у `%T'"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr ""
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr ""
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr ""
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, fuzzy, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C не дазваляе дэкларацыі метак (label)"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, fuzzy, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr ""
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr ""
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr ""
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr ""
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 msgid "array used as initializer"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "Нерэчаісны выбар %s"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr ""
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "Нерэчаісны выбар \"%s\""
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr ""
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr ""
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr ""
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr ""
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr ""
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "аргумент для \"%s\" прапушчан"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr ""
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr ""
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr ""
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "returning initializer list"
 msgstr "прапушчан ініцыялізатар"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr ""
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s value"
 msgid "using rvalue as lvalue"
@@ -73402,17 +73556,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "невядомая назва рэгістра: %s\n"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr ""
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -73437,43 +73591,43 @@ msgstr "прапушчан ініцыялізатар"
 msgid "the address of %qD will never be %<null%>"
 msgstr ""
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr ""
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr ""
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr ""
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr ""
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr ""
@@ -73551,25 +73705,25 @@ msgstr ""
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr ""
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can't open %s for writing"
 msgid "unable to open %s for writing: %m"
 msgstr "немагчыма адчыніць %s для запісу"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "can't open output file `%s'"
 msgid "writing output file %s: %m"
 msgstr "немагчыма адчыніць файл уводу `%s'"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "%s: can't open file `%s' for reading: %s\n"
 msgid "unable to open %s for reading: %m"
 msgstr "%s: немагчыма адчыніць файл `%s' для чытаньня: %s\n"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid ""
 #| "\n"
@@ -73579,12 +73733,12 @@ msgstr ""
 "\n"
 "%s: памылка чытаньня файла ўводу `%s': %s\n"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -73682,7 +73836,7 @@ msgstr ""
 msgid "%qs is not an associative array"
 msgstr "\"%s\" мае незавершаны тып"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -73697,22 +73851,22 @@ msgstr ""
 msgid "%qs is not a field, but a %qs"
 msgstr ""
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr ""
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr ""
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr ""
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr ""
@@ -73804,17 +73958,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -74137,8 +74291,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74415,7 +74569,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr ""
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid string constant `%E'"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -74491,7 +74645,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr ""
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "аргумент `__builtin_args_info' павінен быць канстантай"
@@ -74632,7 +74786,7 @@ msgstr ""
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr ""
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr ""
@@ -74647,7 +74801,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr ""
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr ""
@@ -74788,8 +74942,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74888,9 +75042,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr ""
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -74905,12 +75059,12 @@ msgstr ""
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr ""
@@ -75005,619 +75159,619 @@ msgstr ""
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr ""
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "аргумент для \"%s\" прапушчан"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "пустая сімвальная канстанта"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr ""
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr ""
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr ""
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr ""
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr ""
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr ""
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr ""
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr ""
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr ""
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr ""
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr ""
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr ""
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr ""
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr ""
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr ""
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr ""
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr ""
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr ""
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr ""
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr ""
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr ""
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr ""
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "памер \"%s\" больш чам %d байт"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr ""
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr ""
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr ""
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr ""
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr ""
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "вельмі шмат аргументаў у функцыі \"%s\""
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr ""
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr ""
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr ""
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr ""
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -75683,12 +75837,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -75739,2062 +75893,2062 @@ msgstr ""
 msgid "Simplification error"
 msgstr ""
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "нерэчаісны ініцыялізатар"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr ""
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr ""
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "пустая сімвальная канстанта"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr ""
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr ""
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr ""
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr ""
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing initializer"
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "прапушчан ініцыялізатар"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr ""
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\""
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr ""
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr ""
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "ініцыялізацыя"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr ""
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr ""
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization"
 msgid "Old-style initialization at %C"
 msgstr "ініцыялізацыя"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr ""
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr ""
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr ""
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr ""
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr ""
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr ""
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "вельмі шмат аргументаў у функцыі"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr ""
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr ""
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "Missing name"
 msgid "Missing symbol"
 msgstr "Прапушчана назва"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr ""
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr ""
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr ""
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr ""
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr ""
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr ""
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr ""
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr ""
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr ""
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr ""
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr ""
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr ""
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr ""
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr ""
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr ""
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr ""
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "Unknown procedure name %qs at %C"
 msgstr "невядомая назва рэгістра: %s"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr ""
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr ""
@@ -77937,408 +78091,408 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr ""
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr ""
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr ""
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr ""
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr ""
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr ""
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr ""
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr ""
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr ""
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr ""
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -78346,197 +78500,197 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr ""
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -78557,7 +78711,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -78619,42 +78773,42 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr ""
@@ -78779,12 +78933,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -79210,308 +79364,313 @@ msgstr ""
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr ""
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr ""
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr ""
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr ""
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 #| msgid "failed to find class '%s'"
 msgid "Unable to find symbol %qs"
 msgstr "не знойдзен клас \"%s\""
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr ""
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr ""
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr ""
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr ""
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr ""
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr ""
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr ""
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr ""
@@ -79701,7 +79860,7 @@ msgstr "пераўтварэньне з `%T' у `%T'"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr ""
@@ -80248,7 +80407,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -80423,12 +80582,12 @@ msgstr ""
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -80931,7 +81090,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr ""
@@ -81444,92 +81603,92 @@ msgstr ""
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr ""
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -82521,7 +82680,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -82556,12 +82715,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -83035,7 +83194,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr ""
@@ -83055,7 +83214,7 @@ msgstr ""
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -83085,17 +83244,17 @@ msgstr ""
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -83215,8 +83374,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -83296,7 +83455,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr ""
@@ -83319,7 +83478,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -83359,7 +83518,7 @@ msgstr ""
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr ""
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -83671,598 +83830,608 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr ""
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -84928,62 +85097,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr ""
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr ""
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -84991,7 +85160,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -85449,1082 +85618,1082 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr ""
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr ""
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr ""
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr ""
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr ""
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr ""
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr ""
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr ""
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr ""
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "метка \"%s\" вызначана, але не выкарыстоўваецца"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "памер \"%s\" - %d байт"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr ""
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr ""
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr ""
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qs at %L is not a function"
 msgstr "`%D' - гэта ня функцыя,"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr ""
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr ""
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr ""
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "памер масіва \"%s\" вельмі вялікі"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "першым аргументам \"%s\" павінен быць \"int\""
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr ""
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array `%s' is too large"
 msgid "Substring end index at %L is too large"
 msgstr "памер масіва \"%s\" вельмі вялікі"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -86533,12 +86702,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -86547,414 +86716,414 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid parameter type `%T'"
 msgid "Invalid array reference at %L"
 msgstr "нерэчаісны тып парамэтра `%T'"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr ""
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr ""
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -86963,314 +87132,314 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr ""
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr ""
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr ""
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -87278,213 +87447,213 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr ""
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "abort in %s, at %s:%d"
 msgid "Cannot assign %s to %s at %L"
 msgstr "спынена ў %s, ля %s:%d"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -87492,1059 +87661,1059 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array `%s' is too large"
 msgid "String length at %L is too large"
 msgstr "памер масіва \"%s\" вельмі вялікі"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr ""
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr ""
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr ""
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr ""
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr ""
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr ""
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "label `%s' defined but not used"
 msgid "Label %d at %L defined but not used"
 msgstr "адмеціна `%s' вызначана, але ня выкарыстоўваецца"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "label `%s' defined but not used"
 msgid "Label %d at %L defined but cannot be used"
 msgstr "адмеціна `%s' вызначана, але ня выкарыстоўваецца"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr ""
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -88567,101 +88736,101 @@ msgstr "немагчыма стварыць дырэкторыю \"%s\""
 msgid "%qs is not a directory"
 msgstr "%s: не дырэкторыя"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "пустая сімвальная канстанта"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "сімвальная канстанта вельмі доўгая"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "label `%s' used but not defined"
 msgid "file %qs left but not entered"
 msgstr "адмеціна `%s' выкарыстоўвываецца, але ня вызначана"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr ""
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Could not open data file %s.\n"
 msgid "Cannot open file %qs"
 msgstr "Немагчыма адчыніць файл з дадзенымі %s.\n"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "can't close input file %s"
 msgid "Cannot open included file %qs"
 msgstr "немагчыма зачыніць уваходзячы файл %s"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "can't open output file `%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "немагчыма адчыніць файл уводу `%s'"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr ""
@@ -88827,219 +88996,219 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "second argument of `%s' should be `char **'"
 msgid "Second argument of %s is negative at %L"
 msgstr "другім аргументам \"%s\" павінен быць \"char **\""
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr ""
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr ""
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr ""
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr ""
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr ""
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "нявернае выкарыстанне \"restict\""
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -89377,74 +89546,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr ""
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -89474,29 +89643,34 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr ""
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -89599,114 +89773,114 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr ""
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 #| msgid "unused variable `%s'"
 msgid "Unused variable %qs declared at %L"
 msgstr "невыкарыстоўваемая пераменная \"%s\""
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "тып параметра \"%s\" не аб'яўлены"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr ""
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -89736,13 +89910,13 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "невядомы рэжым машыны \"%s\""
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "Unknown argument list function at %L"
 msgstr "нехапае аргументаў у функцыі \"%s\""
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -89758,12 +89932,12 @@ msgstr ""
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr ""
@@ -89788,183 +89962,183 @@ msgstr "атрыбуты секцыі не падтрымліваюцца для
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 msgid "optional class parameter"
 msgstr "невыкарыстаемы параметр \"%s\""
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr ""
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr ""
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find source %s"
 msgid "Cannot find symbol %qs at %L"
 msgstr "не магу знайсці крыніцу %s"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr ""
@@ -90311,7 +90485,7 @@ msgstr "не магу зачыніць %s"
 msgid "two or more sections for %s"
 msgstr "няма папярэдняга аб'яўлення для \"%s\""
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -90643,32 +90817,32 @@ msgstr "параметр \"%s\" ініцыялізаваны"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr ""
--- a/src/gcc/po/da.po
+++ b/src/gcc/po/da.po
@@ -137,7 +137,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc-9.1-b20190203\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2019-02-14 11:00+0200\n"
 "Last-Translator: Joe Hansen <joedalton2@yahoo.dk>\n"
 "Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
@@ -1524,13 +1524,13 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Kendte PTX ISA-versioner (for brug med tilvalget -misa=):"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 #| msgid "Specify the version of the ptx ISA to use."
 msgid "Specify the PTX ISA version to use."
 msgstr "Angiv versionen for ptx ISA'en at anvende."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers"
 msgid "Initialize ptx registers."
@@ -2425,13 +2425,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 #| msgid "Pass all arguments on stack"
@@ -2943,7 +2943,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Antag at målprocessoren er konfigureret som storendet"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 #| msgid "Assume target CPU is configured as little endian"
 msgid "Assume target CPU is configured as little endian."
@@ -3023,7 +3023,7 @@ msgstr "Benyt subrutiner for funktionsindledning/-afslutninger"
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 #| msgid "Specify the MCU name"
@@ -3064,7 +3064,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 #| msgid "Omit the frame pointer in leaf functions"
 msgid "Omit the frame pointer in leaf functions."
@@ -3181,7 +3181,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -3227,7 +3227,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5743,7 +5743,7 @@ msgstr "Understøt indbyggede RTM-funktioner og kodegenerering"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -6132,7 +6132,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -6463,221 +6463,226 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify the name of the target architecture"
 msgid "The register used to access the thread pointer:"
 msgstr "Angiv navnet på målarkitekturen"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 #| msgid "Use given thread-local storage dialect"
 msgid "Specify the thread pointer register."
 msgstr "Benyt den givne tråd-lokale lagringsdialekt"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, fuzzy, no-c-format
 #| msgid "Don't assume that unaligned accesses are handled by the system"
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "Antag ikke at ujusterede tilgange håndteres af systemet"
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 #| msgid "Specify bit size of immediate TLS offsets"
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Angiv bitstørrelse for umiddelbar TLS-afsæt"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "Specify the name of the target architecture"
 msgid "Use features of architecture ARCH."
 msgstr "Angiv navnet på målarkitekturen"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule code for given CPU"
 msgid "Use features of and optimize for CPU."
 msgstr "Benyt faciliteter fra og planlæg koden til en given processor"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, fuzzy, no-c-format
 #| msgid "Optimize for 3900"
 msgid "Optimize for CPU."
 msgstr "Optimér for 3900"
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "Generate code that conforms to the given ABI"
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Opret kode som overholde den angivne ABI"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate a call to abort if a noreturn function returns"
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Generér et kald til abort hvis en noreturn-funktion returnerer"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "`%s' is deprecated"
 msgid "This option is deprecated."
@@ -12344,7 +12349,7 @@ msgstr "Aktivér sammenkæderoptimeringer"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -19662,97 +19667,97 @@ msgstr ""
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a map"
 msgid "argument must be passed by copying"
 msgstr "1. parameter skal være en oversættelse"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 #, fuzzy
 #| msgid "argument #%d is a structure"
 msgid "callee returns a structure"
 msgstr "%d. parameter er en struktur"
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 #| msgid "call %d returns = %s\n"
 msgid "callee returns twice"
 msgstr "kald %d returnerer = %s\n"
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 #| msgid "call %d returns = %s\n"
 msgid "callee does not return"
 msgstr "kald %d returnerer = %s\n"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "sizeof applied to a function type"
 msgid "volatile function type"
 msgstr "sizeof benyttet på en funktionstype"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "forventet funktion"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "destructors take no parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "destruktionsfunktioner kan ikke have parametre"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support %s"
 msgid "frontend does not support sibling call"
 msgstr "%s understøtter ikke %s"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "variable size arguments"
 msgstr "ugyldig typeparameter"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "Pass all arguments on stack"
 msgid "hidden string length argument passed on stack"
 msgstr "Overbring alle parametre på stakken"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "verification error at PC=%d"
 msgid "tail call production failed"
@@ -19874,12 +19879,12 @@ msgstr "»%%l«-operand er ikke en etiket"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "kommatalskonstant misbrugt"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -21228,13 +21233,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "dette er instruktionen:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "invalid operand address"
 msgid "unable to reload address in "
 msgstr "ugyldig operandadresse"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "kunne ikke generere genindlæsninger for:"
 
@@ -21462,7 +21467,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC-heuristikker: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonym>"
@@ -21858,20 +21863,20 @@ msgstr "Ikke understøttet operand for koden »%c«"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "ugyldig operand for »%%%c«"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid constant"
 msgid "invalid vector constant"
@@ -21920,82 +21925,82 @@ msgstr "ugyldig operandpræfiks »%%%c«"
 msgid "invalid address mode"
 msgstr "ugyldig adresseringstilstand"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "ugyldig konvertering fra %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type `%T' from type `%T'"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "ugyldig omdannelse til typen '%T' fra typen '%T'"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "pointers are not permitted as case values"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "henvisningsvariabler er ikke tilladt som case-værdier"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 msgid "negation operation not permitted on svbool_t"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 #| msgid "-fstack-limit- options are not supported on this cpu"
 msgid "subscript operation not supported on svbool_t"
 msgstr "-fstack-limit- tilvalg er ikke understøttet på denne cpu"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands to binary %s"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "ugyldige operander til binær %s"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -22012,13 +22017,13 @@ msgid "invalid %%r value"
 msgstr "ugyldig %%r-værdi"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "ugyldig %%R-værdi"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "ugyldig %%N-værdi"
@@ -22033,7 +22038,7 @@ msgstr "ugyldig %%P-værdi"
 msgid "invalid %%h value"
 msgstr "ugyldig %%h-værdi"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "ugyldig %%L-værdi"
@@ -22048,7 +22053,7 @@ msgstr "ugyldig %%m-værdi"
 msgid "invalid %%M value"
 msgstr "ugyldig %%M-værdi"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "ugyldig %%U-værdi"
@@ -22409,7 +22414,7 @@ msgstr "uventet operand"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -22658,140 +22663,140 @@ msgstr "ugyldig konstant:"
 msgid "Expected register or constant integer."
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "ugyldig UNSPEC som operand"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of register '%s'"
 msgstr "ugyldig brug af 'restrict'"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "ugyldig brug af asm-flaguddata"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "ugyldig operandstørrelse for operandkoden »O«"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "ugyldig operandstørrelse for operandkoden »z«"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand type used with operand code 'Z'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "ugyldig operandtype brugt med operandkoden »Z«"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand size for operand code 'O'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "ugyldig operandstørrelse for operandkoden »O«"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "operand er ikke en betingelseskode, ugyldig operandkode »Y«"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "operand er ikke en betingelseskode, ugyldig operandkode »D«"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "operand er ikke en betingelseskode, ugyldig operandkode »%c«"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "operand er ikke en offsettable-hukommelsesreference, ugyldig operandkode »H«"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "operand er ikke et heltal, ugyldig operandkode »K«"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "operand er ikke et specifikt heltal, ugyldig operandkode »r«"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "operand er ikke et heltal, ugyldig operandkode »R«"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 #| msgid "operand is not a specific integer, invalid operand code 'r'"
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "operand er ikke et specifikt heltal, ugyldig operandkode »r«"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "operand er ikke en offsettable-hukommelsesreference, ugyldig operandkode »H«"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "ugyldig operandkode »%c«"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "ugyldige begrænsninger for operand"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "invalid constant"
 msgid "invalid vector immediate"
 msgstr "ugyldig konstant:"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "ukendt instruktionstilstand"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "ugyldig konvertering fra %<__fpreg%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "ugyldig konvertering fra %<__fpreg%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "ugyldig konvertering til %<__fpreg%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type `%T' from type `%T'"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "ugyldig omdannelse til typen '%T' fra typen '%T'"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -22870,9 +22875,9 @@ msgstr "»%%%c« er ikke et gyldigt operandpræfiks"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "ugyldig brug af »%%%c«"
@@ -22938,7 +22943,7 @@ msgid "insn contains an invalid address !"
 msgstr "instruktion indeholder en ugyldig adresse!"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "ugyldig adresse"
 
@@ -23014,7 +23019,7 @@ msgstr "ugyldig %%d-operand"
 msgid "invalid %%H value"
 msgstr "ugyldig %%H-værdi"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "ugyldig %%d-værdi"
@@ -23073,37 +23078,37 @@ msgstr "ikke-understøttet kombination: %s"
 msgid "unsupported memory expression:"
 msgstr "fast-punkt-konvertering er ikke understøttet"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%r operand"
 msgid "invalid vector operand"
 msgstr "ugyldig %%r-operand"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, fuzzy, c-format
 #| msgid "`sigof' applied to non-aggregate expression"
 msgid "modifier 'N' require register operand"
 msgstr "'sigof' benyttet på et udtryk der ikke er af en sammensat type"
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "ugyldig operand til »b«-ændring"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, fuzzy, c-format
 #| msgid "`sigof' applied to non-aggregate expression"
 msgid "modifier 'H' require register operand"
 msgstr "'sigof' benyttet på et udtryk der ikke er af en sammensat type"
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "unsupported size for integer register"
 msgid "modifier 'H' is for integer registers only"
 msgstr "størrelse er ikke understøttet for heltalsregister"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "`%V' qualifiers cannot be applied to `%T'"
 msgid "modifier 'H' cannot be applied to R31"
@@ -23176,7 +23181,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "ugyldig %%J-værdi"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "ugyldig %%D-værdi"
@@ -23216,7 +23221,7 @@ msgstr "ugyldig %%J-kode"
 msgid "invalid %%k value"
 msgstr "ugyldig %%k-værdi"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "ugyldig %%K-værdi"
@@ -23247,18 +23252,18 @@ msgstr "ugyldig %%T-værdi"
 msgid "invalid %%u value"
 msgstr "ugyldig %%u-værdi"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "ugyldig %%v-værdi"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%J value"
 msgid "invalid %%V value"
 msgstr "ugyldig %%J-værdi"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "ugyldig %%x-værdi"
@@ -23478,28 +23483,28 @@ msgstr "ugyldig %%s-operand"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "kommatalskonstant er ikke en gyldig umiddelbar operand"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "»B«-operanden er ikke konstant"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "»B«-operanden har flere bit sat"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "»o«-operanden er ikke konstant"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "`%%d' operand isn't a register"
 msgid "'h' operand is not SImode register"
 msgstr "operanden '%%d' er ikke et register"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: ukendt kode"
@@ -23557,24 +23562,24 @@ msgstr "ugyldig operandadresse (4)"
 msgid "Unable to load DLL."
 msgstr "Generér kode til en DLL"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "ugyldig test"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "ugyldig maske"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "ugyldig %%t/%%b-værdi"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "ingen registre i adresse"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "adresseafsæt er ikke en konstant"
 
@@ -23607,7 +23612,7 @@ msgstr "<anonym %s>"
 msgid "aka"
 msgstr "aka"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anonym})"
 
@@ -23632,8 +23637,8 @@ msgstr "({anonym})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "%<;%> forventet"
@@ -23662,7 +23667,7 @@ msgstr "forventede %<:%> or %<::%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "%<)%> forventet"
@@ -23670,7 +23675,7 @@ msgstr "%<)%> forventet"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "%<]%> forventet"
@@ -23690,13 +23695,13 @@ msgstr "%<;%>, %<,%> eller %<)%> forventet"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "%<(%> forventet"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "%<[%> forventet"
@@ -23705,7 +23710,7 @@ msgstr "%<[%> forventet"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -23722,13 +23727,13 @@ msgstr "%<{%> forventet"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "%<:%> forventet"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "%<while%> forventet"
@@ -23738,7 +23743,7 @@ msgstr "%<while%> forventet"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "%<,%> forventet"
@@ -23748,18 +23753,18 @@ msgid "expected %<.%>"
 msgstr "%<.%> forventet"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "%<@end%> forventet"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "%<>%> forventet"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "%<,%> eller %<)%> forventet"
@@ -23769,14 +23774,14 @@ msgstr "%<,%> eller %<)%> forventet"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "%<=%> forventet"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<)%> or %<,%>"
@@ -23784,32 +23789,32 @@ msgstr "%<,%> eller %<)%> forventet"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "%<}%> forventet"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<else%>"
 msgstr "forventede %<delete%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "%<#pragma omp section%> eller %<}%> forventet"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anonym)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "%<<%> forventet"
@@ -23837,7 +23842,7 @@ msgstr "candidate%s: %+#D"
 msgid "  after user-defined conversion:"
 msgstr "Aktivér brug af DB-instruktioner"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 #, fuzzy
 msgid "candidate is:"
 msgid_plural "candidates are:"
@@ -23949,7 +23954,7 @@ msgstr "skabelonsparameter '%#D'"
 msgid "<statement>"
 msgstr ""
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr ""
@@ -23978,330 +23983,375 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 #, fuzzy
 #| msgid "parse error"
 msgid "<expression error>"
 msgstr "tolkningsfejl"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr ""
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
+#: cp/reflect.cc:408
 #, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "akkumulator er ikke et konstant heltal"
+#| msgid "internal gcc abort"
+msgid "reflect_constant_array failed"
+msgstr "intern GCC-afbrydelse"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "internal gcc abort"
 msgid "reflect_constant failed"
 msgstr "intern GCC-afbrydelse"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "akkumulator er ikke et konstant heltal"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "`%D' cannot have default arguments"
 msgid "reflection does not have template arguments"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "called object is not a function"
 msgid "reflection does not represent a function or function type"
 msgstr "det kaldte objekt er ikke en funktion"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "format argument is not a pointer (arg %d)"
 msgid "operators argument is not a valid operator"
 msgstr "formateringsparameter er ikke en henvisning (parameter %d)"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 msgid "reflection does not have a type"
 msgstr "'%D' erklærer ikke en skabelonstype"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 msgid "reflection does not represent parameter of current function"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 #| msgid "called object is not a function"
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "det kaldte objekt er ikke en funktion"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 msgid "non-constant offset for offset_of"
 msgstr "erklæring uden static af '%s' følger static-erklæring"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "forsøg på at følge en henvisning til en variabel af en ufuldstændig type"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment"
 msgid "reflection not suitable for alignment_of"
 msgstr "Finjustér ikke justering af skrivbare data"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "too few arguments to function `%s'"
 msgid "alignment_of on function type"
 msgstr "for få parametre til funktionen '%s'"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 #| msgid "function with computed jump cannot inline"
 msgid "reflection with incomplete type in alignment_of"
 msgstr "funktioner med beregnede spring kan ikke indbygges"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "forsøg på at følge en henvisning til en variabel af en ufuldstændig type"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "expected function"
 msgid "reflect_function failed"
 msgstr "forventet funktion"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "parameter name missing"
 msgid "value member missing"
 msgstr "parameternavn mangler"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "garbage at end of #line"
 msgid "unexpected value of value member"
 msgstr "ragelse i slutningen af #line"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 #, fuzzy
 #| msgid "parameter name missing"
 msgid "type member missing"
 msgstr "parameternavn mangler"
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 #| msgid "bit-field `%#D' with non-integral type"
 msgid "reflection represents non-integral or bool type"
 msgstr "bitfelt '%#D' med en ikke-heltalstype"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qE attribute"
 msgid "invalid argument to can_substitute"
 msgstr "ugyldig parameter for egenskaben %qE"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "cannot declare pointers to references"
 msgid "type is not object or reference type"
 msgstr "kan ikke erklære henvisninger til referencer"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 #, fuzzy
 #| msgid "conversion of `%E' from `%T' to `%T' is ambiguous"
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "konvertering af '%E' fra '%T' til '%T' er tvetydigt"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "`%T' is not a valid expression"
 msgid "name is not a valid identifier"
 msgstr "'%T' er ikke et gyldigt udtryk"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 #, fuzzy
 #| msgid "`bool' is now a keyword"
 msgid "name is a keyword"
 msgstr "'bool' er et reserveret ord"
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "registernavn ikke angivet for %q+D"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "both signed and unsigned specified for `%s'"
 msgid "both alignment and bit_width specified"
 msgstr "både signed og unsigned er angivet for '%s'"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "angivelse af feltbredde"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "shift count is negative"
 msgid "bit_width is negative"
 msgstr "skifteantal er negativ"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+msgid "name unspecified and type is const"
+msgstr "justering må ikke angives for '%s'"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+msgid "name unspecified and type is volatile"
+msgstr "justering må ikke angives for '%s'"
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "-falign-labels=%d is not supported"
 msgid "alignment is not power of two"
 msgstr "-falign-labels=%d understøttes ikke"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "shift count is negative"
 msgid "alignment is negative"
 msgstr "skifteantal er negativ"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "assignment (not initialization) in declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "tildeling (ikke klargøring) i erklæring"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "type to vector delete is neither pointer or array type"
+msgid "reflection does not have non-array object type"
+msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "`%D' is not a member template function"
+msgid "current scope does not represent a function"
+msgstr "'%D' er ikke en medlemsskabelonfunktion"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+msgid "current scope does not represent a class nor a member function"
+msgstr "friend-erklæringen er ikke i klassedefinitionen"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class `%s'"
 msgid "incomplete parent class"
 msgstr "ufuldstændig implementering af klassen '%s'"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "`%T' is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "'%T' er ikke en klasse eller et navnerum"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "return type is an incomplete type"
 msgid "not a complete class type"
 msgstr "returtypen er en ufuldstændig type"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 #, fuzzy
 #| msgid "close %d"
 msgid "closure type"
 msgstr "close %d"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "template parameters cannot be friends"
 msgid "value cannot be extracted"
@@ -24363,55 +24413,55 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 #, fuzzy
 msgid "candidates are:"
 msgstr "candidate%s: %+#D"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "forkert parametertype til unært minus"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "forkert parametertype til unært plus"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "forkert parametertype til bitkomplement"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "forkert parametertype til abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "forkert parametertype til konjugation"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 #| msgid "wrong type argument to unary plus"
 msgid "in argument to unary !"
 msgstr "forkert parametertype til unært plus"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -24431,73 +24481,73 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "kommatalskonstant er uden for det gyldige interval"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "NULL() is not interoperable"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "ugyldig konstant:"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "invalid expression as operand"
 msgid "Expression is polymorphic"
 msgstr "ugyldigt udtryk som operand"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "expression statement has incomplete type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "udtrykket er af en ufuldstændig type"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected operand"
 msgid "Procedure unexpected as argument"
 msgstr "uventet operand"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 #| msgid "Zero-length character constant at %0"
 msgid "Type shall have a character length of 1"
 msgstr "Nul-længde tegnkonstant ved %0"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "typer er ikke helt forenelige"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -24567,7 +24617,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 #| msgid "assignment"
 msgid "array assignment"
@@ -24578,18 +24628,18 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, fuzzy, c-format
 #| msgid "type mismatch in conditional expression"
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, fuzzy, c-format
 #| msgid "type mismatch in conditional expression"
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
@@ -24799,11 +24849,11 @@ msgstr ""
 msgid "implied END DO"
 msgstr ""
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "tildeling"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 #, fuzzy
 #| msgid "assignment"
 msgid "pointer assignment"
@@ -24813,155 +24863,155 @@ msgstr "tildeling"
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "allocatable argument"
 msgstr "ugyldig typeparameter"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 #| msgid "no arguments"
 msgid "asynchronous argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 #| msgid "no arguments"
 msgid "optional argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "no arguments"
 msgid "pointer argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 #| msgid "no arguments"
 msgid "target argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "value argument"
 msgstr "ugyldig typeparameter"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-shape argument"
 msgstr "ugyldig typeparameter"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 #| msgid "no arguments"
 msgid "assumed-rank argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 #| msgid "no arguments"
 msgid "coarray argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "parametrized derived type argument"
 msgstr "ugyldig typeparameter"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "ingen parametre"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-type argument"
 msgstr "ugyldig typeparameter"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 #, fuzzy
 #| msgid "Do not allocate BK register"
 msgid "pointer or allocatable result"
 msgstr "Allokér ikke BK-registeret"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr ""
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 #| msgid "invalid expression as operand"
 msgid "End expression in DO loop"
 msgstr "ugyldigt udtryk som operand"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -24970,31 +25020,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -25058,27 +25108,27 @@ msgstr ""
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -25188,7 +25238,7 @@ msgid "expected boolean type"
 msgstr "forventet boolesk type"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 msgid "expected integer"
 msgstr "uventet operand"
@@ -25261,7 +25311,7 @@ msgstr "ikke nok parametre"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "for mange parametre"
@@ -25717,7 +25767,7 @@ msgstr "function_profiler-understøttelse for MMIX"
 msgid "target OS does not support unaligned accesses"
 msgstr "målprocessoren understøtter ikke interarbejde"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "profilering er endnu ikke implementerer for denne arkitektur"
@@ -25981,13 +26031,13 @@ msgstr "ukendt tilvalg '%s'"
 msgid "Global declarative %s for %s"
 msgstr "en global erklæring"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -26157,13 +26207,13 @@ msgstr "%qs er forældet; brug -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs er forældet; brug -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown autovec preference %qs"
 msgstr "ukendt registernavn: %s"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -26633,8 +26683,8 @@ msgstr "dataområdet '%s' er i modstrid med tidligere erklæring"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration `%#D' here"
 msgid "previous declaration here"
@@ -26654,7 +26704,7 @@ msgstr "egenskabsdirektivet '%s' ignoreret"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "egenskabsdirektivet '%s' ignoreret"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments specified for %qE attribute"
@@ -26666,7 +26716,7 @@ msgstr "forkert antal parametre angivet til egenskaben '%s'"
 msgid "expected %i or more, found %i"
 msgstr "forventede %<return%>"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<,%>"
 msgid "expected %i, found %i"
@@ -26752,12 +26802,12 @@ msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -26877,139 +26927,139 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of functions"
 msgid "location is after end of function"
 msgstr "'%s' erklæret som en tabel af funktioner"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 #| msgid "';' expected"
 msgid "Not expected TAG."
 msgstr "';' forventet"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "kan ikke åben profilefilen %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument of type `%T' does not match `%T'"
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "parameter af typen '%T' passer ikke til '%T'"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read LTO mode table from %s"
 msgid "cannot read summary information from %s"
 msgstr "kan ikke læse LTO-tilstandstabel fra %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read LTO mode table from %s"
 msgid "cannot read string table from %s"
 msgstr "kan ikke læse LTO-tilstandstabel fra %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot read function profile from %s."
 msgid "cannot read function profile from %s"
 msgstr "kan ikke læse funktionsprofil fra %s."
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot read function profile from %s."
 msgid "cannot read module profile from %s"
@@ -27021,7 +27071,7 @@ msgstr "kan ikke læse funktionsprofil fra %s."
 msgid "offset %qwi outside bounds of constant string"
 msgstr "forskydning udenfor grænserne af konstant streng"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "%qE declared here"
@@ -27141,7 +27191,7 @@ msgstr "konstant parameter uden for det gyldige interval for '%s'"
 msgid "illegal argument 0 to %qs"
 msgstr "ugyldig typeparameter"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third arg to `__builtin_prefetch' must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -27227,12 +27277,12 @@ msgstr "parameteren til 'asm' er ikke en konstant streng"
 msgid "cannot tail-call: %s"
 msgstr "[kan ikke finde %s]"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "funktionskald har en sammensat værdi"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 #| msgid "Pass all arguments on stack"
 msgid "passing too large argument on stack"
@@ -27941,360 +27991,360 @@ msgstr "basisblokkene er ikke nummeret i rækkefølge"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "antallet af basisbloknoter i instruktionskæden (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "caller edge count invalid"
 msgstr "venstreskiftsantal er negativ"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing counts for called function %s/%i"
 msgid "missing direct call for speculation %i"
 msgstr "Manglende antal for kaldt funktion %s/%i"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing barrier after block %i"
 msgid "missing ref for speculation %i"
 msgstr "manglende barriere efter blok %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline clone count is not compatible"
 msgstr "startværdielement er ikke en konstant"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "tp_first_run must be non-negative"
 msgstr "%s-roteringsantal er negativt"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 #| msgid "no symbol table found"
 msgid "local symbols must be defined"
 msgstr "ingen symboltabel fundet"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "%D renamed after being referenced in assembly"
 msgid "inline clone is referenced by assembly"
 msgstr "%D omdøbt efter at være refereret i maskinkode"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 #| msgid "`return' with no value, in function returning non-void"
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "'return' uden nogen værdi i en funktion der ikke returnerer void"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "target specific option mismatch"
 msgid "semantic interposition mismatch"
 msgstr "misforhold i målspecifikke tilvalg"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "edge count is not compatible with function count"
 msgstr "-march=%s er ikke forenelig med den valgte ABI"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "-march=%s er ikke forenelig med den valgte ABI"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, fuzzy, gcc-internal-format
 #| msgid "section pointer missing"
 msgid "inlined_to pointer is wrong"
 msgstr "sektionshenvisning mangler"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple inline callers"
 msgstr "mere end én 'virtual'-angivelse"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr ""
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "caller edge count does not match BB count"
 msgstr "venstreskiftsantal er negativ"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr ""
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer to bit-field `%D'"
 msgid "inlined_to pointer refers to itself"
 msgstr "ugyldig henvisning til bitfeltet '%D'"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' used prior to declaration"
 msgid "edge points to wrong declaration:"
 msgstr "'%s' benyttes før erklæringen"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr ""
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "origin points to a different parent"
 msgstr "typeomtvingelse fra henvisning til heltal af en anden størrelse"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, fuzzy, gcc-internal-format
 #| msgid "verify_flow_info failed"
 msgid "verify_cgraph_node failed"
 msgstr "verify_flow_info mislykkedes"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "string section missing"
 msgid "%s: section %s.%d is missing"
@@ -29128,17 +29178,17 @@ msgstr "størrelsen af tabellen '%s' er for stor"
 msgid "impossible constraint in %<asm%>"
 msgstr "umulig begrænsing i 'asm'"
 
-#: function.cc:4285
+#: function.cc:4292
 #, fuzzy, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "variablen '%s' bliver måske overskrevet af 'longjmp' eller 'vfork'"
 
-#: function.cc:4306
+#: function.cc:4313
 #, fuzzy, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "parameteren '%s' bliver måske overskrevet af 'longjmp' eller 'vfork'"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "funktion returnerer en værdi af en sammensat type"
@@ -29875,7 +29925,7 @@ msgstr "højreskiftsantal er negativ"
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "fleksibelt tabelmedlem ikke i slutningen af struktur"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -29917,7 +29967,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "%qD defined here"
@@ -29940,24 +29990,24 @@ msgstr "henvisning"
 msgid "function may return address of local variable"
 msgstr "funktion kan returnere adressen på en lokal variabel"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "funktion returnerer adressen på en lokal variabel"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -30913,7 +30963,7 @@ msgstr "højreskiftsantal er negativ"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "returned from %qD"
@@ -30995,230 +31045,230 @@ msgstr "Ugyldig erklæring"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "Finjustér justering til en given chip- eller processorversion"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of `%s'"
 msgid "invalid memory model %qs for %qD"
 msgstr "ugyldig typeparameter '%s'"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of `%s'"
 msgid "invalid memory model %wi for %qD"
 msgstr "ugyldig typeparameter '%s'"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "invalid argument of `%s' attribute"
 msgid "valid models are %e"
 msgstr "ugyldig parameter til egenskaben '%s'"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of `%s'"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "ugyldig typeparameter '%s'"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of `%s' attribute"
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "ugyldig parameter til egenskaben '%s'"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' must take either one or two arguments"
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "'%D' skal tage mod én eller to parametre"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "right shift count is negative"
 msgid "argument %i value %s is negative"
 msgstr "højreskiftsantal er negativ"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "referencing argument %u of type %qT"
 msgstr "forsøg på at følge en henvisning til en variabel af en ufuldstændig type"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "Ugyldig erklæring"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function `%s'"
 msgid "in a call to function %qD"
 msgstr "for mange parametre til funktionen '%s'"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to `%D'"
 msgid "in a call with type %qT"
 msgstr "  i kald af '%D'"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "assigned here"
 msgstr "'%s' tidligere defineret her"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "'%D' er ikke en medlemsskabelonfunktion"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to a member used in arithmetic"
 msgid "pointer %qE may be used after %qD"
 msgstr "henvisning til et medlem benyttet i udregning"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "ubenyttet parameter '%s'"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to a member used in arithmetic"
 msgid "pointer may be used after %qD"
 msgstr "henvisning til et medlem benyttet i udregning"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "ubenyttet parameter '%s'"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "call to %qD here"
 msgstr "  '%#D' erklæret her"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode `%s'"
 msgid "using dangling pointer %qE to %qD"
 msgstr "ugyldig henvisningstilstand '%s'"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member `%D'"
 msgid "dangling pointer to %qD may be used"
 msgstr "antager henvisning til medlemmet '%D'"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode `%s'"
 msgid "using a dangling pointer to %qD"
 msgstr "ugyldig henvisningstilstand '%s'"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "%qD declared here"
 msgstr "  '%#D' erklæret her"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "plugin cannot register an unnamed pass"
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "udvidelsesmodul kan ikke registrere en unavngivet videregivelse"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "unnamed temporary defined here"
 msgstr "'%s' tidligere defineret her"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function `%D'"
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "kald af ikke-funktion '%D'"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function `%D'"
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "kald af ikke-funktion '%D'"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to `%D'"
 msgid "call to %qD"
 msgstr "  i kald af '%D'"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable `%D' returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -32085,374 +32135,374 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "ugyldig brug af '%D"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for virtual method `%D'"
 msgid "contains additional virtual method %qD"
 msgstr "ugyldig startværdi til virtuel medlemsfunktion '%D'"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "tidligere definition her"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, fuzzy, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "tidligere definition her"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "a different type is defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "the incompatible type defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, fuzzy, gcc-internal-format
 #| msgid "type `%T' is not derived from type `%T'"
 msgid "type name %qs should match type name %qs"
 msgstr "typen '%T' er ikke nedarvet fra typen '%T'"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in %s"
 msgid "the incompatible type is defined here"
 msgstr "uforenelige typer i %s"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 #| msgid "forming reference to void"
 msgid "array types have different bounds"
 msgstr "danner reference til void"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "return value type mismatch"
 msgstr "typen af startværdien for feltet passer ikke"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in parameter %i"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 #| msgid "different type"
 msgid "types have different parameter counts"
 msgstr "anden type"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, fuzzy, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "tidligere definition her"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 #| msgid "type `%T' is not derived from type `%T'"
 msgid "type %qT should match type %qT"
 msgstr "typen '%T' er ikke nedarvet fra typen '%T'"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "a type with different bases is defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "fields have different layout in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "memory layout mismatch"
 msgstr "typen af startværdien for feltet passer ikke"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "the extra base is defined here"
 msgstr "'%s' tidligere defineret her"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "tidligere definition her"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 #| msgid "no file specified with -fdump-translation-unit"
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "ingen filer angivet med -fdump-translation-unit"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "mismatching definition"
@@ -32473,7 +32523,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "Ugyldig erklæring"
@@ -32717,13 +32767,13 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr "kan ikke finde et register at bortødsle i klassen '%s'"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent operand constraints in an `asm'"
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "inkonsistente operandbegræsninger i 'asm'"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -33120,7 +33170,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -34603,25 +34653,25 @@ msgstr "implicit aflæste registre skal grupperes i toppen af stakken"
 msgid "output operand %d must use %<&%> constraint"
 msgstr "uddataoperand %d skal bruge %<&%>-begrænsningen"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data: [%u] Ugyldig next_regno til tom kæde (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data: Løkke i registertalskæde (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data: [%u] Ugyldig oldest_regno (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -35629,190 +35679,190 @@ msgstr "ydre transaktion i %<transaction_safe%> funktion"
 msgid "ignoring loop annotation"
 msgstr "ignorerer løkkeannotation"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "konstant blev ikke genberegnet da ADDR_EXPR ændrede sig"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "sideeffekter blev ikke genberegnet da ADDR_EXPR ændrede sig"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "adresse optaget, men ADDRESSABLE-bit er ikke angivet"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "non-scalar %qs"
 msgstr "I konstruktionen"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size operand to %qs"
 msgstr "ugyldig position eller størrelsesoperant for BIT_FIELD_REF"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "type mismatch in %qs reference"
 msgstr "indeks mangler i tabelopslag"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from `%T' to `%T' is ambiguous"
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "konvertering fra '%T' til '%T' er tvetydigt"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "typeomtvingelse fra henvisning til heltal af en anden størrelse"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, fuzzy, gcc-internal-format
 #| msgid "non-lvalue in %s"
 msgid "non-top-level %qs"
 msgstr "ikke-venstreværdi i %s"
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "ugyldig operand til %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in %qs"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offset operand of MEM_REF"
 msgid "invalid %qs offset operator"
 msgstr "ugyldig forskydningsoperand for MEM_REF"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s operand"
 msgid "invalid address operand in %qs"
 msgstr "ugyldig %%s-operand"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%f operand"
 msgid "invalid offset operand in %qs"
 msgstr "ugyldig %%f-operand"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "invalid clique in %qs"
 msgstr "ugyldig brug af '%D"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "INDIRECT_REF in gimple IL"
 msgid "%qs in gimple IL"
 msgstr "INDIRECT_REF i gimple IL"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "struct type value used where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "værdi af struct-type angivet hvor skalar er påkrævet"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "invalid expression for min lvalue"
 msgstr "ugyldigt udtryk som operand"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, fuzzy, gcc-internal-format
 #| msgid "-split has no argument."
 msgid "gimple call has no target"
 msgstr "-split uden parametre"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "Ugyldig erklæring"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "funktion kan ikke indbygges"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 #| msgid "invalid return type for function `%#D'"
 msgid "invalid pure const state for function"
 msgstr "ugyldig returtype for funktionen '%#D'"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PC in line number table"
 msgid "invalid LHS in gimple call"
 msgstr "ugyldig PC i linjetalstabel"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, fuzzy, gcc-internal-format
 #| msgid "invalid version number format"
 msgid "invalid conversion in gimple call"
 msgstr "ugyldigt versionsnummerformat"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PC in line number table"
 msgid "invalid static chain in gimple call"
 msgstr "ugyldig PC i linjetalstabel"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -35823,674 +35873,674 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "`__builtin_next_arg' called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "`__builtin_next_arg' kaldt uden en parameter"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of `%s' attribute"
 msgid "invalid argument to gimple call"
 msgstr "ugyldig parameter til egenskaben '%s'"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operands in gimple comparison"
 msgstr "ugyldig operand i instruktionen"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid method declaration, return type required"
 msgid "invalid vector comparison resulting type"
 msgstr "Ugyldig metodeerklæring, returtype påkrævet"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operand in unary operation"
 msgstr "ugyldig operand i instruktionen"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid token in expression"
 msgid "invalid vector types in nop conversion"
 msgstr "ugyldigt symbol udtryk"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, fuzzy, gcc-internal-format
 #| msgid "invalid token in expression"
 msgid "invalid types in nop conversion"
 msgstr "ugyldigt symbol udtryk"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 #| msgid "invalid token in expression"
 msgid "invalid types in address space conversion"
 msgstr "ugyldigt symbol udtryk"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, fuzzy, gcc-internal-format
 #| msgid "invalid token in expression"
 msgid "invalid types in fixed-point conversion"
 msgstr "ugyldigt symbol udtryk"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid suffix \"%.*s\" on floating constant"
 msgid "invalid types in conversion to floating-point"
 msgstr "ugyldig endelse \"%.*s\" i kommatalskonstant"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type `void' for new"
 msgid "invalid types in conversion to integer"
 msgstr "ugyldig type 'void' til new"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in %qs expression"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid prototype for '%s'"
 msgid "invalid types for %qs"
 msgstr "ugyldig prototype for »%s«"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid prototype for '%s'"
 msgid "invalid type for %qs"
 msgstr "ugyldig prototype for »%s«"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, fuzzy, gcc-internal-format
 #| msgid "invalid version number format"
 msgid "non-trivial conversion in unary operation"
 msgstr "ugyldigt versionsnummerformat"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands to binary %s"
 msgid "invalid operands in binary operation"
 msgstr "ugyldige operander til binær %s"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid non-vector operands to %qs"
 msgstr "ugyldig operand til %%R"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode `%s'"
 msgid "invalid (pointer) operands %qs"
 msgstr "ugyldig henvisningstilstand '%s'"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "vector type expected in %qs"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in binary expression"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operands in ternary operation"
 msgstr "ugyldig operand i instruktionen"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "vector types expected in %qs"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "vectors with different element number found in %qs"
 msgstr "operander til ?: har forskellige typer"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rotate insn"
 msgid "invalid mask type in %qs"
 msgstr "ugyldig roteringsinstruktion"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "not allowed type combination in %qs"
 msgstr "ikke-understøttet kombination: %s"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size in %qs"
 msgstr "ugyldig position eller størrelsesoperant for BIT_FIELD_REF"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 #| msgid "`sigof' applied to non-aggregate expression"
 msgid "%qs into non-mode-precision operand"
 msgstr "'sigof' benyttet på et udtryk der ikke er af en sammensat type"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for `%s'"
 msgid "insertion out of range in %qs"
 msgstr "konstant parameter uden for det gyldige interval for '%s'"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a directory"
 msgid "%qs not at element boundary"
 msgstr "%qs er ikke en mappe"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "non-trivial conversion in %qs"
 msgstr "ugyldig venstreværdi i tildeling"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter type `%T'"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "ugyldig parametertype '%T'"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid init statement"
 msgid "%qs LHS in clobber statement"
 msgstr "Ugyldig klargøringssætning"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "ugyldig operand til %%R"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %qs size argument in load"
 msgstr "ugyldig typeparameter"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid indirect memory address"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "ugyldig indirekte hukommelsesadresse"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "incorrect type of vector %qs elements"
 msgstr "venstreskiftsantal er større end bredden af typen"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "incorrect number of vector %qs elements"
 msgstr "for få parametre til funktionen '%s'"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "non-vector %qs with elements"
 msgstr "operander til ?: har forskellige typer"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operand in return statement"
 msgstr "ugyldig operand i instruktionen"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid init statement"
 msgid "invalid conversion in return statement"
 msgstr "Ugyldig klargøringssætning"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "goto destination is neither a label nor a pointer"
 msgstr "værdien der er påført et indeks, er hverken en tabel eller en henvisningsvariabel"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%s code"
 msgid "invalid operand to switch statement"
 msgstr "ugyldig operand til %%s-koden"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "Generate code for huge switch statements"
 msgid "non-integral type switch statement"
 msgstr "Generér kode til store switch-sætninger"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate label `%s' in switch statement"
 msgid "invalid default case label in switch statement"
 msgstr "mere end én '%s'-etiket i switch-sætningen"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate label `%s' in switch statement"
 msgid "invalid case label in switch statement"
 msgstr "mere end én '%s'-etiket i switch-sætningen"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "invalid case range in switch statement"
 msgstr "ugyldig venstreværdi i asm-sætning"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type precision mismatch in switch statement"
 msgstr "case-etiket befinder sig ikke inden i en switch-sætning"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate label `%s' in switch statement"
 msgid "type mismatch for case label in switch statement"
 msgstr "mere end én '%s'-etiket i switch-sætningen"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "case labels not sorted in switch statement"
 msgstr "case-etiket befinder sig ikke inden i en switch-sætning"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "label context is not the current function declaration"
 msgstr "parameternavne (uden typer) i funktionserklæringen"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, fuzzy, gcc-internal-format
 #| msgid "format string has invalid operand number"
 msgid "incorrect setting of landing pad number"
 msgstr "formateringsstrengen har et ugyldigt operandtal"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%p code"
 msgid "invalid comparison code in gimple cond"
 msgstr "ugyldig operand til %%p-koden"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in increment"
 msgid "invalid labels in gimple cond"
 msgstr "ugyldig venstreværdi i forøgelse"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid address"
 msgid "invalid %<PHI%> result"
 msgstr "ugyldig adresse"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing number"
 msgid "missing %<PHI%> def"
 msgstr "manglende tal"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %<PHI%> argument"
 msgstr "ugyldig typeparameter"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in %s"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "uforenelige typer i %s"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_flow_info failed"
 msgid "%<verify_gimple%> failed"
 msgstr "verify_flow_info mislykkedes"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as non-function"
 msgid "local declaration from a different function"
 msgstr "erklæring af '%D' som ikke-funktion"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, fuzzy, gcc-internal-format
 #| msgid "verify_flow_info failed"
 msgid "verify_gimple failed"
 msgstr "verify_flow_info mislykkedes"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "overskydende krøllede paranteser ved slutningen af startværdien"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "overskydende krøllede paranteser ved slutningen af startværdien"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "exit block count is not compatible with entry block count"
 msgstr "-march=%s er ikke forenelig med den valgte ABI"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing initializer"
 msgid "count of bb %d not initialized"
 msgstr "manglende startværdi"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "verify_flow_info: Wrong probability of edge %i->%i %i"
 msgid "probability of edge %d->%d not initialized"
 msgstr "verify_flow_info: Ukorrekt sandsynlighed for kant %i->%i %i"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-march=%s er ikke forenelig med den valgte ABI"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 #| msgid "field `%D' has incomplete type"
 msgid "label %qD has incorrect context in bb %d"
 msgstr "feltet '%D' er af en ufuldstændig type"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "flow control insn inside a basic block"
 msgid "control flow in the middle of basic block %d"
 msgstr "strømkontrolinstruktion inden i en basisblok"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "flow control insn inside a basic block"
 msgid "label %qD in the middle of basic block %d"
 msgstr "strømkontrolinstruktion inden i en basisblok"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fallthru edge after unconditional jump %i"
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "Fald gennem-kant efter ubetinget spring %i"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "explicit instantiation of `%#D'"
 msgid "explicit goto at end of bb %d"
 msgstr "eksplicit instantiering af '%#D'"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 #| msgid "trampolines not supported"
 msgid "case labels not sorted: "
 msgstr "trampoliner understøttes ikke"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing field '%s' in '%s'"
 msgid "missing edge %i->%i"
 msgstr "manglende felt '%s' i '%s'"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 #| msgid "`noreturn' function does return"
 msgid "%<noreturn%> function does return"
 msgstr "funktion med egenskaben 'noreturn' returnerer"
 
 # RETMIG: dette må kunne gøres bedre
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "kontrol når til slutningen af ikke-void funktion"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of `%D', declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "%Hignorerer returværdi for '%D' erklæret med egenskaben warn_unused_result"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of `%D', declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -36679,13 +36729,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -37224,7 +37274,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -37675,30 +37725,30 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' incompatible attribute ignored"
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "uforenelig egenskab '%s' ignoreret"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "tidligere erklæring af %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "strider mod tidligere erklæring '%#D'"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 msgid "%qD conflicts for version %qB"
 msgstr "strider mod tidligere erklæring '%#D'"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "strider mod tidligere erklæring '%#D'"
@@ -37780,7 +37830,7 @@ msgstr "kun nulstartværdier er tilladte i sektion %qs"
 msgid "no initializers are allowed in section %qs"
 msgstr "kun nulstartværdier er tilladte i sektion %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "registernavn ikke angivet for %q+D"
@@ -37942,7 +37992,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "kan ikke erklære medlemsfunktion '%D' til at have statisk kædning"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration; ignored"
 msgid "alias definitions not supported in this configuration"
@@ -37988,61 +38038,61 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored for `%s'"
 msgid "%qE attribute argument has type %qT"
 msgstr "'%s'-egenskaben ignoreret for '%s'"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored for `%s'"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "'%s'-egenskaben ignoreret for '%s'"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "parameteren til egenskaben '%s' er ikke en heltalskonstant"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "parameteren til egenskaben '%s' er ikke en heltalskonstant"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to function types"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktionstyper"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to function types"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktionstyper"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "standardparameter givet til %d. parameter for '%#D'"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -38060,13 +38110,13 @@ msgstr "'%D' skal tage mod én eller to parametre"
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "'%D' skal tage mod én eller to parametre"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
@@ -38300,12 +38350,12 @@ msgstr "kan ikke konverteres til en henvisningstype"
 msgid "mode %qs applied to inappropriate type"
 msgstr "'sigof' benyttet på en type der ikke er sammensat"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "sektionsegenskaber understøttes ikke på denne målarkitektur"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, fuzzy, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "sektionsegenskaben er ikke tilladt for '%s'"
@@ -38316,18 +38366,18 @@ msgstr "sektionsegenskaben er ikke tilladt for '%s'"
 msgid "section attribute argument not a string constant"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "sektionsegenskaben kan ikke angives for lokale variabler"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "sektionen '%s' strider mod tidligere erklæring"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 #| msgid "function `%D' cannot be declared friend"
 msgid "section of %q+D cannot be overridden"
@@ -38420,7 +38470,7 @@ msgstr "'defined' optræder uden et kaldenavn"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "dataområdet '%s' er i modstrid med tidligere erklæring"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "Ugyldig erklæring"
@@ -38471,13 +38521,13 @@ msgstr "egenskaben '%s' kan kun anvendes på variabler"
 msgid "%qE attribute is only applicable on functions"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktioner"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktioner"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to functions"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -38489,12 +38539,12 @@ msgstr "egenskaben '%s' kan kun anvendes sammen med funktioner"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not an integer constant"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -38598,25 +38648,25 @@ msgstr "'%s' brugt, men aldrig defineret"
 msgid "visibility argument not a string"
 msgstr "synlighedsparameter er ikke en streng"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored for `%s'"
 msgid "%qE attribute ignored on types"
 msgstr "'%s'-egenskaben ignoreret for '%s'"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "'%#D' omerklæret som en anden form for symbol"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -38633,7 +38683,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
@@ -38713,7 +38763,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -38798,7 +38848,7 @@ msgstr "-march=%s er ikke forenelig med den valgte ABI"
 msgid "%qE argument is not a function"
 msgstr "ingen parametre til specifikationsfunktion"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 #| msgid "second token after #line is not a string"
 msgid "deprecated message is not a string"
@@ -38873,7 +38923,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "'%s'-egenskaben ignoreret for '%s'"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a string constant argument"
 msgid "%qE attribute requires a string argument"
@@ -39051,16 +39101,16 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_trap not supported by this target"
 msgid "empty string in attribute %<target%>"
 msgstr "__builtin_trap understøttes ikke på denne målarkitektur"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "%qE attribute argument not a string constant"
@@ -39359,7 +39409,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "foreslår paranteser omkring tildeling der er benyttet som boolsk værdi"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of %<restrict%>"
@@ -39555,8 +39605,8 @@ msgstr "for få parametre til funktionen"
 msgid "missing sentinel in function call"
 msgstr "Forbyd PC-relative funktionskald"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -40696,7 +40746,7 @@ msgstr "muligvis begyndelsen af uafsluttet strengkonstant"
 msgid "traditional C rejects string constant concatenation"
 msgstr "traditionel C tillader ikke strengsammensætning"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -40753,7 +40803,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "typedef-navn kan ikke klassemodificeres"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "invalid type for iteration variable %qE"
@@ -40771,19 +40821,19 @@ msgstr "ugyldig vektortype for egenskaben '%s'"
 msgid "%qE is not initialized"
 msgstr "manglende startværdi"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, fuzzy, gcc-internal-format
 #| msgid "missing '(' after predicate"
 msgid "missing controlling predicate"
 msgstr "manglende '(' efter udsagn"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid control expression"
 msgid "invalid controlling predicate"
 msgstr "Ugyldigt kontroludtryk"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 #| msgid "missing ')' in expression"
 msgid "missing increment expression"
@@ -40794,7 +40844,7 @@ msgstr "manglende ')' i udtryk"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid control expression"
 msgid "invalid increment expression"
@@ -40896,19 +40946,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function template"
 msgid "%qD is not a function argument"
 msgstr "'%D' er ikke en funktionsskabelon"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%s' has invalid type"
 msgid "bit-field %qE in %qs clause"
@@ -40919,8 +40969,8 @@ msgstr "bitfeltet '%s' er af en ufuldstændig type"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE har ikke en mappable-type i %qs-klausul"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%s' has invalid type"
 msgid "%<_Atomic%> %qE in %qs clause"
@@ -41502,7 +41552,7 @@ msgstr "manglende '(' for '#pragma %s' - ignoreret"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "forkert udformet '#pragma %s' - ignoreret"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, fuzzy, gcc-internal-format
 #| msgid "junk at end of #pragma %s"
 msgid "junk at end of %<#pragma %s%>"
@@ -41581,8 +41631,8 @@ msgstr "#pragma %s er allerede registreret"
 msgid "wrong type argument to %s"
 msgstr "forkert parametertype til %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -42127,19 +42177,19 @@ msgstr "for få parametre til funktionen '%s'"
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, fuzzy, gcc-internal-format
 #| msgid "%s of read-only location"
 msgid "assignment of read-only location %qE"
 msgstr "%s af placering der kun må læses"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, fuzzy, gcc-internal-format
 #| msgid "%s of read-only location"
 msgid "increment of read-only location %qE"
 msgstr "%s af placering der kun må læses"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, fuzzy, gcc-internal-format
 #| msgid "%s of read-only location"
 msgid "decrement of read-only location %qE"
@@ -42440,7 +42490,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "typeomtvingning fra '%T' til '%T' kasserer modifikationer på henvisningsmålets type"
 msgstr[1] "typeomtvingning fra '%T' til '%T' kasserer modifikationer på henvisningsmålets type"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, fuzzy, gcc-internal-format
 #| msgid "the conditional began here"
 msgid "this condition has identical branches"
@@ -43466,7 +43516,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -44166,7 +44216,7 @@ msgstr "%s opretter et heltal ud fra en henvisningsvariabel uden en typeomtvingn
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate definition of class method `%s'"
 msgid "duplicate definition of %qs"
@@ -44220,7 +44270,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "klassen '%T' har ikke et felt ved navn '%D'"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "'%s' brugt, men aldrig defineret"
@@ -44279,7 +44329,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -44384,19 +44434,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec-parameter sendt til funktion uden prototype"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -44445,205 +44495,205 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "egenskaben '%s' ignoreret"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option %s"
 msgid "invalid format for %<sve_width%>"
 msgstr "ugyldigt tilvalg %s"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %h value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "ugyldig %h-værdi"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid range %s in option %s"
 msgid "tuning string missing in option (%s)"
 msgstr "ugyldigt interval %s i tilvalg %s"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown spec function `%s'"
 msgid "unknown tuning option (%s)"
 msgstr "ukendt specifikationsfunktion '%s'"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 #| msgid "Specify the register allocation order"
 msgid "specify a system register with a small string length"
 msgstr "Angiv registerallokeringsordnen"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%s understøtter ikke %s"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "streaming functions require the ISA extension %qs"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid arg to `__builtin_frame_address'"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "ugyldig parameter til '__builtin_frame_address'"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "ugyldig typeparameter"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march= switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "tilvalget -mcpu=%s er i konflikt med tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "%s understøtter ikke %s"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "'%s' er forældet"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in x32 mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "kodemodellen %qs er ikke understøttet i x32-tilstand"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -mtune= switch"
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -mcpu="
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
@@ -44651,27 +44701,27 @@ msgstr "ugyldig værdi (%s) til tilvalget -march="
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "forkert udformet specifikationsfunktionsnavn"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, fuzzy, gcc-internal-format
 #| msgid "%s only accepts 1 argument"
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "%s accepterer kun 1 parameter"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, fuzzy, gcc-internal-format
 #| msgid "target system does not support the %qs debug format"
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "målarkitektursystem understøtter ikke %qs-fejlsøgningsformatet"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 #| msgid "\"%s\" is not defined"
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "\"%s\" er ikke defineret"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -44680,224 +44730,224 @@ msgstr "\"%s\" er ikke defineret"
 msgid "attribute %<target%> argument not a string"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "attribute %<target_version%> has multiple values"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "missing value in %<target_version%> attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "stakgrænseudtryk understøttes ikke"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "Profiling is not supported on this target."
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "Profilering er ikke understøttet på målarkitekturen."
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "'%s' tidligere erklæret her"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, fuzzy, gcc-internal-format
 #| msgid "line number out of range"
 msgid "lane %wd out of range %wd - %wd"
 msgstr "linjenummer er uden for det gyldige interval"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported version"
 msgid "unsupported simdlen %wd"
 msgstr "versionen er ikke understøttet"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "ubenyttede parametre i formatering med $"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "unsupported return type %qT for simd"
 msgstr "ubenyttede parametre i formatering med $"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "ubenyttede parametre i formatering med $"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "unsupported argument type %qT for simd"
 msgstr "ubenyttede parametre i formatering med $"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "The -shared option is not currently supported for VAX ELF."
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "Tilvalget -shared understøttes i øjeblikket ikke for VAX ELF."
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 #| msgid "The -shared option is not currently supported for VAX ELF."
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "Tilvalget -shared understøttes i øjeblikket ikke for VAX ELF."
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "%q+D defined here"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 #| msgid "argument of `asm' is not a constant string"
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "parameteren til 'asm' er ikke en konstant streng"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "%s with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "%s med anderledes bredde på grund af prototypen"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "%s with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "%s med anderledes bredde på grund af prototypen"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "%s with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "%s med anderledes bredde på grund af prototypen"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "%s with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "%s med anderledes bredde på grund af prototypen"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%s) for -march= switch"
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 #, fuzzy
 #| msgid "bad value (%s) for -march= switch"
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "ugyldig værdi (%s) til tilvalget -march="
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 #| msgid "bad value (%s) for -march= switch"
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
@@ -45105,12 +45155,12 @@ msgstr "parameteren til egenskaben '%s er ikke \"ilink1\" eller \"ilink2\""
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to functions"
@@ -45266,25 +45316,25 @@ msgid "argument of %qE attribute ignored"
 msgstr "parameteren til egenskaben '%s er ikke \"ilink1\" eller \"ilink2\""
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to variables"
 msgid "%qE attribute only applies to variables"
 msgstr "egenskaben '%s' kan kun anvendes på variabler"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "Statement at %0 invalid in this context"
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "Sætning ved %0 er ugyldig i denne kontekst"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown %<asm%> flag output %qs"
 msgstr "ukendt registernavn: %s"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for make function"
 msgid "invalid type for %<asm%> flag output"
@@ -45877,13 +45927,13 @@ msgstr "-pipe understøttes ikke"
 msgid "%<-fPIE%> is not supported"
 msgstr "-pipe understøttes ikke"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 #| msgid "-traditional and -ansi are mutually exclusive"
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-traditional og -ansi er indbyrdes uforenelige"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 #| msgid "`-%c' option must have argument"
 msgid "%qs function cannot have arguments"
@@ -45894,7 +45944,7 @@ msgstr "tilvalget '-%c' skal have en parameter"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 #| msgid "function cannot be inline"
 msgid "%qs function cannot return a value"
@@ -46258,7 +46308,7 @@ msgstr "Profilering er ikke understøttet på målarkitekturen."
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "invalid argument to built-in function"
@@ -46610,7 +46660,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -46796,197 +46846,197 @@ msgstr "parameter til dss skal være en 2 bit-konstant uden fortegn"
 msgid "parameter to builtin not valid: %s"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt Service Routines cannot be coded in Thumb mode"
 msgid "interrupt service routine cannot be called directly"
 msgstr "afbrydelsesservicerutiner kan ikke kodes i Thumb-tilstand"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 2-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 #| msgid "shift must be an immediate"
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "skifteværdi skal være en umiddelbar værdi"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the third argument must be an 8-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be an 1-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 3-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be a 4-bit unsigned literal"
 msgid "the last argument must be a 4-bit immediate"
 msgstr "3. parameter skal være en 4 bit-konstant uden fortegn"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 1-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid option %s"
 msgid "'%s' needs isa option %s"
 msgstr "ugyldigt tilvalg %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 5-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be an 8-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 #| msgid "third arg to `__builtin_prefetch' must be a constant"
 msgid "the third argument must be comparison constant"
 msgstr "en tredje parameter til '__builtin_prefetch' skal være en konstant"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect insn:"
 msgid "incorrect comparison mode"
 msgstr "ukorrekt instruktion:"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect insn:"
 msgid "incorrect rounding operand"
 msgstr "ukorrekt instruktion:"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be a 4-bit unsigned literal"
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "3. parameter skal være en 4 bit-konstant uden fortegn"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 #| msgid "third arg to `__builtin_prefetch' must be a constant"
 msgid "the fourth argument must be one of enum %qs"
 msgstr "en tredje parameter til '__builtin_prefetch' skal være en konstant"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "two `u's in integer constant"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "to 'u'-endelser i heltalskonstant"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option %s"
 msgid "%qE needs isa option %s"
 msgstr "ugyldigt tilvalg %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "third arg to `__builtin_prefetch' must be a constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "en tredje parameter til '__builtin_prefetch' skal være en konstant"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second arg to __builtin_prefetch; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ugyldig anden parameter til '__builtin_prefetch'; benytter nul"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid third argument"
 msgstr "ugyldig typeparameter"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third arg to __builtin_prefetch; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ugyldig tredje parameter til '__builtin_prefetch'; benytter nul"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third arg to __builtin_prefetch; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ugyldig tredje parameter til '__builtin_prefetch'; benytter nul"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "second argument must be slice or string"
 msgid "second argument must be a const"
 msgstr "anden parameter skal være skive eller streng"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 32-bit immediate"
 msgstr "1. parameter skal være en 5 bit-konstant med fortegn"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 #| msgid "mask must be an immediate"
 msgid "last argument must be an immediate"
 msgstr "maske skal være en umiddelbar værdi"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -47421,8 +47471,8 @@ msgstr "%qs er ikke et gyldigt tilvalg til præprocessoren"
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -47683,7 +47733,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -47709,12 +47759,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -47724,42 +47774,42 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "-march=%s er ikke forenelig med den valgte ABI"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 #| msgid "ms_hook_prologue is not compatible with nested function"
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "ms_hook_prologue er ikke forenelig med den indlejrede funktion"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute is not supported on this platform"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "egenskaben '%s' er ikke understøttet på denne platform"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "-indlejrede funktioner er ikke understøttet på denne målarkitektur"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "%s is not supported by this configuration"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%s understøttes ikke af denne konfiguration"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "-mips%d does not support 64 bit fp registers"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -47767,97 +47817,97 @@ msgstr "-mips%d understøtter ikke 64-bit kommatalsregistre"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 #| msgid "-mips%d does not support 64 bit fp registers"
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "-mips%d understøtter ikke 64-bit kommatalsregistre"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported size for integer register"
 msgid "%<V%> modifier on non-integer register"
 msgstr "størrelse er ikke understøttet for heltalsregister"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "størrelse er ikke understøttet for heltalsregister"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "udvidede registre har ikke høje halvdele"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "ikke-understøttet operandstørrelse for udvidede registre"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand type used with operand code 'Z'"
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "ugyldig operandtype brugt med operandkoden »Z«"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, fuzzy, gcc-internal-format
 #| msgid "assignment (not initialization) in declaration"
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "tildeling (ikke klargøring) i erklæring"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "ingen lave registre er tilgængelige til at modtage værdier fra høje registre"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 #| msgid "Tune alignment for the specified chip or CPU version"
 msgid "unknown architecture specific memory model"
 msgstr "Finjustér justering til en given chip- eller processorversion"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 #| msgid "-mapcs-stack-check incompatible with -mno-apcs-frame"
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
@@ -47912,7 +47962,7 @@ msgstr "gp_offset (%ld) eller end_offset (%ld) er mindre end nul"
 msgid "argument %qd is not a constant"
 msgstr "parameteren %qd er ikke en konstant"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -47924,7 +47974,7 @@ msgstr "PRINT_OPERAND_ADDRESS, nul-henvisning"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: Ukendt tegnsætning »%c«"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -48087,51 +48137,51 @@ msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "version attribute is not a string"
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "versionsattribut er ikke en streng"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 #| msgid "readonly property can not be set"
 msgid "in attribute %qs priority cannot be empty"
 msgstr "skrivebeskyttet egenskab kan ikke angives"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_trap not supported by this target"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "__builtin_trap understøttes ikke på denne målarkitektur"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qs is not supported in target attribute"
@@ -48941,7 +48991,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 #| msgid "bad builtin fcode"
 msgid "bad builtin code"
@@ -49195,86 +49245,86 @@ msgstr "%s: kan ikke åbne datafil\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "integrerede funktioner understøttes ikke for denne returværditype"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 #| msgid "passing floating point arguments in fp regs not yet supported"
 msgid "not generating patch area, nops not supported"
 msgstr "overbringelse af kommatalsparametre i kommatalsregistre er ikke understøttet endnu"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qE attribute requires a void return type"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "sektionsegenskaben er ikke tilladt for '%s'"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "left argument must be a slice"
 msgid "complement argument must be constant"
 msgstr "venstre parameter skal være en skive"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration; ignored"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "aliasdefinitioner er ikke understøttet i denne konfiguration; ignoreret"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration; ignored"
 msgid "non-function alias definitions not supported in this configuration"
@@ -49527,356 +49577,356 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "ugyldig forskydningsoperand for MEM_REF"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "class `%T' does not have any field named `%D'"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "klassen '%T' har ikke et felt ved navn '%D'"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "class `%T' does not have any field named `%D'"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "klassen '%T' har ikke et felt ved navn '%D'"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "beregninger udført på en henvisning til en ufuldstændig type"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "field `%D' has incomplete type"
 msgid "fields cannot have RVV type %qT"
 msgstr "feltet '%D' er af en ufuldstændig type"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "function returns an aggregate"
 msgid "array elements cannot have RVV type %qT"
 msgstr "funktion returnerer en værdi af en sammensat type"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of type `%T'"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "kan ikke allokere et objekt af typen '%T'"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type `%T' to type `%T'"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "kan ikke konvertere typen '%T' til typen '%T'"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of type `%T'"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "kan ikke allokere et objekt af typen '%T'"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type `%T'"
 msgid "capture by copy of RVV type %qT"
 msgstr "kan ikke %s en henvisning til en ufuldstændig type '%T'"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type `%T' is disallowed in Java `throw' or `catch'"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "typen '%T' er ikke tilladt i Java 'throw' eller 'catch'"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared private"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "instansvariablen '%s' er erklæret privat"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecogized wide sub-instruction"
 msgid "unrecognized RVV builtin"
 msgstr "ukendt bred underinstruktion"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to `%D(%A)'"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "ingen passende funktion for kald til '%D(%A)'"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "unknown value %qs for -mtune"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "ukendt værdi %qs for -mtune"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec-parameter sendt til funktion uden prototype"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 #| msgid "Do not use the Xtensa NSA option"
 msgid "%s %qT requires the V ISA extension"
 msgstr "Benyt ikke Xtensa-NSA-indstillingen"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "a -ifile option requires a -map option"
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "et '-ifile'-tilvalg kræver et '-map'-tilvalg"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument of `%s' attribute is not a string constant"
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "parameteren til egenskaben '%s er ikke en strengkonstant"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "`sizeof' applied to incomplete type `%T'"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "'sizeof' benyttet på en ufuldstændig type '%T'"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "%qE-egenskaben kræver en heltalskonstant som parameter"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support APCS-32"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "målprocessoren understøtter ikke APCS-32"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in the %s bit mode"
 msgid "code model %qs with %qs"
 msgstr "kodemodellen %qs er ikke understøttet i %s bit-tilstand"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support the `%%%c' %s format"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "%s understøtter ikke '%%%c' %s-formateringen"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, fuzzy, gcc-internal-format
 #| msgid "--resource requires -o"
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "--resource påkræver -o"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d is not between %d and 12"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d er ikke mellem %d og 12"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qs is not a valid base register in %qs"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%s understøtter ikke %s"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 #| msgid "`-%c' option must have argument"
 msgid "%qs function cannot have different interrupt type"
 msgstr "tilvalget '-%c' skal have en parameter"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "bad value (%s) for -mtune= switch"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -50988,24 +51038,24 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr "function_profiler-understøttelse for MMIX"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "kan ikke bruge va_start i afbrydelsesfunktion"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "switch-sætning med %lu elementer er for stor"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to variables"
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "egenskaben '%s' kan kun anvendes på variabler"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "sektionsegenskaben er ikke tilladt for '%s'"
@@ -51261,33 +51311,33 @@ msgstr "%J'%D' er ikke defineret uden for funktionsvirkefelt"
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D defineret, men ikke brugt"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "booleske registre er påkrævet til kommatalsindstillingen"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "%s understøttes ikke af denne konfiguration"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "kun variabler uden startværdi kan placeres i .bss-sektionen"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -51386,7 +51436,7 @@ msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktioner"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -51477,8 +51527,8 @@ msgstr "%qs er ikke en mappe"
 msgid "could not get size of source file"
 msgstr "kunne ikke finde specifikationsfilen %s\n"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "tom værdi er ikke ignoreret som den burde være"
@@ -52003,7 +52053,7 @@ msgstr "overløb i konstant udtryk"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE defineret som forkert slags mærke"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qE attribute applied to %qD with void return type"
@@ -52164,7 +52214,7 @@ msgstr "ISO C90 understøtter ikke %<static%> eller typemodifikationer i paramet
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 understøtter ikke %<[*]%> arrayerklæringer"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
@@ -52174,7 +52224,7 @@ msgstr "'%D' blev ikke erklæret i dette virkefelt"
 msgid "%q+D is usually a function"
 msgstr "%q+D er normalt en funktion"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "ingen tidligere erklæring af '%s'"
@@ -52257,7 +52307,7 @@ msgstr "kan ikke anbringe et objekt med et volatile-felt i et register"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "konstant '%D' uden startværdi"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -52489,7 +52539,7 @@ msgstr "lagringsklasse angivet for parameter '%s'"
 msgid "storage class specified for unnamed parameter"
 msgstr "lagringsklasse angivet for parameter '%s'"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "lagringsklasse angivet for typenavn"
@@ -52684,7 +52734,7 @@ msgstr "typenavn er erklæret som en funktion, der returnerer en array"
 msgid "function definition has qualified void return type"
 msgstr "funktiondefinition har kvalificeret void-returtype"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "typemodifikationer ignoreret i funktionsreturtypen"
@@ -52824,7 +52874,7 @@ msgstr "ISO C forbyder const eller volatile funktionstyper"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "datamedlem må ikke have variabelt ændret type '%T'"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "variable or field %qE declared void"
@@ -53060,7 +53110,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr "ukendt felt '%s' angivet i startværdi"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "erklæring erklærer ikke noget"
@@ -53131,7 +53181,7 @@ msgstr "navngivne medlemmer"
 msgid "struct has no members"
 msgstr "%s har intet medlem ved navn '%s'"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "fleksibelt tabelmedlem i union"
@@ -53201,7 +53251,7 @@ msgstr "omerklæring af 'enum %s'"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr ""
@@ -53263,7 +53313,7 @@ msgstr "tabelindeks er ikke et heltal"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C begrænser enum-værdier til rækkevidden af 'int'"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "inline funktion '%s' givet egenskaben noinline"
@@ -53421,12 +53471,12 @@ msgstr "parameteren '%s' passer ikke til prototypen"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "parameteren '%s' passer ikke til prototypen"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "ingen return-sætning i en funktion der ikke returnerer void"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "parameter %qD set but not used"
@@ -53515,7 +53565,7 @@ msgstr "'%D' blev ikke erklæret i dette virkefelt"
 msgid "two or more data types in declaration specifiers"
 msgstr "mere end én datatype i erklæringen af '%s'"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, fuzzy, gcc-internal-format
 #| msgid "`long long long' is too long for GCC"
 msgid "%<long long long%> is too long for GCC"
@@ -53632,7 +53682,7 @@ msgstr "ISO C90 understøtter ikke komplekse typer"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C understøtter ikke komplekse heltalstyper"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 #| msgid "Profiling is not supported on this target."
 msgid "%<_Float%d%s%> is not supported on this target"
@@ -53811,12 +53861,12 @@ msgstr "venstre parameter skal være en skive"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ understøtter ikke 'long long'"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -53882,39 +53932,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "-frepo skal bruges med -c"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "venstreskiftsantal er negativ"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "venstreskiftsantal er negativ"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "højreskiftsantal er negativ"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "venstreskiftsantal er større end bredden af typen"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "højreskiftsantal er større end bredden af typen"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "venstreskiftsantal er større end bredden af typen"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -53936,7 +53986,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr "  anden type her"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 #| msgid "garbage at end of #line"
 msgid "expected end of line"
@@ -53948,7 +53998,7 @@ msgstr "ragelse i slutningen af #line"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C forbyder en tom kildefil"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -53999,8 +54049,8 @@ msgid "unknown type name %qE"
 msgstr "ukendt registernavn: %s"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, fuzzy, gcc-internal-format
 #| msgid "repeated declaration of unit `%s'"
 msgid "expected declaration specifiers"
@@ -54039,7 +54089,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored for `%s'"
 msgid "prefix attributes are ignored for methods"
@@ -54056,12 +54106,12 @@ msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 msgid "unexpected attribute"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "sektionsegenskaben er ikke tilladt for '%s'"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "sektionsegenskaben er ikke tilladt for '%s'"
@@ -54106,7 +54156,7 @@ msgstr "tildeling (ikke klargøring) i erklæring"
 msgid "%qs may only be used with a single declarator"
 msgstr "-mn benyttet uden -mh eller -ms"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr ""
@@ -54143,7 +54193,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "funktionen '%s' kan ikke erklæres 'mutable'"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, fuzzy, gcc-internal-format
 #| msgid "_Pragma takes a parenthesized string literal"
 msgid "expected string literal"
@@ -54178,7 +54228,7 @@ msgstr "startværdien for den statiske variabel er ikke en konstant"
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 #| msgid "verification error at PC=%d"
 msgid "static assertion failed"
@@ -54238,8 +54288,8 @@ msgstr "kan ikke konverteres til en henvisningstype"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, fuzzy, gcc-internal-format
 msgid "expected identifier"
 msgstr "uventet operand"
@@ -54273,12 +54323,12 @@ msgstr "ugyldig brug af en type '%s %s' der ikke er defineret"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "typen passer ikke med tidligere underforstået erklæring"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "komma i slutningen af enum-liste"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -54363,25 +54413,25 @@ msgstr "erklæring af '%s' på øverste niveau angiver 'auto'"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected OpenMP directive name"
 msgstr "forventet funktion"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "forventede %<:%> or %<::%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qE attribute does not take any arguments"
@@ -54393,7 +54443,7 @@ msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 understøtter ikke %<[*]%> arrayerklæringer"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -54429,17 +54479,17 @@ msgstr "ISO C89 forbyder angivelse af underobjekt til klargøring"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "forældet brug af udpeget startværdi uden '='"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -54449,44 +54499,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qs attribute does not take any arguments"
@@ -54519,7 +54569,7 @@ msgstr "ISO C89 forbyder blandede erklæringer og kode"
 msgid "expected %<}%> before %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -54534,7 +54584,7 @@ msgstr "forældet brug af etiket i slutningen af sammensat sætning"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, fuzzy, gcc-internal-format
 msgid "expected statement"
 msgstr "uventet operand"
@@ -54571,30 +54621,30 @@ msgstr "ISO C understøtter ikke komplekse heltalstyper"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declaration"
 msgstr "tom erklæring"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, fuzzy, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "tom krop i en else-sætning"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "tom krop i en else-sætning"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, fuzzy, gcc-internal-format
 #| msgid "%Hsuggest explicit braces to avoid ambiguous `else'"
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "%Hforeslår eksplicitte krøllede paranteser for at undgå tvetydig 'else'"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -54616,12 +54666,12 @@ msgstr "flere erklærerer i skabelonserklæring"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "ugyldigt register i instruktionen"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -54637,8 +54687,8 @@ msgstr ""
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "case-værdi optræder mere end én gang"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, fuzzy, gcc-internal-format
 msgid "first seen here"
 msgstr "  første type her"
@@ -54663,12 +54713,12 @@ msgstr "ISO C forbyder udeladelse af den midterste del af et '?:'-udtryk"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "first %<sizeof%> operand was declared here"
@@ -54862,7 +54912,7 @@ msgstr "ISO C90 understøtter ikke komplekse typer"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected expression"
@@ -54878,13 +54928,13 @@ msgstr "sætningsblokke i udtryk er kun tilladt inde i en funktion"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C forbyder sætningsblokke inden i udtryk"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of `va_start' not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "den anden parameter til 'va_start' er ikke den sidste navngivne parameter"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -55050,7 +55100,7 @@ msgstr "parameteren til '__builtin_eh_return_regno' skal være konstant"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "en tredje parameter til '__builtin_prefetch' skal være en konstant"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
@@ -55098,7 +55148,7 @@ msgstr "parameter der ikke er et kommatal, til funktionen '%s'"
 msgid "rotate count is negative"
 msgstr "%s-roteringsantal er negativt"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -55214,7 +55264,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -55257,13 +55307,13 @@ msgstr "Klasse- eller grænsefladeerklæring forventet"
 msgid "no type or storage class may be specified here,"
 msgstr "lagringsklasse angivet for typenavn"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 #| msgid "readonly property can not be set"
 msgid "empty property attribute list"
 msgstr "skrivebeskyttet egenskab kan ikke angives"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -55275,60 +55325,60 @@ msgstr "manglende Code-egenskab"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "Ukendt processor: -mcpu=%s"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "%<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected %qE selector name"
 msgstr "tom krop i en else-sætning"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma once in main file"
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "'#pragma once' i hovedfil"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -55338,12 +55388,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr ""
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr ""
@@ -55353,11 +55403,11 @@ msgstr ""
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %qs clauses"
@@ -55375,67 +55425,67 @@ msgstr "udsagn skal være et kaldenavn"
 msgid "%qD is not a variable"
 msgstr "'%D' er ikke et navnerum"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qD is not a pointer variable"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "collapse argument needs positive constant integer expression"
 msgstr "sammenlign mellem signed og unsigned heltalsudtryk"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<none%> or %<present%>"
 msgstr "forventede %<:%> or %<::%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "expected constant logical expression"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<data%>"
 msgstr "forventede %<catch%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<if%> clauses"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<if%> clauses without modifier"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -55459,24 +55509,24 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%<priority%> value must be non-negative"
 msgstr "%s-roteringsantal er negativt"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
@@ -55488,111 +55538,111 @@ msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%qs expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%qs value must be positive"
 msgstr "%s-roteringsantal er negativt"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments"
 msgid "too many %<static%> arguments"
 msgstr "for mange parametre"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "unexpected argument"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not an integer constant"
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "parameteren til egenskaben '%s' er ikke en heltalskonstant"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<self%> clauses"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<new%>"
 msgid "expected %<concurrent%>"
 msgstr "forventede %<new%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "ordered argument needs positive constant integer expression"
 msgstr "sammenlign mellem signed og unsigned heltalsudtryk"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "chunk size value must be positive"
 msgstr "%s-roteringsantal er negativt"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "ugyldig roteringsinstruktion"
@@ -55602,40 +55652,40 @@ msgstr "ugyldig roteringsinstruktion"
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "%<,%> eller %<)%> forventet"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "duplikere %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
@@ -55651,23 +55701,23 @@ msgstr "uventet operand"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple linear modifiers"
 msgstr "mere end én 'virtual'-angivelse"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple %<step%> modifiers"
@@ -55678,7 +55728,7 @@ msgstr "mere end én 'virtual'-angivelse"
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -55693,341 +55743,341 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%d operand"
 msgid "invalid depend kind"
 msgstr "ugyldig %%d-operand"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid doacross kind"
 msgstr "ugyldig maske"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "expected %<fallback%> modifier"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%s-roteringsantal er negativt"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "illegal comma"
 msgstr "ugyldig operand "
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<always%> modifiers"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<close%> modifiers"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid map kind"
 msgstr "ugyldig maske"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "forventede %<:%> or %<::%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "ugyldig roteringsinstruktion"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rotate insn"
 msgid "invalid proc_bind kind"
 msgstr "ugyldig roteringsinstruktion"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "%<;%>, %<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "sammenlign mellem signed og unsigned heltalsudtryk"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "invalid string literal, ignoring final '\\'"
 msgid "string literal must not contain %<\\0%>"
 msgstr "ugyldig strengkonstant, ignorerer afsluttende '\\'"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "undefining `%s'"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "glemmer definitionen af '%s'"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "expected string literal or constant integer expression"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "forventede %<:%> or %<::%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `const'"
 msgid "duplicated %<fr%> preference selector"
 msgstr "'const' optræder mere end én gang"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "_Pragma takes a parenthesized string literal"
 msgid "non-empty string literal expected"
 msgstr "_Pragma tager en strengkonstant med paranteser omkring"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "mere end én 'virtual'-angivelse"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `volatile'"
 msgid "duplicate %<target%> modifier"
 msgstr "'volatile' optræder mere end én gang"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `const'"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "'const' optræder mere end én gang"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected EOF while reading source file %s.\n"
 msgid "expected an OpenACC clause"
 msgstr "Stødt på slutningen af kildefilen %s tidligere end forventet.\n"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%s understøtter ikke %s"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr ""
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of \"%s\" shadows a global declaration"
 msgid "array section in %<#pragma acc declare%>"
 msgstr "erklæring af '%s' skygger for en global erklæring"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "erklæring af '%s' der er en 'extern'-variabel, i begyndelseserklæring i 'for'-løkke"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "skabelonsparameter '%T' er en variabelt ændret type"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "erklæring af '%s' der er en 'extern'-variabel, i begyndelseserklæring i 'for'-løkke"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "erklæring af '%s' der er en 'extern'-variabel, i begyndelseserklæring i 'for'-løkke"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma once in main file"
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "'#pragma once' i hovedfil"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -56043,7 +56093,7 @@ msgstr "'%#D' kan ikke erklæres"
 msgid "expected function name"
 msgstr "forventet funktion"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "%qD does not refer to a function"
@@ -56054,24 +56104,24 @@ msgstr "'%D' er ikke en medlemsskabelonfunktion"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, fuzzy, gcc-internal-format
 #| msgid "braced-group within expression allowed only inside a function"
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "sætningsblokke i udtryk er kun tilladt inde i en funktion"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 #| msgid "braced-group within expression allowed only inside a function"
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "sætningsblokke i udtryk er kun tilladt inde i en funktion"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -56098,7 +56148,7 @@ msgstr ""
 msgid "modified here"
 msgstr "'%s' tidligere defineret her"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
@@ -56134,121 +56184,121 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "%<;%>, %<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many atomic clauses"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many memory order clauses"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "--resource requires -o"
 msgid "%qs clause requires %qs clause"
 msgstr "--resource påkræver -o"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "'%s' er erklæret inline efter dens definition"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "ugyldig #pragma %s"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "forventede %<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "ugyldig #pragma %s"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "ugyldig #pragma %s"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand for 'p' modifier"
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "ugyldig operand til 'p'-ændring"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
@@ -56258,30 +56308,30 @@ msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "%<;%>, %<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -56291,34 +56341,34 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr ""
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "forventede %<:%> or %<::%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp section%> or %<}%>"
 msgid "expected %<#pragma omp scan%>"
 msgstr "%<#pragma omp section%> eller %<}%> forventet"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 #| msgid "')' or term expected"
 msgid "for statement expected"
@@ -56327,71 +56377,71 @@ msgstr "')' eller term forventet"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "')' or term expected"
 msgid "loop nest expected"
 msgstr "')' eller term forventet"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, fuzzy, gcc-internal-format
 #| msgid "repeated declaration of automaton `%s'"
 msgid "expected iteration declaration or initialization"
 msgstr "gentaget erklæring af automaten '%s'"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough arguments"
 msgid "not enough nested loops"
 msgstr "ikke nok parametre"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr ""
@@ -56402,7 +56452,7 @@ msgstr ""
 msgid "expected a function name"
 msgstr "forventet funktion"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected target-function call"
@@ -56413,48 +56463,48 @@ msgstr "forventet funktion"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected %<point%>"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -56469,65 +56519,65 @@ msgstr "en global registervariabel følger en funktionsdefinition"
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected trait selector name"
 msgstr "tom krop i en else-sætning"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 #| msgid "unknown value %qs for -mtune"
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "ukendt værdi %qs for -mtune"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type `%T' does not have member `%D'"
 msgid "selector %qs does not accept any properties"
 msgstr "ufuldstændig type '%T' har ikke medlemmet '%D'"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "'%D' kan kun angives inden i en klasse"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%<score%> argument must be non-negative"
 msgstr "%s-roteringsantal er negativt"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "_Pragma takes a parenthesized string literal"
 msgid "expected identifier or string literal"
 msgstr "_Pragma tager en strengkonstant med paranteser omkring"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "property must be integer expression"
 msgstr "uventet adresseudtryk"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "code model `large' not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "kodemodellen 'large' er ikke understøttet endnu"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected context selector set name"
@@ -56539,30 +56589,30 @@ msgstr "tom krop i en else-sætning"
 msgid "variant %qD is not a function"
 msgstr "'%s' er ikke en funktion,"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "field `%s' declared as a function"
 msgid "variant %qD is the same as base function"
 msgstr "feltet '%s' er erklæret som en funktion"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "%<;%>, %<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<match%> clauses"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 #| msgid "%s used with `%%%c' %s format"
 msgid "%qD is specified more than once"
@@ -56574,7 +56624,7 @@ msgstr "%s brugt med '%%%c' %s-formatering"
 msgid "%qD is not of pointer type"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -56585,18 +56635,18 @@ msgstr "forventede %<:%> or %<::%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%s understøtter ikke %s"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected %<interop%>"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%> clause"
@@ -56619,13 +56669,13 @@ msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 msgid "base function %qD declared here"
 msgstr "  '%#D' erklæret her"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "long and short specified together for `%s'"
 msgid "%<append_args%> specified here"
@@ -56636,7 +56686,7 @@ msgstr "long og short er begge angivet for '%s'"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "variant %qD and base %qD have incompatible types"
@@ -56647,7 +56697,7 @@ msgstr "-f%s og -msdata=%s er indbyrdes uforenelige"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
@@ -56664,89 +56714,89 @@ msgstr "new kan ikke bruges på en funktionstype"
 msgid "no declaration of base function %qs"
 msgstr "underforstået erklæring af funktionen '%s'"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared `register'"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "'register' er påhæftet funktionsdefinitionen"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%>"
 msgstr "forventede %<catch%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<::%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "forventede %<:%> or %<::%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "uventet operand"
@@ -56775,12 +56825,12 @@ msgstr "erklæring af '%s' skygger for en global erklæring"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T var tidligere erklæret her"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 msgid "unexpected clause"
 msgstr "uventet operand"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "missing %<map%> clause"
@@ -56844,33 +56894,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -56887,170 +56937,170 @@ msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<while%>"
 msgid "expected %<sizes%>"
 msgstr "%<while%> forventet"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not an integer constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "parameteren til egenskaben '%s' er ikke en heltalskonstant"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "%<;%>, %<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %qs or %qs"
 msgstr "%<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected directive name"
 msgstr "forventet funktion"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown assumption clause %qs"
 msgstr "ukendt registernavn: %s"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected assumption clause"
 msgstr "forventet funktion"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "%<;%>, %<,%> eller %<)%> forventet"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "for mange inddatafiler"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "ukendt registernavn: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr ""
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "parameteren er af en ufuldstændig type"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -57061,7 +57111,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "%<transaction_may_cancel_outer%> funktionskald er ikke inden for ydre transaktion eller %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -57078,7 +57128,7 @@ msgstr "fejl ved lukning af %s: %m"
 msgid "%qD has an incomplete type %qT"
 msgstr "'%s' er af en ufuldstændig type"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "ugyldig brug af void-udtryk"
@@ -57111,181 +57161,181 @@ msgstr "ugyldig brug af ufuldstændig typedef '%s'"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktioner"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "funktionstyper ikke er fuldt ud forenelige i ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "typer er ikke helt forenelige"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 #| msgid "types are not quite compatible"
 msgid "pointer target types incompatible in C++"
 msgstr "typer er ikke helt forenelige"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, fuzzy, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "en funktions returtype kan ikke være en funktion"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "ugyldig brug af struktur med fleksibelt tabelmedlem"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 #| msgid "'%D' has no member named '%E'"
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "'%D' har intet medlem ved navn '%E'"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, fuzzy, gcc-internal-format
 #| msgid "'%D' has no member named '%E'"
 msgid "%qT has no member named %qE"
 msgstr "'%D' har intet medlem ved navn '%E'"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, fuzzy, gcc-internal-format
 #| msgid "protected member `%#D' in anonymous union"
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "beskyttet medlem '%#D' i en anonym union"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, fuzzy, gcc-internal-format
 #| msgid "request for member `%s' in something not a structure or union"
 msgid "request for member %qE in something not a structure or union"
 msgstr "forespørgsel efter medlemmet '%s' i noget der hverken er en union eller en struktur"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing `void *' pointer"
 msgid "dereferencing %<void *%> pointer"
 msgstr "forsøg på at følge en 'void *'-henvisning"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "værdien der er påført et indeks, er hverken en tabel eller en henvisningsvariabel"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "tabelindeks er ikke et heltal"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, fuzzy, gcc-internal-format
 #| msgid "passing arg of pointer to function"
 msgid "subscripted value is pointer to function"
 msgstr "videregiver parameter af henvisning til funktion"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "tabelindeks er ikke et heltal"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting `register' array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C forbyder opslag i 'register'-tabel"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 forbyder opslag i tabel der ikke er venstreværdi"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "'%D' erklæret som en reference, men bliver ikke tildelt en startværdi"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "called object is not a function"
 msgid "called object %qE is not a function or function pointer"
 msgstr "det kaldte objekt er ikke en funktion"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "called object is not a function"
 msgid "called object %qD is not a function or function pointer"
 msgstr "det kaldte objekt er ikke en funktion"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 #| msgid "called object is not a function"
 msgid "called object is not a function or function pointer"
@@ -57294,245 +57344,245 @@ msgstr "det kaldte objekt er ikke en funktion"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, fuzzy, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "sizeof benyttet på en ufuldstændig type"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified void function return type"
 msgid "function with qualified void return type called"
 msgstr "ISO C forbyder void funktionsreturtype med modifikationer"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "typen af den formelle parameter %d er ufuldstændig"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, fuzzy, gcc-internal-format
 #| msgid "%s as integer rather than floating due to prototype"
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "%s som heltal i stedet for kommatal på grund af prototypen"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, fuzzy, gcc-internal-format
 #| msgid "%s as integer rather than complex due to prototype"
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "%s som heltal i stedet for complex på grund af prototypen"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, fuzzy, gcc-internal-format
 #| msgid "%s as complex rather than floating due to prototype"
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "%s som complex i stedet for kommatal på grund af prototypen"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, fuzzy, gcc-internal-format
 #| msgid "%s as floating rather than integer due to prototype"
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "%s som kommatal i stedet for heltal på grund af prototypen"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, fuzzy, gcc-internal-format
 #| msgid "%s as complex rather than integer due to prototype"
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "%s som complex i stedet for heltal på grund af prototypen"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, fuzzy, gcc-internal-format
 #| msgid "%s as floating rather than complex due to prototype"
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "%s som kommatal i stedet for complex på grund af prototypen"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, fuzzy, gcc-internal-format
 #| msgid "%s as `float' rather than `double' due to prototype"
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "%s som float i stedet for double på grund af prototypen"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, fuzzy, gcc-internal-format
 #| msgid "%s as integer rather than complex due to prototype"
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "%s som heltal i stedet for complex på grund af prototypen"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, fuzzy, gcc-internal-format
 #| msgid "%s with different width due to prototype"
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "%s med anderledes bredde på grund af prototypen"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, fuzzy, gcc-internal-format
 #| msgid "%s as unsigned due to prototype"
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "%s som unsigned på grund af prototypen"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, fuzzy, gcc-internal-format
 #| msgid "%s as signed due to prototype"
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "%s som signed på grund af prototypen"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function `%s'"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "for mange parametre til funktionen '%s'"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "for mange parametre til funktionen"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "for mange parametre til funktionen"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr ""
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "for få parametre til funktionen"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "for få parametre til funktionen"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "for få parametre til funktionen"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, fuzzy, gcc-internal-format
 #| msgid "%Jweak declaration of '%D' after first use results in unspecified behavior"
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "%Jsvag erklæring af '%D' efter første brug resulterer i ikke-defineret opførsel"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "sammenligning mellem henvisningsvariabel og heltal"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "casting `%T' to `%T' does not dereference pointer"
 msgid "did you mean to dereference the pointer?"
 msgstr "typeomtvingning af '%T' til '%T' følger ikke henvisning"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "two `u's in integer constant"
 msgid "zero as null pointer constant"
 msgstr "to 'u'-endelser i heltalskonstant"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between `%#T' and `%#T'"
 msgid "comparison between %qT and %qT"
 msgstr "sammenligning mellem '%#T' og '%#T'"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, fuzzy, gcc-internal-format
 #| msgid "pointer of type `void *' used in subtraction"
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "henvisning af typen 'void *' benyttet i subtraktion"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "henvisning til en funktion benyttet i subtraktion"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "beregninger udført på en henvisning til en ufuldstændig type"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "beregninger udført på en henvisning til en ufuldstændig type"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "%<~%> on a boolean expression"
 msgstr "uventet adresseudtryk"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support `~' for complex conjugation"
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C understøtter ikke '~' til compleks-konjugering"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "forkert parametertype til abs"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "forkert parametertype til unært udråbstegn"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, fuzzy, gcc-internal-format
 #| msgid "enumeration value `%s' not handled in switch"
 msgid "increment of enumeration value is invalid in C++"
 msgstr "enum-værdien '%s' håndteres ikke i switch-sætning"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, fuzzy, gcc-internal-format
 #| msgid "enumeration value `%s' not handled in switch"
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "enum-værdien '%s' håndteres ikke i switch-sætning"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "increment of a boolean expression"
 msgstr "uventet adresseudtryk"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "decrement of a boolean expression"
 msgstr "uventet adresseudtryk"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support `++' and `--' on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
@@ -57540,1837 +57590,1837 @@ msgstr "ISO C understøtter ikke '++' og '--' for complex-typer"
 
 # man kan ikke stikke en forøgelse (++) en type som parameter, 'type
 # argument' skal opfattes på en anden måde
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "forkert parametertype til forøgelse"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "forkert parametertype til formindskelse"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "beregninger udført på en henvisning til en ufuldstændig type"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "beregninger udført på en henvisning til en ufuldstændig type"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of expression of type %<void%>"
 msgstr "tager adressen på midlertidig variabel"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field `%s'"
 msgid "cannot take address of bit-field %qD"
 msgstr "kan ikke finde adressen af bitfeltet '%s'"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of an unaligned member"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "kan ikke tage adressen af et ikke-justeret medlem"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable `%s' requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "forespørgsel efter adressen af registervariablen '%s'"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable `%s' requested"
 msgid "address of register compound literal requested"
 msgstr "forespørgsel efter adressen af registervariablen '%s'"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, fuzzy, gcc-internal-format
 #| msgid "global register variable `%s' used in nested function"
 msgid "global register variable %qD used in nested function"
 msgstr "global registervariabel '%s' benyttet i indlejret funktion"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, fuzzy, gcc-internal-format
 #| msgid "register variable `%s' used in nested function"
 msgid "register variable %qD used in nested function"
 msgstr "registervariabel '%s' benyttet i indlejret funktion"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, fuzzy, gcc-internal-format
 #| msgid "address of global register variable `%s' requested"
 msgid "address of global register variable %qD requested"
 msgstr "forespørgsel efter adressen af den globale registervariabel '%s'"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable `%s' requested"
 msgid "address of register variable %qD requested"
 msgstr "forespørgsel efter adressen af registervariablen '%s'"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "non-lvalue array in conditional expression"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "enumeration value `%s' not handled in switch"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "enum-værdien '%s' håndteres ikke i switch-sætning"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C forbyder betingede udtryk med kun én tom side"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "henvisningstyperne i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "henvisningstyperne i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "henvisningstyperne i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids conditional expr between `void *' and function pointer"
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C++ forbyder betinget udtryk mellem 'void *' og funktionshenvisning"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "henvisningstyperne i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "first expression has type %qT"
 msgstr "uventet adresseudtryk"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "second expression has type %qT"
 msgstr "uventet adresseudtryk"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "henvisnings- og heltalstype i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "typerne i betingelsesudtrykket passer ikke sammen"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of `%D', declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "%Hignorerer returværdi for '%D' erklæret med egenskaben warn_unused_result"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of `%D', declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "%Hignorerer returværdi for '%D' erklæret med egenskaben warn_unused_result"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of `%D', declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "%Hignorerer returværdi for '%D' erklæret med egenskaben warn_unused_result"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of `%D', declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "%Hignorerer returværdi for '%D' erklæret med egenskaben warn_unused_result"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "in call to %qD, declared here"
 msgstr "  '%#D' erklæret her"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "venstreoperanden til kommaudtrykket har ingen virkning"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "right-hand operand of comma expression has no effect"
 msgstr "venstreoperanden til kommaudtrykket har ingen virkning"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 #| msgid "cast adds new qualifiers to function type"
 msgid "cast adds %q#v qualifier to function type"
 msgstr "typeomtvingning tilføjer modifikationer til en funktionstype"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "typeomtvingelse kasserer modifikationer på henvisningsmålets type"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "typetildelingen angiver en tabeltype"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "typetildelingen angiver en funktionstype"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C forbyder omtvingelse af ikke-skalar til den samme type"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "skabelonsparameter '%T' benytter lokal type '%T'"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C forbyder omtvingelse til uniontype"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "typetildeling til en uniontype fra en type der ikke findes i union'en"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "sammenligning med forskellige henvisningstyper mangler en typeomtvingelse"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "sammenligning med forskellige henvisningstyper mangler en typeomtvingelse"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "sammenligning med forskellige henvisningstyper mangler en typeomtvingelse"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "typeomtvingelse forøger den påkrævne justering af måltypen"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "typeomtvingelse fra henvisning til heltal af en anden størrelse"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "typeomtvingelse fra heltal til henvisning af en anden størrelse"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C forbyder sammenligning af 'void *' med funktionshenvisning"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C forbyder sammenligning af 'void *' med funktionshenvisning"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t convert from incomplete type %qT to %qT"
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "kan ikke konvertere fra ufuldstændig type %qT til %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 #| msgid "assignment suppression"
 msgid "assignment to expression with array type"
 msgstr "tildelingsundertrykkelse"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, fuzzy, gcc-internal-format
 #| msgid "(near initialization for `%s')"
 msgid "(near initialization for %qs)"
 msgstr "(i nærheden af klargøringen af '%s')"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, fuzzy, gcc-internal-format
 #| msgid "char-array initialized from wide string"
 msgid "array initialized from parenthesized string constant"
 msgstr "char-tabel får tildelt startværdi fra en bred streng"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "argument missing after %s"
 msgid "expected %e but argument is of type %e"
 msgstr "en parameter mangler efter %s"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "built-in %qD declared here"
 msgstr "  '%#D' erklæret her"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "  `%#D' declared here"
 msgid "%e declared here"
 msgstr "  '%#D' erklæret her"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "konvertering fra NaN til unsigned int"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "kan ikke konvertere '%T' til '%T' i %s"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "konvertering fra NaN til unsigned int"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from `%#T' to `%#T'"
 msgid "implicit conversion from %qT to %qT"
 msgstr "konvertering fra '%#T' til '%#T'"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 #| msgid "%s makes qualified function pointer from unqualified"
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "%s opretter en funktionshenvisning med modifikationer fra én uden"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 #| msgid "%s makes qualified function pointer from unqualified"
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "%s opretter en funktionshenvisning med modifikationer fra én uden"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 #| msgid "%s makes qualified function pointer from unqualified"
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "%s opretter en funktionshenvisning med modifikationer fra én uden"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 #| msgid "%s makes qualified function pointer from unqualified"
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "%s opretter en funktionshenvisning med modifikationer fra én uden"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 #| msgid "cast from `%T' to `%T' discards qualifiers from pointer target type"
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "typeomtvingning fra '%T' til '%T' kasserer modifikationer på henvisningsmålets type"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "typeomtvingelse kasserer modifikationer på henvisningsmålets type"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "typeomtvingelse kasserer modifikationer på henvisningsmålets type"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "typeomtvingelse kasserer modifikationer på henvisningsmålets type"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C forbyder parameterkonvertering til uniontype"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, fuzzy, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "konvertering fra NaN til unsigned int"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 #| msgid "passing arg %d of pointer to function"
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "videregiver den %d. parameter af henvisning til funktion"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "typeomtvingelse fra henvisning til heltal af en anden størrelse"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got `%E'"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "  forventede en type, modtog '%E'"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, fuzzy, gcc-internal-format
 #| msgid "function might be possible candidate for `%s' format attribute"
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "funktion er en mulig kandidat til '%s'-formateringsegenskab"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about functions which might be candidates for format attributes"
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "Advar om funktioner som kan være kandidater til formateringsegenskaber"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, fuzzy, gcc-internal-format
 #| msgid "function might be possible candidate for `%s' format attribute"
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "funktion er en mulig kandidat til '%s'-formateringsegenskab"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, fuzzy, gcc-internal-format
 #| msgid "function might be possible candidate for `%s' format attribute"
 msgid "return type might be a candidate for a format attribute"
 msgstr "funktion er en mulig kandidat til '%s'-formateringsegenskab"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with a value, in function declared with a void return type"
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "return-sætning med en værdi i en funktion der er erklæret med en void returtype"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids %s between function pointer and `void *'"
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C forbyder %s mellem funktionshenvisning og 'void *'"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids %s between function pointer and `void *'"
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C forbyder %s mellem funktionshenvisning og 'void *'"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids %s between function pointer and `void *'"
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C forbyder %s mellem funktionshenvisning og 'void *'"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids %s between function pointer and `void *'"
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C forbyder %s mellem funktionshenvisning og 'void *'"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in %s differ in signedness"
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "fortegnene i henvisningsmål i %s er forskellige"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in %s differ in signedness"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "fortegnene i henvisningsmål i %s er forskellige"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in %s differ in signedness"
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "fortegnene i henvisningsmål i %s er forskellige"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in %s differ in signedness"
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "fortegnene i henvisningsmål i %s er forskellige"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "%s from incompatible pointer type"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "%s from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "%s from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "%s from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "return-statement with a value, in function declared with a void return type"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "return-sætning med en værdi i en funktion der er erklæret med en void returtype"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "return-statement with a value, in function declared with a void return type"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "return-sætning med en værdi i en funktion der er erklæret med en void returtype"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes pointer from integer without a cast"
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "%s opretter en henvisningsvariabel ud fra et heltal uden en typeomtvingning"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes pointer from integer without a cast"
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "%s opretter en henvisningsvariabel ud fra et heltal uden en typeomtvingning"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes pointer from integer without a cast"
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "%s opretter en henvisningsvariabel ud fra et heltal uden en typeomtvingning"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes pointer from integer without a cast"
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "%s opretter en henvisningsvariabel ud fra et heltal uden en typeomtvingning"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes integer from pointer without a cast"
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "%s opretter et heltal ud fra en henvisningsvariabel uden en typeomtvingning"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes integer from pointer without a cast"
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "%s opretter et heltal ud fra en henvisningsvariabel uden en typeomtvingning"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes integer from pointer without a cast"
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "%s opretter et heltal ud fra en henvisningsvariabel uden en typeomtvingning"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 #| msgid "%s makes integer from pointer without a cast"
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "%s opretter et heltal ud fra en henvisningsvariabel uden en typeomtvingning"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible type for argument %d of `%s'"
 msgid "incompatible type for argument %d of %qE"
 msgstr "typen af den %d. parameter i '%s' passer ikke"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of `%T' to `%T'"
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "uforenelige typer i tildeling af '%T' til '%T'"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of `%T' to `%T'"
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "uforenelige typer i tildeling af '%T' til '%T'"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr ""
 
 # 'automatic aggregate' betyder automatisk allokerede variabler, dvs.
 # ganske almindelige lokale variabler (kan evt. erklæres med 'auto')
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "traditionel C forbyder klargøring af auto-variabler af sammensatte typer"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "navnerum '%D' ikke tilladt i using-erklæring"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "klargøring af fleksibelt tabelmedlem"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "startværdistrengen til char-tabellen er for lang"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "startværdistrengen til char-tabellen er for lang"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, fuzzy, gcc-internal-format
 #| msgid "char-array initialized from wide string"
 msgid "array of inappropriate type initialized from string constant"
 msgstr "char-tabel får tildelt startværdi fra en bred streng"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "ugyldig brug af en tabel der ikke kan optræde som en venstreværdi"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "ugyldig startværdi"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "startværdielement er ikke en konstant"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "tabel får tildelt en startværdi fra et tabeludtryk der ikke er konstant"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "initializer element is not a constant expression"
 msgstr "startværdielement er ikke en konstant"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from `%T' to `%T' discards qualifiers"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "konvertering fra '%T' til '%T' forkaster modifikationer"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "startværdielement kan ikke beregnes ved indlæsningstidspunktet"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, fuzzy, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "objekt af typen '%T' med variabel størrelse må ikke tildeles en startværdi"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "overskydende krøllede paranteser ved slutningen af startværdien"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "krøllede paranteser omkring skalarstartværdi"
 
 # RETMIG: eller er det fleksibel tabel-medlem
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "klargøring af fleksibelt tabelmedlem i en indlejret kontekst"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "krøllede paranteser mangler omkring startværdien"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member `%D'"
 msgid "missing initializer for field %qD of %qT"
 msgstr "manglende startværdi for medlemmet '%D'"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "overskydende elementer i skalarstarværdi"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "tabelindeks i en startværdi der ikke er en tabel"
 
 # RETMIG: record?
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "feltnavn ikke i struktur- eller union-startværdi"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer exceeds array bounds"
 msgid "array index in initializer not of integer type"
 msgstr "tabelindeks i startværdi overskrider tabelgrænser"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "array index in initializer is not an integer constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "tabelindekset i startværdien er ikke en konstant"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "tabelindeks i startværdi overskrider tabelgrænser"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "tomt indeksinterval i startværdi"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "tabelindeksinterval i startværdi overskrider tabelgrænser"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, fuzzy, gcc-internal-format
 #| msgid "initialized field with side-effects overwritten"
 msgid "initialized field overwritten"
 msgstr "klargjort felt med bivirkninger overskrevet"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "klargjort felt med bivirkninger overskrevet"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "for mange elementer i union-startværdi"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "for mange elementer i struct-startværdi"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "ikke-statisk klargøring af fleksibelt tabelmedlem"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "for mange elementer i union-startværdi"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "traditionel C forbyder tildeling af startværdi til unioner"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "for mange elementer i tabelstartværdi"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "for mange elementer i vektorstartværdi"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "for mange elementer i skalarstartværdi"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra `;' outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C tillader ikke ekstra ';' uden for funktioner"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in output operand outside of a function"
 msgstr "en type med en variabel størrelse er erklæret uden for en funktion"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "uddataoperand %d skal bruge %<&%>-begrænsningen"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' cannot be used as a function"
 msgid "%<-%> modifier used inside of a function"
 msgstr "'%E' kan ikke bruges som en funktion"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, fuzzy, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in input operand outside of a function"
 msgstr "en type med en variabel størrelse er erklæret uden for en funktion"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%J'%D' is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%J'%D' er ikke defineret uden for funktionsvirkefelt"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids `goto *expr;'"
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C forbyder 'goto *udtryk;'"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "computed goto must be pointer type"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, fuzzy, gcc-internal-format
 #| msgid "function declared `noreturn' has a `return' statement"
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "funktion der er erklæret 'noreturn' har en 'return'-sætning"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, fuzzy, gcc-internal-format
 #| msgid "`return' with no value, in function returning non-void"
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "'return' uden nogen værdi i en funktion der ikke returnerer void"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, fuzzy, gcc-internal-format
 #| msgid "`return' with a value, in function returning void"
 msgid "%<return%> with a value, in function returning void"
 msgstr "'return' med en værdi i en funktion der returnerer void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, fuzzy, gcc-internal-format
 #| msgid "`return' with a value, in function returning void"
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "'return' med en værdi i en funktion der returnerer void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of label"
 msgstr "funktion returnerer adressen på en lokal variabel"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "funktion returnerer adressen på en lokal variabel"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch-størrelsen er ikke et heltal"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, fuzzy, gcc-internal-format
 #| msgid "`long' switch expression not converted to `int' in ISO C"
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "'long'-udtryk i switch konverteres ikke til 'int' i ISO C"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "case label is not an integer constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case-etiket befinder sig ikke inden i en switch-sætning"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, fuzzy, gcc-internal-format
 #| msgid "`default' label not within a switch statement"
 msgid "%<default%> label not within a switch statement"
 msgstr "'default'-etiket befinder sig ikke inden i en switch-sætning"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break-sætning befinder sig ikke i en løkke- eller switch-konstruktion"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "break statement used with OpenMP for loop"
 msgstr "break-sætning befinder sig ikke i en løkke- eller switch-konstruktion"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue-sætning befinder sig ikke i en løkke"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, fuzzy, gcc-internal-format
 #| msgid "%Hstatement with no effect"
 msgid "statement with no effect"
 msgstr "%Hsætning uden nogen virkning"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "udtrykket er af en ufuldstændig type"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "comparing vectors with different element types"
 msgstr "operander til ?: har forskellige typer"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, fuzzy, gcc-internal-format
 #| msgid "operand constraints for `asm' differ in number of alternatives"
 msgid "comparing vectors with different number of elements"
 msgstr "operandbegrænsninger til 'asm' har forskellige antal alternativer"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types `%#T' and `%#T'"
 msgid "comparison between types %qT and %qT"
 msgstr "sammenligning mellem typerne '%#T' og '%#T'"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "sammenligning af kommatal med == eller != er ikke sikkert"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "sammenligning med forskellige henvisningstyper mangler en typeomtvingelse"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids comparison of `void *' with function pointer"
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C forbyder sammenligning af 'void *' med funktionshenvisning"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "sammenligning med forskellige henvisningstyper mangler en typeomtvingelse"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "sammenligning mellem henvisningsvariabel og heltal"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "sammenligning mellem en fuldstændig og ufuldstændig henvisning"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C forbyder ordnede sammenligninger af henvisninger til funktioner"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with null pointer"
 msgstr "ordnet sammenligning af henvisning med heltallet nul"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "ordnet sammenligning af henvisning med heltallet nul"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, fuzzy, gcc-internal-format
 #| msgid "array type value used where scalar is required"
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "værdi af tabeltype angivet hvor skalar er påkrævet"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, fuzzy, gcc-internal-format
 #| msgid "struct type value used where scalar is required"
 msgid "used struct type value where scalar is required"
 msgstr "værdi af struct-type angivet hvor skalar er påkrævet"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, fuzzy, gcc-internal-format
 #| msgid "union type value used where scalar is required"
 msgid "used union type value where scalar is required"
 msgstr "værdi af union-type angivet hvor skalar er påkrævet"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 #| msgid "struct type value used where scalar is required"
 msgid "used vector type where scalar is required"
 msgstr "værdi af struct-type angivet hvor skalar er påkrævet"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "for mange inddatafiler"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qD is not a variable in %qs clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qE is not a variable in %qs clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%s' has invalid type"
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "bitfeltet '%s' er af en ufuldstændig type"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "low bound %qE of array section does not have integral type"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "length %qE of array section does not have integral type"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected EOF while reading source file %s.\n"
 msgid "expected single pointer in %qs clause"
 msgstr "Stødt på slutningen af kildefilen %s tidligere end forventet.\n"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "Intern oversætterfejl i %s ved %s:%d."
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "for array function parameter length expression must be specified"
 msgstr "udsagn skal være et kaldenavn"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE does not have pointer or array type"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "kaster NULL som har en heltals-, ikke en henvisningstype"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "parameter has incomplete type"
 msgid "iterator %qD has const qualified type"
 msgstr "parameteren er af en ufuldstændig type"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%#D' with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "bitfelt '%#D' med en ikke-heltalstype"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "begin expression refers to outer iterator %qD"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "end expression refers to outer iterator %qD"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "step expression refers to outer iterator %qD"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected pointer in %qs clause"
 msgstr "uventet operand"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%s' has invalid type"
 msgid "zero sized type %qT in %qs clause"
 msgstr "bitfeltet '%s' er af en ufuldstændig type"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%s' has invalid type"
 msgid "variable sized type %qT in %qs clause"
 msgstr "bitfeltet '%s' er af en ufuldstændig type"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, fuzzy, gcc-internal-format
 #| msgid "invalid return type for function `%#D'"
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "ugyldig returtype for funktionen '%#D'"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "brug af '%D' er tvetydigt"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qE is not a variable in clause %qs"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in motion clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD fremgår mere end en gang i motion-klausuller"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared private"
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "instansvariablen '%s' er erklæret privat"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared private"
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "instansvariablen '%s' er erklæret privat"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%<_Atomic%> %qD i %<aligned%>-klausul"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<depend%> clause"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE er ikke en variable i %<depend%>-klausul"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in map clauses"
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qD fremgår mere end en gang i map-klausuller"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in map clauses"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qD fremgår mere end en gang i map-klausuller"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "\"%s\" cannot be used as a macro name as it is an operator in C++"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "\"%s\" kan ikke bruges som et makronavn da det er en operator i C++"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "aggregate initializer is not constant"
 msgid "traits array must be initialized with constants"
 msgstr "startværdi til variabel af en sammensat type er ikke en konstant"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<depend%> clause"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE er ikke en variable i %<depend%>-klausul"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "unsupported map expression %qE"
 msgstr "ubenyttede parametre i formatering med $"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD fremgår mere end en gang i motion-klausuller"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD fremgår mere end en gang i map-klausuller"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD har ikke en mappable-type i %qs-klausul"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE er hverken en variabel eller et funktionsnavn i klausul %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "base operand of `->' is not a pointer"
 msgid "%qs variable is not a pointer"
 msgstr "grundoperanden til '->' er ikke en henvisning"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %qs clauses on a task construct"
 msgstr "for mange inddatafiler"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in motion clauses"
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD fremgår mere end en gang i motion-klausuller"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take `void'"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "'%D' skal tage mod 'void'"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qD shall not be const"
 msgstr "'%s' er ikke en funktion,"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to `va_arg' not of type `va_list'"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "den første parameter til 'va_arg' er ikke af typen 'va_list'"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to `va_arg' not of type `va_list'"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "den første parameter til 'va_arg' er ikke af typen 'va_list'"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to `va_arg' not of type `va_list'"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "den første parameter til 'va_arg' er ikke af typen 'va_list'"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -59675,259 +59725,254 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD should be initialized"
 msgid "%s should not be null"
 msgstr "%qD skal tildeles en startværdi"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE har ikke en mappable-type i %qs-klausul"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: invalid file name: %s\n"
 msgid "%s: Invalid field type %s:"
 msgstr "%s: ugyldigt filnavn: %s\n"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "Missing comma in FORMAT statement at %0"
 msgid "Not valid for ACCEPT statement."
 msgstr "Manglende komma i FORMAT-sætning ved %0"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "Missing comma in FORMAT statement at %0"
 msgid "Not valid for DISPLAY statement."
 msgstr "Manglende komma i FORMAT-sætning ved %0"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode `%s'"
 msgid "unknown %<setop_t%> code %d"
 msgstr "ukendt maskintilstand '%s'"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "unavngiven klargøring af '%T' som ikke har nogen stamklasser"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "Planlæg ikke begyndelsen og slutningen af proceduren"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -59936,74 +59981,84 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "tom erklæring"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown register name: %s"
 msgid "Unknown type %d"
 msgstr "ukendt registernavn: %s"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "-march=%s er ikke forenelig med den valgte ABI"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -60013,13 +60068,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "for mange inddatafiler"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "cannot read LTO mode table from %s"
 msgid "cannot get %<float%> value from %s"
@@ -60037,67 +60092,67 @@ msgstr "%s:%d:   instantieret fra '%s'\n"
 msgid "%s exited with status %d"
 msgstr "%s: %s afsluttede med status %d\n"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: wait: %s\n"
 msgid "%s: data item %s #"
 msgstr "%s: vent: %s\n"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%s: key must be field"
 msgstr "%s-roteringsantal er negativt"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: would convert file `%s'\n"
 msgid "%s:%d: could not add '%s'"
 msgstr "%s: ville omdanne filen '%s'\n"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling `%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s: oversætter '%s'\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -60584,7 +60639,7 @@ msgstr "ingen passende 'operator delete' for '%T'"
 msgid "%q#D is private within this context"
 msgstr "i denne kontekst"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "declared private here"
@@ -60596,7 +60651,7 @@ msgstr "  '%#D' erklæret her"
 msgid "%q#D is protected within this context"
 msgstr "i denne kontekst"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "declared protected here"
@@ -60964,7 +61019,7 @@ msgstr "parameter der ikke er et kommatal, til funktionen '%s'"
 msgid "constructor delegates to itself"
 msgstr "konstruktionsfunktioner kan ikke erklæres virtual"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "cannot convert %qH to %qI"
@@ -60986,7 +61041,7 @@ msgstr "ingen passende funktion for kald til '%T::%D(%A)%#V'"
 msgid "call to non-function %qD"
 msgstr "kald af ikke-funktion '%D'"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call destructor `%T::~%T' without object"
 msgid "cannot call constructor %<%T::%D%> directly"
@@ -61664,7 +61719,7 @@ msgstr "fleksibelt tabelmedlem i ellers tom struktur"
 msgid "next member %q#D declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of `%#T'"
 msgid "redefinition of %q#T"
@@ -61675,7 +61730,7 @@ msgstr "omdefinering af '%#T'"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -61824,7 +61879,7 @@ msgstr "ugyldig returtype for medlemsfunktionen '%#D'"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
@@ -61879,7 +61934,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -61917,344 +61972,344 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "undtagelse af typen '%T' vil blive fanget"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take either one or two arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "'%D' skal tage mod én eller to parametre"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "'%D' erklæret med en undtagelsesspecifikation"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "'%D' erklæret med en undtagelsesspecifikation"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s understøtter ikke %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' used without template parameters"
 msgid "%qD called with unexpected %qs argument"
 msgstr "'%D' benyttet uden skabelonsparametre"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to bit-complement"
 msgid "wrong number of arguments to %qs call"
 msgstr "forkert parametertype til bitkomplement"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "programs: %s\n"
 msgid "constexpr message: %.*s"
 msgstr "programmer: %s\n"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "tom erklæring"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%q+E is not a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function `%D'"
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "kald af ikke-funktion '%D'"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing `void *' pointer"
 msgid "dereferencing a null pointer"
 msgstr "forsøg på at følge en 'void *'-henvisning"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %qE"
 msgid "the comparison reduces to %qE"
 msgstr "for mange parametre til %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined `%D' always evaluates both arguments"
 msgid "%qE evaluates to false"
 msgstr "brugerdefineret '%D' evaluerer altid begge parametre"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function `%D'"
 msgid "call to internal function %qE"
 msgstr "kald af ikke-funktion '%D'"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "  oprindelig definition er her"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type `%T' is not a base type for type `%T'"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "typen '%T' er ikke en grundtype for typen '%T'"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object of type `%T' may not be initialized"
 msgid "virtual table pointer is used uninitialized"
 msgstr "objekt af typen '%T' med variabel størrelse må ikke tildeles en startværdi"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is an ambiguous base of `%T'"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "'%T' er en tvetydig stamklasse til '%T'"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function `%D' without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "kan ikke kalde medlemsfunktionen '%D' uden et objekt"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run `%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "kunne ikke køre '%s': %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "»o«-operanden er ikke konstant"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, fuzzy, gcc-internal-format
 #| msgid "-client_name not allowed with -dynamiclib"
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "-client_name er ikke tilladt med -dynamiclib"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 msgid "allocation performed here"
 msgstr "  oprindelig definition er her"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "-client_name not allowed with -dynamiclib"
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "-client_name er ikke tilladt med -dynamiclib"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of \"%s\" shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "erklæring af '%s' skygger for en tidligere lokal variabel"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' implicitly declared before its definition"
 msgid "%qD used before its definition"
 msgstr "'%s' er underforstået erklæret efter dens definition"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, fuzzy, gcc-internal-format
 #| msgid "protocol `%s' has circular dependency"
 msgid "call has circular dependency"
 msgstr "protokollen '%s' har cirkulær afhængighed"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'"
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "skabelonsinstantieringsdybden overskrider maksimum på %d (benyt -ftemplate-depth-NN for at forøge maksimum) ved instantiering af '%D'"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is negative"
 msgstr "højreskiftsantal er negativ"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "højreskiftsantal er negativ"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "venstreoperanden til kommaudtrykket har ingen virkning"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr ""
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member `%D'"
 msgid "accessing uninitialized array element"
 msgstr "manglende startværdi for medlemmet '%D'"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing `void *' pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "forsøg på at følge en 'void *'-henvisning"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
@@ -62262,584 +62317,584 @@ msgstr "forsøg på at følge en 'void *'-henvisning"
 msgid "%qE is not a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member `%D'"
 msgid "accessing uninitialized member %qD"
 msgstr "manglende startværdi for medlemmet '%D'"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "-indlejrede funktioner er ikke understøttet på denne målarkitektur"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member `%D'"
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "manglende startværdi for medlemmet '%D'"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "%qT object created here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "%q#D declared here"
 msgstr "  '%#D' erklæret her"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "allocated here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "%qD used in its own initializer"
 msgstr "for mange elementer i union-startværdi"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%q#D is not const"
 msgstr "'%s' er ikke en funktion,"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 #| msgid "`%+#D' is private"
 msgid "%q#D is volatile"
 msgstr "'%+#D' er privat"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "%qD was not declared %<constexpr%>"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "kan ikke konvertere '%T' til '%T' i %s"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'"
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "skabelonsinstantieringsdybden overskrider maksimum på %d (benyt -ftemplate-depth-NN for at forøge maksimum) ved instantiering af '%D'"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline assembly is not a constant expression"
 msgstr "startværdielement er ikke en konstant"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "use of %qD"
 msgstr "ugyldig brug af '%D"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "'%D' erklæret med en undtagelsesspecifikation"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'"
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "skabelonsinstantieringsdybden overskrider maksimum på %d (benyt -ftemplate-depth-NN for at forøge maksimum) ved instantiering af '%D'"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral and non-enumeral type in conditional expression"
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "enum- og ikke enum-type i betinget udtryk"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 #| msgid "invalid return type for function `%#D'"
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "ugyldig returtype for funktionen '%#D'"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "pointed-to object declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%<goto%> is not a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "unexpected expression %qE of kind %s"
 msgstr "uventet adresseudtryk"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "»B«-operanden er ikke konstant"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "break-sætning befinder sig ikke i en løkke- eller switch-konstruktion"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "continue statement not within a loop"
 msgid "%<continue%> outside of a loop"
 msgstr "continue-sætning befinder sig ikke i en løkke"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "%<return%> in a statement expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "%s kan ikke finde adressen af flertydiggjort funktion"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "ugyldig reinterpret_cast af et højreværdiudtryk fra typen '%T' til typen '%T'"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid reinterpret_cast from type `%T' to type `%T'"
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "ugyldig reinterpret_cast fra typen '%T' til typen '%T'"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "en virtuel funktion kan ikke erklæres som friend"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 #| msgid "field `%D' declared static in union"
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "feltet '%D' er erklæret statisk i union"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 #| msgid "field `%D' declared static in union"
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "feltet '%D' er erklæret statisk i union"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "division by zero is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "non-constant array initialization"
 msgstr "tabelindekset i startværdien er ikke en konstant"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unexpected type for `id' (%s)"
 msgid "unexpected AST of kind %s"
@@ -62988,407 +63043,408 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT is not nothrow copy assignable"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "typen '%T' har ingen destruktionsfunktion"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT is not nothrow copy constructible"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a namespace"
 msgid "%qT is not trivially copy assignable"
 msgstr "'%D' er ikke et navnerum"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "typen '%T' har ingen destruktionsfunktion"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT is not trivially copy constructible"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "base class `%#T' has a non-virtual destructor"
 msgid "%qT is not trivially destructible"
 msgstr "stamklassen '%#T' har en ikke-virtuel destruktionsfunktion"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%qT does not have unique object representations, because"
 msgstr "%qE har ikke en mappable-type i %qs-klausul"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "base class `%#T' has a non-virtual destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "stamklassen '%#T' har en ikke-virtuel destruktionsfunktion"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' is not a template"
 msgid "%qT is not an abstract class"
 msgstr "'%#T' er ikke en skabelon"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not an aggregate type"
 msgid "%qT is not an aggregate"
 msgstr "'%T' er ikke en sammensat type"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a namespace"
 msgid "%qT is not an array"
 msgstr "'%D' er ikke et navnerum"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not assignable from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT is not a bounded array"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' is not a template"
 msgid "%qT is not a class"
 msgstr "'%#T' er ikke en skabelon"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qT is not a const type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "typen '%T' har ingen destruktionsfunktion"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not constructible from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not destructible, because"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' is not a template"
 msgid "%qT is not an empty class"
 msgstr "'%#T' er ikke en skabelon"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not an enum"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' is not a template"
 msgid "%qT is not a final class"
 msgstr "'%#T' er ikke en skabelon"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qT is not a function"
 msgstr "'%s' er ikke en funktion,"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not invocable, because"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not invocable by %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "-march=%s er ikke forenelig med den valgte ABI"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qT is not a literal type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "'%D' er ikke en medlemsskabelonfunktion"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of `%T'"
 msgid "%qT is not a member object pointer"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of `%T'"
 msgid "%qT is not a member pointer"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "typen '%T' har ingen destruktionsfunktion"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not nothrow destructible, because"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not nothrow invocable, because"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "'%T' er en utilgængelig stamklasse til '%T'"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not a POD type"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "base operand of `->' is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "grundoperanden til '->' er ikke en henvisning"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qT is not a polymorphic type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a namespace"
 msgid "%qT is not a reference"
 msgstr "'%T' er ikke et navnerum"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "'%T' er ikke et navnerum"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qT is not a trivial type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "overløb i konstant udtryk"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not trivially copyable"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not trivially destructible, because"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not an unbounded array"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qT is not a union"
 msgstr "'%s' er ikke en funktion,"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "parameteren til 'asm' er ikke en konstant streng"
+#| msgid "`%T' is not a class or union type"
+msgid "%qT is not a structural type"
+msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "'%E' kan ikke bruges som en funktion"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "`%#D' cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' not declared"
 msgid "%qT is not destructurable"
 msgstr "'%D' ikke erklæret"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "type `%T' is not derived from type `%T'"
 msgid "%qD is not deducible from %qT"
 msgstr "typen '%T' er ikke nedarvet fra typen '%T'"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "ugyldig konstant:"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined `%D' always evaluates both arguments"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "brugerdefineret '%D' evaluerer altid begge parametre"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "constructors may not be `%s'"
 msgid "constraints not satisfied"
 msgstr "konstruktionsfunktioner må ikke være '%s'"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -63422,52 +63478,52 @@ msgstr "asm-erklæring er i konflikt med tidligere omdøbelse"
 msgid "previous declaration with fewer contracts here"
 msgstr "tidligere erklæring af '%#D' med %L-kædning"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type `%T' declared `friend'"
 msgid "parameter declared here"
 msgstr "skabelonsparametertypen '%T' erklæret 'friend'"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "global declaration `%#D'"
 msgid "declaration adds contracts to %q#D"
 msgstr "global erklæring '%#D'"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "first declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -63547,7 +63603,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%qD-mål erklæret her"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "no type named `%#T' in `%#T'"
 msgid "no member named %qE in %qT"
@@ -63629,91 +63685,91 @@ msgstr "den modificerede type '%T' passer ikke til destruktionsfunktionsnavnet '
 msgid "awaitable type %qT is not a structure"
 msgstr "den modificerede type '%T' passer ikke til destruktionsfunktionsnavnet '~%T'"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%s kan ikke bruges i asm her"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared `noreturn' has a `return' statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "funktion der er erklæret 'noreturn' har en 'return'-sætning"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third arg to `__builtin_prefetch' must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "en tredje parameter til '__builtin_prefetch' skal være en konstant"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third arg to `__builtin_prefetch' must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "en tredje parameter til '__builtin_prefetch' skal være en konstant"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "ingen tidligere prototype for '%s'"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate `%s'"
 msgid "duplicate info for %qE"
 msgstr "'%s' optræder mere end én gang"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "henvisningsvariabler er ikke tilladt som case-værdier"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when a variable is unused"
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "Advar når en variabel ikke benyttes"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "%J'%D' is not defined outside of function scope"
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "%J'%D' er ikke defineret uden for funktionsvirkefelt"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -63740,77 +63796,83 @@ msgstr "'%D' er ikke en medlemsskabelonfunktion"
 msgid "%qs used outside of constant expressions"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "empty declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "tom erklæring"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor"
 msgid "taking address of an immediate function %qD"
 msgstr "tager adressen på en destruktionsfunktion"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qE attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "ugyldig parameter for egenskaben %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid expression statement"
 msgid "use fold expression in the attribute argument instead"
 msgstr "Ugyldig udtrykssætning"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qD is not a type"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qD is not a class type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -63859,7 +63921,7 @@ msgstr "ugyldig const_cast af en højreværdi fra typen '%T' til typen '%T'"
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "konvertering fra '%T' til '%T' forkaster modifikationer"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, fuzzy, gcc-internal-format
 #| msgid "casting `%T' to `%T' does not dereference pointer"
 msgid "casting %qT to %qT does not dereference pointer"
@@ -64301,7 +64363,7 @@ msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "erklæring af '%D' som %s"
 
 # hænger sammen med næste tekst
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration `%D'"
 msgid "previous declaration %qD"
@@ -64558,12 +64620,12 @@ msgstr "standardparameter givet til %d. parameter for '%#D'"
 msgid "previous specification in %q#D here"
 msgstr "efter tidligere specifikation i '%#D'"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously declared here"
 msgid "previously declared here without exporting"
@@ -64786,7 +64848,7 @@ msgstr "  springer over klargøring af '%#D'"
 msgid "  enters %<template for%> statement"
 msgstr "uventet operand"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' used without template parameters"
 msgid "%qD used without template arguments"
@@ -64839,618 +64901,618 @@ msgstr "'%D::%D' er ikke en skabelon"
 msgid "template parameters do not match template %qD"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "-falign-labels=%d is not supported"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "-falign-labels=%d understøttes ikke"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 #| msgid "`%#D' invalid; an anonymous union can only have non-static data members"
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "'%#D' er ugyldig; en anonym union kan kun have ikke-statiske datamedlemmer"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, fuzzy, gcc-internal-format
 #| msgid "-traditional is deprecated and may be removed"
 msgid "this flexibility is deprecated and will be removed"
 msgstr "-traditional er forældet og kan blive fjernet"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "anonym struct er ikke inden i en navngiven type"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, fuzzy, gcc-internal-format
 #| msgid "member %#D' with constructor not allowed in anonymous aggregate"
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "medlemmet '%#D' med konstruktionsfunktion er ikke tilladt i anonym sammensat type"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, fuzzy, gcc-internal-format
 #| msgid "member %#D' with destructor not allowed in anonymous aggregate"
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "medlemmet '%#D' med destruktionsfunktion er ikke tilladt i anonym sammensat type"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, fuzzy, gcc-internal-format
 #| msgid "member %#D' with copy assignment operator not allowed in anonymous aggregate"
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "medlemmet '%#D' med kopitildelingsoperator er ikke tilladt i anonym sammensat type"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 #| msgid "forward declaration of `%#T'"
 msgid "attribute ignored in declaration of %q#T"
 msgstr "forhåndserklæring af '%#T'"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "flere typer i én erklæring"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of C++ built-in type `%T'"
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "omerklæring af indbygget type i C++ '%T'"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for objects and functions"
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "'%D' kan kun angives for objekter og funktioner"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "manglende typenavn i typedef-erklæring"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ forbyder anonyme strukturer"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "'%D' kan kun angives for funktioner"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "'%D' kan kun angives for funktioner"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified inside a class"
 msgid "%<friend%> can only be specified inside a class"
 msgstr "'%D' kan kun angives inden i en klasse"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for constructors"
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "'%D' kan kun angives for konstruktionsfunktioner"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for objects and functions"
 msgid "a storage class can only be specified for objects and functions"
 msgstr "'%D' kan kun angives for objekter og funktioner"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "'%D' kan kun angives for objekter og funktioner"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "'%D' kan kun angives for objekter og funktioner"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "'%D' kan kun angives for objekter og funktioner"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "'%D' kan kun angives for objekter og funktioner"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 #| msgid "type defaults to `int' in declaration of `%s'"
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "typen antages at være 'int' i erklæringen af '%s'"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "tom erklæring"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter list used in explicit instantiation"
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "skabelonsparameterliste benyttet i eksplicit instantiering"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to class definitions"
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored"
 msgid "attribute ignored"
 msgstr "egenskaben '%s' ignoreret"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to class definitions"
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
 # init dækker over værditildeling her - samme for de næste mange
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef `%D' is initialized (use __typeof__ instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef '%D' bliver tildelt en værdi (benyt __typeof__ i stedet)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D' has `extern' and is initialized"
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "erklæringen af '%#D' indeholder 'extern' og variablen bliver tildelt en startværdi"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, fuzzy, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "'auto' er påhæftet funktionsdefinitionen"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "'%#D' er ikke et statisk medlem af '%#T'"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of `%#D'"
 msgid "non-member-template declaration of %qD"
 msgstr "skabelonserklæring af '%#D'"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member template declaration `%D'"
 msgid "does not match member template declaration here"
 msgstr "ugyldig medlemsskabelonerklæring '%D'"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not permit `%T::%D' to be defined as `%T::%D'"
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ tillader ikke '%T::%D' at blive defineret som '%T::%D'"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "duplicate initialization of %qD"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D' outside of class is not definition"
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "erklæring af '%#D' uden for en klasse er ikke en definition"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, fuzzy, gcc-internal-format
 #| msgid "variable `%#D' has initializer but incomplete type"
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "variablen '%#D' bliver tildelt en startværdi, men er af en ufuldstændig type"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, fuzzy, gcc-internal-format
 #| msgid "elements of array `%#D' have incomplete type"
 msgid "elements of array %q#D have incomplete type"
 msgstr "elementer i tabellen '%#D' er af en ufuldstændig type"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, fuzzy, gcc-internal-format
 #| msgid "aggregate `%#D' has incomplete type and cannot be defined"
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "den sammensatte type '%#D' er af en ufuldstændig type og kan ikke defineres"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as reference but not initialized"
 msgid "%qD declared as reference but not initialized"
 msgstr "'%D' erklæret som en reference, men bliver ikke tildelt en startværdi"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "ikke-trivielle udpegede startværdier er ikke understøttet"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "startværdien giver ikke størrelsen af %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "tabelstørrelsen mangler i %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "nulstørrelsestabel %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "lagringsstørrelsen af %qD er ikke kendt"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of `%D' isn't constant"
 msgid "storage size of %qD isn%'t constant"
 msgstr "lagringsstørrelsen af '%D' er ikke konstant"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "semantikken for indlejret funktionsstatisk data '%#D' er forkert (du ender med flere kopier)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "semantikken for indlejret funktionsstatisk data '%#D' er forkert (du ender med flere kopier)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "  du kan arbejde dig rundt om dette ved at fjerne startværdien"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const `%D'"
 msgid "uninitialized %<const %D%>"
 msgstr "konstant '%D' uden startværdi"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 #| msgid "register variable `%s' used in nested function"
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "registervariabel '%s' benyttet i indlejret funktion"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 #| msgid "register variable `%s' used in nested function"
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "registervariabel '%s' benyttet i indlejret funktion"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "typen '%T' har ingen destruktionsfunktion"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for virtual method `%D'"
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "ugyldig startværdi til virtuel medlemsfunktion '%D'"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, fuzzy, gcc-internal-format
 #| msgid "initializer for `%T' must be brace-enclosed"
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "startværdi for '%T' skal være indesluttet i krøllede paranteser"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, fuzzy, gcc-internal-format
 #| msgid "request for member `%D' is ambiguous"
 msgid "request for member %qD is ambiguous"
 msgstr "forespørgsel efter medlemmet '%D' er tvetydigt"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' has no non-static data member named `%D'"
 msgid "%qT has no non-static data member named %qD"
 msgstr "'%T' har intet ikke-statisk medlem ved navn '%D'"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of `%T'"
 msgid "%qD is not a direct member of %qT"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer for %q#D"
 msgstr "ugyldig startværdi"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in aggregate initializer"
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "for mange elementer i startværdi til sammensat type"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "for mange startværdier for %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for `%T'"
 msgid "braces around scalar initializer for type %qT"
 msgstr "krøllede paranteser omkring skalarstartværdi for '%T'"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for `%T'"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "krøllede paranteser omkring skalarstartværdi for '%T'"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, fuzzy, gcc-internal-format
 #| msgid "missing braces around initializer"
 msgid "missing braces around initializer for %qT"
 msgstr "krøllede paranteser mangler omkring startværdien"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding has incomplete type %qT"
 msgstr "forsøg på at følge en henvisning til en variabel af en ufuldstændig type"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 #| msgid "elements of array `%#D' have incomplete type"
 msgid "elements of array %q#T have incomplete type"
 msgstr "elementer i tabellen '%#D' er af en ufuldstændig type"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C89 forbids compound literals"
 msgid "variable-sized compound literal"
 msgstr "ISO C89 forbyder sammensatte konstanter"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' has incomplete type"
 msgid "%q#D has incomplete type"
 msgstr "'%D' er af en ufuldstændig type"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "scalar object %qD requires one element in initializer"
 msgstr "for mange elementer i union-startværdi"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must be initialized by constructor, not by `{...}'"
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "'%D' skal klargøres af en konstruktionsfunktion, ikke af '{...}'"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, fuzzy, gcc-internal-format
 #| msgid "_Pragma takes a parenthesized string literal"
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "_Pragma tager en strengkonstant med paranteser omkring"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "tildeling af startværdi er ugyldig for statisk medlem med konstruktionsfunktion"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member `%D'"
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "ISO C++ forbyder tildeling af startværdi i klasse til ikke-konstant statisk medlem '%D'"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member `%D'"
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "ISO C++ forbyder tildeling af startværdi i klasse til ikke-konstant statisk medlem '%D'"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(en klargøring uden for klassens erklæring er nødvendig)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable `%s' requested"
 msgid "address of explicit register variable %qD requested"
 msgstr "forespørgsel efter adressen af registervariablen '%s'"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 #| msgid "member `%D' with uninitialized const fields"
 msgid "reference %qD is initialized with itself"
 msgstr "medlem '%D' med konstante felter uden startværdi"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not at beginning of declaration"
 msgid "could not find variant declaration"
 msgstr "'%s' er ikke ved begyndelsen af erklæringen"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s `%+#D'"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "for få parametre til %s '%+#D'"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "using-erklæring for destruktionsfunktion"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "tildeling (ikke klargøring) i erklæring"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++17 tillader ikke %<register%>-lagerklasseangivelse"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %s `%s'"
 msgid "%<register%> storage class specifier used"
 msgstr "lagringsklasse angivet for %s '%s'"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D' has `extern' and is initialized"
 msgid "declaration of %q#D has no initializer"
 msgstr "erklæringen af '%#D' indeholder 'extern' og variablen bliver tildelt en startværdi"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of member (did you forget the `&' ?)"
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "ugyldig brug af medlem (glemte du en '&'?)"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type `%#T' is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -65458,136 +65520,136 @@ msgstr "returtype '%#T' er ufuldstændig"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "`%#D' cannot be declared"
 msgid "%<::main%> cannot be deleted"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, fuzzy, gcc-internal-format
 #| msgid "shadowing previous type declaration of `%#D'"
 msgid "shadowing previous type declaration of %q#D"
 msgstr "skygger for tidligere typeerklæring af '%#D'"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to variables"
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "egenskaben '%s' kan kun anvendes på variabler"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, fuzzy, gcc-internal-format
 #| msgid "function `%#D' is initialized like a variable"
 msgid "function %q#D is initialized like a variable"
 msgstr "funktionen '%#D' bliver tildelt en startværdi som en variabel"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field `%D' with function type"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "kan ikke erklære bitfelt '%D' med funktionstype"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "lambda declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at `%D' because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "  kan ikke bruge forældet binding til '%D' fordi den har en destruktionsfunktion"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type `%T'"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "opretter henvisning til medlem af typen '%T' der ikke er en klasse"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "no sclass for %s stab (0x%x)\n"
 msgid "in base class of %qT"
 msgstr "ingen sclass for %s stab (0x%x)\n"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding refers to incomplete type %qT"
 msgstr "forsøg på at følge en henvisning til en variabel af en ufuldstændig type"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%D' includes %s to array of unknown bound `%T'"
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "parameteren '%D' inkluderer %s til tabel med ukendt grænse '%T'"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable-size array `%s'"
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 forbyder tabellen '%s' med variabel størrelse"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable-size array `%s'"
 msgid "cannot decompose variable length vector %qT"
 msgstr "ISO C90 forbyder tabellen '%s' med variabel størrelse"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field `%D' with function type"
 msgid "cannot decompose union type %qT"
 msgstr "kan ikke erklære bitfelt '%D' med funktionstype"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type `%T'"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "opretter henvisning til medlem af typen '%T' der ikke er en klasse"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "forsøg på at følge en henvisning til en variabel af en ufuldstændig type"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "array initializer for structured binding declaration in condition"
 msgstr "ugyldig startværdi til bitstreng"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "storage class specified for structure field `%s'"
 msgid "%u name provided for structured binding"
@@ -65595,2019 +65657,2030 @@ msgid_plural "%u names provided for structured binding"
 msgstr[0] "lagringsklasse angivet for strukturfelt '%s'"
 msgstr[1] "lagringsklasse angivet for strukturfelt '%s'"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "in initialization of structured binding pack %qD"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "in initialization of structured binding variable %qD"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "ugyldig brug af ikke-statisk felt '%D'"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 #| msgid "initializer fails to determine size of `%D'"
 msgid "initializer fails to determine size of %qT"
 msgstr "startværdien giver ikke størrelsen af '%D'"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 #| msgid "array size missing in `%D'"
 msgid "array size missing in %qT"
 msgstr "tabelstørrelsen mangler i '%D'"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 #| msgid "zero-size array `%D'"
 msgid "zero-size array %qT"
 msgstr "nulstørrelsestabel '%D'"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, fuzzy, gcc-internal-format
 #| msgid "destructor for alien class `%T' cannot be a member"
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "destruktionsfunktionen for den fremmede klasse '%T' kan ikke være et medlem"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, fuzzy, gcc-internal-format
 #| msgid "constructor for alien class `%T' cannot be a member"
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "konstruktionsfunktionen for den fremmede klasse '%T' kan ikke være et medlem"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a `virtual' %s"
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "'%D' erklæret som 'virtual' %s"
 
 # %s bliver omsat til typen
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 #| msgid "`const' and `volatile' function specifiers on `%D' invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "'const'- og 'volatile'-funktionsangivelser til '%D' er ugyldigt i erklæring af %s"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a `virtual' %s"
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "'%D' erklæret som 'virtual' %s"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "'%D' er erklæret som en ven"
 
 # %s bliver omsat til typen
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 #| msgid "`const' and `volatile' function specifiers on `%D' invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "'const'- og 'volatile'-funktionsangivelser til '%D' er ugyldigt i erklæring af %s"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a `virtual' %s"
 msgid "%qD declared as a %<virtual%> type"
 msgstr "'%D' erklæret som 'virtual' %s"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as an `inline' %s"
 msgid "%qD declared as an %<inline%> type"
 msgstr "'%D' erklæret som 'inline' %s"
 
 # %s bliver omsat til typen
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 #| msgid "`const' and `volatile' function specifiers on `%D' invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "'const'- og 'volatile'-funktionsangivelser til '%D' er ugyldigt i erklæring af %s"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a `virtual' %s"
 msgid "%qD declared as a %<virtual%> field"
 msgstr "'%D' erklæret som 'virtual' %s"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as an `inline' %s"
 msgid "%qD declared as an %<inline%> field"
 msgstr "'%D' erklæret som 'inline' %s"
 
 # %s bliver omsat til typen
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 #| msgid "`const' and `volatile' function specifiers on `%D' invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "'const'- og 'volatile'-funktionsangivelser til '%D' er ugyldigt i erklæring af %s"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a friend"
 msgid "%q+D declared as a friend"
 msgstr "'%D' er erklæret som en ven"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared with an exception specification"
 msgid "%q+D declared with an exception specification"
 msgstr "'%D' erklæret med en undtagelsesspecifikation"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' not in a namespace surrounding `%D'"
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "erklæring af '%D' er ikke i et navnerum der omgiver '%D'"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, fuzzy, gcc-internal-format
 #| msgid "static member function `%#D' declared with type qualifiers"
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "statisk medlemsfunktion '%#D' erklæret med typemodifikationer"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "--driver understøttes ikke længere"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "constraints on a non-templated function"
 msgstr "'%D' er ikke en medlemsskabelonfunktion"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization `%D' in friend declaration"
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "definering af eksplicit specialisering '%D' i friend-erklæring"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of template-id `%D' in declaration of primary template"
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "ugyldig brug af skabelons-id '%D' i erklæring af primær skabelon"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are not allowed in declaration of friend template specialization `%D'"
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "standardparametre er ikke tilladt i erklæring af venneskabelonsspecialisering '%D'"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, fuzzy, gcc-internal-format
 #| msgid "`inline' is not allowed in declaration of friend template specialization `%D'"
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "'inline' er ikke tilladt i erklæring venneskabelonsspecialisering '%D'"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D' outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "erklæring af '%#D' uden for en klasse er ikke en definition"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "kan ikke erklære %<::main%> som en skabelon"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "kan ikke erklære %<::main%> som indlejret"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare `::main' to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "kan ikke erklære '::main' som statisk"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare `::main' to be static"
 msgid "cannot declare %<::main%> to be static"
 msgstr "kan ikke erklære '::main' som statisk"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be %<constexpr%>"
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "kan ikke erklære %<::main%> til at være %<constexpr%>"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "kan ikke erklære %<::main%> som en skabelon"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type `%T' declared `friend'"
 msgid "explicit object parameter declared here"
 msgstr "skabelonsparametertypen '%T' erklæret 'friend'"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %D after instantiation"
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "specialisering af '%D' efter instantiering"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "  declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %D after instantiation"
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "specialisering af '%D' efter instantiering"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "erklæring af '%D' som ikke-funktion"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 #| msgid "template with C linkage"
 msgid "literal operator with C linkage"
 msgstr "skabelon med C-kædning"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 #| msgid "#%s with invalid argument"
 msgid "%qD has invalid argument list"
 msgstr "#%s med ugyldig parameter"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must be a nonstatic member function"
 msgid "%qD must be a non-member function"
 msgstr "'%D' skal være en ikke-statisk medlemsfunktion"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, fuzzy, gcc-internal-format
 #| msgid "`main' must return `int'"
 msgid "%<::main%> must return %<int%>"
 msgstr "'main' skal returnere typen 'int'"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, fuzzy, gcc-internal-format
 #| msgid "definition of implicitly-declared `%D'"
 msgid "definition of implicitly-declared %qD"
 msgstr "definition af underforstået-erklæret '%D'"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "definition of implicitly-declared `%D'"
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "definition af underforstået-erklæret '%D'"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 #| msgid "`%#D' previously defined here"
 msgid "%q#D explicitly defaulted here"
 msgstr "'%#D' tidligere defineret her"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, fuzzy, gcc-internal-format
 #| msgid "no `%#D' member function declared in class `%T'"
 msgid "no %q#D member function declared in class %qT"
 msgstr "ingen medlemsfunktion '%#D' erklæret i klassen '%T'"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare `::main' to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "kan ikke erklære '::main' som en skabelon"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %D after instantiation"
 msgid "concept must be defined at namespace scope"
 msgstr "specialisering af '%D' efter instantiering"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "--driver understøttes ikke længere"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type `%T'"
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "ugyldig tildeling af startværdi i klasse til statisk datamedlem af en ikke-heltalstype '%T'"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type `%T'"
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "ugyldig tildeling af startværdi i klasse til statisk datamedlem af en ikke-heltalstype '%T'"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type `%T'"
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "ugyldig tildeling af startværdi i klasse til statisk datamedlem af en ikke-heltalstype '%T'"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type `%T'"
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "ugyldig tildeling af startværdi i klasse til statisk datamedlem af en ikke-heltalstype '%T'"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member `%D'"
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ forbyder tildeling af startværdi i klasse til ikke-konstant statisk medlem '%D'"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'"
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ forbyder tildeling af startværdi til medlemskonstant '%D' af en ikke-heltallig type"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "størrelsen af tabellen '%D' er ikke af en heltalstype"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "størrelsen af tabel er ikke af en heltalstype"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "størrelsen af tabel er ikke af et heltalligt konstantudtryk"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array `%D'"
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ forbyder tabellen '%D' med størrelsen nul"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ forbyder tabel med størrelsen nul"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids variable-size array `%D'"
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ forbyder tabellen '%D' med variabel størrelse"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids variable-size array"
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ forbyder tabel med variabel størrelse"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "tabeldimension for stor"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a friend"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "'%D' er erklæret som en ven"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type `%T'"
 msgid "creating array of template placeholder type %qT"
 msgstr "opretter henvisning til medlemsreference af typen '%T'"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of voids"
 msgid "declaration of %qD as array of void"
 msgstr "'%s' erklæret som en tabel af void"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of `%T'"
 msgid "creating array of void"
 msgstr "opretter tabel af '%T'"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of functions"
 msgid "declaration of %qD as array of functions"
 msgstr "'%s' erklæret som en tabel af funktioner"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of functions"
 msgid "creating array of functions"
 msgstr "'%s' erklæret som en tabel af funktioner"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of functions"
 msgid "declaration of %qD as array of references"
 msgstr "'%s' erklæret som en tabel af funktioner"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of `%T'"
 msgid "creating array of references"
 msgstr "opretter tabel af '%T'"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of functions"
 msgid "declaration of %qD as array of function members"
 msgstr "'%s' erklæret som en tabel af funktioner"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of functions"
 msgid "creating array of function members"
 msgstr "'%s' erklæret som en tabel af funktioner"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as multidimensional array must have bounds for all dimensions except the first"
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "erklæring af '%D' som flerdimensional tabel skal have grænser for alle dimensioner pånær den første"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "flerdimensional tabel skal have grænser for alle dimensioner pånær den første"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when a variable is unused"
 msgid "variable-length array of %<auto%>"
 msgstr "Advar når en variabel ikke benyttes"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "angivelse af returneringstypen til konstruktionsfunktion er ugyldigt"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "angivelse af returneringstypen til destruktionsfunktion er ugyldigt"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, fuzzy, gcc-internal-format
 #| msgid "return type specified for `operator %T'"
 msgid "return type specified for %<operator %T%>"
 msgstr "returtype angivet for 'operator %T'"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "angivelse af returneringstypen til destruktionsfunktion er ugyldigt"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "unavngiven variabel eller felt erklæret void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "variabel eller felt erklæret void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `inline' invalid for function `%s' declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "lagringsklassen 'inline' er ugyldig for funktionen '%s' erklæret uden for det globale virkefelt"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it has a base class"
 msgstr "type er ikke forenelig med dens variant"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "type er ikke forenelig med dens variant"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, fuzzy, gcc-internal-format
 #| msgid "%s as integer rather than floating due to prototype"
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr "%s som heltal i stedet for kommatal på grund af prototypen"
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "signed and unsigned given together for `%s'"
 msgid "%e and %e specified together"
 msgstr "signed og unsigned er begge angivet for '%s'"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of member `%D'"
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "ugyldig brug af medlemmet '%D'"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 #| msgid "invalid definition of qualified type `%T'"
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "ugyldig definition af modificeret type '%T'"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of member `%D'"
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "ugyldig brug af medlemmet '%D'"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "'%T' er ikke en klasse eller et navnerum"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "erklæring af '%D' som ikke-funktion"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as non-function"
 msgid "declaration of %qE as non-member"
 msgstr "erklæring af '%D' som ikke-funktion"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, fuzzy, gcc-internal-format
 #| msgid "declarator-id missing; using reserved word `%D'"
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "erklærer-id mangler; bruger reserveret ord '%D'"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared `register'"
 msgid "function definition does not declare parameters"
 msgstr "'register' er påhæftet funktionsdefinitionen"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as non-function"
 msgid "declaration of %qD as non-function"
 msgstr "erklæring af '%D' som ikke-funktion"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as %s"
 msgid "declaration of %qD as %<typedef%>"
 msgstr "erklæring af '%D' som %s"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D' shadows a parameter"
 msgid "declaration of %qD as parameter"
 msgstr "erklæring af '%#D' skygger for en parameter"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, fuzzy, gcc-internal-format
 #| msgid "both long and short specified for `%s'"
 msgid "both %qs and %qs specified"
 msgstr "både long og short er angivet for '%s'"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "navnerum '%D' ikke tilladt i using-erklæring"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, fuzzy, gcc-internal-format
 #| msgid "two or more data types in declaration of `%s'"
 msgid "two or more data types in declaration of %qs"
 msgstr "mere end én datatype i erklæringen af '%s'"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain `complex' meaning `double complex'"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C understøtter ikke at blot 'complex' betyder 'double complex'"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids declaration of `%s' with no type"
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ forbyder erklæring af '%s' uden en type"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_trap not supported by this target"
 msgid "%<__int%d%> is not supported by this target"
 msgstr "__builtin_trap understøttes ikke på denne målarkitektur"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support `long long'"
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ understøtter ikke 'long long'"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "%s used with `%%%c' %s format"
 msgid "%qs specified with %qT"
 msgstr "%s brugt med '%%%c' %s-formatering"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 #| msgid "%s used with `%%%c' %s format"
 msgid "%qs specified with typedef-name %qD"
 msgstr "%s brugt med '%%%c' %s-formatering"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<decltype%>"
 msgid "%qs specified with %<decltype%>"
 msgstr "forventede %<decltype%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%s used with `%%%c' %s format"
 msgid "%qs specified with %<typeof%>"
 msgstr "%s brugt med '%%%c' %s-formatering"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, fuzzy, gcc-internal-format
 #| msgid "complex invalid for `%s'"
 msgid "complex invalid for %qs"
 msgstr "complex ugyldig for '%s'"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member `%D' cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "medlemmet '%D' kan ikke afklæres både virtual og static"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member `%D' cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "medlemmet '%D' kan ikke afklæres både virtual og static"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "typedef-erklæringer er ugyldig i parametererklæringer"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter `%s'"
 msgid "storage class specified for template parameter %qs"
 msgstr "lagringsklasse angivet for parameter '%s'"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter `%s'"
 msgid "storage class specified for parameter %qs"
 msgstr "lagringsklasse angivet for parameter '%s'"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "a parameter cannot be declared %qs"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "virtual outside class declaration"
 msgid "%<virtual%> outside class declaration"
 msgstr "virtual angivet uden for klasseerklæring"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 #| msgid "forward declaration of `%#T'"
 msgid "structured binding declaration cannot be %qs"
 msgstr "forhåndserklæring af '%#T'"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "konstruktionsfunktioner kan ikke erklæres virtual"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "konstruktionsfunktioner kan ikke erklæres virtual"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "Ugyldig erklæring"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, fuzzy, gcc-internal-format
 #| msgid "function `%s' cannot be declared `mutable'"
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "funktionen '%s' kan ikke erklæres 'mutable'"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 #| msgid "function `%D' cannot be declared friend"
 msgid "structured binding declaration cannot have type %qT"
 msgstr "funktionen '%D' kan ikke erklæres friend"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, fuzzy, gcc-internal-format
 #| msgid "function `%D' cannot be declared friend"
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "funktionen '%D' kan ikke erklæres friend"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of `%s'"
 msgid "multiple storage classes in declaration of %qs"
 msgstr "flere lagringsklasser optræder i erklæringen af '%s'"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %s `%s'"
 msgid "storage class specified for %qs"
 msgstr "lagringsklasse angivet for %s '%s'"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, fuzzy, gcc-internal-format
 #| msgid "nested function `%s' declared `extern'"
 msgid "nested function %qs declared %<extern%>"
 msgstr "indlejret funktion '%s' er erklæret 'extern'"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, fuzzy, gcc-internal-format
 #| msgid "top-level declaration of `%s' specifies `auto'"
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "erklæring af '%s' på øverste niveau angiver 'auto'"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, fuzzy, gcc-internal-format
 #| msgid "function-scope `%s' implicitly auto and declared `__thread'"
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "'%s' i funktionsvirkefelt underforstået auto og erklæret '__thread'"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "lagringsklasseanvisninger er ugyldige i vennefunktionserklæringer"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of `%s'"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "flere lagringsklasser optræder i erklæringen af '%s'"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses"
 msgstr "uventet operand"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 #| msgid "function cannot be inline"
 msgid "a function type cannot have an explicit object parameter"
 msgstr "funktion kan ikke indbygges"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "en virtuel funktion kan ikke erklæres som friend"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type `%T' declared `friend'"
 msgid "valid explicit object parameter declared here"
 msgstr "skabelonsparametertypen '%T' erklæret 'friend'"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "requires-clause on return type"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "en virtuel funktion kan ikke erklæres som friend"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "ugyldig brug af '%D"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "ugyldig brug af ikke-statisk felt '%D'"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "typemodifikationer ignoreret i funktionsreturtypen"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "en virtuel funktion kan ikke erklæres som friend"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "a conversion function cannot have a trailing return type"
 msgstr "en virtuel funktion kan ikke erklæres som friend"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' declared as function returning a function"
 msgid "%qs declared as function returning a function"
 msgstr "'%s' er erklæret som en funktion der returnerer en funktion"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' declared as function returning an array"
 msgid "%qs declared as function returning an array"
 msgstr "'%s' er erklæret som en funktion der returnerer en tabel"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr ""
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "destruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "destructors may not be cv-qualified"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, fuzzy, gcc-internal-format
 #| msgid "constructors may not be `%s'"
 msgid "constructors may not be cv-qualified"
 msgstr "konstruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "destructors may not be ref-qualified"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "constructors may not be ref-qualified"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "konstruktionsfunktioner kan ikke erklæres virtual"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "en virtuel funktion kan ikke erklæres som friend"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 #| msgid "can't define friend function `%s' in a local class definition"
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "kan ikke definere vennefunktion '%s' i en lokal klassedefinition"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function `%D' cannot have `%T' method qualifier"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "%smedlemsfunktion '%D' kan ikke have metodemodifikationen '%T'"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "konstruktionsfunktioner kan ikke erklæres virtual"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "'%D' skal være en ikke-statisk medlemsfunktion"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "destruktionsfunktioner må ikke have parametre"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to `%#T'"
 msgid "cannot declare pointer to %q#T"
 msgstr "kan ikke erklære henvisning til '%#T'"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to `%#T'"
 msgid "cannot declare reference to %q#T"
 msgstr "kan ikke erklære reference til '%#T'"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to `%#T' member"
 msgid "cannot declare pointer to %q#T member"
 msgstr "kan ikke erklære henvisning til medlemmet '%#T'"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare references to references"
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "kan ikke erklære referencer til referencer"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field `%D' with function type"
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "kan ikke erklære bitfelt '%D' med funktionstype"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, fuzzy, gcc-internal-format
 #| msgid "template-id `%D' used as a declarator"
 msgid "template-id %qD used as a declarator"
 msgstr "skabelons-id '%D' benyttet som erklærer"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "medlemsfunktioner er underforstået venner af deres klasse"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, fuzzy, gcc-internal-format
 #| msgid "extra qualification `%T::' on member `%s' ignored"
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "ekstra modifikation '%T::' af medlemmet '%s' ignoreret"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function `%T::%s' within `%T'"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "kan ikke erklære medlemsfunktion '%T::%s' inde i '%T'"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function `%T::%s' within `%T'"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "kan ikke erklære medlemsfunktion '%T::%s' inde i '%T'"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member `%T::%s' within `%T'"
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "kan ikke erklære medlem '%T::%s' inde i '%T'"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, fuzzy, gcc-internal-format
 #| msgid "data member may not have variably modified type `%T'"
 msgid "data member may not have variably modified type %qT"
 msgstr "datamedlem må ikke have variabelt ændret type '%T'"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, fuzzy, gcc-internal-format
 #| msgid "parameter may not have variably modified type `%T'"
 msgid "parameter may not have variably modified type %qT"
 msgstr "parameter må ikke have variabelt ændret type '%T'"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 #| msgid "virtual outside class declaration"
 msgid "%<explicit%> outside class declaration"
 msgstr "virtual angivet uden for klasseerklæring"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization `%D' in friend declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "definering af eksplicit specialisering '%D' i friend-erklæring"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 #| msgid "only declarations of constructors can be `explicit'"
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "kun erklæringer af konstruktionsfunktioner kan være 'explicit'"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, fuzzy, gcc-internal-format
 #| msgid "non-member `%s' cannot be declared `mutable'"
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "'%s' som ikke er medlem, kan ikke erklæres 'mutable'"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, fuzzy, gcc-internal-format
 #| msgid "non-object member `%s' cannot be declared `mutable'"
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "'%s' som ikke er objektmedlem, kan ikke erklæres 'mutable'"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, fuzzy, gcc-internal-format
 #| msgid "function `%s' cannot be declared `mutable'"
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "funktionen '%s' kan ikke erklæres 'mutable'"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static `%s' cannot be declared `mutable'"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "static '%s' kan ikke erklæres 'mutable'"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const `%s' cannot be declared `mutable'"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "const '%s' kan ikke erklæres 'mutable'"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "referencen %qs kan ikke erklæres %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not at beginning of declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "'%s' er ikke ved begyndelsen af erklæringen"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef erklæret %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "typedef-navn kan ikke være en indlejret-navn-specifikation"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ forbyder indlejret type %qD med samme navn som den omgivende klasse"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> angivet for friend class-erklæring"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "friend-erklæring kræver klasseangivelse, dvs. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "friend-erklæring kræver klasseangivelse, dvs. %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "forsøg på at gøre klassen %qT til ven af det globale virkningsfelt"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "ugyldige modifikationer for ikke-medlemsfunktionstype"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, fuzzy, gcc-internal-format
 #| msgid "abstract declarator `%T' used as declaration"
 msgid "abstract declarator %qT used as declaration"
 msgstr "abstrakt erklærer '%T' benyttet som erklæring"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type `%T'"
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "ugyldig omtvingelse til funktionstypen '%T'"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use `::' in parameter declaration"
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "kan ikke bruge '::' i parametererklæring"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter `%D' to be of type `%T'"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "kan ikke erklære parameteren '%D' til at være af typen '%T'"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%D' declared void"
 msgid "parameter declared %<auto%>"
 msgstr "parameteren '%D' erklæret void"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of template-name '%E' in a declarator"
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "ugyldig brug af skabelonsnavn '%E' i erklæring"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' has no non-static data member named `%D'"
 msgid "non-static data member declared with placeholder %qT"
 msgstr "'%T' har intet ikke-statisk medlem ved navn '%D'"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C90 understøtter ikke fleksible tabelmedlemmer"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 understøtter ikke fleksible tabelmedlemmer"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `::'"
 msgid "invalid use of %<::%>"
 msgstr "ugyldig brug af '::'"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of C function `%#D' conflicts with"
 msgid "declaration of function %qD in invalid context"
 msgstr "erklæring af C-funktionen '%#D' strider mod"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function `%D' declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "funktionen '%D' erklæret virtual inden i en union"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot be declared virtual, since it is always static"
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "'%D' kan ikke erklæres virtual eftersom den altid er statisk"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' shadows a member of `this'"
 msgid "declaration of %qD as member of %qT"
 msgstr "erklæring af '%s' skygger for et medlem af 'this'"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "a destructor cannot be %qs"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be `%s'"
 msgid "a constructor cannot be %<concept%>"
 msgstr "destruktionsfunktioner må ikke være '%s'"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be a member function"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "kan ikke åbne %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of implicitly-declared special member function"
 msgid "specialization of variable template %qD declared as function"
 msgstr "specialisering af underforstået erklæret speciel medlemsfunktion"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "variable template declared here"
 msgstr "variabel eller felt erklæret void"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 #| msgid "field `%D' has incomplete type"
 msgid "field %qD has incomplete type %qT"
 msgstr "feltet '%D' er af en ufuldstændig type"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, fuzzy, gcc-internal-format
 #| msgid "name `%T' has incomplete type"
 msgid "name %qT has incomplete type"
 msgstr "navnet '%T' er af en ufuldstændig type"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is neither function nor member function; cannot be declared friend"
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "'%s' er hverken en almindelig funktion eller en medlemsfunktion; kan ikke erklæres som friend"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "'%s' er hverken en almindelig funktion eller en medlemsfunktion; kan ikke erklæres som friend"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization `%D' in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "definering af eksplicit specialisering '%D' i friend-erklæring"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "static member `%D' declared `register'"
 msgid "static data member %qE declared %qs"
 msgstr "statisk medlem '%D' erklæret 'register'"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type `%T'"
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "ugyldig tildeling af startværdi i klasse til statisk datamedlem af en ikke-heltalstype '%T'"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "static member `%D' declared `register'"
 msgid "non-static data member %qE declared %qs"
 msgstr "statisk medlem '%D' erklæret 'register'"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `auto' invalid for function `%s'"
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "lagringsklassen 'auto' er ugyldig for funktionen '%s'"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `register' invalid for function `%s'"
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "lagringsklassen 'register' er ugyldig for funktionen '%s'"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `__thread' invalid for function `%s'"
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "lagringsklassen '__thread' er ugyldig for funktionen '%s'"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `__thread' invalid for function `%s'"
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "lagringsklassen '__thread' er ugyldig for funktionen '%s'"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' can only be specified for functions"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "'%D' kan kun angives for funktioner"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 #| msgid "type specifier `%s' not allowed after struct or class"
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "typeangivelsen '%s' er ikke tilladt efter struct eller class"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `inline' invalid for function `%s' declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "lagringsklassen 'inline' er ugyldig for funktionen '%s' erklæret uden for det globale virkefelt"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `inline' invalid for function `%s' declared out of global scope"
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "lagringsklassen 'inline' er ugyldig for funktionen '%s' erklæret uden for det globale virkefelt"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, fuzzy, gcc-internal-format
 #| msgid "virtual non-class function `%s'"
 msgid "virtual non-class function %qs"
 msgstr "virtuel funktion '%s' tilhører ikke en klasse"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in class context"
 msgid "%qs defined in a non-class scope"
 msgstr "metodedefinitionen optræder ikke i en klassekontekst"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "%qs declared in a non-class scope"
 msgstr "using-erklæring for ikke-medlem ved klassevirkefelt"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function `%D' to have static linkage"
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "kan ikke erklære medlemsfunktion '%D' til at have statisk kædning"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "kan ikke erklære en funktion for static inden i en anden funktion"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, fuzzy, gcc-internal-format
 #| msgid "`static' may not be used when defining (as opposed to declaring) a static data member"
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "'static' må ikke bruges ved definering (i modsætning til erklæring) af et statisk datamedlem"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, fuzzy, gcc-internal-format
 #| msgid "static member `%D' declared `register'"
 msgid "static member %qD declared %<register%>"
 msgstr "statisk medlem '%D' erklæret 'register'"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member `%#D' to have extern linkage"
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "kan ikke eksplicit erklære medlemmet '%#D' til at have extern-kædning"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%#D' outside of class is not definition"
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "erklæring af '%#D' uden for en klasse er ikke en definition"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' initialized and declared `extern'"
 msgid "%qs initialized and declared %<extern%>"
 msgstr "'%s' bliver tildelt en startværdi og er samtidig erklæret 'extern'"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' has both `extern' and initializer"
 msgid "%qs has both %<extern%> and initializer"
 msgstr "'%s' er erklæret 'extern', men bliver tildelt en startværdi"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 #| msgid "default argument `%E' uses local variable `%D'"
 msgid "default argument %qE uses %qD"
 msgstr "standardparameter '%E' bruger lokal variabel '%D'"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, fuzzy, gcc-internal-format
 #| msgid "default argument `%E' uses local variable `%D'"
 msgid "default argument %qE uses local variable %qD"
 msgstr "standardparameter '%E' bruger lokal variabel '%D'"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `virtual' in template declaration of `%#D'"
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "ugyldig brug af 'virtual' i skabelonserklæring af '%#D'"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of template-name '%E' in a declarator"
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "ugyldig brug af skabelonsnavn '%E' i erklæring"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter type `%T'"
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "ugyldig parametertype '%T'"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%D' invalidly declared method type"
 msgid "parameter %qD invalidly declared method type"
 msgstr "parameteren '%D' er på ugyldig vis erklæret som af en medlemsfunktionstype"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%D' includes %s to array of unknown bound `%T'"
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "parameteren '%D' inkluderer %s til tabel med ukendt grænse '%T'"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%D' includes %s to array of unknown bound `%T'"
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "parameteren '%D' inkluderer %s til tabel med ukendt grænse '%T'"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constructor; you probably meant `%T (const %T&)'"
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "ugyldig konstruktionsfunktion; du mente sandsynligvis '%T (const %T&)'"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "%qD may not be declared within a namespace"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "'%D' skal være en ikke-statisk medlemsfunktion"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must be a nonstatic member function"
 msgid "%qD must be a member function"
 msgstr "'%D' skal være en ikke-statisk medlemsfunktion"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must be either a non-static member function or a non-member function"
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "'%D' skal enten være en ikke-statisk medlemsfunktion eller ikke en medlemsfunktion"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must have an argument of class or enumerated type"
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "'%D' skal have en parameter af en klasse- eller enum-type"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ forbyder flertydiggørelse af operatoren ?:"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take either one or two arguments"
 msgid "%qD must not have variable number of arguments"
 msgstr "'%D' skal tage mod én eller to parametre"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "'%D' skal tage mod nul eller én parameter"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "'%D' skal tage mod én eller to parametre"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix `%D' must take `int' as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "postfiks '%D' skal tage mod 'int' som parameter"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix `%D' must take `int' as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "postfiks '%D' skal tage mod 'int' som den anden parameter"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "'%s' skal tage mod to parametre"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "'%s' skal tage mod én parameter"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "'%s' skal tage mod to parametre"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "%qD cannot have default arguments"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "konvertering til %s%s vil aldrig bruge en typekonverteringsoperator"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "konvertering til %s%s vil aldrig bruge en typekonverteringsoperator"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "konvertering til %s%s vil aldrig bruge en typekonverteringsoperator"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "konvertering til %s%s vil aldrig bruge en typekonverteringsoperator"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "konvertering til %s%s vil aldrig bruge en typekonverteringsoperator"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined `%D' always evaluates both arguments"
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "brugerdefineret '%D' evaluerer altid begge parametre"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, fuzzy, gcc-internal-format
 #| msgid "prefix `%D' should return `%T'"
 msgid "prefix %qD should return %qT"
 msgstr "præfiks '%D' skal returnere '%T'"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, fuzzy, gcc-internal-format
 #| msgid "postfix `%D' should return `%T'"
 msgid "postfix %qD should return %qT"
 msgstr "postfiks '%D' skal returnere '%T'"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' should return by value"
 msgid "%qD should return by value"
 msgstr "'%D' skal returnere pr. værdi (ikke reference)"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter `%T' after `%s'"
 msgid "using template type parameter %qT after %qs"
 msgstr "bruger skabelonstypeparameter '%D' efter '%s'"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous template specialization `%D' for `%+D'"
 msgid "using alias template specialization %qT after %qs"
 msgstr "tvetydig skabelonsspecialisering '%D' for '%+D'"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, fuzzy, gcc-internal-format
 #| msgid "using typedef-name `%D' after `%s'"
 msgid "using typedef-name %qD after %qs"
 msgstr "bruger typedef-navn '%D' efter '%s'"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "tidligere erklæring som '%#D'"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, fuzzy, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "'%#D' omerklæret som %C"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "dette er en tidligere erklæring"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, fuzzy, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "'%#D' omerklæret som %C"
@@ -67619,109 +67692,109 @@ msgstr "'%#D' omerklæret som %C"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, fuzzy, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "ikke-skabelon benyttet som skabelon"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qT is not a template"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, fuzzy, gcc-internal-format
 #| msgid "use of enum `%#D' without previous declaration"
 msgid "use of enum %q#D without previous declaration"
 msgstr "brug af enum '%#D' uden tidligere erklæring"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration `%#D' declares a non-template function"
 msgid "redeclaration of %qT as a non-template"
 msgstr "friend-erklæring '%#D' erklærer en ikke-skabelonsfunktion"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, fuzzy, gcc-internal-format
 #| msgid "derived union `%T' invalid"
 msgid "derived union %qT invalid"
 msgstr "nedarvet union '%T' ugyldig"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in the class %T"
 msgid "%qT defined with multiple direct bases"
 msgstr "'%D' er allerede defineret i klassen '%T'"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type `%D' is not a direct or virtual base of `%T'"
 msgid "%qT defined with direct virtual base"
 msgstr "typen '%D' er ikke en direkte eller en virtuel stamklasse til '%T'"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, fuzzy, gcc-internal-format
 #| msgid "base type `%T' fails to be a struct or class type"
 msgid "base type %qT fails to be a struct or class type"
 msgstr "stamklassetype '%T' er hverken en struct- eller class-type"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "recursive type `%T' undefined"
 msgid "recursive type %qT undefined"
 msgstr "rekursiv type '%T' ikke defineret"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate base type `%T' invalid"
 msgid "duplicate base type %qT invalid"
 msgstr "stamklassetype '%T' optræder mere end én gang"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 msgid "previous definition here"
 msgstr "tidligere definition her"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "underlying type %qT of %qT must be an integral type"
@@ -67731,98 +67804,104 @@ msgstr "parameter til '%s' skal være en 2 bit-konstant"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for `%s' not integer constant"
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "enum-værdien for '%s' er ikke en heltalskonstant"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for `%s' not integer constant"
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "enum-værdien for '%s' er ikke en heltalskonstant"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr ""
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C restricts enumerator values to range of `int'"
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "ISO C begrænser enum-værdier til rækkevidden af 'int'"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in enumeration values at `%D'"
 msgid "overflow in enumeration values at %qD"
 msgstr "enum-værdier for store ved '%D'"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "flere definitioner af %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, fuzzy, gcc-internal-format
 #| msgid "return type `%#T' is incomplete"
 msgid "return type %q#T is incomplete"
 msgstr "returtype '%#T' er ufuldstændig"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, fuzzy, gcc-internal-format
 #| msgid "`operator=' should return a reference to `*this'"
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "'operator=' bør returnere en reference til '*this'"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statements in function returning %qT"
 msgstr "ingen return-sætning i en funktion der ikke returnerer void"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr ""
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "ingen return-sætning i en funktion der ikke returnerer void"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in class `%T'"
 msgid "%qD is already defined in class %qT"
 msgstr "'%D' er allerede defineret i klassen '%T'"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "error closing %s: %m"
 msgid "using %qs"
 msgstr "fejl ved lukning af %s: %m"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "`%#D' used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "'%#D' benyttet før erklæring"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -68307,390 +68386,390 @@ msgstr "'%#D' omerklæret som en anden form for symbol"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "brug af skabelonsmodifikation uden for skabelon"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    indlejret fra %qs ved %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d%R"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    indlejret fra %qs ved %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    indlejret fra %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In member function `%s':"
 msgid "In static member function %qD"
 msgstr "I medlemsfunktionen '%s':"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "In copy constructor %qD"
 msgstr "I konstruktionen"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "In constructor %qD"
 msgstr "I konstruktionen"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In construct"
 msgid "In destructor %qD"
 msgstr "I konstruktionen"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 #| msgid "In function"
 msgid "In lambda function"
 msgstr "I funktionen"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In member function `%s':"
 msgid "In explicit object member function %qD"
 msgstr "I medlemsfunktionen '%s':"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "I medlemsfunktionen %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "I funktionen %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not of type `%T'"
 msgid "but %qE is a type"
 msgstr "'%E' er ikke af typen '%T'"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "but %qE is an expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 #| msgid "structure"
 msgid "but %qE is a structured binding"
 msgstr "struktur"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a namespace"
 msgid "but %qE is a variable"
 msgstr "'%D' er ikke et navnerum"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter"
 msgid "but %qE is a parameter"
 msgstr "en parameter"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "but %qE is a function"
 msgstr "'%s' er ikke en funktion,"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' has pointer data members"
 msgid "but %qE is a data member"
 msgstr "'%#T' har henvisningsdatamedlemmer"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function template"
 msgid "but %qE is a function template"
 msgstr "'%D' er ikke en funktionsskabelon"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "but %qE is a class template"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "but %qE is a variable template"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is a namespace"
 msgid "but %qE is a namespace"
 msgstr "'%D' er et navnerum"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a namespace"
 msgid "but %qE is an enumerator"
 msgstr "'%D' er ikke et navnerum"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template `%T'"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "  i instantiering af skabelonen '%T'"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 #| msgid "%s: In instantiation of `%s':\n"
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s: i instantiering af '%s':\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of `%s':\n"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s: i instantiering af '%s':\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "kaldt herfra"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "recursively required from here\n"
 msgstr "kaldt herfra"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "required from here\n"
 msgstr "kaldt herfra"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 #| msgid "no args to macro `%s'"
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "ingen parametre givet til makroen '%s'"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of `%D'"
 msgid "required for the satisfaction of %qE"
 msgstr "'%D' er tidligere erklæret"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c or -S required for Ada"
 msgid "required for constraint satisfaction\n"
 msgstr "-c eller -S kræves til Ada"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "ingen parametre"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "ingen parametre"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, fuzzy, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "ufuldstændig type '%T' kan ikke bruges til at navngive et virkefelt"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, fuzzy, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "'%D' has no member named '%E'"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "'%D' har intet medlem ved navn '%E'"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of `%T'"
 msgid "%qD is not a member of %qT"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "'%D' has no member named '%E'"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "'%D' har intet medlem ved navn '%E'"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "'%#D' kan ikke erklæres"
@@ -68942,7 +69021,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "medlemmet '%D' er en reference uden startværdi"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -69075,7 +69154,7 @@ msgstr "typen '%D' er ikke en direkte eller en virtuel stamklasse til '%T'"
 msgid "type %qT is not a direct base of %qT"
 msgstr "typen '%D' er ikke en direkte stamklasse til '%T'"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
@@ -69280,43 +69359,43 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "startværdien slutter for tidligt"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "ukendt tabelstørrelse i delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "returtypen er en ufuldstændig type"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
@@ -69353,91 +69432,99 @@ msgstr "kan ikke %s en henvisning til en ufuldstændig type '%T'"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "Ugyldig erklæring"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr ""
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "assignment (not initialization) in declaration"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "tildeling (ikke klargøring) i erklæring"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "assignment (not initialization) in declaration"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "tildeling (ikke klargøring) i erklæring"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "ugyldig #pragma %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "'#pragma vtable' understøttes ikke længere"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %s appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "'#pragma implementation' til %s optræder efter filen er inkluderet"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' not defined"
 msgid "%qD not defined"
 msgstr "'%D' er ikke defineret"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "%qD was not declared in this scope"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -69447,68 +69534,61 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of `%D' will change in a future version of GCC"
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "det ABI-navnet for '%D' vil ændre sig i en fremtidig version af GCC"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of `%D' will change in a future version of GCC"
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "det ABI-navnet for '%D' vil ændre sig i en fremtidig version af GCC"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of `%D' will change in a future version of GCC"
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "det ABI-navnet for '%D' vil ændre sig i en fremtidig version af GCC"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of `%D' will change in a future version of GCC"
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "det ABI-navnet for '%D' vil ændre sig i en fremtidig version af GCC"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of `%D' will change in a future version of GCC"
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
@@ -69929,7 +70009,7 @@ msgstr "tidligere erklæring af '%#D' med %L-kædning"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "modstridende erklæringer af '%s'"
@@ -69944,461 +70024,461 @@ msgstr "modstridende erklæringer af '%s'"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for `%#D'"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "modstridende returtyper angivet for '%#D'"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "modstridende erklæringer af '%s'"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration `%D'"
 msgid "existing declaration %#qD"
 msgstr "i erklæringen '%D'"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for `%D'"
 msgid "conflicting default argument for %#qD"
 msgstr "ingen standardparameter til '%D'"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "existing default declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument missing for parameter %P of `%+#D'"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "standardparameter mangler for parameter %P  i '%+#D'"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of `%#D' doesn't match"
 msgid "definition of %qD does not match"
 msgstr "extern-erklæring af '%#D' passer ikke med"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "existing definition %qD"
 msgstr "manglende startværdi"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of `%#D' doesn't match"
 msgid "enumerator %qD does not match ..."
 msgstr "extern-erklæring af '%#D' passer ikke med"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of `enum %s'"
 msgid "... this enumerator %qD"
 msgstr "omerklæring af 'enum %s'"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not of type `%T'"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "'%E' er ikke af typen '%T'"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "erklæring af skabelon '%#D'"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%qD omerklæret med anden adgang"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' used without template parameters"
 msgid "%qD has TU-local template argument %qD"
 msgstr "'%D' benyttet uden skabelonsparametre"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "%qD has TU-local template argument %qT"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "%qD refers to TU-local function %qD"
 msgstr "'%D' er ikke en medlemsskabelonfunktion"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for `%#D'"
 msgid "recursive lazy load"
 msgstr "omdefinering af standardparameter for '%#D'"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %D after first use"
 msgid "module %qs depends on itself"
 msgstr "eksplicit specialisering af %D efter første brug"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "module %qs declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' as array of voids"
 msgid "indirect import %qs is not already loaded"
 msgstr "'%s' erklæret som en tabel af void"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "tidligere definition her"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "inconsistent imported macro definition %qE"
 msgstr "inkonsistent instansvariabelangivelse"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 #| msgid "%s: can't delete file `%s': %s\n"
 msgid "compiled module file is %qs"
 msgstr "%s: kan ikke slette filen '%s': %s\n"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Display the compiler's version"
 msgid "compiled module is %sversion %s"
 msgstr "Vis oversætterens version"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2-version %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "no symbol table found"
 msgid "module %qs found"
 msgstr "ingen symboltabel fundet"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 #| msgid "function attribute mismatch"
 msgid "fixed tree mismatch"
 msgstr "forskellige funktionsattributter"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "stakgrænseudtryk understøttes ikke"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to find class '%s'"
 msgid "failed to read compiled module: %s"
 msgstr "kunne ikke finde klassen '%s'"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration `%#D'"
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "strider mod indbygget erklæring '%#D'"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration `%#D'"
 msgid "declaration %qD conflicts with builtin"
 msgstr "strider mod indbygget erklæring '%#D'"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "asm declaration conflicts with previous rename"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "asm-erklæring er i konflikt med tidligere omdøbelse"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template `%#D'"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "erklæring af skabelon '%#D'"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with new declaration with %L linkage"
 msgid "conflicting declaration of %qD in global module"
 msgstr "strider mod ny erklæring af med %L-kædning"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously declared here"
 msgid "previously declared in module %qs"
 msgstr "'%s' tidligere erklæret her"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously declared here"
 msgid "previously declared in global module"
 msgstr "'%s' tidligere erklæret her"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration `%#D' declares a non-template function"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "friend-erklæring '%#D' erklærer en ikke-skabelonsfunktion"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "tidligere erklæring af '%#D' med %L-kædning"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "creating %s"
 msgid "reading CMI %qs"
 msgstr "opretter %s"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown cpu: -mcpu=%s"
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "Ukendt processor: -mcpu=%s"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "metodedefinitionen optræder ikke i @implementation-kontekst"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "module declared here"
@@ -70411,116 +70491,116 @@ msgstr "  '%#D' erklæret her"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Symbols have a leading underscore"
 msgid "module already declared"
 msgstr "Symboler har en indledende understreg"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 #| msgid "Symbols have a leading underscore"
 msgid "module already imported"
 msgstr "Symboler har en indledende understreg"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "module %qs imported here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown punctuation '%c'"
 msgid "unknown compiled module interface: %s"
 msgstr "ukendt tegnsætning »%c«"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, fuzzy, gcc-internal-format
 #| msgid "while writing precompiled header"
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "under skrivning af præoversat inkluderingsfil"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Aktivér stakprøvning"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param value %qs"
 msgid "invalid header name %qs"
 msgstr "ugyldig »--param«-værdi %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid macro name `%s'"
 msgid "invalid module name %qs"
 msgstr "ugyldigt makronavn '%s'"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "fejl ved skrivning til %s"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "first error in %qD appeared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to find class '%s'"
 msgid "failed to write compiled module: %s"
 msgstr "kunne ikke finde klassen '%s'"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown header kind %qs"
@@ -70536,7 +70616,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "funktionen '%s' omerklæret med egenskaben noinline"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
@@ -70587,288 +70667,298 @@ msgstr "erklæring af '%#D' skygger for en parameter"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "erklæring af '%s' skygger for et medlem af 'this'"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "erklæring af parameteren '%s', men ingen sådan parameter"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s: %s: "
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s: %s: "
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "%q#D declared here with no linkage"
 msgstr "  '%#D' erklæret her"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' undeclared here (not in a function)"
 msgid "%q#D declared here with internal linkage"
 msgstr "'%s' ikke erklæret her (ikke i en funktion)"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "%q#D declared here with module linkage"
 msgstr "  '%#D' erklæret her"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' names constructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "'%D' navngiver en konstruktionsfunktion"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "using-erklæring for ikke-medlem ved klassevirkefelt"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or namespace"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "'%T' er ikke en klasse eller et navnerum"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "using-erklæring for destruktionsfunktion"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "using-erklæring for ikke-medlem ved klassevirkefelt"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type `%D' is not a direct base of `%T'"
 msgid "%qT is not a direct base of %qT"
 msgstr "typen '%D' er ikke en direkte stamklasse til '%T'"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "using-erklæring for destruktionsfunktion"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' names constructor"
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "'%D' navngiver en konstruktionsfunktion"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' not in a namespace surrounding `%D'"
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "erklæring af '%D' er ikke i et navnerum der omgiver '%D'"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate type qualifiers in %s declaration"
 msgid "explicit qualification in declaration of %qD"
 msgstr "dobbelte typemodifikationer i %s-erklæring"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' should have been declared inside `%D'"
 msgid "%qD should have been declared inside %qD"
 msgstr "'%D' skulle have været erklæret inden i '%D'"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "'%D' er erklæret som en ven"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to variables"
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "egenskaben '%s' kan kun anvendes på variabler"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "egenskabsdirektivet '%s' ignoreret"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "`%#D' cannot be declared"
 msgid "the macro %qs had not yet been defined"
 msgstr "'%#D' kan ikke erklæres"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "it was later defined here"
 msgstr "'%s' tidligere defineret her"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, fuzzy, gcc-internal-format
 #| msgid "brace-enclosed initializer used to initialize `%T'"
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "startværdi i krøllede paranteser benyttet til at klargøre '%T'"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "switch \"%s\" is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "tilvalget '%s' understøttes ikke længere"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, fuzzy, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr "Angiv klassesti (forældet: benyt --classpath i stedet)"
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on uninstantiated type"
 msgid "annotation on using directive"
 msgstr "ugyldig operation på uudskiftet type"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "cannot nest more than %d namespaces"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "use of `%D' is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, fuzzy, gcc-internal-format
 #| msgid "namespace alias `%D' not allowed here, assuming `%D'"
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "navnerumsalias '%D' er ikke tilladt her, antager '%D'"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "tidligere erklæring af '%#D' med %L-kædning"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "forventede %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "sektionsegenskaben kan ikke angives for lokale variabler"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "`%#D' conflicts with previous using declaration `%#D'"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "'%#D' strider mod tidligere using-erklæring '%#D'"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "tidligere definition her"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -70900,7 +70990,7 @@ msgstr "kaldenavnet '%s' er i modstrid med den interne navngivningsstrategi i GN
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
@@ -70948,7 +71038,7 @@ msgstr "'%#D' kan ikke erklæres"
 msgid "request for member %qE in non-class type %qT"
 msgstr "forespørgsel efter medlemmet '%D' i '%E' som er af en ikke-klassetype '%T'"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "'%#D' kan ikke erklæres"
@@ -71029,7 +71119,7 @@ msgstr "semikolon mangler efter erklæring af '%T'"
 msgid "%qE is not a class template"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qE is not a template"
@@ -71363,1850 +71453,1861 @@ msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11
 msgid "pack index missing"
 msgstr "parameternavn mangler"
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "denne mediafunktion er kun tilgængelig på fr500"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected a reflection of a type"
 msgstr "forventet funktion"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "`%D' is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "'%D' er ikke en funktionsskabelon"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "ikke-skabelon benyttet som skabelon"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or namespace"
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "'%T' er ikke en klasse eller et navnerum"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 #| msgid "-Wno-strict-prototypes is not supported in C++"
 msgid "fixed-point types not supported in C++"
 msgstr "-Wno-strict-prototypes er ikke understøttet i C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ forbyder krøllet parantes-grupper inden i udtryk"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, fuzzy, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "sætningsblokke i udtryk er kun tilladt inde i en funktion"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected primary-expression"
 msgstr "uventet adresseudtryk"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "Advar om extern-erklæringer som ikke er ved filvirkefeltsniveauet"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, fuzzy, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "denne mediafunktion er kun tilgængelig på fr500"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected id-expression"
 msgstr "uventet adresseudtryk"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr ""
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "template-id not allowed for destructor in C++20"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%s' shadows a member of `this'"
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "erklæring af '%s' skygger for et medlem af 'this'"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, fuzzy, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "skabelons-id '%D' benyttet som erklærer"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr ""
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qD is not a template"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "ufuldstændig type '%T' kan ikke bruges til at navngive et virkefelt"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "ufuldstændig type '%T' kan ikke bruges til at navngive et virkefelt"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "ufuldstændig type '%T' kan ikke bruges til at navngive et virkefelt"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "uventet operand"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "forkert antal skabelonsparametre (%d, skulle være %d)"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to bit-complement"
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "forkert parametertype til bitkomplement"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "forkert antal skabelonsparametre (%d, skulle være %d)"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "forkert antal skabelonsparametre (%d, skulle være %d)"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "Ugyldig erklæring"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ forbyder sammensatte konstanter"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "invalid use of %qD"
 msgstr "ugyldig brug af '%D"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 #| msgid "`%D::%D' is not a member of `%T'"
 msgid "%<%D::%D%> is not a class member"
 msgstr "'%D::%D' er ikke et medlem af '%T'"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "typedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "typedef-navn kan ikke være en indlejret-navn-specifikation"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new kan ikke bruges på en referencetype"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "new kan ikke bruges på en funktionstype"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ tillader ikke %<alignof%> med en ikke-type"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in a new-expression"
 msgid "types may not be defined in %qs expressions"
 msgstr "typer kan ikke defineres i et nyt udtryk"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "typer kan ikke defineres i et nyt udtryk"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, fuzzy, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "egenskaber i parametertabelerklæring ignoreret"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected expression-list or type-id"
 msgstr "uventet adresseudtryk"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, fuzzy, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "brug af ældre type typeomtvingning"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, fuzzy, gcc-internal-format
 #| msgid "suggest parentheses around && within ||"
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "foreslår paranteser omkring && inden i ||"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow ?: with omitted middle operand"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ tillader ikke ?: med udeladt midter operand"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, fuzzy, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "ISO C forbyder brug af typeomtvingningsudtryk som venstreværdier"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr ""
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %s to references"
 msgid "%<this%> cannot be captured by reference"
 msgstr "kan ikke erklære %s til referencer"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, fuzzy, gcc-internal-format
 #| msgid "non-empty initializer for array of empty elements"
 msgid "empty initializer for lambda init-capture"
 msgstr "en startværdi der ikke er tom, tildeles til en tabel med tomme elementer"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 #| msgid "%s of read-only variable `%s'"
 msgid "capture of non-variable %qE"
 msgstr "%s af variablen '%s' der kun må læses"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<...%> in lambda capture"
 msgstr "for mange inddatafiler"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of `%#D'"
 msgid "default argument specified for lambda parameter"
 msgstr "standardparameter givet til %d. parameter for '%#D'"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of `%#D'"
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "standardparameter givet til %d. parameter for '%#D'"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of `%#D'"
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "standardparameter givet til %d. parameter for '%#D'"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "  `%#D' declared here"
+msgid "%q#E declared here"
+msgstr "  '%#D' erklæret her"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "egenskaber i parametertabelerklæring ignoreret"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected labeled-statement"
 msgstr "tom krop i en else-sætning"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, fuzzy, gcc-internal-format
 #| msgid "case label `%E' not within a switch statement"
 msgid "case label %qE not within a switch statement"
 msgstr "case-etiket '%E' befinder sig ikke inden i en switch-sætning"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "'%D' erklærer ikke en skabelonstype"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 #| msgid "In statement function"
 msgid "compound-statement in %<constexpr%> function"
 msgstr "I sætningsfunktion"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "%<if consteval%> requires compound statement"
 msgstr "ugyldig venstreværdi i asm-sætning"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected selection-statement"
 msgstr "tom krop i en else-sætning"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returns an aggregate"
 msgid "condition declares an array"
 msgstr "funktion returnerer en værdi af en sammensat type"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field `%s' declared as a function"
 msgid "condition declares a function"
 msgstr "feltet '%s' er erklæret som en funktion"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "new kan ikke bruges på en referencetype"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 #| msgid "empty scalar initializer"
 msgid "expected initializer"
 msgstr "tom skalarstartværdi"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "sizeof applied to a function type"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "sizeof benyttet på en funktionstype"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "udtrykket er af en ufuldstændig type"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "uventet operand"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in aggregate initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "for mange elementer i startværdi til sammensat type"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "using-erklæring for destruktionsfunktion"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ forbyder beregnede goto'er"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "uventet operand"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected module-partition"
 msgstr "tom erklæring"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 msgid "expected module-name"
 msgstr "uventet operand"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in class context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "metodedefinitionen optræder ikke i en klassekontekst"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "using-erklæring for ikke-medlem ved klassevirkefelt"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "scope opened here"
 msgstr "'%s' tidligere defineret her"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "private module fragment"
 msgstr "ingen parametre"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "using-erklæring for ikke-medlem ved klassevirkefelt"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra `;' outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C tillader ikke ekstra ';' uden for funktioner"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra `;' outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C tillader ikke ekstra ';' uden for funktioner"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "'%s' er erklæret inline efter dens definition"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored"
 msgid "attributes may be inserted here"
 msgstr "egenskaben '%s' ignoreret"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template `%T'"
 msgid "explicit specializations are not permitted here"
 msgstr "eksplicit specialisering af '%T' der ikke er en skabelon"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template `%#D'"
 msgid "explicit instantiations are not permitted here"
 msgstr "eksplicit instantiering af ikke-skabelon '%#D'"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "  oprindelig definition er her"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, fuzzy, gcc-internal-format
 #| msgid "multiple declarations `%T' and `%T'"
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "flere erklæringer '%T' og '%T'"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 #| msgid "using `typename' outside of template"
 msgid "structured binding pack outside of template"
 msgstr "bruger 'typename' uden for en skabelon"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "tom erklæring"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "annotation on structured binding"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "empty structured binding declaration"
 msgstr "tom erklæring"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "invalid initializer for structured binding declaration"
 msgstr "ugyldig startværdi til bitstreng"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "forward declaration of `%#T'"
 msgid "for-range-declaration cannot be %qs"
 msgstr "forhåndserklæring af '%#T'"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "lagringsklasseanvisninger er ugyldige i parametererklæringer"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr ""
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %qD"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "afsnitstypekonflikt med %qD"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in friend function declarations"
 msgid "%qD invalid in condition"
 msgstr "lagringsklasseanvisninger er ugyldige i vennefunktionserklæringer"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' invalid in `%#T'"
 msgid "%qD invalid in lambda"
 msgstr "'%D' ugyldig i '%#T'"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in friend function declarations"
 msgid "type-specifier invalid in lambda"
 msgstr "lagringsklasseanvisninger er ugyldige i vennefunktionserklæringer"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, fuzzy, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "funktionen '%D' kan ikke erklæres friend"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid linkage-specification"
 msgstr "ugyldig stamklasseangivelse"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of void expression"
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "ugyldig brug af void-udtryk"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 #| msgid "only constructors take base initializers"
 msgid "only constructors take member initializers"
 msgstr "kun konstruktionsfunktioner har stamklasseklargøringer"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member `%D'"
 msgid "cannot expand initializer for member %qD"
 msgstr "manglende startværdi for medlemmet '%D'"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr ""
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, fuzzy, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "forældet stamklasseklargøring"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "expected suffix identifier"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type modifier within pointer declarator"
 msgid "invalid encoding prefix in literal operator"
 msgstr "ugyldig typemodifikation i erklæring af henvisning"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected operator"
 msgstr "uventet operand"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, fuzzy, gcc-internal-format
 #| msgid "keyword `export' not implemented, and will be ignored"
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "det reserverede ord 'export' er ikke implementeret og vil blive ignoreret"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword `export' not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "det reserverede ord 'export' er ikke implementeret og vil blive ignoreret"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "invalid constrained type parameter"
 msgstr "ugyldig catch-parameter"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "cv-qualified type parameter"
 msgstr "ugyldig catch-parameter"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "template parameter packs cannot have default arguments"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 msgid "expected template-id"
 msgstr "uventet operand"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, fuzzy, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "objektet '%E' kan ikke bruges som skabelonsparameter"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "uventet operand"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, fuzzy, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "objektet '%E' kan ikke bruges som skabelonsparameter"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 msgid "expected template-name"
 msgstr "uventet operand"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, fuzzy, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "ikke-skabelon benyttet som skabelon"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, fuzzy, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "skabelons-id '%D' i erklæring af primær skabelon"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 msgid "expected template-argument"
 msgstr "uventet operand"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 #| msgid "address of non-extern `%E' cannot be used as template argument"
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "adresse på ikke-ekstern '%E' kan ikke bruges som skabelonsparameter"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of `%#D' after"
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "eksplicit instantiering af '%#D' efter"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of `%#D' after"
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "eksplicit instantiering af '%#D' efter"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of `%#D' after"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "eksplicit instantiering af '%#D' efter"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "skabelonsspecialisering med C-kædning"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 #| msgid "sigof type specifier"
 msgid "expected type specifier"
 msgstr "sigof-typeangivelse"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids forward parameter declarations"
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "ISO C forbyder forhåndsparametererklæringer"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids forward parameter declarations"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "ISO C forbyder forhåndsparametererklæringer"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids forward parameter declarations"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "ISO C forbyder forhåndsparametererklæringer"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "forventet skabelon-id for typen"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "forventet type-navn"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "'%D' erklærer ikke en skabelonstype"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "concept defined here"
 msgstr "'%s' tidligere defineret her"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%D'"
 msgid "invalid use of concept-name %qD"
 msgstr "ugyldig brug af '%D"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "uventet operand"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "declaration %qD does not declare anything"
 msgstr "erklæring erklærer ikke noget"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on uninstantiated type"
 msgid "attributes ignored on uninstantiated type"
 msgstr "ugyldig operation på uudskiftet type"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "attributes ignored on template instantiation"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function template"
 msgid "%qD is an enumeration template"
 msgstr "'%D' er ikke en funktionsskabelon"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 #| msgid "Min/max instructions not allowed"
 msgid "unnamed scoped enum is not allowed"
 msgstr "Min/max-instruktioner ikke tilladt"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr ""
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 #| msgid "Enable automatic template instantiation"
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "Aktivér automatisk skabelonsinstantiering"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' in `%D' which does not enclose `%D'"
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "erklæring af '%D' i '%D' som ikke omgiver '%D'"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' in `%D' which does not enclose `%D'"
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "erklæring af '%D' i '%D' som ikke omgiver '%D'"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "ekstra kvalifikation er ikke tilladt"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ forbyder tomme unavngivet enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "'%D' erklærer ikke en skabelonstype"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD er ikke et navnerum-navn"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "forventet navnerum-navn"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "uventet operand"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr "navnerumnavn krævet"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 #| msgid "Min/max instructions not allowed"
 msgid "a nested namespace definition cannot have attributes"
 msgstr "Min/max-instruktioner ikke tilladt"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "function with nested functions cannot be inline"
 msgid "a nested namespace definition cannot be inline"
 msgstr "funktion med indlejrede funktioner kan ikke indbygges"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "namespace `%T' undeclared"
 msgid "namespace %qD entered"
 msgstr "navnerummet '%T' er ikke erklæret"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 #| msgid "Min/max instructions not allowed"
 msgid "%<namespace%> definition is not allowed here"
 msgstr "Min/max-instruktioner ikke tilladt"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, fuzzy, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "navnerum '%D' ikke tilladt i using-erklæring"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of undefined type `%#T'"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "ugyldig brug af en ikke-defineret type '%#T'"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete typedef `%s'"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "ugyldig brug af ufuldstændig typedef '%s'"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration `%#D' here"
 msgid "opaque-enum-declaration here"
 msgstr "tidligere erklæring af '%#D' her"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected multiplicative operand"
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "uventet multiplikativ operand"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate case value"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "case-værdi optræder mere end én gang"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "%J'%D' is not defined outside of function scope"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%J'%D' er ikke defineret uden for funktionsvirkefelt"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "'%T' er ikke et navnerum"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "use of %s from containing function"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "brug af %s fra indeholdende funktion"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "forward declaration of `%#T'"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "forhåndserklæring af '%#T'"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "parameternavne (uden typer) i funktionserklæringen"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "egenskaber i parametertabelerklæring ignoreret"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "parameternavne (uden typer) i funktionserklæringen"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "funktionen '%s' omerklæret som inline"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "global register variable `%s' used in nested function"
 msgid "cannot handle qualified name for variant function"
 msgstr "global registervariabel '%s' benyttet i indlejret funktion"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "declare variant directives are not allowed on destructors"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "'defined' optræder uden et kaldenavn"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of C function `%#D' conflicts with"
 msgid "no declaration of base function %qs in this scope"
 msgstr "erklæring af C-funktionen '%#D' strider mod"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "%s kan ikke finde adressen af flertydiggjort funktion"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "en funktionsdefinition er ikke tilladt her"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, fuzzy, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 #| msgid "initializer specified for non-member function `%D'"
 msgid "initializer provided for function"
 msgstr "startværdi angivet for ikke-medlemsfunktion '%D'"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, fuzzy, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "egenskaber i parametertabelerklæring ignoreret"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "funktionen '%s' omerklæret som inline"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array bound is not an integer constant"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type `%T'"
 msgid "cannot define member of dependent typedef %qT"
 msgstr "opretter henvisning til medlemsreference af typen '%T'"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 #| msgid "`%D::%D' is not a template"
 msgid "%<%T::%E%> is not a type"
@@ -73216,297 +73317,297 @@ msgstr "'%D::%D' er ikke en skabelon"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "ugyldig erklærer"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "ugyldig brug af ikke-statisk felt '%D'"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid declaration"
 msgid "qualified-id in declaration"
 msgstr "Ugyldig erklæring"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declarator"
 msgstr "tom erklæring"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is a namespace"
 msgid "%qD is a namespace"
 msgstr "'%D' er et navnerum"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type `%T'"
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "opretter henvisning til medlem af typen '%T' der ikke er en klasse"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected ptr-operator"
 msgstr "uventet operand"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate case value"
 msgid "duplicate cv-qualifier"
 msgstr "case-værdi optræder mere end én gang"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple ref-qualifiers"
 msgstr "mere end én 'virtual'-angivelse"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, fuzzy, gcc-internal-format
 #| msgid "--resource requires -o"
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "--resource påkræver -o"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "duplicate virt-specifier"
 msgstr "mere end én 'virtual'-angivelse"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%T'"
 msgid "invalid use of %qT"
 msgstr "ugyldig brug af '%T'"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "uventet operand"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "forventede %<,%> eller %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "lagringsklasseanvisninger er ugyldige i parametererklæringer"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, fuzzy, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "standardparameter givet til %d. parameter for '%#D'"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "template parameter pack cannot have a default argument"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "parameter pack cannot have a default argument"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "skabelonsparametre kan ikke være venner"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ tillader ikke GNU-udpegede startværdier"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ tillader ikke C99-udpegede startværdier"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "%<...%> er ikke tilladt i udpegede startværdiliste"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "forventet klasse-navn"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "'%s' er erklæret inline efter dens definition"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr ""
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "'%s' er erklæret inline efter dens definition"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "duplicate %qD specifier"
 msgstr "mere end én 'virtual'-angivelse"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "forventede %<{%> eller %<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "bruger 'typename' uden for en skabelon"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, fuzzy, gcc-internal-format
 #| msgid "invalid redeclaration of `%D'"
 msgid "invalid class name in declaration of %qD"
 msgstr "ugyldig omerklæring af '%D'"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization `%D' in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "definering af eksplicit specialisering '%D' i friend-erklæring"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, fuzzy, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "eksplicit specialisering følger ikke efter 'template <>'"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "ikke-skabelon benyttet som skabelon"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of `%#T'"
 msgid "previous definition of %q#T"
@@ -73515,291 +73616,291 @@ msgstr "tidligere definition af '%#T'"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 msgid "expected class-key"
 msgstr "uventet operand"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "uventet operand"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, fuzzy, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "friend-erklæringen er ikke i klassedefinitionen"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 #| msgid "`__alignof' applied to a bit-field"
 msgid "default member initializer for unnamed bit-field"
 msgstr "'__alignof' benyttet på et bitfelt"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field `%#D' with non-integral type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "bitfelt '%#D' med en ikke-heltalstype"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, fuzzy, gcc-internal-format
 #| msgid "brace-enclosed initializer used to initialize `%T'"
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "startværdi i krøllede paranteser benyttet til at klargøre '%T'"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "sektionsegenskaben kan ikke angives for lokale variabler"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, fuzzy, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "bruger 'typename' uden for en skabelon"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "Generér ikke kode til at kontrollere undtagelsesspecifikationer"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "ugyldig brug af %<auto%> i undtagelsesspecifikation"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%>i tom erklæring"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to variables"
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "egenskaben '%s' kan kun anvendes på variabler"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "sektionsegenskaben kan ikke angives for lokale variabler"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected attribute before %<...%>"
 msgstr "uventet operand"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected conditional-expression"
 msgstr "uventet adresseudtryk"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "%qs is only available with %qs"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored for `%s'"
 msgid "attributes are ignored on %qs"
 msgstr "'%s'-egenskaben ignoreret for '%s'"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "ugyldig operation på uudskiftet type"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "ikkestatisk datamedlemsstartværdier er kun tilgængelige med -std=c++11 eller -std=gnu++11"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "expression must be enclosed in parentheses"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "asm template is not a string constant"
 msgid "result type is not a plain type-constraint"
 msgstr "asm-sætning er ikke en strengkonstant"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "angivet justering er ikke en konstant"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 #| msgid "invalid redeclaration of `%D'"
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "ugyldig omerklæring af '%D'"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, fuzzy, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "for få skabelonsparameterlister angivet i erklæring af '%D'"
@@ -73808,458 +73909,458 @@ msgstr "for få skabelonsparameterlister angivet i erklæring af '%D'"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, fuzzy, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "for mange skabelonsparameterlister angivet i erklæring af '%D'"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of `operator %T'"
 msgid "template-id not allowed for constructor in C++20"
 msgstr "modifikationer er ikke tilladt i erklæring af 'operator %T'"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, fuzzy, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "--driver understøttes ikke længere"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, fuzzy, gcc-internal-format
 #| msgid "invalid declaration of member template `%#D' in local class"
 msgid "invalid declaration of member template in local class"
 msgstr "ugyldig erklæring af medlemsskabelon '%#D' i lokal klasse"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "skabelon med C-kædning"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization here"
 msgid "invalid explicit specialization"
 msgstr "eksplicit specialisering her"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of `%#D'"
 msgid "template declaration of %<typedef%>"
 msgstr "skabelonserklæring af '%#D'"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "erklæring erklærer ikke noget"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization here"
 msgid "explicit template specialization cannot have a storage class"
 msgstr "eksplicit specialisering her"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "'>>' skulle have været '> >' i skabelonsklassenavn"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, fuzzy, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "'>>' skulle have været '> >' i skabelonsklassenavn"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "'>>' skulle have været '> >' i skabelonsklassenavn"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid use of %qD in linkage specification"
 msgstr "ugyldig stamklasseangivelse"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %qD"
 msgid "%qD specifier conflicts with %qs"
 msgstr "afsnitstypekonflikt med %qD"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> før %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 #| msgid "%s used with `%%%c' %s format"
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%s brugt med '%%%c' %s-formatering"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 understøtter ikke %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr ""
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "duplikere %qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "duplikere %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "forventede %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "forventede %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "forventede %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "forventede %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "forventede %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "forventede %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "forventede %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "forventede %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "forventede %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "forventede %<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "forventede %<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "forventede %<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "forventede %<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "forventede %<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "forventede %<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<auto%>"
 msgstr "forventede %<catch%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "forventede %<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "forventede %<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "forventede %<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "forventede %<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "forventede %<__transaction_atomic%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "forventede %<__transaction_relaxed%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<@end%>"
 msgid "expected %<co_yield%>"
 msgstr "%<@end%> forventet"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "forventede %<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "forventede %<...%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "forventede %<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "forventede %<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "forventede %<:%> or %<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "%<:%> forventet"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' tag used in naming `%#T'"
 msgid "%qs tag used in naming %q#T"
 msgstr "'%s'-mærke benyttet i navngivning af '%#T'"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T var tidligere erklæret her"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to `%#T'"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "kan ikke erklære reference til '%#T'"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' not declared"
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "'%D' ikke erklæret"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "uventet operand"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "%qT defined as %qs here"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "  first declared as `%#D' here"
 msgid "%qT first declared as %qs here"
 msgstr "  først erklæret som '%#D' her"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD omerklæret med anden adgang"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, fuzzy, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "%Hslutningen af filen læst inden i standardparameter"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 #| msgid "Class or interface declaration expected"
 msgid "objective-c++ method declaration is expected"
 msgstr "Klasse- eller grænsefladeerklæring forventet"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "sektionsegenskaben kan ikke angives for lokale variabler"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name `%s' for register variable"
 msgid "invalid type for instance variable"
 msgstr "ugyldigt registernavn '%s' for registervariabel"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, fuzzy, gcc-internal-format
 #| msgid "Identifier expected"
 msgid "identifier expected after %<@protocol%>"
 msgstr "Kaldenavn forventet"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute ignored for `%s'"
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "'%s'-egenskaben ignoreret for '%s'"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid type for property"
 msgstr "ugyldig typeparameter"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown property attribute %qE"
 msgstr "ukendt registernavn: %s"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected integer expression list"
 msgstr "uventet adresseudtryk"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr ""
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid identifier `%s'"
 msgid "invalid reduction-identifier"
 msgstr "ugyldigt kaldenavn '%s'"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "new kan ikke bruges på en referencetype"
@@ -74268,184 +74369,184 @@ msgstr "new kan ikke bruges på en referencetype"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "'#pragma vtable' understøttes ikke længere"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, fuzzy, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "typedef-navn kan ikke klassemodificeres"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 #| msgid "register variable `%s' used in nested function"
 msgid "iteration variable %qD should not be reduction"
 msgstr "registervariabel '%s' benyttet i indlejret funktion"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr ""
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qD is not a C pointer"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "uventet operand"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "ugyldig startværdi"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected side-effects in address"
 msgid "expected id-expression (arguments)"
 msgstr "uventede bivirkninger i adresse"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of \"%s\" shadows a global declaration"
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "erklæring af '%s' skygger for en global erklæring"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "forventede %<class%>, %<typename%>, eller %<template%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "%qD does not refer to a namespace scope function"
 msgstr "'%D' er ikke en medlemsskabelonfunktion"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "In statement function"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "I sætningsfunktion"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "malformed #pragma map, ignored"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "forkert udformet '#pragma map' - ignoreret"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "braced-group within expression allowed only inside a function"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "sætningsblokke i udtryk er kun tilladt inde i en funktion"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "profilering understøttes ikke endnu"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -74983,19 +75084,25 @@ msgstr "omgivende klasseskabeloner er ikke eksplicit specialiserede"
 msgid "redeclaration of %qD with different constraints"
 msgstr "'%#D' omerklæret som en anden form for symbol"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "storage class specified for parameter `%s'"
+msgid "local class in lambda in template parameter list"
+msgstr "lagringsklasse angivet for parameter '%s'"
+
+#: cp/pt.cc:6461
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not a template type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, fuzzy, gcc-internal-format
 #| msgid "too few template parameter lists in declaration of `%D'"
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "for få skabelonsparameterlister angivet i erklæring af '%D'"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' used without template parameters"
 msgid "redeclared with %d template parameter"
@@ -75003,7 +75110,7 @@ msgid_plural "redeclared with %d template parameters"
 msgstr[0] "'%D' benyttet uden skabelonsparametre"
 msgstr[1] "'%D' benyttet uden skabelonsparametre"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration `%#D' here"
 msgid "previous declaration %qD used %d template parameter"
@@ -75011,533 +75118,533 @@ msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "tidligere erklæring af '%#D' her"
 msgstr[1] "tidligere erklæring af '%#D' her"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter `%#D'"
 msgid "template parameter %q+#D"
 msgstr "skabelonsparameter '%#D'"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here as `%#D'"
 msgid "redeclared here as %q#D"
 msgstr "omerklæret her som '%#D'"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid "redeclared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "'%#D' omerklæret som en anden form for symbol"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "  oprindelig definition er her"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "'%#D' omerklæret som en anden form for symbol"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "den skal være adressen af en funktion med ekstern kædning"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, fuzzy, gcc-internal-format
 #| msgid "it must be the address of a function with external linkage"
 msgid "it must be the name of a function with external linkage"
 msgstr "den skal være adressen af en funktion med ekstern kædning"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, fuzzy, gcc-internal-format
 #| msgid "it must be a pointer-to-member of the form `&X::Y'"
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "den skal være en henvisning til medlem på formen '&X::Y'"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of `%T'"
 msgid "because it is a member of %qT"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "got %d template parameters for `%#D'"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "modtog %d skabelonsparametre for '%#D'"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types `%#T' and `%#T'"
 msgid "  mismatched types %qT and %qT"
 msgstr "sammenligning mellem typerne '%#T' og '%#T'"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
 # flertalsform unødvendig
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 #| msgid "template argument `%E' involves template parameter(s)"
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "skabelonsparameter '%E' involverer skabelonsparameter"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr ""
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "  member function type %qT is not a valid template argument"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type `%T' to type `%T'"
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "kan ikke konvertere typen '%T' til typen '%T'"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is an ambiguous base of `%T'"
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "'%T' er en tvetydig stamklasse til '%T'"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 #| msgid "type `%T' is not derived from type `%T'"
 msgid "  %qT is not derived from %qT"
 msgstr "typen '%T' er ikke nedarvet fra typen '%T'"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type `%T'"
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "kan ikke %s en henvisning til en ufuldstændig type '%T'"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "  template argument %qE does not match %qE"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "the address of %qD is not a valid template argument"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, fuzzy, gcc-internal-format
 #| msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "strengkonstanten %E er ikke en gyldig skabelonsparameter fordi den er adressen af et objekt med statisk kædning"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr ""
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' is not a valid template argument"
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "'%E' er ikke en gyldig skabelonsparameter"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr ""
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "ignoring attributes in template argument %qE"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, fuzzy, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `restrict'"
 msgid "invalid use of destructor %qE as a type"
 msgstr "ugyldig brug af 'restrict'"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, fuzzy, gcc-internal-format
 #| msgid "to refer to a type member of a template parameter, use `typename %E'"
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "benyt 'typename %E' for at referere til et typemedlem af en skabelonsparameter"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for `%D'"
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "type/værdi-konflikt ved %d. parameter i skabelonsparameterliste for '%D'"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a constant of type `%T', got `%T'"
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  forventede en konstant af typen '%T', modtog '%T'"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for parameter of type `%T' has type `%T'"
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "standardparameter for parameter af typen '%T' har typen '%T'"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, fuzzy, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  forventede en klasseskabelon, modtog '%T'"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got `%E'"
 msgid "  expected a type, got %qE"
 msgstr "  forventede en type, modtog '%E'"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got `%T'"
 msgid "  expected a type, got %qT"
 msgstr "  forventede en type, modtog '%T'"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a class template, got `%T'"
 msgid "  expected a class template, got %qT"
 msgstr "  forventede en klasseskabelon, modtog '%T'"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a template of type `%D', got `%D'"
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  forventede en skabelon af typen '%D', modtog '%D'"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for `%D'"
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "type/værdi-konflikt ved %d. parameter i skabelonsparameterliste for '%D'"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got `%E'"
 msgid "  expected %qD but got %qD"
 msgstr "  forventede en type, modtog '%E'"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument `%E' to `%T'"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "kunne ikke konvertere skabelonsparameteren '%E' til '%T'"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "forkert antal skabelonsparametre (%d, skulle være %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "forkert antal skabelonsparametre (%d, skulle være %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for `%D'"
 msgid "provided for %qD"
 msgstr "angivet for '%D'"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of `%#D'"
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "standardparameter givet til %d. parameter for '%#D'"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function template"
 msgid "%q#D is not a function template"
 msgstr "'%D' er ikke en funktionsskabelon"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, fuzzy, gcc-internal-format
 #| msgid "non-template type `%T' used as a template"
 msgid "non-template type %qT used as a template"
 msgstr "ikke-skabelonstype '%T' benyttet som skabelon"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, fuzzy, gcc-internal-format
 #| msgid "for template declaration `%D'"
 msgid "for template declaration %q+D"
 msgstr "til skabelonserklæring '%D'"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "internal gcc abort"
 msgid "template constraint failure for %qD"
 msgstr "intern GCC-afbrydelse"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "use of invalid variable template %qE"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'"
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "skabelonsinstantieringsdybden overskrider maksimum på %d (benyt -ftemplate-depth-NN for at forøge maksimum) ved instantiering af '%D'"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "score argument must be constant integer expression"
 msgstr "sammenlign mellem signed og unsigned heltalsudtryk"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "score argument must be non-negative"
 msgstr "%s-roteringsantal er negativt"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "property must be constant integer expression"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template `%T'"
 msgid "instantiating erroneous template"
 msgstr "  i instantiering af skabelonen '%T'"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 msgid "first error appeared here"
 msgstr "  første type her"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "fleksibelt tabelmedlem i union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "'%s' er ikke ved begyndelsen af erklæringen"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot read function profile from %s."
 msgid "cannot index an empty pack"
 msgstr "kan ikke læse funktionsprofil fra %s."
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for `%#D'"
 msgid "  when instantiating default argument for call to %qD"
 msgstr "omdefinering af standardparameter for '%#D'"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member function of non-class type `%T'"
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "opretter henvisning til medlemsfunktion af typen '%T' der ikke er en klasse"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between types `%#T' and `%#T'"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -75556,139 +75663,139 @@ msgstr "sammenligning mellem typerne '%#T' og '%#T'"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 #| msgid "sizeof applied to a function type"
 msgid "variable %qD has function type"
 msgstr "sizeof benyttet på en funktionstype"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter type `%T'"
 msgid "invalid parameter type %qT"
 msgstr "ugyldig parametertype '%T'"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration `%D'"
 msgid "in declaration %q+D"
 msgstr "i erklæringen '%D'"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, fuzzy, gcc-internal-format
 #| msgid "function returns an aggregate"
 msgid "function returning an array"
 msgstr "funktion returnerer en værdi af en sammensat type"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' declared as function returning a function"
 msgid "function returning a function"
 msgstr "'%s' er erklæret som en funktion der returnerer en funktion"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "\"%s\" is not defined"
 msgid "%qE is not usable in a splice type"
 msgstr "\"%s\" er ikke defineret"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qE is not usable in a splice scope"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "danner reference til void"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type `%T'"
 msgid "forming pointer to reference type %qT"
 msgstr "danner %s til referencetypen '%T'"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type `%T'"
 msgid "forming reference to reference type %qT"
 msgstr "danner %s til referencetypen '%T'"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "forming pointer to qualified function type %qT"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "forming reference to qualified function type %qT"
 msgstr "ISO C forbyder funktionsreturtype med modifikationer"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type `%T'"
 msgid "creating pointer to member of non-class type %qT"
 msgstr "opretter henvisning til medlem af typen '%T' der ikke er en klasse"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type `%T'"
 msgid "creating pointer to member reference type %qT"
 msgstr "opretter henvisning til medlemsreference af typen '%T'"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type `%T'"
 msgid "creating pointer to member of type void"
 msgstr "opretter henvisning til medlemsreference af typen '%T'"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of `%T'"
 msgid "creating array of %qT"
 msgstr "opretter tabel af '%T'"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr "tabellen '%s' antages kun at have ét element"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class, struct, or union type"
 msgid "%qT is not a class, struct, or union type"
 msgstr "'%T' er ikke en class-, struct- eller union-type"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "unavngiven klargøring af '%T' som ikke har nogen stamklasser"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "unavngiven klargøring af '%T' som ikke har nogen stamklasser"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "empty body in an else-statement"
 msgid "expected a reflection of a type template"
 msgstr "tom krop i en else-sætning"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, fuzzy, gcc-internal-format
 #| msgid "use of `%s' in template"
 msgid "use of %qs in template"
@@ -75697,236 +75804,236 @@ msgstr "brug af '%s' i skabelon"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %D after first use"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "eksplicit specialisering af %D efter første brug"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 #| msgid "qualified type `%T' does not match destructor name `~%T'"
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "den modificerede type '%T' passer ikke til destruktionsfunktionsnavnet '~%T'"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, fuzzy, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "'%D' benyttes som en type, men er ikke defineret som en type"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, fuzzy, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "  (benyt 'typename %T::%D' hvis det er hvad du mener)"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "startværdielement er ikke en konstant"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of void expression"
 msgid "invalid use of pack expansion expression"
 msgstr "ugyldig brug af void-udtryk"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, fuzzy, gcc-internal-format
 #| msgid "non-empty initializer for array of empty elements"
 msgid "empty initializer in lambda init-capture"
 msgstr "en startværdi der ikke er tom, tildeles til en tabel med tomme elementer"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' undeclared here (not in a function)"
 msgid "%qD declared here, later in the translation unit"
 msgstr "'%s' ikke erklæret her (ikke i en funktion)"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to __builtin_choose_expr not a constant"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "første parameter til '__builtin_choose_expr' skal være en konstant"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for `%s' attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "forkert antal parametre angivet til egenskaben '%s'"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or namespace"
 msgid "%qT is not a class or namespace"
 msgstr "'%T' er ikke en klasse eller et navnerum"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or namespace"
 msgid "%qD is not a class or namespace"
 msgstr "'%T' er ikke en klasse eller et navnerum"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, fuzzy, gcc-internal-format
 #| msgid "missing static field `%s'"
 msgid "using invalid field %qD"
 msgstr "manglende statisk felt '%s'"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "skabelonsparameter '%T' benytter anonym type"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for `%#D' has type `%T'"
 msgid "template argument for %qD uses local type %qT"
 msgstr "standardparameter for '%#D' har typen '%T'"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, fuzzy, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "skabelonsparameter '%T' er en variabelt ændret type"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, fuzzy, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, fuzzy, gcc-internal-format
 #| msgid "  trying to instantiate `%D'"
 msgid "  trying to instantiate %qD"
 msgstr "  ved forsøg på at instantiere '%D'"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for `%#T'"
 msgid "ambiguous template instantiation for %q#T"
 msgstr "tvetydig klasseskabelonsinstantiering for '%#T'"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for `%#T'"
 msgid "ambiguous template instantiation for %q#D"
 msgstr "tvetydig klasseskabelonsinstantiering for '%#T'"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %+#D"
 msgid "%s %#qS"
 msgstr "%s %+#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template `%#D'"
 msgid "explicit instantiation of non-template %q#D"
 msgstr "eksplicit instantiering af ikke-skabelon '%#D'"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "'%#D' er ikke et statisk medlem af '%#T'"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, fuzzy, gcc-internal-format
 #| msgid "no matching template for `%D' found"
 msgid "no matching template for %qD found"
 msgstr "ingen passende skabelon for '%D' fundet"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type `%T'"
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "eksplicit instantiering af '%T' der ikke er en skabelonstype"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of `%#D'"
 msgid "explicit instantiation of %q#D"
 msgstr "eksplicit instantiering af '%#D'"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate explicit instantiation of `%#D'"
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "'%#D' er blevet eksplicit instantieret mere end én gang"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids the use of `extern' on explicit instantiations"
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ forbyder brugen af 'extern' ved eksplicitte instantieringer"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "storage class %qD applied to template instantiation"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template `%#D'"
 msgid "explicit instantiation of non-class template %qD"
 msgstr "eksplicit instantiering af ikke-skabelon '%#D'"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type `%T'"
 msgid "explicit instantiation of non-template type %qT"
 msgstr "eksplicit instantiering af '%T' der ikke er en skabelonstype"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of `%#T' before definition of template"
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "eksplicit instantiering af '%T' før definering af skabelonen"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids the use of `%s' on explicit instantiations"
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ forbyder brugen af '%s ved eksplicitte instantieringer"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate explicit instantiation of `%#T'"
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "'%#T' er blevet eksplicit instantieret mere end én gang"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %D after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "eksplicit specialisering af %D efter første brug"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "type specifier `%s' not allowed after struct or class"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -75939,177 +76046,177 @@ msgstr "typeangivelsen '%s' er ikke tilladt efter struct eller class"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of `%D' but no definition available"
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "eksplicit instantiering af '%D', men ingen definition tilgængelig"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "skabelonsinstantieringsdybden overskrider maksimum på %d (benyt -ftemplate-depth-NN for at forøge maksimum) ved instantiering af '%D'"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' is not a valid type for a template constant parameter"
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "'%#T' er ikke en gyldig type for en skabelonsparameterkonstant "
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "invalid template non-type parameter"
 msgstr "ugyldig catch-parameter"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' is not a valid type for a template constant parameter"
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "'%#T' er ikke en gyldig type for en skabelonsparameterkonstant "
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "bruger 'typename' uden for en skabelon"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be constrained"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a namespace"
 msgid "concept %qE not in namespace scope"
 msgstr "'%T' er ikke et navnerum"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of `%#T' inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "definition af '%#T' inden i skabelonsparameterliste"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, fuzzy, gcc-internal-format
 #| msgid "brace-enclosed initializer used to initialize `%T'"
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "startværdi i krøllede paranteser benyttet til at klargøre '%T'"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "ikke-skabelon benyttet som skabelon"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "#include nested too deeply"
 msgid "use %qD directly instead"
 msgstr "#include indlejret for dybt"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "class template argument deduction failed:"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "funktion overvejes ikke for indbygning"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "Ugyldig erklæring"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "skabelonsparameter %d er ugyldig"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid method declaration, return type required"
 msgid "unable to deduce lambda return type from %qE"
 msgstr "Ugyldig metodeerklæring, returtype påkrævet"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr ""
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "instruktion tilfredsstiller ikke sine begrænsninger:"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "instruktion tilfredsstiller ikke sine begrænsninger:"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -76117,378 +76224,441 @@ msgstr "instruktion tilfredsstiller ikke sine begrænsninger:"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new kan ikke bruges på en referencetype"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new kan ikke bruges på en funktionstype"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "ugyldig brug af skabelonstypeparameter"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "new kan ikke bruges på en funktionstype"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new kan ikke bruges på en funktionstype"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new kan ikke bruges på en funktionstype"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of `%s'"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "typen af den %d. parameter i '%s' passer ikke"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "'%T' er ikke et navnerum"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run `%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "kunne ikke køre '%s': %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "forventede %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run `%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "kunne ikke køre '%s': %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got `%E'"
 msgid "unexpected return type of %qs"
 msgstr "  forventede en type, modtog '%E'"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function template"
 msgid "%qT must be a function type"
 msgstr "'%D' er ikke en funktionsskabelon"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "uventet operand"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field `%D' with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "kan ikke erklære bitfelt '%D' med funktionstype"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "  oprindelig definition er her"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "ugyldig standardparameter i skabelon"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<decltype%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "forventede %<decltype%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "unexpected argument to %qs"
 msgstr "uventet operand"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of `%s'"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "typen af den %d. parameter i '%s' passer ikke"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for `%#D'"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "modstridende returtyper angivet for '%#D'"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for `%#D'"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "modstridende returtyper angivet for '%#D'"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function `%s'"
 msgid "unknown metafunction %qD"
 msgstr "ukendt specifikationsfunktion '%s'"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "splice argument must be an expression of type %qs"
 msgstr "startværdielement er ikke en konstant"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot disable built-in function `%s'"
+msgid "cannot splice a null reflection"
+msgstr "kan ikke deaktivere den indbyggede funktion '%s'"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use `::' in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "kan ikke bruge '::' i parametererklæring"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' was not declared in this scope"
 msgid "add %<constexpr%>"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, fuzzy, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "'%D' blev ikke erklæret i dette virkefelt"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared `auto'"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "'auto' er påhæftet funktionsdefinitionen"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "expected a reflection of an expression"
 msgstr "uventet adresseudtryk"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "bruger 'typename' uden for en skabelon"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace `%D' as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "brug af navnerummet '%D' som udtryk"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member `%#D' to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "kan ikke eksplicit erklære medlemmet '%#D' til at have extern-kædning"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "invalid cast to function type `%T'"
+msgid "invalid class member access of type template %qE"
+msgstr "ugyldig omtvingelse til funktionstypen '%T'"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can%'t use %qs as a call-used register"
+msgid "cannot use %qE to access a class member"
+msgstr "kan ikke bruge %qs som et kald-brugt register"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 #| msgid "use of %s from containing function"
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "brug af %s fra indeholdende funktion"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "`%D' is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "'%D' er ikke en funktionsskabelon"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -76861,640 +77031,640 @@ msgstr "ugyldig definition af modificeret type '%T'"
 msgid "invalid base-class specification"
 msgstr "ugyldig stamklasseangivelse"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 #| msgid "protected member `%#D' in anonymous union"
 msgid "cannot capture member %qD of anonymous union"
 msgstr "beskyttet medlem '%#D' i en anonym union"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' not declared"
 msgid "%qD is not captured"
 msgstr "'%D' ikke erklæret"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "use of %s from containing function"
 msgid "use of local variable with automatic storage from containing function"
 msgstr "brug af %s fra indeholdende funktion"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, fuzzy, gcc-internal-format
 #| msgid "use of %s from containing function"
 msgid "use of parameter from containing function"
 msgstr "brug af %s fra indeholdende funktion"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "use of %s from containing function"
 msgid "use of parameter outside function body"
 msgstr "brug af %s fra indeholdende funktion"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, fuzzy, gcc-internal-format
 #| msgid "use of class template `%T' as expression"
 msgid "use of class template %qT as expression"
 msgstr "brug af klasseskabelonen '%T' som udtryk"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "request for member `%D' is ambiguous in multiple inheritance lattice"
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "forespørgsel efter medlemmet '%D' er tvetydigt i det multiple nedarvningsnet"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, fuzzy, gcc-internal-format
 #| msgid "type of `%E' is unknown"
 msgid "type of %qE is unknown"
 msgstr "typen af '%E' er ukendt"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not an enumeration type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "størrelsen af tabel er ikke af en heltalstype"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "pack index is not an integral constant"
 msgstr "tabelindeks er ikke et heltal"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "pack index %qE is negative"
 msgstr "højreskiftsantal er negativ"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "lagringsklasseanvisninger er ugyldige i parametererklæringer"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "ugyldig brug af ikke-statisk felt '%D'"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "ugyldig brug af ikke-statisk felt '%D'"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "ugyldig brug af ikke-statisk felt '%D'"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "trampolines not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "trampoliner understøttes ikke"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %+#D"
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "invalid return type for function `%#D'"
 msgid "%qE has const type for %<reduction%>"
 msgstr "ugyldig returtype for funktionen '%#D'"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "erklæring af '%s' der er en 'extern'-variabel, i begyndelseserklæring i 'for'-løkke"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qD is not a variable in clause %qs"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared private"
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "instansvariablen '%s' er erklæret privat"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared private"
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "instansvariablen '%s' er erklæret privat"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<gang%> static expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%<gang%> static value must be positive"
 msgstr "%s-roteringsantal er negativt"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<gang%> num expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<vector%> length expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<worker%> num expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "%<vector%> length value must be positive"
 msgstr "angivet justering er ikke en potens af 2"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 #| msgid "left argument must be a slice"
 msgid "%<worker%> num value must be positive"
 msgstr "venstre parameter skal være en skive"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in map clauses"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD fremgår mere end en gang i map-klausuller"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in map clauses"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD fremgår mere end en gang i map-klausuller"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "\"%s\" cannot be used as a macro name as it is an operator in C++"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "\"%s\" kan ikke bruges som et makronavn da det er en operator i C++"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when a variable is unused"
 msgid "variable length traits arrays are not supported"
 msgstr "Advar når en variabel ikke benyttes"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is not a valid class name"
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "'%s' er et ugyldigt klassenavn"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "template %qE in clause %qs"
 msgstr "for mange inddatafiler"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<grainsize%> expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<priority%> expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<hint%> expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "%<filter%> expression must be integral"
 msgstr "udsagn skal være et kaldenavn"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "slice end must be integer"
 msgid "%<tile%> argument needs integral type"
 msgstr "skive-slutning skal være heltal"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "overløb i konstant udtryk"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, fuzzy, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr "konverterer NULL til en ikke-henvisningstype"
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "verification error at PC=%d"
 msgid "static assertion failed: %.*s"
 msgstr "verifikationsfejl ved PC=%d"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, fuzzy, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "erklæring uden static af '%s' følger static-erklæring"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "use of class template `%T' as expression"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "brug af klasseskabelonen '%T' som udtryk"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%s kan ikke finde adressen af flertydiggjort funktion"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a class or union type"
 msgid "%qT is not a non-union class type"
 msgstr "'%T' er ikke af en klasse- eller union-type"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "`__builtin_next_arg' called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "`__builtin_next_arg' kaldt uden en parameter"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "`__builtin_next_arg' called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "`__builtin_next_arg' kaldt uden en parameter"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a field reference"
 msgid "%qs argument %qT is a reference"
 msgstr "parameter skal være en feltreference"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qD is not a class or alias template"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "venstreoperanden til kommaudtrykket har ingen virkning"
 
 # flertalsform unødvendig
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument `%E' involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "skabelonsparameter '%E' involverer skabelonsparameter"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second arg to `__builtin_prefetch' must be a constant"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -77503,384 +77673,384 @@ msgstr "den anden parameter til '__builtin_prefetch' skal være en konstant"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "new kan ikke bruges på en funktionstype"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, fuzzy, gcc-internal-format
 #| msgid "`%V' qualifiers cannot be applied to `%T'"
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "modifikationerne '%V' kan ikke anvendes på '%T'"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "  `%#D' declared here"
 msgid " declared here"
 msgstr "  '%#D' erklæret her"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, fuzzy, gcc-internal-format
 #| msgid "assignment (not initialization) in declaration"
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "tildeling (ikke klargøring) i erklæring"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is a floating-point type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "'%D' er ikke et medlem af '%T'"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "`%#T' has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "'%#T' har henvisningsdatamedlemmer"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between `%#T' and `%#T'"
 msgid "padding occurs between %qD and %qD"
 msgstr "sammenligning mellem '%#T' og '%#T'"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "\"%s\" er ikke et ugyldigt filnavn"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class `%T' has incomplete type"
 msgid "base class %qT is not public"
 msgstr "stamklasse '%T' er af en ufuldstændig type"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' not declared"
 msgid "%qD is not public"
 msgstr "'%D' ikke erklæret"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a namespace"
 msgid "%qD is mutable"
 msgstr "'%D' er ikke et navnerum"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template"
 msgid "%qD has a non-structural type"
 msgstr "'%T' er ikke en skabelon"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "parameteren til egenskaben '%s' er ikke en strengkonstant"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to Java class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "egenskaben '%s' kan kun anvendes med Java-klassedefinitioner"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "%qE attribute takes no arguments"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to functions"
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktioner"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "Ugyldig erklæring"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a template type"
 msgid "%<alignas%> on enumerated type"
 msgstr "'%T' er ikke en skabelonstype"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "`__alignof' applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "'__alignof' benyttet på et bitfelt"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "størrelse i tabel-new skal være en heltalstype"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 #| msgid "`__alignof' applied to a bit-field"
 msgid "%qE on unnamed bit-field"
 msgstr "'__alignof' benyttet på et bitfelt"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "den udbedte init_priority er ikke en heltalskonstant"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, fuzzy, gcc-internal-format
 #| msgid "can only use `%s' attribute on file-scope definitions of objects of class type"
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "kan kun bruge egenskaben '%s' på filvirkefeltsdefinitioner af objekter af klassetype"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "den udbedte init_priority er uden for det gyldige interval"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "den udbedte init_priority er reserveret til intern brug"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of `%D' as %s"
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "erklæring af '%D' som %s"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute requires an integer constant argument"
 msgid "the %qE attribute requires arguments"
 msgstr "egenskaben '%s' kræver en heltalskonstant som parameter"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 #| msgid "argument of `%s' attribute is not a string constant"
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "parameteren til egenskaben '%s er ikke en strengkonstant"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 #| msgid "argument of `%s' attribute is not a string constant"
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "parameteren til egenskaben '%s er ikke en strengkonstant"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "'%T::%D' er ikke en gyldig erklærer"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a valid expression"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "'%T' er ikke et gyldigt udtryk"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute only applies to function types"
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "egenskaben '%s' kan kun anvendes sammen med funktionstyper"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute can only be applied to class definitions"
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 #| msgid "storage class `%D' applied to template instantiation"
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "lagringsklasse '%D' anvendt på skabelonsinstantiering"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 #| msgid "comparison is always false due to limited range of data type"
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "sammenligning er altid falsk på grund af den begrænsede rækkevidde af datatypen"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about implicit function declarations"
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "Advar om underforståede funktionserklæringer"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "`sizeof' applied to a bit-field"
 msgid "annotation applied to a label"
 msgstr "'sizeof' benyttet på et bitfelt"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 #| msgid "`__alignof' applied to a bit-field"
 msgid "annotation on unnamed bit-field"
 msgstr "'__alignof' benyttet på et bitfelt"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter"
 msgid "annotation on void parameter"
 msgstr "en parameter"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "funktionen returnerer ikke en strengtype"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -78102,903 +78272,909 @@ msgstr "'%D' har intet medlem ved navn '%E'"
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "'%D' har intet medlem ved navn '%E'"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, fuzzy, gcc-internal-format
 #| msgid "`%D::%D' is not a member of `%T'"
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "'%D::%D' er ikke et medlem af '%T'"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "`%D' is not a member of `%T'"
+msgid "%q#D is not a member of %qT"
+msgstr "'%D' er ikke et medlem af '%T'"
+
+#: cp/typeck.cc:3781
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member template function"
 msgid "%qD is not a member template function"
 msgstr "'%D' er ikke en medlemsskabelonfunktion"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, fuzzy, gcc-internal-format
 #| msgid "`%T' is not a pointer-to-object type"
 msgid "%qT is not a pointer-to-object type"
 msgstr "'%T' er ikke af en henvisning til objekt-type"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%s' on pointer to member"
 msgid "invalid use of array indexing on pointer to member"
 msgstr "ugyldig brug af '%s' på henvisning til medlem"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%s' on pointer to member"
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "ugyldig brug af '%s' på henvisning til medlem"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of `%s' on pointer to member"
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "ugyldig brug af '%s' på henvisning til medlem"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "indeks mangler i tabelopslag"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, fuzzy, gcc-internal-format
 #| msgid "subscripting array declared `register'"
 msgid "subscripting array declared %<register%>"
 msgstr "indeksering af tabel som er erklæret 'register'"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "værdien der er påført et indeks, er hverken en tabel eller en henvisningsvariabel"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, fuzzy, gcc-internal-format
 #| msgid "object missing in use of `%E'"
 msgid "object missing in use of %qE"
 msgstr "objekt mangler i brug af '%E'"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "Generate default single-precision SH4 code"
 msgid "no default version in scope"
 msgstr "Opret standardkode for enkelpræcision SH4"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids calling `::main' from within program"
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ forbyder kald af '::main' inde fra programmet"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, fuzzy, gcc-internal-format
 #| msgid "must use .* or ->* to call pointer-to-member function in `%E (...)'"
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "brug .* eller ->* i kald af henvisning til medlemsfunktion i '%E (...)'"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "'%E' kan ikke bruges som en funktion"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' cannot be used as a function"
 msgid "%qE cannot be used as a function"
 msgstr "'%E' kan ikke bruges som en funktion"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' cannot be used as a function"
 msgid "%qD cannot be used as a function"
 msgstr "'%E' kan ikke bruges som en funktion"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 #| msgid "`%E' cannot be used as a function"
 msgid "expression cannot be used as a function"
 msgstr "'%E' kan ikke bruges som en funktion"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "too many arguments to constructor %q#D"
 msgstr "for mange parametre til %s '%+#D'"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s `%+#D'"
 msgid "too few arguments to constructor %q#D"
 msgstr "for få parametre til %s '%+#D'"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments to member function %q#D"
 msgstr "for mange parametre til funktionen"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to member function %q#D"
 msgstr "for få parametre til funktionen"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function"
 msgid "too many arguments to function %q#D"
 msgstr "for mange parametre til funktionen"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function"
 msgid "too few arguments to function %q#D"
 msgstr "for få parametre til funktionen"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "too many arguments to method %q#D"
 msgstr "for mange parametre til %s '%+#D'"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s `%+#D'"
 msgid "too few arguments to method %q#D"
 msgstr "for få parametre til %s '%+#D'"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "for mange parametre til funktionen"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "for få parametre til funktionen"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, fuzzy, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "parameteren '%s' er af en ufuldstændig type"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, fuzzy, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "parameteren er af en ufuldstændig type"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "operander til ?: har forskellige typer"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types `%T' and `%T' lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "%s mellem forskellige henvisningstyper '%T' og '%T' mangler en typeomtvingelse"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "operander til ?: har forskellige typer"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types `%T' and `%T' lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "%s mellem forskellige henvisningstyper '%T' og '%T' mangler en typeomtvingelse"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "complex arguments must have floating-point type"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "komplekse parametre skal have kommatalstype"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "%s from incompatible pointer type"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "%s fra en henvisningstype der ikke er forenelig med målets"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "overløb i konstant udtryk"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of `%T' to `%T'"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "uforenelige typer i tildeling af '%T' til '%T'"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, fuzzy, gcc-internal-format
 #| msgid "assuming cast to type `%T' from overloaded function"
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "antager typeomtvingning til typen '%T' fra flertydig funktion"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL benyttet i udregning"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ forbyder sammenligning mellem henvisningsvariabel og heltal"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "ordnet sammenligning af henvisning med heltallet nul"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "uordnet sammenligning af ikke-kommatalsparameter"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "konvertering fra NaN til unsigned int"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands of types `%T' and `%T' to binary `%O'"
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "ugyldige operander af typerne '%T' og '%T' til binær '%O'"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids using pointer of type `void *' in subtraction"
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ forbyder brug af henvisning af typen 'void *' i fratrækning"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ forbyder brug af henvisning til funktion i fratrækning"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ forbyder brug af henvisning til medlemsfunktion i fratrækning"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "ugyldig brug af en henvisning til en ufuldstændig type i henvisningsberegning"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor"
 msgid "taking address of constructor %qD"
 msgstr "tager adressen på en destruktionsfunktion"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor"
 msgid "taking address of destructor %qD"
 msgstr "tager adressen på en destruktionsfunktion"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of '%E' to form a pointer-to-member-function.  Use a qualified-id."
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "ugyldig brug af '%E' til at danne en henvisning til medlemsfunktion; benyt et kaldenavn med klassepræfiks"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, fuzzy, gcc-internal-format
 #| msgid "parenthesis around '%E' cannot be used to form a pointer-to-member-function"
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "paranteser omkring '%E' kan ikke bruges til at danne en henvisning til medlemsfunktion"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, fuzzy, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ forbyder at tage adressen på en ikke-modificeret, ikke-statisk medlemsfunktion for at danne en henvisning til medlemsfunktion; brug '&%T::%D'"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ forbyder at tage adressen på en ikke-modificeret, ikke-statisk medlemsfunktion for at danne en henvisning til medlemsfunktion; brug '&%T::%D'"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say `&%T::%D'"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ forbyder at tage adressen på en bundet medlemsfunktion for at danne en henvisning til medlemsfunktion; brug '&%T::%D'"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say `&%T::%D'"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ forbyder at tage adressen på en bundet medlemsfunktion for at danne en henvisning til medlemsfunktion; brug '&%T::%D'"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with `&%E')"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(en henvisning til medlem kan kun dannes med '&%E')"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "tager adressen på midlertidig variabel"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking address of function `::main'"
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ forbyder at tage adressen på funktionen '::main'"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, fuzzy, gcc-internal-format
 #| msgid "cannot create pointer to reference member `%D'"
 msgid "cannot create pointer to reference member %qD"
 msgstr "kan ikke oprette henvisning til reference medlemmet '%D'"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field `%s'"
 msgid "attempt to take address of bit-field"
 msgstr "kan ikke finde adressen af bitfeltet '%s'"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "tager adressen på midlertidig variabel"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ forbyder %s af en enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ forbyder %s af en enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type `%T'"
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "kan ikke %s en henvisning til en ufuldstændig type '%T'"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type `%T'"
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "kan ikke %s en henvisning til en ufuldstændig type '%T'"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing a pointer of type `%T'"
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ forbyder %s af en henvisning af typen '%T'"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing a pointer of type `%T'"
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ forbyder %s af en henvisning af typen '%T'"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, fuzzy, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr "ISO C forbyder brug af typeomtvingningsudtryk som venstreværdier"
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of `this', which is an rvalue expression"
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "kan ikke tage adressen af 'this' som er et højreværdiudtryk"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, fuzzy, gcc-internal-format
 #| msgid "address requested for `%D', which is declared `register'"
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "adresse forespurgt for '%D' som er erklæret 'register'"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "static_cast fra typen '%T' til typen '%T' fjerner konstanthed"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "static_cast fra typen '%T' til typen '%T' fjerner konstanthed"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from `%T' to `%T' casts away const (or volatile)"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "reinterpret_cast fra '%T' til '%T' fjerner const (eller volatile)"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "skabelonsparameter '%T' benytter lokal type '%T'"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "typemodifikationer ignoreret i funktionsreturtypen"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type `%T' to type `%T'"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "ugyldig static_cast fra typen '%T' til typen '%T'"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 #| msgid "return type `%#T' is incomplete"
 msgid "class type %qT is incomplete"
 msgstr "returtype '%#T' er ufuldstændig"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from `%T' to `%T'"
 msgid "converting from %qH to %qI"
 msgstr "konvertering fra '%T' til '%T'"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "ugyldig reinterpret_cast af et højreværdiudtryk fra typen '%T' til typen '%T'"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "reinterpret_cast from `%T' to `%T' loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "reinterpret_cast fra '%T' til '%T' mister præcision"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "%s mellem forskellige henvisningstyper '%T' og '%T' mangler en typeomtvingelse"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from `%T' to `%T' increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "typeomtvingning fra '%T' til '%T' forøger den påkrævede justering af målets type"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ forbyder sammenligninger mellem henvisning til funktion og henvisning til objekt"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type `%T' to type `%T'"
 msgid "invalid cast from type %qT to type %qT"
 msgstr "ugyldig const_cast fra typen '%T' til typen '%T'"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "ugyldig brug af const_cast med typen '%T' som ikke er en henvisnings-, reference- eller en henvisning til datamedlem-type"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type `%T', which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "ugyldig brug af const_cast med typen '%T' som er en henvisning eller reference til funktion"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type `%T' to type `%T'"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "ugyldig const_cast af en højreværdi fra typen '%T' til typen '%T'"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type `%T' to type `%T'"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "ugyldig const_cast fra typen '%T' til typen '%T'"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting to an array type `%T'"
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ forbyder omtvingelse af typen til en tabeltype '%T'"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type `%T'"
 msgid "invalid cast to function type %qT"
 msgstr "ugyldig omtvingelse til funktionstypen '%T'"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert `%E' from type `%T' to type `%T'"
 msgid "moving %qE of type %qT to itself"
 msgstr "kan ikke konvertere '%E' fra typen '%T' til typen '%T'"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, fuzzy, gcc-internal-format
 #| msgid "  in evaluation of `%Q(%#T, %#T)'"
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  i evaluering af '%Q(%#T, %#T)'"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "assigning to an array from an initializer list"
 msgstr "tabelindekset i startværdien er ikke en konstant"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of `%T' to `%T'"
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "uforenelige typer i tildeling af '%T' til '%T'"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 #| msgid "bad array initializer"
 msgid "array used as initializer"
 msgstr "ugyldig tildeling af startværdi til tabel"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "invalid array assignment"
 msgstr "ugyldig venstreværdi i tildeling"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   i henvisning til medlemsfunktion-omdannelse"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, fuzzy, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "henvisning til medlem-omdannelse via den virtuelle stamklasse '%T' af '%T'"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   i henvisning til medlem-omdannelse"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to type `%T' from type `%T'"
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "ugyldig omdannelse til typen '%T' fra typen '%T'"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 #| msgid "cannot convert `%T' to `%T' for argument `%P' to `%D'"
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "kan ikke konvertere '%T' til '%T' for parameter '%P' til '%D'"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "kan ikke konvertere '%T' til '%T' i %s"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "kan ikke konvertere '%T' til '%T' i %s"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "cannot convert %qH to %qI in return"
 msgstr "kan ikke konvertere '%T' til '%T' i %s"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 #| msgid "cannot convert `%T' to `%T' in %s"
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "kan ikke konvertere '%T' til '%T' i %s"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about functions which might be candidates for format attributes"
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "Advar om funktioner som kan være kandidater til formateringsegenskaber"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 #| msgid "function might be possible candidate for `%s' format attribute"
 msgid "parameter might be a candidate for a format attribute"
 msgstr "funktion er en mulig kandidat til '%s'-formateringsegenskab"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about functions which might be candidates for format attributes"
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "Advar om funktioner som kan være kandidater til formateringsegenskaber"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 #| msgid "function might be possible candidate for `%s' format attribute"
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "funktion er en mulig kandidat til '%s'-formateringsegenskab"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 #| msgid "function might be possible candidate for `%s' format attribute"
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "funktion er en mulig kandidat til '%s'-formateringsegenskab"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of `%+D'"
 msgid "in passing argument %P of %qD"
 msgstr "i overbringelse af parameter %P af '%+D'"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "returnerer reference til midlertidig variabel"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "returnerer reference til midlertidig variabel"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable `%D' returned"
 msgid "reference to local variable %qD returned"
 msgstr "reference til den lokale variabel '%D' returneret"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable `%D' returned"
 msgid "address of label %qD returned"
 msgstr "adresse af den lokale variabel '%D' returneret"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable `%D' returned"
 msgid "address of local variable %qD returned"
 msgstr "adresse af den lokale variabel '%D' returneret"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "too many 'l' suffixes in integer constant"
 msgid "redundant move in return statement"
 msgstr "for mange 'l'-endelser i heltalskonstant"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "too many 'l' suffixes in integer constant"
 msgid "redundant move in initialization"
 msgstr "for mange 'l'-endelser i heltalskonstant"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "returnerer en værdi fra en destruktionsfunktion"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "kan ikke returnere fra en håndtering af en funktions-try-blok i en konstruktionsfunktion"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "returnerer en værdi fra en konstruktionsfunktion"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, fuzzy, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "'return' uden nogen værdi i en funktion der ikke returnerer void"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "returning initializer list"
 msgstr "manglende startværdi"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, fuzzy, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "new kan ikke bruges på en referencetype"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "'return' uden nogen værdi i en funktion der ikke returnerer void"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "'operator new' må ikke returnere NULL medmindre den er erklæret 'throw()' (eller -fcheck-new er benyttet)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for `%#D'"
 msgid "not eliding copy on return from %qD"
 msgstr "ugyldig kovariant returneringstype for '%#D'"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s value"
 msgid "using rvalue as lvalue"
@@ -79470,18 +79646,18 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown attribute %qs"
 msgstr "ukendt registernavn: %s"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "'%s' er erklæret inline efter at være blevet kaldt"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -79508,47 +79684,47 @@ msgstr "manglende startværdi for medlemmet '%D'"
 msgid "the address of %qD will never be %<null%>"
 msgstr "adressen af '%D' vil altid være 'true'"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to `%#T'"
 msgid "cannot get frame pointer to %qs"
 msgstr "kan ikke erklære henvisning til '%#T'"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "Gem funktionsnavne i objektkode"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is neither function nor member function; cannot be declared friend"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "'%s' er hverken en almindelig funktion eller en medlemsfunktion; kan ikke erklæres som friend"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable `%s' used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "registervariabel '%s' benyttet i indlejret funktion"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "forming reference to void"
 msgid "forward reference to frame of %qs"
@@ -79640,34 +79816,34 @@ msgstr "ugyldig typeparameter"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "ugyldig typeparameter"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "kan ikke åbne %s til skrivning: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "åbner uddatafilen %s"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "kan ikke åbne %s til skrivning: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "åbner afhængighedsfilen %s"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -79776,7 +79952,7 @@ msgstr "ukendt tls-model %qs"
 msgid "%qs is not an associative array"
 msgstr "\"%s\" er ikke defineret"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -79791,25 +79967,25 @@ msgstr "'%s' er normalt en ikke-statisk funktion"
 msgid "%qs is not a field, but a %qs"
 msgstr "%s understøtter ikke %s"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to `%#T'"
 msgid "recursive reference %qs"
 msgstr "kan ikke erklære reference til '%#T'"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "overløb i konstant udtryk"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%qs is not an expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "type %qs is not an expression"
@@ -79911,17 +80087,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "integrerede kommatalskonstanter er ikke understøttede på denne vært"
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -80265,8 +80441,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -80557,7 +80733,7 @@ msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid suffix on integer constant"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -80643,7 +80819,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr ""
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -80794,7 +80970,7 @@ msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr ""
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "different type"
 msgid "Different type kinds at %L"
@@ -80810,7 +80986,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr ""
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr ""
@@ -80960,8 +81136,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -81065,9 +81241,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -81082,12 +81258,12 @@ msgstr ""
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr ""
@@ -81189,640 +81365,640 @@ msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "'%s' skal tage mod to parametre"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 #| msgid "missing argument to `%s' option"
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "der mangler en parameter til tilvalget '%s'"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "for få parametre til funktionen '%s'"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "different type"
 msgid "Different character kinds at %L"
 msgstr "anden type"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr ""
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr ""
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr ""
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr ""
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr ""
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr ""
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to `%s' must be a 2-bit unsigned literal"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant uden fortegn"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr ""
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr ""
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr ""
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr ""
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr ""
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr ""
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr ""
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr ""
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr ""
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr ""
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr ""
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr ""
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr ""
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' is not a function template"
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "'%D' er ikke en funktionsskabelon"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "for mange parametre til %s '%+#D'"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s `%+#D'"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "for få parametre til %s '%+#D'"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr ""
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr ""
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr ""
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "Too many arguments to %s at %L"
 msgstr "for mange parametre til %s '%+#D'"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "forkert antal skabelonsparametre (%d, skulle være %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "different type"
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "anden type"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr ""
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -81890,12 +82066,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -81950,2175 +82126,2175 @@ msgstr ""
 msgid "Simplification error"
 msgstr "omerklæring af '%#D'"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid initializer for virtual method `%D'"
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "ugyldig startværdi til virtuel medlemsfunktion '%D'"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid initializer for virtual method `%D'"
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "ugyldig startværdi til virtuel medlemsfunktion '%D'"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "Empty old style initializer list at %C"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "overskydende elementer i skalarstarværdi"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "two `u's in integer constant"
 msgid "Repeat spec must be an integer at %C"
 msgstr "to 'u'-endelser i heltalskonstant"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "objekt mangler i brug af '%E'"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "End of scalar initializer expected at %C"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "for mange elementer i tabelstartværdi"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "for mange elementer i tabelstartværdi"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr ""
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Zero-length character constant at %0"
 msgid "Old-style character length at %C"
 msgstr "Nul-længde tegnkonstant ved %0"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in method specification"
 msgid "Syntax error in character length specification at %C"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in `%T'"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "'%D' er allerede defineret i '%T'"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in `%T'"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "'%D' er allerede defineret i '%T'"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "External procedure `%A' is passed as actual argument at %0 but not explicitly declared EXTERNAL"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Ekstern procedure '%A' er overbragt som faktisk parameter ved %0, men ikke eksplicit erklæret EXTERNAL"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 #| msgid "Symbols have a leading underscore"
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Symboler har en indledende understreg"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "two `u's in integer constant"
 msgid "CHARACTER length must be a constant at %L"
 msgstr "to 'u'-endelser i heltalskonstant"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing initializer"
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "manglende startværdi"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize multi-dimensional array with initializer"
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "kan ikke klargøre multidimensional tabel med startværdi"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize multi-dimensional array with initializer"
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "kan ikke klargøre multidimensional tabel med startværdi"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "base initializer for `%T'"
 msgid "Bad shape of initializer at %L"
 msgstr "stamklasseklargøring for '%T'"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot create pointer to reference member `%D'"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "kan ikke oprette henvisning til reference medlemmet '%D'"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in `%T'"
 msgid "Component %qs at %C already declared at %L"
 msgstr "'%D' er allerede defineret i '%T'"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can't match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "en parameterliste med '...' passer ikke til en erklæring med en tom parameterliste"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization designators may not nest"
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "klargøringstegn må ikke indlejres"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "Error in pointer initialization at %C"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "non-NULL pointer initialization at %C"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, fuzzy, gcc-internal-format
 #| msgid "INTENT is not allowed inside of BLOCK at %C"
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "INTENT er ikke tilladt i BLOCK ved %C"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "`-%c' option must have argument"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "tilvalget '-%c' skal have en parameter"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "invalid character '%c' in #if"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "ugyldigt tegn '%c' i #if"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr ""
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Zero-size array at %0"
 msgid "Implied-shape array at %L"
 msgstr "Nulstørrelsestabel ved %0"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in method specification"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot read function profile from %s."
 msgid "Cannot set pointee array spec."
 msgstr "kan ikke læse funktionsprofil fra %s."
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "Old-style initialization at %C"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr ""
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Expected an initialization expression at %C"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Jweak declaration of '%D' not supported"
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "%Jsvag erklæring af '%D' ikke understøttet"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "nested extern declaration of `%s'"
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "indlejret extern-erklæring af '%s'"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing formal parameter term"
 msgid "Missing right parenthesis at %C"
 msgstr "Manglende formel parameterterm"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Expected initialization expression at %C"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Expected scalar initialization expression at %C"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "rounding mode not supported for VAX floats"
 msgid "Kind %d not supported for type %s at %C"
 msgstr "afrundingstilstand er ikke understøttet for VAX-kommatal"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "rounding mode not supported for VAX floats"
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "afrundingstilstand er ikke understøttet for VAX-kommatal"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Structure name expected after RECORD at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' cannot have default arguments"
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "'%D' kan ikke have standardparametre"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type argument"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "ugyldig typeparameter"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type argument"
 msgid "Malformed type-spec at %C"
 msgstr "ugyldig typeparameter"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing comma in FORMAT statement at %0"
 msgid "IMPORT statement at %C"
 msgstr "Manglende komma i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr "Planlæg ikke begyndelsen og slutningen af proceduren"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Conflicting I/O control specifications at %0 and %1"
 msgid "Missing codimension specification at %C"
 msgstr "Modstridende I/O-kontrolangivelser ved %0 og %1"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing %A specifier in statement at %0"
 msgid "Missing dimension specification at %C"
 msgstr "Manglende %A-angivelse i sætning ved %0"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate ConstantValue attribute for field '%s'"
 msgid "Duplicate %s attribute at %L"
 msgstr "mere end én ConstantValue-egenskab for feltet '%s'"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "egenskaben '%s' kan kun anvendes med klassedefinitioner"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "en global registervariabel følger en funktionsdefinition"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr ""
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "Missing term"
 msgid "Missing symbol"
 msgstr "Manglende term"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr ""
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong type argument to %s"
 msgid "Alternate-return argument at %C"
 msgstr "forkert parametertype til %s"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "skabelonsparameter er påkrævet for '%T'"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Planlæg ikke begyndelsen og slutningen af proceduren"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't specify array dimension in a declaration"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Kan ikke angive tabeldimension i en erklæring"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "conflicts with function declaration `%#D'"
 msgid "Unexpected junk after function declaration at %C"
 msgstr "strider mod funktionserklæring '%#D'"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "sektionsegenskaben kan ikke angives for lokale variabler"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "ENTRY statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "ENTRY-sætning ved %C kan ikke fremgå i en STRUCTURE-blok"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing first operand for binary operator at %0"
 msgid "Missing closing paren for binding label at %C"
 msgstr "Manglende første operand for binær operator ved %0"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected END statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "No label definition for FORMAT statement at %0"
 msgid "END statement instead of %s statement at %L"
 msgstr "Ingen etiketdefinition for FORMAT-sætning ved %0"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "%s-udtryk forventet ved %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Expecting %s statement at %L"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate label `%s' in switch statement"
 msgid "Expected label %qs for %s statement at %C"
 msgstr "mere end én '%s'-etiket i switch-sætningen"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing %A specifier in statement at %0"
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Manglende %A-angivelse i sætning ved %0"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "predicate must be an identifier"
 msgid "Cray pointer at %C must be an integer"
 msgstr "udsagn skal være et kaldenavn"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
 msgstr "kan ikke konverteres til en henvisningstype"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT er ikke tilladt i BLOCK ved %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "OPTIONAL er ikke tilladt i BLOCK ved %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Syntaksfejl i PROTECTED-udtryk ved %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Access specifier or PRIVATE statement at %0 invalid for derived-type definition within other than the specification part of a module"
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "Tilgangsangivelse eller PRIVATE-sætning ved %0 er ugyldig for nedarvet typedefinition som ikke er i specifikationsdelen af et modul"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Access specifier or PRIVATE statement at %0 invalid for derived-type definition within other than the specification part of a module"
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "Tilgangsangivelse eller PRIVATE-sætning ved %0 er ugyldig for nedarvet typedefinition som ikke er i specifikationsdelen af et modul"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious sign in FORMAT statement at %0"
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Mystisk fortegn i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initializing array with parameter list"
 msgid "Initializing already initialized variable at %C"
 msgstr "klargør tabel med en parameterliste"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "VALUE statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "VOLATILE statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "forward declaration of `%#T'"
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "forhåndserklæring af '%#T'"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at `%D' because it has a destructor"
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "  kan ikke bruge forældet binding til '%D' fordi den har en destruktionsfunktion"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr ""
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in `%T'"
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "'%D' er allerede defineret i '%T'"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Junk after MAP statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Junk after UNION statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing structure name for outer structure definition at %0"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Manglende strukturnavn for ydre strukturdefinition ved %0"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "Type name at %0 not the same as name at %1"
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Typenavn ved %0 er ikke det samme som navn ved %1"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "empty declaration"
 msgid "Mangled derived type definition at %C"
 msgstr "tom erklæring"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 #| msgid "Type name at %0 not the same as name at %1"
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Typenavn ved %0 er ikke det samme som navn ved %1"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 #| msgid "Type name at %0 not the same as name at %1"
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Typenavn ved %0 er ikke det samme som navn ved %1"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr ""
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "type name expected before `*'"
 msgid "ENUM definition statement expected before %C"
 msgstr "der forventedes et typenavn før '*'"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "multiple access specifiers"
 msgid "Duplicate access-specifier at %C"
 msgstr "mere end én tilgangsangivelse"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Forventede tilgangsangivere ved %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Forventede bindingattribut ved %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NON_OVERRIDABLE and DEFERRED can't both appear at %C"
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE og DEFERRED kan ikke begge vises ved %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "%<)%> forventet ved %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "PROCEDURE-liste ved %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%<=> target%> er ugyldig for DEFERRED-binding ved %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "Forventede %<::%> ved %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Forventede generisk navn elelr operatordeskriptor ved %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Forkert udformet GENERIC-udtryk ved %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "Forventede %<=>%> ved %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "ukendt registernavn: %s"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected access-specifier at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Forventede tilgangsangivere ved %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "Unknown procedure name %qs at %C"
 msgstr "ukendt registernavn: %s"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is already defined in `%T'"
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "'%D' er allerede defineret i '%T'"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "\"%s\" må ikke optræde i makroparameterliste"
@@ -84266,422 +84442,422 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr "Manglende komma i FORMAT-sætning ved %0"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing operand for operator at %1 at end of expression at %0"
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Manglende operand for operator ved %1 i slutningen af udtryk ved %0"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing operand for operator at %1 at end of expression at %0"
 msgid "Numeric operands are required in expression at %L"
 msgstr "Manglende operand for operator ved %1 i slutningen af udtryk ved %0"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr ""
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr ""
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 #| msgid "double quoted strings not allowed in #if expressions"
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "strenge med dobbelte anførselstegn er ikke tilladte i #if-udtryk"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "Funktion %qs ved %L skal være PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter `%T' after `%s'"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "bruger skabelonstypeparameter '%D' efter '%s'"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs ved %L er ikke en VÆRDI"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "incompatible types in assignment of `%T' to `%T'"
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "uforenelige typer i tildeling af '%T' til '%T'"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "incompatible types in assignment of `%T' to `%T'"
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "uforenelige typer i tildeling af '%T' til '%T'"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 #| msgid "Array or substring specification for `%A' out of range in statement at %0"
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Tabel- eller understrengsangivelse for '%A' er uden for det gyldige interval i sætning ved %0"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "ugyldig venstreværdi i tildeling"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "Statement at %0 invalid in context established by statement at %1"
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Sætning ved %0 er ugyldig i den kontekst der er etableret af sætning ved %1"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr ""
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "ugyldig venstreværdi i tildeling"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -84689,201 +84865,201 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "pointer/integer type mismatch in conditional expression"
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "henvisnings- og heltalstype i betingelsesudtrykket passer ikke sammen"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Manglende eller ugyldigt konstant udtryk"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Statement at %0 invalid in context established by statement at %1"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Sætning ved %0 er ugyldig i den kontekst der er etableret af sætning ved %1"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 #| msgid "Statement at %0 invalid in context established by statement at %1"
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Sætning ved %0 er ugyldig i den kontekst der er etableret af sætning ved %1"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -84906,7 +85082,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "creating array of `%T'"
@@ -84972,42 +85148,42 @@ msgstr "overløb i konstant udtryk"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between `%#T' and `%#T'"
 msgid "%s between %L and %L"
@@ -85136,12 +85312,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -85583,322 +85759,327 @@ msgstr ""
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 #| msgid "Missing value at %1 for real-number exponent at %0"
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Manglende værdi ved %1 for reel eksponent ved %0"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "External procedure `%A' is passed as actual argument at %0 but not explicitly declared EXTERNAL"
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Ekstern procedure '%A' er overbragt som faktisk parameter ved %0, men ikke eksplicit erklæret EXTERNAL"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 #| msgid "External procedure `%A' is passed as actual argument at %0 but not explicitly declared EXTERNAL"
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Ekstern procedure '%A' er overbragt som faktisk parameter ved %0, men ikke eksplicit erklæret EXTERNAL"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr ""
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid option argument `%s'"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "ugyldig tilvalgsparameter '%s'"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Intrinsic `%A' is passed as actual argument at %0 but not explicitly declared INTRINSIC"
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Indbygget '%A' er overbragt som faktisk parameter ved %0, men ikke eksplicit erklæret INTRINSIC"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 #| msgid "failed to find class '%s'"
 msgid "Unable to find symbol %qs"
 msgstr "kunne ikke finde klassen '%s'"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, fuzzy, gcc-internal-format
 #| msgid "internal error - too many interface type"
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "intern fejl - for mange grænsefladetyper"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "kunne ikke konvertere '%E' til '%T'"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "accumulator number is out of bounds"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "akkumulatortal er uden for det gyldig interval"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "complex arguments must have identical types"
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "komplekse parametre skal have identiske typer"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE statement or attribute at %1 cannot be specified along with SAVE statement or attribute at %0"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "SAVE-sætning eller -egenskab ved %1 kan ikke angives sammen med SAVE-sætning eller -egenskab ved %0"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' must take exactly one argument"
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "'%s' skal tage mod én parameter"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "for mange parametre til %s '%+#D'"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -86101,7 +86282,7 @@ msgstr "konvertering fra NaN til int"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "kunne ikke konvertere '%E' til '%T'"
@@ -86693,7 +86874,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -86878,12 +87059,12 @@ msgstr "heltalsoverløb i udtryk"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -87423,7 +87604,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -87964,102 +88145,102 @@ msgstr ""
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "SELECT RANK statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Spurious number in FORMAT statement at %0"
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Mystisk tal i FORMAT-sætning ved %0"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected CASE statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in method specification"
 msgid "Syntax error in CASE specification at %C"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in method specification"
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in method specification"
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected RANK statement at %C"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in method specification"
 msgid "Syntax error in RANK specification at %C"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -89119,7 +89300,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -89154,12 +89335,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -89662,7 +89843,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr ""
@@ -89683,7 +89864,7 @@ msgstr "%s understøttes ikke af denne konfiguration"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "%s understøttes ikke af denne konfiguration"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -89713,17 +89894,17 @@ msgstr "Intern oversætterfejl i %s ved %s:%d."
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -89844,8 +90025,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -89928,7 +90109,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr ""
@@ -89951,7 +90132,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -89994,7 +90175,7 @@ msgstr "Symboler har en indledende understreg"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qD fremgår mere end en gang i map-klausuller"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -90315,618 +90496,628 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "variablen til tabel-delete er hverken af en henvisnings- eller en tabeltype"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array `%D' is not an integral constant-expression"
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "størrelsen af tabellen '%D' er ikke af et heltalligt konstantudtryk"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "overflow in constant expression"
 msgid "SIZES requires constant expression at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "environment variable DJGPP not defined"
 msgid "The event handle at %L must not be an array element"
 msgstr "miljøvariablen DJGPP er ikke defineret"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "environment variable DJGPP not defined"
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "miljøvariablen DJGPP er ikke defineret"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected binary operator between expressions at %0 and at %1"
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Forventede binær operator mellem udtryk ved %0 og ved %1"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "instance variable `%s' is declared private"
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "instansvariablen '%s' er erklæret privat"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "register variable `%s' used in nested function"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "registervariabel '%s' benyttet i indlejret funktion"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid token at %0 in expression or subexpression at %1"
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "Ugyldigt symbol ved %0 i udtryk eller underudtryk ved %1"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute `%s'"
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "ugyldig vektortype for egenskaben '%s'"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "not enough type information"
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "ikke tilstrækkelig information om typen"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "%s rotate count is negative"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%s-roteringsantal er negativt"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initializer element is not constant"
 msgid "property must be a logical expression at %L"
 msgstr "startværdielement er ikke en konstant"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "two `u's in integer constant"
 msgid "property must be an integer expression at %L"
 msgstr "to 'u'-endelser i heltalskonstant"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "størrelsen af medlemmet '%D' er ikke konstant"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "klargøringsliste behandlet som et sammensat udtryk"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "overflow in constant expression"
 msgid "TILE requires constant expression at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of `%s' attribute"
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "ugyldig parameter til egenskaben '%s'"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "']' expected, invalid type expression"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "']' forventet, ugyldigt typeudtryk"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't specify array dimension in a declaration"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Kan ikke angive tabeldimension i en erklæring"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -91613,69 +91804,69 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr ""
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "No label definition for FORMAT statement at %0"
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Ingen etiketdefinition for FORMAT-sætning ved %0"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Statement at %0 invalid in context established by statement at %1"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "Sætning ved %0 er ugyldig i den kontekst der er etableret af sætning ved %1"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected %s statement in MODULE at %C"
@@ -91684,7 +91875,7 @@ msgstr "Ikke-understøttet VXT-sætning ved %0"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -92169,1134 +92360,1134 @@ msgstr "Mystisk fortegn i FORMAT-sætning ved %0"
 msgid "%qs at %C is not a variable"
 msgstr "\"%s\" er ikke et ugyldigt filnavn"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr ""
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier at %0 invalid within a function"
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Alternativ returangivelse ved %0 er ugyldig inden i en funktion"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier at %0 invalid within a function"
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Alternativ returangivelse ved %0 er ugyldig inden i en funktion"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Null argument at %0 for statement function reference at %1"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Nulparameter ved %0 for sætningsfunktionsreference ved %1"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Planlæg ikke begyndelsen og slutningen af proceduren"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "inkonsistent instansvariabelangivelse"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "inkonsistent instansvariabelangivelse"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "RETURN statement at %0 invalid within a main program unit"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "RETURN-sætning ved %0 ugyldig inden i en hovedprogramenhed"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s `%+#D'"
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "for mange parametre til %s '%+#D'"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 #| msgid "use of `%D' is ambiguous"
 msgid "%qs at %L is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Label %d referenced at %L is never defined"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "External procedure `%A' is passed as actual argument at %0 but not explicitly declared EXTERNAL"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Ekstern procedure '%A' er overbragt som faktisk parameter ved %0, men ikke eksplicit erklæret EXTERNAL"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function `%A' defined at %0 is not used"
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Sætningsfunktion '%A' defineret ved %0, men er ikke brugt"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 #| msgid "External procedure `%A' is passed as actual argument at %0 but not explicitly declared EXTERNAL"
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Ekstern procedure '%A' er overbragt som faktisk parameter ved %0, men ikke eksplicit erklæret EXTERNAL"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 #| msgid "use of `%D' is ambiguous"
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "brug af '%D' er tvetydigt"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Statement at %0 invalid in this context"
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Sætning ved %0 er ugyldig i denne kontekst"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr ""
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "ugyldig venstreværdi i tildeling"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "'%D' erklærer ikke en skabelonstype"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "No calls in function %s\n"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "Ingen kald i funktionen %s\n"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unexpected junk after %qs at %L"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "%qs at %L is not a function"
 msgstr "'%s' er ikke en funktion,"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "der mangler en parameter til tilvalget '-%s'"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 #| msgid "sizeof applied to a function type"
 msgid "resolve_function(): bad function type"
 msgstr "sizeof benyttet på en funktionstype"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is deprecated"
 msgid "Using function %qs at %L is deprecated"
 msgstr "'%s' er forældet"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 #| msgid "cast does not match function type"
 msgid "resolve_subroutine(): bad function type"
 msgstr "typeomtvingelse passer ikke til funktionstype"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is deprecated"
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "'%s' er forældet"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "shared and mdll are not compatible"
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "shared og mdll er indbyrdes uforenelige"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "Impure function at %L might not be evaluated"
 msgstr "Advar når en inline funktion ikke kan indbygges"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "sammenligning med unsigned udtryk >= 0 er altid sand"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type argument"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "ugyldig typeparameter"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "inconsistent operand constraints in an `asm'"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "inkonsistente operandbegræsninger i 'asm'"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%V' qualifiers cannot be applied to `%T'"
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "modifikationerne '%V' kan ikke anvendes på '%T'"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid string constant `%E'"
 msgid "Equality comparison for %s at %L"
 msgstr "ugyldig strengkonstant '%E'"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid string constant `%E'"
 msgid "Inequality comparison for %s at %L"
 msgstr "ugyldig strengkonstant '%E'"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr ""
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "ukendt registernavn: %s"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "Unknown operator %qs at %L"
 msgstr "ukendt registernavn: %s"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "venstreoperanden til kommaudtrykket har ingen virkning"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "indeks mangler i tabelopslag"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "Argument dim at %L must be scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Null element at %0 for array reference at %1"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Nulelement ved %0 for tabelreference ved %1"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array `%A' at %0 is too large to handle"
 msgid "Array index at %L is an array of rank %d"
 msgstr "Tabellen '%A' ved %0 er for stor til at håndtere"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "TEAM argument at %L must be scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "STAT argument at %L must be scalar"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' is not a member of type `%T'"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "'%D' er ikke et medlem af typen '%T'"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "STAT's expression at %L must be a variable"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring begin/end point at %0 out of defined range"
 msgid "Substring end index at %L must be scalar"
 msgstr "Understrengs begyndelses-/slutpunkt ved %0 er uden for det definerede interval"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "requested alignment is too large"
 msgid "Substring end index at %L is too large"
 msgstr "angivet justering er for stor"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous conversion for array subscript"
 msgid "Illegal coarray index"
 msgstr "tvetydig konvertering af tabelindeks"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -93305,12 +93496,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -93319,429 +93510,429 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "Null element at %0 for array reference at %1"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "Nulelement ved %0 for tabelreference ved %1"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' is deprecated"
 msgid "Using variable %qs at %L is deprecated"
 msgstr "'%s' er forældet"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Null element at %0 for array reference at %1"
 msgid "Invalid array reference at %L"
 msgstr "Nulelement ved %0 for tabelreference ved %1"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate initialization of %D"
 msgid "Error in typebound call at %L"
 msgstr "%D tildelt startværdi mere end én gang"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "\"%s\" after # is not a positive integer"
 msgid "%s at %L must be integer"
 msgstr "\"%s\" efter # er ikke et positivt heltal"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Label %A already defined at %1 when redefined at %0"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Etiket %A er allerede defineret ved %1 ved omdefinering ved %0"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE statement or attribute at %1 cannot be specified along with SAVE statement or attribute at %0"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "SAVE-sætning eller -egenskab ved %1 kan ikke angives sammen med SAVE-sætning eller -egenskab ved %0"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Intern oversætterfejl i %s ved %s:%d."
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "%s understøttes ikke af denne konfiguration"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing operand for operator at %1 at end of expression at %0"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Manglende operand for operator ved %1 i slutningen af udtryk ved %0"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array or substring specification for `%A' out of range in statement at %0"
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Tabel- eller understrengsangivelse for '%A' er uden for det gyldige interval i sætning ved %0"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array or substring specification for `%A' out of range in statement at %0"
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Tabel- eller understrengsangivelse for '%A' er uden for det gyldige interval i sætning ved %0"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array or substring specification for `%A' out of range in statement at %0"
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Tabel- eller understrengsangivelse for '%A' er uden for det gyldige interval i sætning ved %0"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "No label definition for FORMAT statement at %0"
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Ingen etiketdefinition for FORMAT-sætning ved %0"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "No label definition for FORMAT statement at %0"
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Ingen etiketdefinition for FORMAT-sætning ved %0"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "No label definition for FORMAT statement at %0"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "Ingen etiketdefinition for FORMAT-sætning ved %0"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -93750,324 +93941,324 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "udtrykket er af en ufuldstændig type"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "%s kan ikke finde adressen af flertydiggjort funktion"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "\"%s\" cannot be used as a macro name as it is an operator in C++"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "\"%s\" kan ikke bruges som et makronavn da det er en operator i C++"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "Selector at %L cannot be NULL()"
 msgstr "udtrykket er af en ufuldstændig type"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parameter `%s' has incomplete type"
 msgid "Selector at %L has no type"
 msgstr "parameteren '%s' er af en ufuldstændig type"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' must take exactly one argument"
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "'%s' skal tage mod én parameter"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "use of class template `%T' as expression"
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "brug af klasseskabelonen '%T' som udtryk"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "use of class template `%T' as expression"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "brug af klasseskabelonen '%T' som udtryk"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr ""
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Statement at %0 invalid in context established by statement at %1"
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Sætning ved %0 er ugyldig i den kontekst der er etableret af sætning ved %1"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -94075,220 +94266,220 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Statement at %0 invalid in context established by statement at %1"
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Sætning ved %0 er ugyldig i den kontekst der er etableret af sætning ved %1"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unsupported VXT statement at %0"
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "In construct"
 msgid "FORALL construct at %L"
 msgstr "I konstruktionen"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Expected shadow variable name to start with _"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "kunne ikke konvertere '%E' til '%T'"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "Pointer procedure assignment at %L"
 msgstr "ugyldig venstreværdi i tildeling"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid string constant `%E'"
 msgid "Invalid NULL at %L"
 msgstr "ugyldig strengkonstant '%E'"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%s' declared void"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "parameteren '%s' erklæret void"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -94296,63 +94487,63 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer at %0 too large"
 msgid "String length at %L is too large"
 msgstr "Heltal ved %0 for stort"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -94360,1016 +94551,1016 @@ msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "fstat %s"
 msgid "%s at %L"
 msgstr "fejl ved egenskabsundersøgelse af filen %s"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 #| msgid "function cannot be inline"
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "funktion kan ikke indbygges"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object of type `%T' may not be initialized"
 msgid "External object %qs at %L may not have an initializer"
 msgstr "objekt af typen '%T' med variabel størrelse må ikke tildeles en startværdi"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "konstruktionsfunktionen kan ikke være en statisk medlemsfunktion"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' must take exactly one argument"
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "'%s' skal tage mod én parameter"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "udtrykket er af en ufuldstændig type"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "argument to `%s' attribute larger than %d"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "parameter til egenskaben '%s' er større end %d"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initialization of new expression with `='"
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "'%#D' kan ikke erklæres"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "uforenelig afledt type i PARAMETER ved %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "overflow in constant expression"
 msgid "Expecting constant expression near %L"
 msgstr "overløb i konstant udtryk"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "No specification for implied-DO iterator `%A' at %0"
 msgid "Bad specification for assumed size array at %L"
 msgstr "Ingen angivelse af underforstået DO-iterator '%A' ved %0"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "data member `%D' cannot be a member template"
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "datamedlem '%D' kan ikke være en medlemsskabelon"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "slutfeltet '%s' bliver måske ikke klargjort"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extraneous comma in FORMAT statement at %0"
 msgid "Expecting definable entity near %L"
 msgstr "Ekstra komma i FORMAT-sætning ved %0"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr ""
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "CLASS-variablen %qs ved %L kan ikke have PARAMETER-attributten"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "tabelindekset i startværdien er ikke en konstant"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "Label %d at %L defined but not used"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "Label %d at %L defined but cannot be used"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, fuzzy, gcc-internal-format
 #| msgid "Substring of non-CHARACTER entity `%A' in EQUIVALENCE statement"
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr "Understreng af ikke-CHARACTER enhed '%A' i EQUIVALENCE-sætning"
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr ""
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in method specification"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "tolkningsfejl i medlemsfunktionsangivelsen"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -95389,104 +95580,104 @@ msgstr "Ikkeeksisterende include-mappe %qs"
 msgid "%qs is not a directory"
 msgstr "%qs er ikke en mappe"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 #| msgid "Zero-length character constant at %0"
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Nul-længde tegnkonstant ved %0"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid character '%c' in #if"
 msgid "Invalid character 0x%s at %C"
 msgstr "ugyldigt tegn '%c' i #if"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "label `%D' defined but not used"
 msgid "file %qs left but not entered"
 msgstr "etiketten '%D' er defineret, men ikke benyttet"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s in preprocessing directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s i præprocessordirektiv"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "can't open output file `%s'"
 msgid "Cannot open file %qs"
 msgstr "kan ikke åbne uddatafilen '%s'"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot open source file %s\n"
 msgid "Cannot open included file %qs"
 msgstr "Kan ikke åbne kildefilen %s\n"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open profile file %s"
 msgid "Cannot open pre-included file %qs"
 msgstr "kan ikke åben profilefilen %s"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "no input files; unwilling to write output files"
 msgid "Included file %qs is not a regular file"
@@ -95660,225 +95851,225 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "den anden parameter til '%s' skal være 'char **'"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "accumulator number is out of bounds"
 msgid "DIM argument at %L is out of bounds"
 msgstr "akkumulatortal er uden for det gyldig interval"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 of `%s' must be a 2-bit literal"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "parameter til '%s' skal være en 2 bit-konstant"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr ""
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument 1 of __builtin_spe_predicate must be a constant"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "1. parameter til __builtin_spe_predicate skal være en konstant"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr ""
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "trampolines not yet implemented"
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "trampoliner understøttes ikke endnu"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "function call has aggregate value"
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "funktionskald har en sammensat værdi"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid argument of `%s' attribute"
 msgid "invalid argument of SQRT at %L"
 msgstr "ugyldig parameter til egenskaben '%s'"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -96233,74 +96424,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr "Ikke-understøttet VXT-sætning ved %0"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -96333,29 +96524,35 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "initializer element is not constant"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "startværdielement er ikke en konstant"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -96460,120 +96657,120 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr "tildeling af startværdi til new-udtryk med '='"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parameter `%s' has incomplete type"
 msgid "%s at %L has no default type"
 msgstr "parameteren '%s' er af en ufuldstændig type"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return value of function %qs at %L not set"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared %s"
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "instansvariablen '%s' er erklæret '%s'"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable `%s' is declared %s"
 msgid "Unused variable %qs declared at %L"
 msgstr "instansvariablen '%s' er erklæret '%s'"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 #| msgid "parameter `%s' declared void"
 msgid "Unused parameter %qs declared at %L"
 msgstr "parameteren '%s' erklæret void"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Returnér værdier fra funktioner i fpu-registre"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "DW_LOC_OP %s not implemented\n"
 msgid "Unsigned not yet implemented"
 msgstr "DW_LOC_OP %s understøttes ikke\n"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -96605,13 +96802,13 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "ukendt instruktionstilstand"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "too few arguments to function `%s'"
 msgid "Unknown argument list function at %L"
 msgstr "for få parametre til funktionen '%s'"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -96627,12 +96824,12 @@ msgstr ""
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "environment variable DJGPP not defined"
 msgid "The event variable at %L shall not be coindexed"
@@ -96660,198 +96857,198 @@ msgstr "-fprefetch-loop-arrays understøttes ikke på målarkitekturen"
 msgid "implicit mapping of assumed size array %qD"
 msgstr "Ingen angivelse af underforstået DO-iterator '%A' ved %0"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "optional class parameter"
 msgstr "ingen parametre"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "unhandled expression type"
 msgstr "uventet adresseudtryk"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected address expression"
 msgid "unhandled expression"
 msgstr "uventet adresseudtryk"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' previously defined here"
 msgid "Used here"
 msgstr "'%s' tidligere defineret her"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Planlæg ikke begyndelsen og slutningen af proceduren"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to `%s' must be a 2-bit unsigned literal"
 msgid "The base name at %L must not be an entry name"
 msgstr "parameter til '%s' skal være en 2 bit-konstant uden fortegn"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to `%s' must be a 2-bit unsigned literal"
 msgid "The base name at %L must not be a generic name"
 msgstr "parameter til '%s' skal være en 2 bit-konstant uden fortegn"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to `%s' must be a 2-bit unsigned literal"
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "parameter til '%s' skal være en 2 bit-konstant uden fortegn"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "`%D' must take exactly one argument"
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "'%s' skal tage mod én parameter"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "failed to find class '%s'"
 msgid "Cannot find symbol %qs at %L"
 msgstr "kunne ikke finde klassen '%s'"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "'%s' er ikke en funktion,"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "`%D' is not a function,"
 msgid "variant %qs at %L is the same as base function"
 msgstr "'%s' er ikke en funktion,"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "-f%s og -msdata=%s er indbyrdes uforenelige"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument missing after %s"
 msgid "Expected positive argument index at %L"
 msgstr "en parameter mangler efter %s"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array `%A' at %0 is too large to handle"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Tabellen '%A' ved %0 er for stor til at håndtere"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier at %0 invalid within a main program unit"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Alternativ returangivelse ved %0 er ugyldig inden i en hovedprogramenhed"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Null argument at %0 for statement function reference at %1"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Nulparameter ved %0 for sætningsfunktionsreference ved %1"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe is not supported"
 msgid "%<need_device_addr%> not yet supported"
@@ -97209,7 +97406,7 @@ msgstr "luk: %s"
 msgid "two or more sections for %s"
 msgstr "mere end én datatype i erklæringen af '%s'"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -97571,34 +97768,34 @@ msgstr "ugyldig tildeling af startværdi til tabel"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "requested alignment is not a constant"
 msgstr "angivet justering er ikke en konstant"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "requested alignment is not a power of 2"
 msgstr "angivet justering er ikke en potens af 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "angivet justering er for stor"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "justering må ikke angives for '%s'"
@@ -101090,11 +101287,6 @@ msgstr ""
 #~ msgid "non-pointer argument to %<__builtin_launder%>"
 #~ msgstr "ikke-understøttet parameter til '__builtin_return_address'"
 
-#, fuzzy, gcc-internal-format
-#~| msgid "cannot disable built-in function `%s'"
-#~ msgid "cannot call function %qD"
-#~ msgstr "kan ikke deaktivere den indbyggede funktion '%s'"
-
 #, fuzzy, gcc-internal-format
 #~| msgid "%s rotate count is negative"
 #~ msgid "right rotate count is negative"
@@ -103226,6 +103418,10 @@ msgstr ""
 #~ msgid "flexible array member in otherwise empty struct"
 #~ msgstr "fleksibelt tabelmedlem i ellers tom struktur"
 
+#, fuzzy
+#~ msgid "%qD is not a constant"
+#~ msgstr "parameteren til 'asm' er ikke en konstant streng"
+
 #, fuzzy
 #~| msgid "invalid #pragma %s"
 #~ msgid "invalid pragma"
@@ -103376,11 +103572,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "ikke-statisk metode '%s' overskriver statisk metode"
 
-#, fuzzy
-#~| msgid "`%#D' used prior to declaration"
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "'%#D' benyttet før erklæring"
-
 #, fuzzy
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "I %s: overlappende variabel- og undtagelsesintervaller ved %d"
@@ -103596,11 +103787,6 @@ msgstr ""
 #~ msgid "%qs and floating point or vector arguments"
 #~ msgstr "Benyt hardware-kommatalsinstruktioner"
 
-#, fuzzy
-#~| msgid "incompatible type for argument %d of `%s'"
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "typen af den %d. parameter i '%s' passer ikke"
-
 #, fuzzy
 #~ msgid "%q+D:'selectany' attribute applies only to initialized objects"
 #~ msgstr "'%s'-egenskaben kan kun anvendes sammen med funktioner"
--- a/src/gcc/po/de.po
+++ b/src/gcc/po/de.po
@@ -8,10 +8,10 @@
 # Roland Illig <roland.illig@gmx.de>, 2015, 2017-2026.
 msgid ""
 msgstr ""
-"Project-Id-Version: gcc 16.1-b20260329\n"
+"Project-Id-Version: gcc 16.1.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
-"PO-Revision-Date: 2026-03-30 21:36+0200\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
+"PO-Revision-Date: 2026-05-03 23:11+0200\n"
 "Last-Translator: Roland Illig <roland.illig@gmx.de>\n"
 "Language-Team: German <translation-team-de@lists.sourceforge.net>\n"
 "Language: de\n"
@@ -1256,12 +1256,12 @@ msgstr "Alias:"
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Bekannte PTX-ISA-Versionen (für Verwendung mit der Option »-mptx=«):"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "Die Version der PTX-ISA angeben, die verwendet wird."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr "PTX-Register initialisieren."
@@ -2080,13 +2080,13 @@ msgstr "Standardumwandlungen zwischen »__float128« und »long double« einscha
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "Angegebenen Stapelschutz-Wächter verwenden."
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2534,7 +2534,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Ziel-CPU als »big endian«-konfiguriert annehmen."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Ziel-CPU als »little endian«-konfiguriert annehmen."
@@ -2609,7 +2609,7 @@ msgstr "Kleineren, aber langsameren Code für Funktionsprologe und -epiloge verw
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr "Adressen der Form BASE + LARGE_OFFSET in NEW_BASE + SMALL_OFFSET konvertieren, damit mehr Speicherzugriffe als komprimierte Anweisungen generiert werden können. Zielt derzeit auf 32-Bit-Integer-Laden/Speichern ab."
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2647,7 +2647,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr "CSR-Prüfung für die ISA-abhängigen CSR und das schreibgeschützte CSR einschalten. Die ISA-abhängigen CSR sind nur gültig, wenn die entsprechende ISA festgelegt ist. Das schreibgeschützte CSR kann nicht von den CSR-Befehlen geschrieben werden."
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Rahmenzeiger in Blattfunktionen auslassen."
@@ -2757,7 +2757,7 @@ msgstr "-param=vsetvl-strategy=<string>\tOptimierungsstufe des VSETVL-Einfügedu
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr "-param=riscv-two-source-permutes\tSchaltet Permutationen mit zwei Quellvektoren ein."
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr "Das Skalar-Kostenmodell so überschreiben, dass die Vektorisierung immer rentabel ist."
@@ -2803,7 +2803,7 @@ msgstr "-mrvv-vector-bits=<Zeichenkette>\tArt der Bits in einem RVV-Vektorregist
 msgid "The possible TLS dialects:"
 msgstr "Mögliche TLS-Dialekte:"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5065,7 +5065,7 @@ msgstr "Eingebaute Funktionen und Codeerzeugung für RAOINT unterstützen."
 msgid "Enable conservative small loop unrolling."
 msgstr "Konservatives abrollen kleiner Schleifen einschalten."
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr "Begrenzen, wie weit der Autovektorisierer eine Schleife abrollen darf."
@@ -5420,7 +5420,7 @@ msgstr "Beim Binden für Big-Endian-Zielsysteme ein Abbild im veralteten BE32-Fo
 msgid "Cost to assume for a branch insn."
 msgstr "Für Sprungbefehl anzunehmende Kosten."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr "Verzweigungsschutz-Features verwenden."
@@ -5725,212 +5725,217 @@ msgstr "Umgehung von Erratum 835769 für ARM-Cortex-A53."
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr "Umgehung von Erratum 843419 für ARM-Cortex-A53."
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr "Einschalten, dass bei Schreibzugriffen auf 64-Bit-Allzweck-Register nur die unteren 32 Bit geschrieben werden, soweit die oberen 32 Bit ungenutzt sind."
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "Das Register, das für den Zugriff auf den Threadzeiger verwendet wird:"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Das Register für den Threadzeiger angeben."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "Nicht annehmen, dass unausgerichtete Zugriffe vom System behandelt werden."
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Bit-Breite des unmittelbaren TLS-Versatzes angeben. Gültige Werte sind 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "Eigenschaften der Architektur ARCH verwenden."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "Eigenschaften der angegebenen CPU verwenden und dafür optimieren."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr "Für CPU optimieren."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Code erzeugen, der zum angegebenen ABI passt."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr "-fdump-tuning-model=<Dateiname> Aktuelles Tuning-Modell in eine JSON-Datei ausgeben."
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr "-muser-provided-CPU=<JSON-Tuning-Datei> Benutzerspezifische CPU-Feineinstellungen."
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr "-moverride=<Zeichenkette>\tNur für Powernutzer! CPU-Optimierungsparameter übersteuern."
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "Bekannte AArch64-ABIs (für Verwendung mit der Option »-mabi=«):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr "Ladebefehle relativ zum PC."
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr "Gültigkeitsbereich der signierten Rückgabeadressen."
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Unterstützte Rückgabeadress-Signierbereiche für AArch64 (für die Option »-msign-return-address=«):"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Annäherung der reziproken Quadratwurzel einschalten. Dies reduziert die Genauigkeit der reziproken Quadratwurzelergebnisse auf etwa 16 Bits für einfache Genauigkeit und 32 Bits für doppelte Genauigkeit."
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr "Annäherung der Quadratwurzel einschalten. Dies reduziert die Genauigkeit der Quadratwurzelergebnisse auf etwa 16 Bits für einfache Genauigkeit und 32 Bits für doppelte Genauigkeit. Wenn eingeschaltet, bringt es »-mlow-precision-recip-sqrt« mit sich."
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Annäherung der Division einschalten. Dies reduziert die Genauigkeit der Division auf etwa 16 Bits für einfache Genauigkeit und 32 Bits für doppelte Genauigkeit."
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr "Angeben, wann ein früher Registerzuweisungsdurchlauf aktiviert werden soll. Möglichkeiten: alle Funktionen, Funktionen, die Zugriff auf großschrittige Multi-Register-Anweisungen haben, und keine Funktionen."
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "Mögliche SVE-Vektorlängen:"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "-msve-vector-bits=<Anzahl>\tAnzahl der Bits in einem SVE-Vektorregister festlegen."
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Eine ISA-Auswahlstrategie für die automatische Vektorisierung erzwingen. Für optimale Leistung wird dringend empfohlen, stattdessen »-mcpu« oder »-mtune« zu verwenden. Dieser Parameter sollte nur zur Code-Erkundung verwendet werden."
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr "Ausführliche Ausgabe des Kostenmodells in den Debug-Dumpdateien einschalten."
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr "Code generieren, um mitzuverfolgen, wann die CPU falsch spekulieren könnte."
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr "Kopie des AArch64-Lade/Speicher-Paar-Fusionspasses, der vor der Registerzuweisung ausgeführt wird, aktivieren."
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr "Kopie des AArch64-Lade/Speicher-Paar-Fusionspasses, der nach der Registerzuweisung ausgeführt wird, aktivieren."
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Das in der Kommandozeile angegebene Systemregister als Stapelschutz-Wächterregister verwenden. Diese Option ist für fstack-protector-strong gedacht und nicht für die Verwendung in Benutzer-Code."
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Einen konstanten Wert als Offset vom Stapelschutz-Wächterregister verwenden, sp_el0. Diese Option ist für fstack-protector-strong gedacht und nicht für die Verwendung in Benutzer-Code."
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Atomare Operationen durch Hilfsfunktionen implementieren."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr "Bei der Vektorisierung mehrere verschiedene Ansätze in Betracht ziehen und das Kostenmodell verwenden, um den günstigsten auszuwählen."
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr "Die Anzahl der Newton-Iterationen, um den reziproken Wert einer float-Gleitkommazahl zu berechnen. Die Genauigkeit der Division ist proportional zu diesem Parameter, wenn die angenäherte Division angeschaltet ist. Standardwert ist 1."
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr "Die Anzahl der Newton-Iterationen, um den reziproken Wert einer double-Gleitkommazahl zu berechnen. Die Genauigkeit der Division ist proportional zu diesem Parameter, wenn die angenäherte Division angeschaltet ist. Standardwert ist 2."
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr "Ein alter Alias für »-mautovec-preference«. Wenn sowohl »-mautovec-preference« als auch »--param=aarch64-autovec-preference« übergeben werden, wird der Wert von »--param« verwendet."
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr "Konstante memcpy-Größe in Bytes, ab der die MOPS-Sequenz verwendet werden soll."
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr "Konstante memmove-Größe in Bytes, ab der die MOPS-Sequenz verwendet werden soll."
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr "Konstante memset-Größe in Bytes, ab der die MOPS-Sequenz verwendet werden soll."
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr "--param=aarch64-ldp-policy=[default|always|never|aligned] Feinkörnige Richtlinie für Ladepaare."
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr "--param=aarch64-stp-policy=[default|always|never|aligned] Feinkörnige Richtlinie für Speicherpaare."
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr "Begrenzung der Anzahl der Alias-Prüfungen, die beim Versuch, ein ldp/stp-Paar zu bilden, durchgeführt werden."
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr "Parameter, mit dem gesteuert wird, welche Rückschreibegelegenheiten im Load/Store-Paar-Fusionsdurchlauf behandelt werden sollen. Der Wert 0 deaktiviert die Rückschreibebehandlung. Der Wert 1 versucht Paare zu bilden, die nach Möglichkeit einen oder mehrere bestehende individuelle Rückschreibzugriffe beinhalten. Der Wert 2 versucht opportunistisch Rückschreibgelegenheiten zu bilden, indem nachlaufende destruktive Aktualisierungen des von einem Paar verwendeten Basisregisters einklappen."
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr "Schwellenwert für die Anzahl der Granula, ab dem eine explizite Schleife zum Markieren eines Speicherblocks ausgegeben wird."
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, no-c-format
 msgid "This option is deprecated."
 msgstr "Dieser Schalter ist veraltet."
@@ -11253,8 +11258,8 @@ msgstr "Schleifenvektorisierung von Gleitkommabefehlen einschalten."
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
-msgstr "Der Skalierungsfaktor in Prozent, der bei der Durchführung einer Vektorisierungsrentabilitätsanalyse auf alle Kosten einer skalaren Schleife angewendet wird. Der Standardwert ist 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
+msgstr "Einschalten der Vektorisierung von Schleifen, die nach dem Kostenmodell möglicherweise nicht rentabel sind, aber dennoch eine Kostenberechnung zwischen den Vektormodi durchführen."
 
 #: params.opt:1304
 #, no-c-format
@@ -18166,77 +18171,77 @@ msgstr "Mit der Ausgabe 2024 der Sprache D übereinstimmen."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Mit der neuesten Ausgabe 202Y der Sprache D übereinstimmen (experimentell)."
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr "ein durch den Aufgerufenen kopiertes Argument wird im Rahmen der aktuellen Funktion gespeichert"
 
-#: calls.cc:1537
+#: calls.cc:1533
 msgid "argument must be passed by copying"
 msgstr "das Argument muss durch Kopieren übergeben werden"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr "die Maschinenbeschreibung enthält kein Befehlsmuster sibcall_epilogue"
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr "der Aufgerufene gibt eine Struktur zurück"
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr "das Ziel ist nicht in der Lage, den Aufruf in einen Geschwisteraufruf zu optimieren"
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr "der Aufgerufene kehrt zweimal zurück"
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr "der Aufgerufene kehrt nicht zurück"
 
-#: calls.cc:2595
+#: calls.cc:2596
 msgid "volatile function type"
 msgstr "volatile-Funktionstyp"
 
-#: calls.cc:2614
+#: calls.cc:2615
 msgid "nested function"
 msgstr "geschachtelte Funktion"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr "der Angerufene benötigt mehr Stack-Slots als der Aufrufer"
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr "inkonsistente Anzahl von Argumenten, die vom Stack entfernt wurden"
 
-#: calls.cc:2646
+#: calls.cc:2647
 msgid "frontend does not support sibling call"
 msgstr "das Frontend unterstützt keine Geschwisteraufrufe"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr "andere Gründe"
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr "innerhalb eines anderen Aufrufs"
 
-#: calls.cc:3085
+#: calls.cc:3086
 msgid "variable size arguments"
 msgstr "Argumente variabler Größe"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr "verstecktes Stringlängenargument auf dem Stack übergeben"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr "Aufrufer und Aufgerufener sind sich nicht einig über die Promotion des Rückgabewerts der Funktion"
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr "Produktion des Endaufrufs fehlgeschlagen"
 
@@ -18356,12 +18361,12 @@ msgstr "»%%l«-Operand ist keine Marke"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "Gleitkommakonstante falsch verwendet"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19674,11 +19679,11 @@ msgstr "JSON-Literal"
 msgid "this is the insn:"
 msgstr "dies ist der Befehl:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 msgid "unable to reload address in "
 msgstr "Adresse kann nicht neugeladen werden in "
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "Neuladungen konnten nicht generiert werden für:"
 
@@ -19897,7 +19902,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC-Heuristik: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonym>"
@@ -20275,20 +20280,20 @@ msgstr "Operand für Code »%c« nicht unterstützt"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "ungültiger Operand für »%%%c«"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "ungültige Vektorkonstante"
@@ -20333,71 +20338,71 @@ msgstr "ungültiger Operandenpräfix »%%%c«"
 msgid "invalid address mode"
 msgstr "ungültiger Adressierungsmodus"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "ungültige Umwandlung von Typ %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "ungültige Umwandlung in Typ %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "Präinkrement-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "Prädekrement-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "Postinkrement-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "Postdekrement-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr "Negations-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr "Plus-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr "Minus-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr "Mal-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr "Geteilt-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr "Bitschiebe-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr "Nur die Operationen == und != sind auf svbool_t erlaubt"
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr "Arrayindex-Operation nicht erlaubt auf svbool_t"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "Operation nicht erlaubt auf Typ %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "GNU- und SVE-Vektoren können nicht in einer binären Operation kombiniert werden"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20414,13 +20419,13 @@ msgid "invalid %%r value"
 msgstr "ungültiger %%r-Wert"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "ungültiger %%R-Wert"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "ungültiger %%N-Wert"
@@ -20435,7 +20440,7 @@ msgstr "ungültiger %%P-Wert"
 msgid "invalid %%h value"
 msgstr "ungültiger %%h-Wert"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "ungültiger %%L-Wert"
@@ -20450,7 +20455,7 @@ msgstr "ungültiger %%m-Wert"
 msgid "invalid %%M value"
 msgstr "ungültiger %%M-Wert"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "ungültiger %%U-Wert"
@@ -20782,7 +20787,7 @@ msgstr "nicht unterstützter Operand"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21027,126 +21032,126 @@ msgstr "ungültige Gleitkomma-Konstante"
 msgid "Expected register or constant integer."
 msgstr "Register oder konstante Ganzzahl erwartet."
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "ungültiges UNSPEC als Operand"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "Ungültige Verwendung von Register »%s«"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "ungültige Verwendung der asm-Schalter-Ausgabe"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "ungültige Operandengröße für Operandencode »O«"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "ungültige Operandengröße für Operandencode »z«"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "ungültiger Operandentyp mit Operandencode »%c« verwendet"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "ungültige Operandengröße für Operandencode »%c«"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "Operand ist kein Bedingungscode, ungültiger Operandencode »Y«"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "Operand ist kein Bedingungscode, ungültiger Operandencode »D«"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "Operand ist kein Bedingungscode, ungültiger Operandencode »%c«"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "Operand ist keine ausgleichbare Speicherreferenz, ungültiger Operandencode »H«"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "Operand ist keine Ganzzahl, ungültiger Operandencode »K«"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "Operand ist keine bestimmte Ganzzahl, ungültiger Operandencode »r«"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "Operand ist keine Ganzzahl, ungültiger Operandencode »R«"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "Operand ist keine bestimmte Ganzzahl, ungültiger Operandencode »R«"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "Operand ist keine Speicherreferenz, ungültiger Operandencode »v«"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "ungültiger Operandencode »%c«"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "ungültige Bedingungen für Operand"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr "ungültiger Vektordirektwert"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "unbekannter Befehlsmodus"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "ungültige Umwandlung von Typ %<__bf16%> ohne Option %<-msse2%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "ungültige Umwandlung von Typ %<_Float16%> ohne Option %<-msse2%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "ungültige Umwandlung in Typ %<__bf16%> ohne Option %<-msse2%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "ungültige Umwandlung in Typ %<_Float16%> ohne Option %<-msse2%>"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr "Operation nicht erlaubt auf Typ %<__bf16%> ohne Option %<-msse2%>"
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr "Operation nicht erlaubt auf Typ %<_Float16%> ohne Option %<-msse2%>"
 
@@ -21225,9 +21230,9 @@ msgstr "»%%%c« ist kein gültiger Operandenpräfix"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "ungültige Verwendung von »%%%c«"
@@ -21292,7 +21297,7 @@ msgid "insn contains an invalid address !"
 msgstr "Befehl enthält eine ungültige Adresse!"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "ungültige Adresse"
 
@@ -21367,7 +21372,7 @@ msgstr "ungültige Adressverschiebung"
 msgid "invalid %%H value"
 msgstr "ungültiger %%H-Wert"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "ungültiger %%d-Wert"
@@ -21417,32 +21422,32 @@ msgstr "nicht unterstützte konstante Adresse:"
 msgid "unsupported memory expression:"
 msgstr "nicht unterstützter Speicherausdruck:"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, c-format
 msgid "invalid vector operand"
 msgstr "ungültiger Vektoroperand"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr "der Modifizierer »N« erfordert einen Registeroperanden"
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, c-format
 msgid "invalid register number for 'N' modifier"
 msgstr "ungültige Registernummer für Modifizierer »N«"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr "der Modifizierer »H« erfordert einen Registeroperanden"
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr "der Modifizierer »H« ist nur für Ganzzahlregister"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr "der Modifizierer »H« ist nicht auf R31 anwendbar"
@@ -21499,7 +21504,7 @@ msgstr "Falsche 128-Bit-Verschiebung"
 msgid "invalid %%A value"
 msgstr "ungültiger %%A-Wert"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "ungültiger %%D-Wert"
@@ -21539,7 +21544,7 @@ msgstr "ungültiger %%J-Code"
 msgid "invalid %%k value"
 msgstr "ungültiger %%k-Wert"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "ungültiger %%K-Wert"
@@ -21569,17 +21574,17 @@ msgstr "ungültiger %%T-Wert"
 msgid "invalid %%u value"
 msgstr "ungültiger %%u-Wert"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "ungültiger %%v-Wert"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "ungültiger %%V-Wert"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "ungültiger %%x-Wert"
@@ -21788,27 +21793,27 @@ msgstr "ungültiger %%s-Operand"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "Gleitkommakonstante ist kein gültiger direkter Operand"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "»B«-Operand ist nicht konstant"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "»B«-Operand hat mehrere gesetzte Bits"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "»o«-Operand ist nicht konstant"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, c-format
 msgid "'h' operand is not SImode register"
 msgstr "»h«-Operand ist kein SImode-Register"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: unbekannter Code"
@@ -21864,24 +21869,24 @@ msgstr "ungültige Operandenadresse (4)"
 msgid "Unable to load DLL."
 msgstr "Fehler beim Laden der DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "Falscher Test"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "ungültige Maske"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "ungültiger %%t/%%b-Wert"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "Kein Register in Adresse"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "Adressversatz ist keine Konstante"
 
@@ -21913,7 +21918,7 @@ msgstr "{fehlerhaft}"
 msgid "aka"
 msgstr "alias"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anonym})"
 
@@ -21938,8 +21943,8 @@ msgstr "({anonym})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "%<;%> erwartet"
@@ -21967,7 +21972,7 @@ msgstr "%<:%> oder %<)%> erwartet"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "%<)%> erwartet"
@@ -21975,7 +21980,7 @@ msgstr "%<)%> erwartet"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "%<]%> erwartet"
@@ -21995,13 +22000,13 @@ msgstr "%<;%>, %<,%> oder %<)%> erwartet"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "%<(%> erwartet"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "%<[%> erwartet"
@@ -22010,7 +22015,7 @@ msgstr "%<[%> erwartet"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22027,13 +22032,13 @@ msgstr "%<{%> erwartet"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "%<:%> erwartet"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "%<while%> erwartet"
@@ -22043,7 +22048,7 @@ msgstr "%<while%> erwartet"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "%<,%> erwartet"
@@ -22053,18 +22058,18 @@ msgid "expected %<.%>"
 msgstr "%<.%> erwartet"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "%<@end%> erwartet"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "%<>%> erwartet"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "%<,%> oder %<)%> erwartet"
@@ -22074,45 +22079,45 @@ msgstr "%<,%> oder %<)%> erwartet"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "%<=%> erwartet"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "%<)%> oder %<,%> erwartet"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "%<}%> erwartet"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "%<else%> erwartet"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "%<#pragma omp section%> oder %<}%> erwartet"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr "<Meldung nicht zur Compilierzeit bekannt>"
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anonym)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "%<<%> erwartet"
@@ -22137,7 +22142,7 @@ msgstr "Kandidat %i:"
 msgid "  after user-defined conversion:"
 msgstr "  nach benutzerdefinierter Umwandlung:"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "Kandidat ist:"
@@ -22237,7 +22242,7 @@ msgstr "<Template-Parameter-Fehler>"
 msgid "<statement>"
 msgstr "<Anweisung>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<unbekannt>"
@@ -22264,252 +22269,288 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<Ausdrucksfehler>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<unbekannter Operator>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "Im globalen Gültigkeitsbereich:"
 
-#: cp/reflect.cc:565
-msgid "array element not a constant integer"
-msgstr "Arrayelement ist keine Ganzzahlkonstante"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr "reflect_constant_array fehlgeschlagen"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr "reflect_constant fehlgeschlagen"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+msgid "array element not a constant integer"
+msgstr "Arrayelement ist keine Ganzzahlkonstante"
+
+#: cp/reflect.cc:1117
 msgid "reflection does not represent a type"
 msgstr "Reflektion repräsentiert keinen Typen"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 msgid "reflection does not have template arguments"
 msgstr "Reflektion hat keine Template-Argumente"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 msgid "reflection does not represent a function or function type"
 msgstr "Reflektion repräsentiert weder eine Funktion noch einen Funktionstypen"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr "Reflektion repräsentiert weder eine Operatorfunktion noch ein Operatorfunktionstemplate"
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 msgid "operators argument is not a valid operator"
 msgstr "Argument für Operatoren ist kein gültiger Operator"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 msgid "reflection does not have a type"
 msgstr "Reflektion hat keinen Typen"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr "Reflektion repräsentiert weder ein Objekt mit statischer Speicherdauer noch eine Referenz auf solch ein Objekt"
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr "Reflexion repräsentiert weder eine Annotation noch ein gültiges Argument für einen Splice-Ausdruck"
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr "Reflexion repräsentiert keine Entity mit Elternteil"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr "Reflektion repräsentiert keinen Parameter der aktuellen Funktion"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "Reflektion repräsentiert weder eine Funktion noch einen Funktionstyp mit Rückgabetyp"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr "Reflektion einer virtuellen direkten Basisbeziehung mit abstrakter abgeleiteter Klasse"
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr "Reflektion ist ungeeignet für offset_of"
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr "Nicht-konstanter Offset in offset_of"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr "Reflektion ist ungeeignet für size_of"
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr "Reflektion mit unvollständigem Typen in size_of"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 msgid "reflection not suitable for alignment_of"
 msgstr "Reflektion ist ungeeignet für alignment_of"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 msgid "alignment_of on function type"
 msgstr "alignment_of auf einem Funktionstypen"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr "Reflektion mit unvollständigem Typen in alignment_of"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr "Reflektion ungeeignet für bit_size_of"
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "Reflektion mit unvollständigem Typen in bit_size_of"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr "Reflektion mit has_identifier false"
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr "identifier_of ist im gewöhnlichen Encoding für Literale nicht darstellbar"
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr "u8identifier_of ist nicht in UTF-8 darstellbar"
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
-msgstr "Reflexion stellt weder Typ noch Typalias, Variable, Funktion, Namespace, Enumerator, direkte Basisklassenbeziehung oder nicht statisches Datenelement dar"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr "display_string_of ist im gewöhnlichen Encoding für Literale nicht darstellbar"
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr "u8display_string_of ist nicht in UTF-8 darstellbar"
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr "Reflektion stellt weder Typ noch Typalias, Variable, Funktion, Funktionsparameter, Namespace, Enumerator, direkte Basisklassenbeziehung oder nicht statisches Datenelement dar"
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr "Reflektion repräsentiert weder einen vollständigen Typen noch einen Typalias"
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr "reflect_object fehlgeschlagen"
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr "reflect_function fehlgeschlagen"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr "Wertelement fehlt"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr "unerwarteter Wert des Wertelements"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr "Typelement fehlt"
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr "Reflektion repräsentiert keinen vollständigen Aufzählungstypen"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "Reflektion repräsentiert keinen aufzählbaren Aufzählungstypen"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr "Reflektion repräsentiert weder einen Ganzzahltypen noch einen Bool-Typ"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 msgid "reflection does not represent a template"
 msgstr "Reflektion repräsentiert kein Template"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 msgid "invalid argument to can_substitute"
 msgstr "ungültiges Argument für can_substitute"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr "can_substitute hat false zurückgegeben"
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 msgid "type is not object or reference type"
 msgstr "Typ ist weder ein Objekttyp noch ein Referenztyp"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr "Umwandlung aus der gewöhnlichen Codierung von Literalen hin zum Quellzeichensatz fehlgeschlagen"
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "Umwandlung von UTF-8 zum Quellzeichensatz fehlgeschlagen"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 msgid "name is not a valid identifier"
 msgstr "Name ist kein gültiger Bezeichner"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr "Name ist ein Schlüsselwort"
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr "Name ist ein eingebauter Trait"
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr "weder Name noch bit_width angegeben"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr "weder Name noch nichtleere Annotationen angegeben"
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "bit_width an einem Typ angegeben, der weder ein Ganzzahltyp noch ein Aufzählungstyp ist"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 msgid "both alignment and bit_width specified"
 msgstr "sowohl Alignment als auch bit_width angegeben"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr "bit_width angegeben mit no_unique_address true"
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr "bit_width 0 mit angegebenem Name"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr "bit_width ist negativ"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr "Name nicht angegeben und Typ ist konstant"
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr "Name nicht angegeben und Typ ist volatil"
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr "Alignment ist keine Zweierpotenz"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr "Alignment ist negativ"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr "Alignment ist kleiner als alignment_of"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+msgid "reflection does not have non-array object type"
+msgstr "Reflektion muss einen Objekttypen außer Array haben"
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr "aktueller Gültigkeitsbereich repräsentiert keine Funktion"
+
+#: cp/reflect.cc:6526
+msgid "current scope does not represent a class nor a member function"
+msgstr "aktueller Gültigkeitsbereich repräsentiert weder eine Klassen- noch eine Memberfunktion"
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr "unvollständige Elternklasse"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr "weder vollständige Klasse noch Namensraum"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 msgid "not a complete class type"
 msgstr "kein vollständiger Klassentyp"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr "Closuretyp"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 msgid "value cannot be extracted"
 msgstr "Wert kann nicht extrahiert werden"
 
@@ -22553,52 +22594,52 @@ msgstr "Umformung verwirft Konstantheit"
 msgid "source type is not polymorphic"
 msgstr "Quellentyp ist nicht polymorph"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "Kandidaten sind:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "Argument falschen Typs für unäres Minus"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "Argument falschen Typs für unäres Plus"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "Argument falschen Typs für Bit-Komplement"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "Argument falschen Typs für abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "Argument falschen Typs für Konjugation"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "in Argument für unäres !"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "kein Präinkrementoperator für Typ"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "kein Postinkrementoperator für Typ"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "kein Prädekrementoperator für Typ"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "kein Postdekrementoperator für Typ"
 
@@ -22614,59 +22655,59 @@ msgstr " [siehe %<-fallow-invalid-boz%>]"
 msgid "BOZ constant truncated at %L"
 msgstr "BOZ-Konstante wird abgeschnitten, bei %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "Argumente »a%d« und »a%d« für intrinsisches »%s«"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "Argumente »%s« und »%s« für intrinsisches %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "Argumente »%s« und »%s« für intrinsisches »%s«"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr "NULL() ist nicht interoperabel"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 msgid "BOZ literal constant"
 msgstr "literale Konstante BOZ"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr "Ausdruck ist polymorph"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr "Ausdruck ist ein nicht interoperabler abgeleiteter Typ"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 msgid "Procedure unexpected as argument"
 msgstr "Prozedur als Argument unerwartet"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr "Erweiterung, ein LOGICAL in einer Art zu verwenden, die nicht kompatibel zu C_Bool ist"
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr "Erweiterung, ein CHARACTER in einer Art zu verwenden, die nicht kompatibel zu C_CHAR ist"
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr "Der Typ muss eine Zeichenlänge von 1 haben"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr "Kofelder sind nicht interoperabel"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr "Felder mit angenommener Größe sind nicht interoperabel"
 
@@ -22749,7 +22790,7 @@ msgstr "Gelöschte Funktion:"
 msgid "Unsigned:"
 msgstr "Vorzeichenlos:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "Array-Zuweisung"
 
@@ -22759,18 +22800,18 @@ msgstr "Indexvariable %qs neudefiniert bei %L in Prozedur %qs, aufgerufen aus de
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89939
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr "Falsche Ausdehnung in Argument B in MATMUL-Intrinsic in Dimension 1: ist %ld, sollte %ld sein"
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "Unstimmige Arraygrenzen für Dimension 1 des Arrays (%ld/%ld)"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89939
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "Unstimmige Arraygrenzen für Dimension 2 des Arrays (%ld/%ld)"
@@ -22946,11 +22987,11 @@ msgstr "Block-IF"
 msgid "implied END DO"
 msgstr "impliziertes END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "Zuweisung"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "Zeigerzuweisung"
 
@@ -22958,125 +22999,125 @@ msgstr "Zeigerzuweisung"
 msgid "simple IF"
 msgstr "einfaches IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "Elementares Unterprogramm"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "allozierbares Argument"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "asynchrones Argument"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "optionales Argument"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "Zeigerargument"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "Zielargument"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "Wertargument"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "flüchtiges Argument"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "Argument mit angenommener Form"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "Argument mit angenommenem Rang"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "Coarray-Argument"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "parametrisiertes abgeleitetes Typargument"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "polymorphes Argument"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "NO_ARG_CHECK-Attribut"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "Argument von angenommenem Typ"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "Arrayergebnis"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "Zeiger oder allozierbares Resultat"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr "Resultat mit nicht konstanter Zeichenlänge"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "bind(c)-Prozedur"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Schleifenvariable"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "Iteratorvariable"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Anfangs-Ausdruck in DO-Schleife"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "End-Ausdruck in DO-Schleife"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Schrittausdruck in DO-Schleife"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "DEALLOCATE Objekt"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "ALLOCATE Objekt"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "STAT-Variable"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "ERRMSG-Variable"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "Element in READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "Variable ACQUIRED_LOCK"
 
@@ -23085,31 +23126,31 @@ msgstr "Variable ACQUIRED_LOCK"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Unterschiedliche CHARACTER-Längen (%ld/%ld) in Feldkonstruktor"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "Ganzzahlüberlauf bei der Berechnung des zu reservierenden Speichers"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr "Der Wert des Parameters PDT LEN »%s« stimmt nicht mit dem in der Dummy-Deklaration überein"
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Effektive Zeichenkettenlänge passt nicht zur deklarierten für Scheinargument »%s« (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Effektive Zeichenkettenlänge ist kürzer als die deklarierte für Scheinargument »%s« (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "Ziel für neue Rangabbildung ist zu klein (%ld < %ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Zuweisung von Skalar zu unalloziertem Array"
 
@@ -23172,27 +23213,27 @@ msgstr "Argument NCOPIES des intrinsischen REPEAT ist negativ (sein Wert ist %ld
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Argument NCOPIES des intrinsischen REPEAT ist zu groß"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "FROMPOS-Argument (%ld) außerhalb des Bereichs 0:%d in intrinsischem MVBITS"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "LEN-Argument (%ld) außerhalb des Bereichs 0:%d in intrinsischem MVBITS"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "TOPOS-Argument (%ld) außerhalb des Bereichs 0:%d in intrinsischem MVBITS"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsischem MVBITS"
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsischem MVBITS"
@@ -23289,7 +23330,7 @@ msgid "expected boolean type"
 msgstr "boolescher Typ erwartet"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "Ganzzahl erwartet"
@@ -23352,7 +23393,7 @@ msgstr "Nicht genug Argumente"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "zu viele Argumente"
@@ -23747,7 +23788,7 @@ msgstr "Profilerunterstützung für VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "Ziel-Betriebssystem unterstützt keine unausgerichteten Zugriffe"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "Profiling ist für dieses Ziel noch nicht implementiert"
@@ -23990,13 +24031,13 @@ msgstr "Ausnahme %qs"
 msgid "Global declarative %s for %s"
 msgstr "Global deklarative %s für %s"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr "%s:%d: ungültiger %<symbol_type_t%> %d"
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr "SET identifier-11 TO LOCALE"
@@ -24157,12 +24198,12 @@ msgstr "%qs ist veraltet; stattdessen %<-fstack-check%> verwenden"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs ist veraltet; stattdessen %<-fno-zero-initialized-in-bss%> verwenden"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "unbekannte autovec-Einstellung %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "unbekannte LDP/STP-Richtlinie %qs"
@@ -24587,8 +24628,8 @@ msgstr "Attribut %qE steht mit Attribut %qs in Konflikt; wird ignoriert"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "vorherige Deklaration hier"
@@ -24605,7 +24646,7 @@ msgstr "Attribut-Direktive %qE ignoriert"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "Attribut-Direktive im Bereich %<%E::%E%> ignoriert"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "Falsche Anzahl an Argumenten für das Attribut %qE angegeben"
@@ -24615,7 +24656,7 @@ msgstr "Falsche Anzahl an Argumenten für das Attribut %qE angegeben"
 msgid "expected %i or more, found %i"
 msgstr "%i oder mehr erwartet, %i gefunden"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "%i erwartet, %i gefunden"
@@ -24698,12 +24739,12 @@ msgstr "Typattribute ignoriert, nachdem Typ bereits definiert ist"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -24819,133 +24860,133 @@ msgstr "Auto-Profil enthält ungültigen Index %d für Symbolname"
 msgid "auto-profile contains invalid filename index %d"
 msgstr "Auto-Profil enthält ungültigen Index %d für Dateiname"
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr "Auto-Profil von %q+F enthält eine Inline-Funktion mit Symbolname %qs statt Symbolname %qs"
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr "entsprechender Aufruf"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr "doppelte Zählerinformation in Auto-Profil von %q+F mit relativem Ort %i, Diskriminator %i"
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr "entsprechender Quellort"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr "doppelte Aufrufstelle in Auto-Profil von %q+F mit relativem Ort %i, Diskriminator %i"
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr "sowohl Aufrufziele als auch Inline-Aufrufortsinformationen sind im Auto-Profil der Funktion %q+F mit relativem Ort %i und Diskriminator %i vorhanden"
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr "Auto-Profil von %q+F scheint einen verlorenen Diskriminator %i für den Aufruf von %qs am relativen Ort %i zu enthalten"
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr "Auto-Profil von %q+F enthält mehrere Ziele für einen direkten Aufruf mit relativem Ort %i, Diskriminator %i"
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr "Funktion enthält zwei Aufrufe desselben relativen Orts +%i, Diskriminator %i, was zum Verlust des Auto-Profils führt"
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr "Ort des ersten Aufrufs"
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr "Ort des zweiten Aufrufs"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr "Auto-Profil von %q+F enthält indirekte Aufrufziele, die nicht mit einer indirekten Aufrufanweisung zusammenhängen"
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr "Anzahl %<PRIu64> mit relativem Ort +%i, Diskriminator %i"
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr "Auto-Profil von %q+F enthält zusätzliche Anweisungen"
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, gcc-internal-format
 msgid "location is after end of function"
 msgstr "Ort ist nach dem Ende der Funktion"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr "Auto-Profil von %q+F enthält zusätzliche Aufruforte"
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr "Aufruf von %qs mit Gesamtanzahl %<PRId64>, relativem Ort +%i, Diskriminator %i"
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "Unerwartetes TAG."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr "Auto-Profil enthält doppelte Funktionsinstanz »%s«"
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "Profilingdatei %s kann nicht geöffnet werden"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr "Erkennungszahl des AutoFDO-Profils passt nicht"
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "Version %u des AutoFDO-Profils passt nicht zu %u"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "Zusammenfassung aus %s kann nicht gelesen werden"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "Zeichenkettentabelle aus %s kann nicht gelesen werden"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "Funktionsprofil aus %s kann nicht gelesen werden"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "Modulprofil aus %s kann nicht gelesen werden"
@@ -24955,7 +24996,7 @@ msgstr "Modulprofil aus %s kann nicht gelesen werden"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "Offset %qwi ist außerhalb der Grenzen der konstanten Zeichenkette"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qE ist hier deklariert"
@@ -25058,7 +25099,7 @@ msgstr "Nicht konstantes Argument 0 für %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "ungültiges Argument 0 für %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr "Drittes Argument für eingebautes %<crc%> muss eine Konstante sein"
@@ -25133,12 +25174,12 @@ msgstr "letztes Argument von %qD ist keine Ganzzahlkonstante zwischen 0 und 3"
 msgid "cannot tail-call: %s"
 msgstr "Tail-Call nicht möglich: %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "Funktionsaufruf hat zusammengesetzten Wert"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "Übergabe von zu großem Argument auf dem Stapel"
@@ -25782,342 +25823,342 @@ msgstr "Interner Fehler: basic blocks not laid down consecutively"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "Interner Fehler: number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "Interner Fehler: caller edge count invalid"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr "fehlender indirekter Aufruf in der Folge der spekulativen Aufrufe"
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr "indirekter Aufruf in der Folge der spekulativen Aufrufe hat kein Spekulationsflag"
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr "spekulative Kanten sind nicht benachbart"
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr "der direkte Aufruf von %s in der Folge der spekulativen Aufrufe hat kein Spekulationsflag"
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr "der direkte Aufruf von %s in der Folge der spekulativen Aufrufe hat speculative_id %i außerhalb des Bereichs"
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr "doppelter direkter Aufruf von %s in der Folge der spekulativen Aufrufe mit speculative_id %i"
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr "der Hash der Aufrufanweisung zeigt nicht auf die erste direkte Kante der Folge von spekulativen Aufrufen"
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr "doppelter Verweis %s in der Folge der spekulativen Aufrufe mit speculative_id %i"
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "missing direct call for speculation %i"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "missing ref for speculation %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr "Anzahl der spekulativen Ziele %i stimmt nicht mit num_speculative_call_targets %i überein"
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "Interner Fehler: aux field set for edge %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr "Interner Fehler: cgraph count invalid"
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "Interner Fehler: inline clone in same comdat group list"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "inline clone count is not compatible"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "tp_first_run must be non-negative"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "Interner Fehler: local symbols must be defined"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "Interner Fehler: externally visible inline clone"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "Interner Fehler: inline clone with address taken"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "Interner Fehler: inline clone is forced to output"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr "Inline-Klon wird aus Assemblercode heraus referenziert"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr "calls_comdat_local wird außerhalb einer comdat-Gruppe gesetzt"
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr "ungültiger Schalter »calls_comdat_local«"
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "Attribut %<malloc%> ist nur an Funktionen sinnvoll, die einen Zeiger zurückgeben"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr "Fehlzuordnung von semantischer Einlagerung"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "Interner Fehler: aux field set for indirect edge from %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "edge count is not compatible with function count"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "Anzahl der Kanten passt nicht zur Anzahl der Inline-Aufrufe"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "Interner Fehler: An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr "Kante hat sowohl call_stmt als auch lto_stmt_uid gesetzt"
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr "Interner Fehler: comdat-local function called by %s outside its comdat"
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "Interner Fehler: inlined_to pointer is wrong"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "Interner Fehler: multiple inline callers"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "Interner Fehler: inlined_to pointer set for noninline callers"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "Interner Fehler: caller edge count does not match BB count"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "Interner Fehler: indirect call count does not match BB count"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr "Verweis hat sowohl stmt als auch lto_stmt_uid gesetzt"
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "Interner Fehler: inlined_to pointer is set but no predecessors found"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "Interner Fehler: inlined_to pointer refers to itself"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "Interner Fehler: cgraph_node has wrong clone_of"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "Interner Fehler: cgraph_node has wrong clone list"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "Interner Fehler: cgraph_node is in clone list but it is not clone"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "Interner Fehler: cgraph_node has wrong prev_clone pointer"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "Interner Fehler: double linked list of clones corrupted"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "Interner Fehler: Alias has call edges"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "Interner Fehler: Alias has non-alias reference"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "Interner Fehler: Alias has more than one alias reference"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "Interner Fehler: Analyzed alias has no reference"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "Interner Fehler: No edge out of thunk node"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "Interner Fehler: More than one edge out of thunk node"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "Interner Fehler: Thunk is not supposed to have body"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "Interner Fehler: shared call_stmt:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "Interner Fehler: edge points to wrong declaration:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "Interner Fehler: an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "Interner Fehler: missing callgraph edge for call stmt:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "Interner Fehler: reference to dead statement"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr "Kante, die kein Rückruf ist, hat trotzdem callback_id"
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr "Kante hat sowohl %<callback%> als auch %<has_callback%>"
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr "Rückrufkante %s->%s hat keinen Rückruf-Übertrag"
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr "Rückrufkante %s->%s hat inkonsistente Kantenanzahl: höchstens %d erwartet, tatsächlich %d"
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr "Eine rückruftragende Kante zeigt auf __builtin_unreachable, aber ihre Rückruf-Kante %s->%s tut das nicht"
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "Kante %s->%s hat kein entsprechendes call_stmt"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "Interner Fehler: an indirect edge from %s has no corresponding call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr "fehlender Ursprung für einen Knoten in einer verschachtelten Liste"
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "origin points to a different parent"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "Interner Fehler: verify_cgraph_node failed"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "%s: section %s.%d is missing"
@@ -26882,17 +26923,17 @@ msgstr "Gesamtgröße der lokalen Objekte überschreitet das Maximum %wu"
 msgid "impossible constraint in %<asm%>"
 msgstr "unmögliche Bedingung in %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "Variable %q+D könnte von %<longjmp%> oder %<vfork%> zerstört werden"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "Argument %q+D könnte von %<longjmp%> oder %<vfork%> zerstört werden"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "Funktion gibt Aggregat zurück"
@@ -27562,7 +27603,7 @@ msgstr "%qD angegebene Grenze %E ist genau die Größe der Quelle"
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "flexibles Arrayelement %qD hat keine wohldefinierten Paddingbits für %qs"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr "PDP11-Bitfeld-Verarbeitung wird in %qs nicht unterstützt"
@@ -27602,7 +27643,7 @@ msgstr "%qD hat mehr als %u Blöcke, das geforderte Maximum für %<-fharden-cont
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr "Verweis auf das Label %qD, das innerhalb des Attributausdrucks %<assume%> definiert ist, von außerhalb des Attributs"
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr "%qD hier definiert"
@@ -27622,24 +27663,24 @@ msgstr "Dereferenzierung eines Nullzeigers"
 msgid "function may return address of local variable"
 msgstr "Funktion liefert möglicherweise Adresse einer lokalen Variablen zurück"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "Funktion liefert Adresse einer lokalen Variablen zurück"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -28529,7 +28570,7 @@ msgstr "Code erwartet zwischen %E und %E Bytes in einer Region der Größe %E"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr "%qD wird mit Zeiger %qE mit Offset%s ungleich 0 aufgerufen"
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr "zurückgegeben von %qD"
@@ -28599,204 +28640,204 @@ msgstr "in einem Aufruf der hier deklarierten Allokationsfunktion %qD"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "Unbekannte Architekturspezifikation in Speichermodell %wi für %qD"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "ungültiges Speichermodell %qs für %qD"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "ungültiges Speichermodell %wi für %qD"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr "gültige Modelle sind %e"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "ungültiges Fehler-Speichermodell %qs für %qD"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "gültige Fehler-Modelle sind %qs, %qs, %qs, %qs"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "Fehler-Speichermodell %qs kann nicht stärker als Erfolgs-Speichermodell %qs für %qD sein"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "Fehler-Speichermodell %wi kann nicht stärker als Erfolgs-Speichermodell %wi für %qD sein"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "gebundenes Argument %i mit Wert %s ist negativ, für Argument %i vom Typ Array variabler Länge vom Typ %s"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "Argument %i Wert %s ist negativ"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr "Argument %i ist null, aber der Wert des zugehörigen Größenarguments %i ist %s"
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "das verweisende Argument %u vom Typ %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "in einem Aufruf der Funktion %qD, die mit Attribut %qs deklariert wurde"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "in einem Aufruf mit Typ %qT und Attribut %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "in einem Aufruf der Funktion %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "in einem Aufruf mit Typ %qT"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr "%qD wird auf nicht alloziertem Objekt %qD aufgerufen"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr "%qD wird mit Zeiger auf nicht alloziertes Objekt %qE aufgerufen"
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr "hier zugewiesen"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD wird mit Zeiger aufgerufen, der aus einer unpassenden Allozierungsfunktion stammt"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr "%qD wird mit nicht alloziertem Zeiger aufgerufen"
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "Zeiger %qE wird möglicherweise nach %qD verwendet"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "Zeiger %qE wird nach %qD verwendet"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr "Zeiger wird möglicherweise nach %qD verwendet"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "Zeiger wird nach %qD verwendet"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, gcc-internal-format
 msgid "call to %qD here"
 msgstr "%qD wird hier aufgerufen"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr "baumelnder Zeiger %qE auf %qD wird möglicherweise verwendet"
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr "baumelnder Zeiger %qE auf %qD wird verwendet"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "baumelnder Zeiger auf %qD wird möglicherweise verwendet"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr "baumelnder Zeiger auf %qD wird verwendet"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD ist hier deklariert"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr "baumelnder Zeiger %qE auf ein unbenanntes temporäres Objekt wird möglicherweise verwendet"
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr "baumelnder Zeiger %qE auf ein unbenanntes temporäres Objekt wird verwendet"
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr "baumelnder Zeiger auf ein unbenanntes temporäres Objekt wird möglicherweise verwendet"
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "baumelnder Zeiger auf ein unbenanntes temporäres Objekt wird verwendet"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "unbenanntes temporäres Objekt wird hier definiert"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "%qD wird mit Zeiger %qE aufgerufen, der aus der unpassenden Allozierungsfunktion %qD stammt"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "%qD wird mit Zeiger aufgerufen, der aus der unpassenden Allozierungsfunktion %qD stammt"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr "Aufruf von %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "Adresse der lokalen Variable %qD wird in %qE gespeichert"
@@ -29600,346 +29641,346 @@ msgstr "Token %u hat %<y-location == %llu%>"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "ungültige Verwendung des Attributs %<fallthrough%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "virtuelle Tabelle des Typs %qD verletzt die One-Definition-Rule"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "Variable mit demselben Assemblernamen wie die virtuelle Tabelle ist in anderer Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "virtuelle Tabelle des Typs %qD enthält RTTI-Information"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr "wird aber überragt von einer Tabelle ohne RTTI-Informationen aus anderer Übersetzungseinheit"
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "RTTI wird für diesen Typ nicht funktionieren"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "die virtuelle Tabelle des in Konflikt stehenden Typs aus der anderen Übersetzungseinheit ist unterschiedlich groß"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "der in Konflikt stehende Typ aus der anderen Übersetzungseinheit hat unterschiedliche RTTI-Information"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "der in Konflikt stehende Typ aus der anderen Übersetzungseinheit"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "enthält zusätzliche virtuelle Methode %qD"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "der in Konflikt stehende Typ aus der anderen Übersetzungseinheit hat virtuelle Tabelle mit mehr Einträgen"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "virtuelle Methode %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr "sollte der virtuellen Methode %qD entsprechen, tut es aber nicht"
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "der in Konflikt stehende Typ aus der anderen Übersetzungseinheit hat virtuelle Tabelle mit unterschiedlichem Inhalt"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "Typ %qT (typedef von %qT) verletzt die One-Definition-Rule von C++"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "Typ %qT verletzt die One-Definition-Rule von C++"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "ein unterschiedlicher Typ ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr "der erste Unterschied der entsprechenden Definitionen ist Feld %qD"
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr "der erste Unterschied der entsprechenden Definitionen ist Methode %qD"
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "Typ %qT (in unbenanntem Namensraum definiert) kann nicht zum Typ %qT passen (über Grenzen von Übersetzungseinheiten hinaus)"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "Typ %qT (in unbenanntem Namensraum definiert) kann nicht passen (über Grenzen von Übersetzungseinheiten hinaus)"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "der inkompatible Typ, der in einer anderen Übersetzungseinheit definiert ist"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "Typname %qs sollte dem Typnamen %qs entsprechen"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "der inkompatible Typ ist hier definiert"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "Arraytypen haben unterschiedliche Grenzen"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "unverträgliche Rückgabetypen"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "Fehlzuordnung in implizitem this-Zeiger"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "unverträgliche Typen in Parameter %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "Typen haben unterschiedliche Anzahl von Parametern"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "Typ %qT verletzt für sich genommen die One-Definition-Rule von C++"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "Typ %qT sollte Typ %qT entsprechen"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "ein Typ mit unterschiedlicher Genauigkeit ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "ein Vektortyp mit unterschiedlicher Anzahl von Elementen ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "ein Typ mit unterschiedlichem Vorzeichen ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "er ist in einer anderen Übersetzungseinheit als Zeiger in unterschiedlichem Adressraum definiert"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "er ist in einer anderen Übersetzungseinheit als Zeiger auf einen anderen Typen definiert"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "ein Array unterschiedlicher Größe ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "hat unterschiedlichen Rückgabetyp in einer anderen Übersetzungseinheit"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "hat unterschiedliche Parameter in einer anderen Übersetzungseinheit"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "ein Typ aus einer anderen Übersetzungseinheit ist nicht polymorph"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "ein Typ aus einer anderen Übersetzungseinheit ist polymorph"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "ein Typ mit unterschiedlichen Zeigern in der virtuellen Tabelle ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "ein Typ mit unterschiedlichen Basistypen ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "ein Feld mit unterschiedlichem Namen ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "ein Feld mit selbem Namen aber unterschiedlichem Typ ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "Felder haben unterschiedliches Layout in einer anderen Übersetzungseinheit"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr "ein Feld ist ein Bitfeld, das andere jedoch nicht"
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "ein Typ mit unterschiedlicher Anzahl von Feldern ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "ein Typ mit unterschiedlicher Größe ist in einer anderer Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr "ein Typ muss konstruiert sein, der andere nicht"
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "unverträgliches Speicherlayout"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "die zusätzliche Basisklasse ist hier definiert"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] "Wenn Typ %qD »final« wäre, würde %i Aufruf devirtualisiert werden"
 msgstr[1] "Wenn Typ %qD »final« wäre, würden %i Aufrufe devirtualisiert werden"
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Wenn Typ %qD »final« wäre, würde %i Aufruf, der %lli-mal ausgeführt wurde, devirtualisiert werden"
 msgstr[1] "Wenn Typ %qD »final« wäre, würden %i Aufrufe, die %lli-mal ausgeführt wurden, devirtualisiert werden"
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] "Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf einschalten"
 msgstr[1] "Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen einschalten"
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] "Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf einschalten"
 msgstr[1] "Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen einschalten"
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf, der %lli-mal ausgeführt wurde, einschalten"
 msgstr[1] "Wenn der virtuelle Destruktor von %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen, die %lli-mal ausgeführt wurden, einschalten"
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufruf, der %lli-mal ausgeführt wurde, einschalten"
 msgstr[1] "Wenn die Methode %qD als »final« deklariert wäre, würde das die Devirtualisierung von %d Aufrufen, die %lli-mal ausgeführt wurden, einschalten"
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "Typ %qs verletzt die One-Definition-Rule von C++"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "eine Aufzählung mit anderer Anzahl von Werten ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "eine Aufzählung mit unterschiedlichen Wertnamen ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "eine Aufzählung mit anderen Werten ist in einer anderen Übersetzungseinheit definiert"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "der Name %qs unterscheidet sich vom Namen %qs, der in einer anderen Übersetzungseinheit definiert ist"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "Name %qs ist als %u-Bit definiert, in einer anderen Übersetzungseinheit jedoch als %u-Bit"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "Name %qs ist als %wd definiert, in einer anderen Übersetzungseinheit jedoch als %wd"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "Name %qs wird in einer anderen Übersetzungseinheit mit unterschiedlichem Wert definiert"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr "abweichende Definition"
@@ -29959,7 +30000,7 @@ msgstr "IPA-Inline-Zusammenfassung fehlt in Eingabedatei"
 msgid "IPA modref summary is missing in input file"
 msgstr "IPA-modref-Zusammenfassung fehlt in Eingabedatei"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "ungültige Sprungfunktion in LTO-Datenstrom"
@@ -30189,12 +30230,12 @@ msgstr "Höchstzahl der Durchläufe für LRA-Bedingungen ist erreicht (%d)"
 msgid "unable to find a register to spill"
 msgstr "Kein Register zum Auslagern gefunden"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "inkonsistente Operandenbedingungen in einem %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "Höchstzahl der erzeugten Neuladebefehle pro Befehl ist erreicht (%d)"
@@ -30561,7 +30602,7 @@ msgstr "%qs-Klausel mit %<sink%>-Modifizierer wartet auf lexikalisch spätere It
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "%qs-Klausel mit %<sink%>-Modifizierer verweist auf Iteration, die niemals im Iterationsraum ist"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr "ungültiger nicht-rechteckiger OpenMP-Schleifenschritt; %<(%E - %E) * %E%> ist kein Vielfaches von Schleife %d Schritt %qE"
@@ -31955,25 +31996,25 @@ msgid "output operand %d must use %<&%> constraint"
 msgstr "Ausgabeoperand %d muss %<&%>-Bedingung verwenden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93748
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "%s: [%u] Falsches %<next_regno%> für leere Kette (%u)"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93748
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "%s: Zyklus in %<next_regno%>-Kette (%u)"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93748
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "%s: [%u] Falsches %<oldest_regno%> (%u)"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93748
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr "%s: [%u] Nicht leeres Register in Kette (%s %u %i)"
@@ -32938,167 +32979,167 @@ msgstr "äußere Transaktion in %<transaction_safe%>-Funktion"
 msgid "ignoring loop annotation"
 msgstr "Schleifenannotation wird ignoriert"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "Konstante wird bei %<ADDR_EXPR%>-Änderung nicht neu berechnet"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "Seiteneffekte werden bei %<ADDR_EXPR%>-Änderung nicht neu berechnet"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "Adresse genommen, aber %<TREE_ADDRESSABLE%>-Bit nicht gesetzt"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "nicht-skalares %qs"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "ungültiger Positions- oder Größenoperand für %qs"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr "Genauigkeit des ganzzahligen Ergebnistypen passt nicht zur Feldgröße von %qs"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "Betriebsart-Größe des nicht-ganzzahligen Ergebnisses passt nicht zur Feldgröße von %qs"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "Operand von %qs ohne Modus-Genauigkeit"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "Position plus Größe überschreitet die Größe des referenzierten Objekts in %qs"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "Typunverträglichkeit in %qs-Verweis"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "Umwandlung von %qs auf der linken Seite eines %qs"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "Umwandlung eines Registers auf eine andere Größe in %qs"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr "nicht-Top-Level %qs"
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "ungültiger Operand für %qs"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "unverträgliche Typen in %qs"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "ungültiger Offset-Operator %qs"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "ungültiger Adressoperand in %qs"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "ungültiger Offset-Operand in %qs"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "ungültige Clique in %qs"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr "%qs in GIMPLE-IL"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr "%qs als Basis, es ist jedoch ein Nicht-Register erforderlich"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "ungültiger Ausdruck für Min-L-Wert"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "Gimple-Aufruf hat zwei Ziele"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "Gimple-Aufruf hat kein Ziel"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "ungültige Funktion in GIMPLE-Aufruf"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "Nicht-Funktion in GIMPLE-Aufruf"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "ungültiger »pure const«-Status für Funktion"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "ungültige LHS in GIMPLE-Aufruf"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr "LHS in %<noreturn%>-Aufruf"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "ungültige Umwandlung in GIMPLE-Aufruf"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "ungültige statische Kette in GIMPLE-Aufruf"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "statische Kette mit Funktion, die keine verwendet"
@@ -33109,621 +33150,621 @@ msgstr "statische Kette mit Funktion, die keine verwendet"
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "Aufruf von %<__builtin_unreachable%> oder %<__builtin_trap%> mit Argumenten"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr "%<DEFERRED_INIT%>-Aufrufe sollten die gleiche konstante Größe für das erste Argument und LHS haben"
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "ungültiges Argument für GIMPLE-Aufruf"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "ungültige Operanden in GIMPLE-Vergleich"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "Vergleichsoperandentypen passen nicht"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "In booleschem Vektorvergleich ist die Operation oder der Typ nicht unterstützt"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "Nicht-Vektoroperanden in Vektorvergleich"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "ungültiger Ergebnistyp in Vektorvergleich"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "falscher Ergebnistyp bei Vergleich"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "Nicht-Register als LHS von unärer Operation"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "ungültiger Operand in unärer Operation"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "ungültige Vektortypen in NOP-Umwandlung"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "ungültige Typen in NOP-Umwandlung"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "ungültige Typen in Adressraumumwandlung"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "ungültige Typen Festkomma-Umwandlung"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "ungültige Typen in Umwandlung zu Gleitkomma"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "ungültige Typen in Umwandlung in Ganzzahl"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "Typunverträglichkeit in %qs-Ausdruck"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "ungültiger Typen für %qs"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr "%qs sollte von einem Skalar auf einen gleichartigen Vektor abbilden"
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "ungültiger Typ für %qs"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "nicht-triviale Umwandlung in unärer Operation"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "Nicht-Register als LHS von binärer Operation"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "ungültige Operanden in binärer Operation"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "ungültige Nicht-Vektor-Operanden für %qs"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "Ungültige (Zeiger-)Operanden %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "Vektortypen erwartet in %qs"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "Typ passt nicht in binärem Ausdruck"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "Nicht-Register als LHS von ternärer Operation"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "ungültige Operanden in ternärer Operation"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr "das erste Argument eines %qs muss von booleschem Vektortyp sein und gleich viele Elemente wie das Ergebnis haben"
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "Vektortypen erwartet in %qs"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "Vektoren unterschiedlicher Elementanzahl in %qs gefunden"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "ungültiger Maskentyp in %qs"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "unerlaubte Typkombination in %qs"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "ungültige Position oder Größe in %qs"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "%qs in non-mode-precision Operanden"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "Einschub außerhalb des gültigen Bereichs in %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%qs nicht an Elementgrenze"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "nicht-triviale Umwandlung in %qs"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "ungültige linke Seite %qs für Zuweisung: %qs"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "%s auf der linken Seite einer Clobber-Anweisung"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "%qs auf der linken Seite einer Zuweisung"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "ungültiger Operand in %qs"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "ungültiges %qs-Größenargument beim Laden"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "ungültige rechte Seite für GIMPLE-Speicherung: %qs"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr "Nicht-Register als linke Seite mit Vektorkonstruktor"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "ungültiger Typ der Vektor-%qs-Elemente"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "falsche Anzahl der Vektor-%qs-Elemente"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "falscher Typ der Elemente eines Vektorkonstruktors"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr "Interner Fehler: vector %qs with non-NULL element index"
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "Interner Fehler: vector %qs element is not a GIMPLE value"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "Interner Fehler: non-vector %qs with elements"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "Interner Fehler: nontemporal store lhs cannot be a gimple register"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "Interner Fehler: invalid operand in return statement"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "Interner Fehler: invalid conversion in return statement"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "Interner Fehler: goto destination is neither a label nor a pointer"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "Interner Fehler: invalid operand to switch statement"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "Interner Fehler: non-integral type switch statement"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "Interner Fehler: invalid default case label in switch statement"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "Interner Fehler: invalid %<CASE_CHAIN%>"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "Interner Fehler: invalid case label in switch statement"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "Interner Fehler: invalid case range in switch statement"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "Interner Fehler: type precision mismatch in switch statement"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "Interner Fehler: type mismatch for case label in switch statement"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "Interner Fehler: case labels not sorted in switch statement"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "Interner Fehler: label context is not the current function declaration"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90149
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "Interner Fehler: incorrect entry in %<label_to_block_map%>"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90149
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "Interner Fehler: incorrect setting of landing pad number"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90149
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "Interner Fehler: invalid comparison code in gimple cond"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90149
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "Interner Fehler: invalid labels in gimple cond"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr "Interner Fehler: gimple cond condition cannot throw"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "Interner Fehler: invalid %<PHI%> result"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93852
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "Interner Fehler: missing %<PHI%> def"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "Interner Fehler: invalid %<PHI%> argument"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "Interner Fehler: incompatible types in %<PHI%> argument %u"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "Interner Fehler: %<verify_gimple%> failed"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "Interner Fehler: dead statement in EH table"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr "Interner Fehler: location references block not in block tree"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "Interner Fehler: local declaration from a different function"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "Interner Fehler: gimple_bb (phi) is set to a wrong basic block"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr "Interner Fehler: PHI node with location"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "Interner Fehler: incorrect sharing of tree nodes"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "Interner Fehler: virtual PHI with argument locations"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "Interner Fehler: gimple_bb (stmt) is set to a wrong basic block"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "Interner Fehler: statement marked for throw, but doesn%'t"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "Interner Fehler: statement marked for throw in middle of block"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "Interner Fehler: verify_gimple failed"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "Interner Fehler: ENTRY_BLOCK has IL associated with it"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "Interner Fehler: EXIT_BLOCK has IL associated with it"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "Interner Fehler: fallthru to exit from bb %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr "Interner Fehler: entry block count not initialized"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr "Interner Fehler: exit block count not initialized"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr "Interner Fehler: probability of edge from entry block not initialized"
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "Interner Fehler: exit block count is not compatible with entry block count"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr "Interner Fehler: count of bb %d not initialized"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr "Interner Fehler: probability of edge %d->%d not initialized"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "Interner Fehler: count of bb %d is not compatible with entry block count"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr "Interner Fehler: nonlocal label %qD is not first in a sequence of labels in bb %d"
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr "Interner Fehler: EH landing pad label %qD is not first in a sequence of labels in bb %d"
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "Interner Fehler: label %qD to block does not match in bb %d"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "Interner Fehler: label %qD has incorrect context in bb %d"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "Interner Fehler: control flow in the middle of basic block %d"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79878
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr "Interner Fehler: label %qD in the middle of basic block %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr "Interner Fehler: returns_twice call is not last in basic block %d"
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr "Interner Fehler: returns_twice call is not first in basic block %d"
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "Interner Fehler: fallthru edge after a control statement in bb %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "Interner Fehler: true/false edge after a non-GIMPLE_COND in bb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "Interner Fehler: wrong outgoing edge flags at end of bb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "Interner Fehler: explicit goto at end of bb %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "Interner Fehler: return edge does not point to exit in bb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "Interner Fehler: found default case not at the start of case vector"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "Interner Fehler: case labels not sorted: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "Interner Fehler: extra outgoing edge %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "Interner Fehler: missing edge %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "Interner Fehler: %<noreturn%> function does return"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "Interner Fehler: control reaches end of non-void function"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "Rückgabewert von %qD, die mit dem Attribut %<warn_unused_result%> deklariert wurde, wird ignoriert"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "Rückgabewert der mit dem Attribut %<warn_unused_result%> definierten Funktion wird ignoriert"
@@ -33903,12 +33944,12 @@ msgstr "Ziel unterstützt kein Aktualisieren des atomaren Profils, einfacher Mod
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "Ziel unterstützt kein Aktualisieren des atomaren Profils, einfacher Modus wird ausgewählt"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "invalid fn spec attribute \"%s\""
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "invalid fn spec attribute \"%s\" arg %i"
@@ -34432,7 +34473,7 @@ msgstr "Vektorbedingung wird stückweise ausgeweitet"
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "Vektorumverteilungsoperation wird stückweise ausgeweitet"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr "Vektorisierung für eine SIMD-Schleife nicht durchgeführt"
@@ -34852,28 +34893,28 @@ msgstr "Interner Compilerfehler: %<TYPE_CACHED_VALUES_P%> is set while it should
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "Interner Compilerfehler: %<TYPE_METHOD_BASETYPE%> is not main variant"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "Attribut %<target%> fehlt für multiversioniertes %qD"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "vorherige Deklaration von %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D steht mit der überlappenden %<target_clone%>-Deklaration in Konflikt"
 
-#: tree.cc:15804
+#: tree.cc:15824
 msgid "%qD conflicts for version %qB"
 msgstr "%qD steht für Version %qB in Konflikt"
 
-#: tree.cc:15817
+#: tree.cc:15837
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "%qD steht mit einer vorherigen Deklaration für Version %qB in Konflikt"
 
@@ -34947,7 +34988,7 @@ msgstr "In Abschnitt %qs sind nur 0-Initialisierungen erlaubt"
 msgid "no initializers are allowed in section %qs"
 msgstr "In Abschnitt %qs sind keine Initialisierungen erlaubt"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "für %q+D wurde kein Registername angegeben"
@@ -35092,7 +35133,7 @@ msgstr "%qs-Symbol %q+D zielt letztendlich auf sich selbst ab"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "%qs-Symbol %q+D muss statische Bindung haben"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "Alias-Definitionen werden in dieser Konfiguration nicht unterstützt"
@@ -35137,53 +35178,53 @@ msgstr "Gepacktes Layout"
 msgid "cannot tail-call: return value must be a call"
 msgstr "kein Endaufruf möglich: Rückgabewert muss ein Funktionsaufruf sein"
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "Attributargument %qE ist ungültig"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "Attributargument %qE an Position %i ist ungültig"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "Attributargument %qE hat Typ %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "Attributargument %qE an Position %i hat Typ %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "Attributargument %qE hat den Wert %qE, der keine Ganzzahlkonstante ist"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "Attributargument %qE an Position %i hat den Wert %qE, der keine Ganzzahlkonstante ist"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "Attributargument %qE hat den Wert %qE, der nicht auf einen Funktionsparameter verweist"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "Attributargument %qE an Position %i hat den Wert %qE, der nicht auf einen Funktionsparameter verweist"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "Attributargument %qE hat den Wert %qE, der die Anzahl der Funktionsparameter %u übersteigt"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "Attributargument %qE an Position %i hat den Wert %qE, der die Anzahl der Funktionsparameter %u übersteigt"
@@ -35198,12 +35239,12 @@ msgstr "Attributargument %qE hat den Wert %qE, der nicht auf eine variable Argum
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "Attributargument %qE an Position %i hat den Wert %qE, der nicht auf eine variable Argumentliste verweist"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "Attributargument %qE hat den Wert %qE, der auf den Parametertyp %qT verweist"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "Attributargument %qE an Position %i hat den Wert %qE, der auf den Parametertyp %qT verweist"
@@ -35410,12 +35451,12 @@ msgstr "Modus %qs kann nicht für Aufzählungstypen verwendet werden"
 msgid "mode %qs applied to inappropriate type"
 msgstr "Modus %qs auf unpassenden Typen angewendet"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "Abschnitts-Attribute werden für dieses Ziel nicht unterstützt"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "Abschnitts-Attribut nicht erlaubt für %q+D"
@@ -35425,18 +35466,18 @@ msgstr "Abschnitts-Attribut nicht erlaubt für %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "Argument des Abschnittsattributs ist keine Zeichenkettenkonstante"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "Abschnitts-Attribut kann nicht für lokale Variablen angegeben werden"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "Abschnitt von %q+D in Konflikt mit vorheriger Deklaration"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "Abschnitt von %q+D kann nicht aufgehoben werden"
@@ -35521,7 +35562,7 @@ msgstr "Argument %<counted_by%> ist kein Bezeichner"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "Attribut %qE für %<counted_by%> in Konflikt mit vorheriger Deklaration %qE"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "»inline«-Funktion %q+D als »schwach« deklariert"
@@ -35567,12 +35608,12 @@ msgstr "Attribut %qE wird ignoriert, da es sich auf eine uninitialisierte Variab
 msgid "%qE attribute is only applicable on functions"
 msgstr "Attribut %qE bezieht sich nur auf Funktionen"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "Attribut %<symver%> gilt nur für Funktionen und Variablen"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "Attribut %<symver%> bezieht sich nur auf Symbole"
@@ -35582,12 +35623,12 @@ msgstr "Attribut %<symver%> bezieht sich nur auf Symbole"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "Argument des Attributs %<symver%> ist keine Zeichenkettenkonstante"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr "Argument des Attributs »symver« muss das Format %<Name@Knotenname%> haben"
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr "Argument %qs für Attribut %<symver%> muss ein oder zwei %<@%> enthalten"
@@ -35678,23 +35719,23 @@ msgstr "Attribut %qE ignoriert, da %qT bereits definiert ist"
 msgid "visibility argument not a string"
 msgstr "Sichtbarkeitsargument ist keine Zeichenkette"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "Attribut %qE für Typen ignoriert"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "Argument von Attribut %qE muss eins von %qs, %qs, %qs oder %qs sein"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD mit anderer Sichtbarkeit redeklariert"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD wurde als %qs deklariert, was Standardsichtbarkeit mit sich bringt"
@@ -35711,7 +35752,7 @@ msgstr "Argument %qE muss eins von %qs, %qs, %qs oder %qs sein"
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "Attribut %qE kann nur auf Funktionen angewandt werden"
@@ -35782,7 +35823,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "Attribut %qE Argument 1 muss einen Zeigertyp als erstes Argument haben, hat jedoch %qT"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "Attribut %qE an einer Funktion mit Rückgabetyp %qT wird ignoriert"
@@ -35857,7 +35898,7 @@ msgstr "%qD ist mit %qD unverträglich"
 msgid "%qE argument is not a function"
 msgstr "Argument %qE ist keine Funktion"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "Veraltete Meldung ist keine Zeichenkette"
@@ -35923,7 +35964,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "Attribut %qE wird an allen Typen außer Aufzählungen ignoriert"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "Attribut %qE erfordert eine Zeichenkettenkonstante als Argument"
@@ -36086,15 +36127,15 @@ msgid "requested position is less than zero"
 msgstr "Angeforderte Position ist kleiner als Null"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "Leere Zeichenkette in Attribut %<target%>"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "Argument des Attributs %qE ist keine Zeichenkettenkonstante"
@@ -36361,7 +36402,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "Um Zuweisung, die als Wahrheitswert verwendet wird, werden Klammern empfohlen"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "Ungültige Verwendung von %<restrict%>"
@@ -36532,8 +36573,8 @@ msgstr "Zu wenige variable Argumente, um zu einem Wächter zu passen"
 msgid "missing sentinel in function call"
 msgstr "Wächter in Funktionsaufruf fehlt"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "schlechte Option %qs für Attribut %<optimize%>"
@@ -37543,7 +37584,7 @@ msgstr "nicht unterstützte Nicht-Standard-Verkettung von Zeichenkettenliteralen
 msgid "traditional C rejects string constant concatenation"
 msgstr "traditionelles C weist Zeichenkettenkonstantenverkettung zurück"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr "%<#pragma omp critical%> mit %<hint%>-Klausel erfordert einen Namen, außer wenn %<omp_sync_hint_none%> verwendet wird"
@@ -37599,7 +37640,7 @@ msgstr "%<depobj%>-Abhängigkeitstyp in %<depend%>-Klausel von %<depobj%> angege
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "%<iterator%>-Modifizierer darf nicht bei einem %<depobj%>-Konstrukt angegeben sein"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "ungültiger Typ für Schleifenvariable %qE"
@@ -37614,17 +37655,17 @@ msgstr "%<_Atomic%>-Iterationsvariable %qE"
 msgid "%qE is not initialized"
 msgstr "%qE ist nicht initialisiert"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "Steuerprädikat fehlt"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "Steuerprädikat ungültig"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "Erhöhungsausdruck fehlt"
@@ -37634,7 +37675,7 @@ msgstr "Erhöhungsausdruck fehlt"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr "Erhöhung ist weder konstant 1 noch konstant -1 für die %<!=%>-Bedingung"
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "Erhöhungsausdruck ungültig"
@@ -37729,18 +37770,18 @@ msgstr "ungültiger %<task%>-Reduktionsmodifizierer in Konstrukt, das nicht mit
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr "%<inscan%>-%<reduction%>-Klausel bei Konstruktion außer %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr "%qD ist in %<allocate%>-Klausel angegeben, aber nicht in einer expliziten Privatisierungs-Klausel"
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD ist kein Funktionsargument"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "Bitfeld %qE in %qs-Klausel"
@@ -37750,8 +37791,8 @@ msgstr "Bitfeld %qE in %qs-Klausel"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE in %qs-Klausel hat keinen zuordenbaren Typ"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%>-Ausdruck %qE in %qs-Klausel"
@@ -38266,7 +38307,7 @@ msgstr "ungültiger Ort für %<pragma %s%>, ignoriert"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "falsch geformtes %<#pragma %s%>, ignoriert"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "Ausschuss am Ende von %<#pragma %s%>"
@@ -38338,8 +38379,8 @@ msgstr "Interner Fehler: dump flags not handled here"
 msgid "wrong type argument to %s"
 msgstr "Argument falschen Typs für %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -38826,17 +38867,17 @@ msgstr "Verringerung der Funktion %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "Funktion %qD als %<asm%>-Ausgabe verwendet"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "Zuweisung der schreibgeschützten Speicherstelle %qE"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "Erhöhung der schreibgeschützten Speicherstelle %qE"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "Verringerung der schreibgeschützten Speicherstelle %qE"
@@ -39102,7 +39143,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "Argument %i wird an den mit %qs qualifizierten Parameter übergeben, dadurch wird es zum Alias für Argument %Z"
 msgstr[1] "Argument %i wird an den mit %qs qualifizierten Parameter übergeben, dadurch wird es zum Alias für die Argumente %Z"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr "diese Bedingung hat identische Zweige"
@@ -40050,7 +40091,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "ACLE-Funktion %qD erfordert ISA-Erweiterung %qs"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "Sie können %qs mit der Befehlszeilenoption %<-march%> einschalten, oder mit dem Attribut %<target%> oder Pragma"
@@ -40680,7 +40721,7 @@ msgstr "Übergabe von %qT an Argument %d von %qE, das jedoch in der %qT-Form kei
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "doppelte Definition von %qs"
@@ -40726,7 +40767,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "der SVE-Typ %qT hat keine definierte Ausrichtung"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "Variablen vom Typ %qT können keine thread-lokale Speicherdauer haben"
@@ -40777,7 +40818,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "SVE-Typ %qT ist in %<map%>-Klausel nicht erlaubt"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr "innerhalb der %<target%>-Region kann nicht auf die Objekttypen %qT verwiesen werden"
@@ -40870,19 +40911,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "der SVE-Typ %qT kann nur an prototypisierte Funktionen übergeben werden"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich in GCC 13.1 geändert"
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich in GCC 14.1 geändert"
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -40928,189 +40969,189 @@ msgstr "Aufruf einer Funktion, die einen anderen Status als %qs hat, aus einer F
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr "verwenden Sie %<__arm_preserves(\"za\")%>, wenn die aufgerufene Funktion ZA beibehält"
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr "unbekanntes Flag wurde in %<-moverride=%s%> übergeben (%s)"
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr "Zeichenkette %qs ist falsch geformt"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "ungültiges Format für %<sve_width%>"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "ungültiger Wert für %<sve_width%>: %d"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "Tuning-Zeichenkette fehlt in Option »%s«"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "unbekannte Tuning-Option »%s«"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr "die Optionen %<-mstack-protector-guard=global%> und %<-mstack-protector-guard-offset=%s%> sind unverträglich"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90153
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr "wenn %<-mstack-protector-guard=sysreg%> angegeben ist, müssen sowohl %<-mstack-protector-guard-offset%> als auch %<-mstack-protector-guard-reg%> angegeben werden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90154
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr "Systemregister mit einem kurzem Namen angeben"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs ist in %qs kein gültiger Offset"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr "%<-fsanitize=shadow-call-stack%> erfordert %<-ffixed-x18%>"
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "%<-fsanitize=shadow-call-stack%> steht in Konflikt mit der Verwendung von Register x18 durch das Zielbetriebssystem"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "%<-fsanitize=memtag-stack%> erfordert die ISA-Erweiterung %qs"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "Streaming-Funktionen erfordern die ISA-Erweiterung %qs"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "Funktionen mit SME-Zustand erfordern die ISA-Erweiterung %qs"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr "nur die Werte 12 (4 kB) und 16 (64 kB) werden für die Wächtergröße unterstützt. Der angegebene Wert %d (%llu kB) liegt außerhalb des gültigen Bereichs"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90155
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr "Größe des Stapelkollisionswächters %d muss gleich dem Sondierungsintervall %d sein"
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "ungültiges Argument für %<-mharden-sls=%>"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99291
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr "%qs muss für sich allein stehen, für %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "ungültiges Argument %qs für %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "Schalter %<-mcpu=%s%> steht mit dem Schalter %<-march=%s%> in Konflikt und hat dazu geführt, dass die Optionen %qs hinzugefügt wurden"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "Assembler unterstützt %<-mabi=ilp32%> nicht"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%<-mabi=ilp32%> ist veraltet"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr "Signieren der Rückgabeadresse wird nur für %<-mabi=lp64%> unterstützt"
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr "Codemodell %qs mit %<-f%s%>"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "Codemodell %qs wird im ilp32-Modus nicht unterstützt"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "Funktionen mit dem Status %qs erfordern die ISA-Erweiterung %qs"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "fehlender Name für Pragma oder Attribut %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "ungültiger Name %qs für Pragma oder Attribut %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "ungültiger Featuremodifizierer %qs mit Wert %qs in Pragma oder Attribut %<target()%>"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "fehlender Name für Pragma oder Attribut %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "ungültiger Name %qs für Pragma oder Attribut %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "ungültiger Featuremodifizierer %qs mit Wert %qs in Pragma oder Attribut %<target()%>"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "ungültiger Name %qs für Pragma oder Attribut %<target(\"tune=\")%>"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "fehlender Wert für Pragma oder Attribut %<target()%>"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79868
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
@@ -41118,25 +41159,25 @@ msgid "malformed %<target()%> pragma or attribute"
 msgstr "falsch geformtes Pragma oder Attribut %<target()%>"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79868
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "Pragma oder Attribut %<target(\"%s\")%> akzeptiert keine Argumente"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79868
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "Pragma oder Attribut %<target(\"%s\")%> erlaubt keine negierte Form"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "Pragma oder Attribut %<target(\"%s=%s\")%> ist nicht gültig"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41144,194 +41185,194 @@ msgstr "Pragma oder Attribut %<target(\"%s=%s\")%> ist nicht gültig"
 msgid "attribute %<target%> argument not a string"
 msgstr "Argument für Attribut %<target%> ist keine Zeichenkette"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr "der Arch-Erweiterung %qs sollte ein %<+%> vorangestellt werden"
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "Pragma oder Attribut %<target(\"%s\")%> ist nicht gültig"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "falsch geformtes Pragma oder Attribut %<target(\"%s\")%>"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "das Attribut %<target_version%> hat mehrere Werte"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "das Argument des Attributs %<target_version%> ist keine Zeichenkette"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "im Attribut %<target_version%> fehlt der Wert"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "ungültiger Featuremodifizierer %qs mit Wert %qs in Attribut %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "doppelter Featuremodifizierer %qs mit Wert %qs in Attribut %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "Multiversionierung virtueller Funktionen wird nicht unterstützt"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "Multiversionierung erfordert %<ifunc%>, was auf diesem Ziel nicht unterstützt wird"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr "%q+D hat einen inkonsistenten Prioritätswert für die Funktion mit mehreren Versionen"
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+D wurde vorher hier deklariert mit Prioritätswert %d"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr "die Parameterübergabe für das Argument vom Typ %qT mit %<[[no_unique_address]]%>-Elementen hat sich %{in GCC 10.1%} geändert"
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich, sofern C++17 aktiviert ist, so geändert, dass es C++14 %{in GCC 10.1%} entspricht"
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr "die Parameterübergabe für das Argument vom Typ %qT hat sich %{mit GCC 12.1%} geändert"
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "Spur %wd ist außerhalb des Wertebereiches %wd bis %wd"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "nicht unterstützte simdlen %wd"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "GCC bietet derzeit keine Unterstützung für Rückgabetyp %qT für SIMD-Funktionen"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "nicht unterstützter Rückgabetyp %qT für SIMD"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "GCC bietet derzeit keine Unterstützung für Parametertyp %qT für SIMD-Funktionen"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "nicht unterstützter Argumenttyp %qT für SIMD"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "GCC unterstützt derzeit %<simdlen %wd%> für Typ %qT nicht"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "GCC unterstützt derzeit kein simdclone mit simdlens %wd und %wd für diese Typen."
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "das Attribut %qs kann nicht auf %q+D angewendet werden, nachdem die Funktion definiert worden ist"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "%q+D hier definiert"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr "nichtlokale Gotos in Funktionen mit SME-Zustand"
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr "Abfangen von Nicht-Aufruf-Ausnahmen in Funktionen mit SME-Zustand"
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "Argument %d von %qE muss ein konstanter ganzzahliger Ausdruck sein"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "Übergabe von %wd an Argument %d von %qE, das jedoch den Wert %wd erwartet"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "Übergabe von %wd an das Argument %d von %qE, das einen Wert im Bereich [%wd, %wd] erwartet"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "Übergabe von %wd an Argument %d von %qE, das jedoch entweder %wd oder %wd erwartet"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "Übergabe von %wd an Argument %d von %qE, das jedoch entweder %wd, %wd, %wd oder %wd erwartet"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "Übergabe von %wd an Argument %d von %qE, das jedoch einen gültigen %qT-Wert erwartet"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "das Attribut %<target_clones%> darf keine leere Zeichenkette sein"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "ungültiger Featuremodifizierer %qs in Version %qB für Attribut %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "doppelter Featuremodifizierer %qs in Version %qB für Attribut %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "ungültiges Feature %qs in Version %qB für Attribut %<target_clones%>"
 
@@ -41519,12 +41560,12 @@ msgstr "Argument des Attributes %qE ist weder »ilink« oder »firq«"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41657,22 +41698,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "Argument des Attributs %qE wird ignoriert"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "Attribut %qE bezieht sich nur auf Variablen"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "Alternativen sind in %<asm%>-Flag-Ausgabe nicht erlaubt"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "unbekannte Ausgabe %qs des %<asm%>-Schalters"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "ungültiger Typ für %<asm%>-Schalter-Ausgabe"
@@ -42208,12 +42249,12 @@ msgstr "%<-fpie%> wird nicht unterstützt"
 msgid "%<-fPIE%> is not supported"
 msgstr "%<-fPIE%> wird nicht unterstützt"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "Funktionsattribute %qs und %qs schließen sich gegenseitig aus"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "Funktion %qs kann keine Argumente haben"
@@ -42223,7 +42264,7 @@ msgstr "Funktion %qs kann keine Argumente haben"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr "die Methode %qs hat ein implizites Argument %<this%>"
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "Funktion %qs kann keinen Wert zurückgeben"
@@ -42551,7 +42592,7 @@ msgstr "indirekter Aufruf in Funktion, das wird von eBPF nicht unterstützt"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "ungültiges Argument für eingebaute Funktion"
@@ -42867,7 +42908,7 @@ msgstr "%<vector_length (64)%> wird verwendet, %d wird ignoriert"
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr "%<vector_length (64)%> wird verwendet, Laufzeiteinstellung wird ignoriert"
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr "%<num_workers (%d)%> wird verwendet, %d wird ignoriert"
@@ -43033,168 +43074,168 @@ msgstr "Parameter für eingebaute Funktion muss Zeichenkettenkonstante oder Lite
 msgid "parameter to builtin not valid: %s"
 msgstr "Parameter für eingebaute Funktion ist ungültig: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "Interrupt-Dienst-Routinen können nicht direkt aufgerufen werden"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "Das letzte Argument muss ein 2-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "fünftes Argument muss ein 8-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "drittes Argument muss ein 8-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "Das letzte Argument muss ein 1-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "das letzte Argument muss ein 3-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "Das letzte Argument muss ein 4-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "Das letzte Argument muss ein 1-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr "»%s« erfordert die ISA-Option %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "Das letzte Argument muss ein 5-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "Das vorletzte Argument muss ein 8-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "Das letzte Argument muss ein 8-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "das dritte Argument muss eine Vergleichskonstante sein"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "Falscher Vergleichsmodus"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "Falscher Rundungsoperand"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "Der direkte Argument muss ein 4-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "Das direkte Argument muss ein 5-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "Das direkte Argument muss ein 8-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "das vierte Argument muss eins der Aufzählung %qs sein"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "Selektor muss eine Ganzzahlkonstante im Bereich [0, %wi] sein"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE erfordert unbekannte ISA-Option"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE erfordert ISA-Option %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "das zweite, dritte und vierte Argument müssen konstant sein"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ungültiges zweites Argument für %<__builtin_ia32_prefetch%>; es wird 0 verwendet"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, gcc-internal-format
 msgid "invalid third argument"
 msgstr "ungültiges drittes Argument"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr "Vorausladen von Befehlen ist aktiv im 64-Bit-Modus mit RIP-relativer Adressierung und der Option %<-mprefetchi%>; sonst bleiben sie NOPs"
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "Ungültiges viertes Argument für %<__builtin_ia32_prefetch%>; es wird 0 verwendet"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "Ungültiges drittes Argument für %<__builtin_ia32_prefetch%>; es wird 0 verwendet"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "zweites Argument muss konstant sein"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "Das letzte Argument muss ein 32-Bit-Immediate sein"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "das letzte Argument muss ein Immediate sein"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "Das letzte muss Skalierung 1, 2, 4, 8 sein"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "Das Argument zum eingebauten %<xabort%> ein 8-Bit-Direktwert sein"
@@ -43589,8 +43630,8 @@ msgstr "%qs ist kein gültiges Basisregister in %<-mstack-protector-guard-reg=%>
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr "%<-fcf-protection=full%> wird von %<-fhardened%> nicht aktiviert, da es in der Befehlszeile angegeben wurde"
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%<-fcf-protection%> ist nicht mit diesem Ziel kompatibel"
@@ -43832,7 +43873,7 @@ msgstr "das ABI der Strukturübergabe mit %<complex float%>-Element hat sich in
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "das ABI der C-Strukturübergabe mit Bitfeldern der Breite 0 hat sich in GCC %{12.1%} geändert"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr "SSE-Registerrückgabe mit SSE2 ausgeschaltet"
@@ -43857,12 +43898,12 @@ msgstr "SSE-Registerargument mit SSE ausgeschaltet"
 msgid "x87 register return with x87 disabled"
 msgstr "x87-Registerrückgabe mit ausgeschaltetem x87"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "Aufruf von %qD mit SSE-Aufrufkonvention, ohne dass SSE/SSE2 eingeschaltet ist"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr "dies ist ein GCC-Bug; ein Workaround ist, die aufgerufene Funktion mit dem »used«-Attribut zu markieren"
@@ -43873,129 +43914,129 @@ msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC
 msgstr "Das ABI der Parameterübergabe mit %d-Byte-Ausrichtung hat sich in GCC 4.6 geändert"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90163
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "%<-mcall-ms2sysv-xlogues%> ist nicht kompatibel mit %<%s%>"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "Attribut %<ms_hook_prologue%> ist mit %<-mfentry%> für 32 Bit nicht verträglich"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr "Dynamic Realign Argument Pointer (DRAP) wird in Interrupt-Service-Routinen nicht unterstützt. Ein Workaround ist, Funktionen mit Aggregat-Rückgabetypen zu vermeiden."
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "Stapel-Neuausrichtung mit %<__builtin_eh_return%> wird nicht unterstützt"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "geschachtelte Funktion mit regparm wird mit %<__builtin_eh_return%> nicht unterstützt"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%<-fsplit-stack%> unterstützt nicht fastcall mit geschachtelter Funktion"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "%<-fsplit-stack%> unterstützt nicht 2 Registerparameter für eine geschachtelte Funktion"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "%<-fsplit-stack%> unterstützt nicht 3 Registerparameter"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "%<-mtls-dialect=gnu2%> kann nur an einer Funktion mit dem Attribut %<no_caller_saved_registers%> verwendet werden"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "%<-mtls-dialect=gnu2%> kann nur mit einer Ausnahme-Serviceroutine verwendet werden"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "%<-mtls-dialect=gnu2%> kann nur mit einer Interrupt-Service-Routine verwendet werden"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr "%<V%>-Modifikator an nicht-ganzzahligem Register"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "nicht unterstützte Größe für Ganzzahlregister"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "erweiterte Register haben keine oberen Hälften"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "nicht unterstützte Operandengröße für erweitertes Register"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "Nicht-Ganzzahl-Operand mit Operandencode %<z%> verwendet"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90164
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "das ABI zum Übergeben von leeren Klassen (%qT) als Parametern hat sich mit %<-fabi-version=12%> (GCC 8) geändert"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "die Ausrichtung von %<_Atomic %T%>-Feldern wurde mit %{GCC 11.1%} geändert"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "kein Register für die Profilerstellung von %<-mcmodel=large%s%> verfügbar"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "Profiling von %<-mcmodel=large%> wird mit PIC nicht unterstützt"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr "%<__bfloat16%> ist seit GCC 13.1 von typedef %<short%> zum echten %<__bf16%> umdefiniert, Vorsicht bei impliziter Konvertierung zwischen %<__bf16%> und %<short%>; hier kann ein explizites Bitcast nötig sein"
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "Unbekanntes architekturspezifisches Speichermodell"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr "%<HLE_ACQUIRE%> wird mit %<ACQUIRE%> oder stärkerem Speichermodell nicht verwendet"
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr "%<HLE_RELEASE%> wird mit %<RELEASE%> oder stärkerem Speichermodell nicht verwendet"
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "%<-fexcess-precision=16%> ist nicht mit %<-mfpmath=387%> kompatibel"
@@ -44046,7 +44087,7 @@ msgstr "%<gp_offset%> (%ld) oder %<end_offset%> (%ld) ist kleiner als null"
 msgid "argument %qd is not a constant"
 msgstr "Argument %qd ist keine Konstante"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr "%<PRINT_OPERAND_ADDRESS%>, Null-Zeiger"
@@ -44056,7 +44097,7 @@ msgstr "%<PRINT_OPERAND_ADDRESS%>, Null-Zeiger"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "%<PRINT_OPERAND%>: Unbekanntes Satzzeichen %<%c%>"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr "%<PRINT_OPERAND%> Null-Zeiger"
@@ -44209,48 +44250,48 @@ msgstr "der Wert des Pragma oder des Attributs %<target(\"%s\")%> darf nicht lee
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "beim Attribut %<target%> ist das Argument %qs unbekannt"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "»default« darf nicht zusammen mit anderen Features in %qs festgelegt werden"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "das Zeichen vor %<;%> in Attribut %qs darf nicht leer sein"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr "im Attribut %qs darf die Priorität nicht leer sein"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr "im Attribut %qs darf die Anzahl der Features höchstens 2 sein"
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr "ungültiger Wert %qs für Attribut %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr "im Attribut %qs sollte das zweite Feature \"priority=%<Zahl%>\" sein statt %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr "im Attribut %qs fehlt der Wert für \"arch\""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "Attribut %qs wird weder in %<target_version%> noch in %<target_clones%> unterstützt"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "%qs wird im Zielattribut nicht unterstützt"
@@ -45005,7 +45046,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr "eingebaute MSP430-Funktionen sind nur innerhalb von Interrupt-Handlern einsetzbar"
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "Falscher eingebauter Code"
@@ -45230,82 +45271,82 @@ msgstr "zwischenzeitliche ptx-Datei kann nicht geöffnet werden"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "Option »%s« wird zusammen mit %<-fopenacc%> nicht unterstützt"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr "PTX-Version %<-mptx%> muss mindestens %s sein, um die ausgewählte %<-misa%> (sm_%s) zu unterstützen"
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "%<-march=%> muss angegeben werden"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "Patchbereich wird nicht angelegt, da NOPs nicht unterstützt werden"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr "statische Initialisierung der Variablen %q+D in %<.shared%>-Speicher wird nicht unterstützt"
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr "in PTX-Assembler können keine unausgerichteten Zeiger erzeugt werden"
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr "PTX unterstützt keine schwachen Deklarationen (nur schwache Definitionen)"
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "Attribut %qE erfordert den Rückgabetyp »void«"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "Attribut %qE nicht mit Speicherklasse »auto« erlaubt"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "Barrierenwert muss im Bereich [0, 15] liegen"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "Komplement-Argument muss eine Konstante sein"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr "%<vector_length (%d)%> wird verwendet, da eine vektor-partitionierbare Routine aufgerufen wird, %d wird ignoriert"
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr "%<vector_length (%d)%> wird verwendet, Laufzeiteinstellung wird ignoriert"
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr "%<vector_length (%d)%> wird verwendet, %d wird ignoriert"
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr "Variable %qD angepasst für OpenACC-Privatisierungsgrad: %qs"
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "schwache Alias-Definitionen werden in dieser Konfiguration nicht unterstützt"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "Alias-Definitionen werden in dieser Konfiguration nur für Funktionen unterstützt"
@@ -45539,321 +45580,321 @@ msgstr "Interner Fehler: expected mode %s for operand %d of insn %s but got mode
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "Interner Fehler: invalid number of operands for insn %s, expected %d but got %d.\n"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr "Übergabe von %wd an das Argument %d von %qE, das einen Wert im Bereich [%wd, %wd] oder %wd erwartet"
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "der RVV-Typ %qT hat keine feste Größe"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "der RVV-Typ %qT hat keine definierte Ausrichtung"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "Arithmetik mit Zeiger auf RVV-Typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr "Membervariablen können nicht vom RVV-Typ %qT sein"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "Felder können nicht vom RVV-Typ %qT sein"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "Arrayelemente können nicht vom RVV-Typ %qT sein"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "Objekte vom RVV-Typ %qT können nicht alloziert werden"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "Objekte vom RVV-Typ %qT können nicht gelöscht werden"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "der RVV-Typ %qT kann weder geworfen noch gefangen werden"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "der RVV-Typ %qT kann nicht durch Kopieren gefangen werden"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "RVV-Typ %qT ist in %<map%>-Klausel nicht erlaubt"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "RVV-Typ %qT ist in %<target%>-%<private%>-Klausel nicht erlaubt"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "RVV-Typ %qT ist in %<target%>-%<firstprivate%>-Klausel nicht erlaubt"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "RVV-Typ %qT ist in %<target%>-Geräteklauseln nicht erlaubt"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "eingebaute Funktion %qE erfordert die ISA-Erweiterung zvfbfmin oder zvfbfwma"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "Eingebaute Funktion %qE erfordert die ISA-Erweiterung zvfhmin oder zvfh"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "Eingebaute Funktion %qE erfordert die ISA-Erweiterung zve32f, zve64f, zve64d oder v"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "Eingebaute Funktion %qE erfordert die ISA-Erweiterung zve64d oder v"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "Eingebaute Funktion %qE erfordert die ISA-Erweiterung zve64x, zve64f, zve64d oder v"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "unerkanntes eingebaute Funktion für RVV"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "Eingebaute Funktion %qE erfordert die ISA-Erweiterung %qs"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "kein passender Funktionsaufruf für %qE mit leeren Argumenten"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "unbekannte CPU %qs für %<-mtune%>"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "diese Operation erfordert die RVV-ISA-Erweiterung"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "Sie können RVV mit der Befehlszeilenoption %<-march%>, oder mit dem Attribut %<target%> oder Pragma aktivieren"
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "ABI für abgeflachte Struktur mit Bit-Feldern der Länge 0 hat wurde mit GCC 10 geändert"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "ABI für abgeflachte leere Union und Array mit Länge 0 wurde mit GCC 16 geändert"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "der RVV-Typ %qT kann nur an prototypisierte Funktionen übergeben werden"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "%s %qT benötigt die V-ISA-Erweiterung"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT benötigt die ISA-Erweiterung zve64x, zve64f, zve64d oder v"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "%s %qT benötigt die ISA-Erweiterung zvfhmin oder zvfh"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT benötigt die ISA-Erweiterung zve32f, zve64f, zve64d oder v"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "%s %qT benötigt die ISA-Erweiterung zve64d oder v"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr "%s %qT benötigt mindestens die Vektorlänge %qd, aber %qd ist gegeben"
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "Funktionsattribut %qs erfordert die ISA-Erweiterung V"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr "der Wert %d für %<ABI_VLEN%> des Attributs %qs muss eine Zweierpotenz im Bereich [32, 16384] sein"
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "das Funktionsattribut %qs erfordert die Vektor-ISA-Erweiterung"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "das Attribut »rnmi« erfordert die ISA-Erweiterung Smrnmi"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "Argument des Attributs %qE muss %<\"supervisor\"%>, %<\"machine\"%> oder %<\"rnmi\"%> sein"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr "%qs wird nur unterstützt, wenn %<-mrvv-vector-bits=zvl%> angegeben ist"
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qs angewendet auf Nicht-RVV-Typ %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "%qs erfordert eine konstante Ganzzahl"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr "ungültige RVV-Vektorgröße %qd, erwartete Größe ist %qd basierend auf LMUL des Typs und %qs"
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr "%<-mdiv%> erfordert %<-march%>, um die %<M%>-Erweiterung zu ermitteln"
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "Derzeit erfordert die %<V%>-Implementierung die %<M%>-Erweiterung"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr "Der aktuelle RISC-V-GCC unterstützt keine VLEN größer als 4096bit für die Erweiterung »V«"
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "Der aktuelle RISC-V-GCC unterstützt RVV im Big-Endian-Modus nicht"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "Codemodell %qs mit %qs"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr "die angeforderte ABI erfordert %<-march%>, um die %qc-Erweiterung zu ermitteln"
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr "rv32e erfordert die ilp32e-ABI"
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr "rv64e erfordert lp64e-ABI"
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, gcc-internal-format
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ILP32E ABI unterstützt die %qc-Erweiterung nicht"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr "das LP64E-ABI ist im GCC als veraltet gekennzeichnet"
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr "wenn Sie LP64E benötigen, benachrichtigen Sie bitte das GCC-Projekt über %{PR116152%}"
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr "z*inx erfordert ABI ilp32, ilp32e, lp64 oder lp64e"
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "ABI erfordert %<-march=rv%d%>"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "%<-mpreferred-stack-boundary=%d%> muss zwischen %d und %d liegen"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr "%<-mriscv-attribute%> RISC-V-ELF-Attribut erfordert GNU as 2.32 [%<-mriscv-attribute%>]"
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs ist in %qs kein gültiges Basisregister"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs ist in %qs keine gültige Zahl"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qs-Funktion kann keine andere Interrupt-Art haben"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr "vl-Register für %qs kann auf diesem Ziel nicht alloziert werden"
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "ungültige Version %qB für Attribut %<target_clones%>"
 
@@ -46853,22 +46894,22 @@ msgstr "Lokale Variablenspeicheranforderungen überschreiten Kapazität"
 msgid "%<function_profiler%> support"
 msgstr "Unterstützung für %<function_profiler%>"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "%<va_start%> kann nicht in Unterbrechungsfunktion verwendet werden"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "switch-Anweisung der Größe %lu Einträge ist zu groß"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "Attribut %<__BELOW100__%> bezieht sich nur auf Variablen"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "Attribut %<__BELOW100__%> nicht mit Speicherklasse »auto« erlaubt"
@@ -47088,32 +47129,32 @@ msgstr "%qs ist geladen, aber das Symbol %qs wurde nicht gefunden: %s"
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%qs ist definiert, aber die Plugin-Unterstützung ist deaktiviert"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "Boolesche Register für die Gleitkommaoption benötigt"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "%<-f%s%> wird mit CONST16-Befehlen nicht unterstützt"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC wird benötigt, wird aber nicht mit CONST16-Befehlen unterstützt"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "Nur uninitialisierte Variablen können in einem %<.bss%>-Abschnitt platziert werden"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr "Interner Fehler: constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr "Interner Fehler: constantsynth: Methode %qs Wert nicht übereinstimmend, erwartet %wd (%wx) synthetisiert %wd (%wx)"
@@ -47199,7 +47240,7 @@ msgstr "Attribut %qs benötigt Prototypen mit benannten Argumenten"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "Attribut %qs gilt nur für variadische Funktionen"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47280,8 +47321,8 @@ msgstr "die angegebene Datei %s ist ein Verzeichnis"
 msgid "could not get size of source file"
 msgstr "Größe der Quelldatei kann nicht ermittelt werden"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "void-Wert nicht ignoriert wie es sein sollte"
@@ -47759,7 +47800,7 @@ msgstr "switch springt in Anweisungs-Ausdruck"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE als falsche Symbolart definiert"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "Attribut %qE auf %qD mit Rückgabetyp »void« angewendet"
@@ -47908,7 +47949,7 @@ msgstr "ISO-C90 unterstützt kein %<static%> oder Typkennzeichner in Parameterar
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO-C90 unterstützt %<[*]%>-Arraydeklaratoren nicht"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "%<omp::%s%> darf in diesem Kontext nicht angegeben werden"
@@ -47918,7 +47959,7 @@ msgstr "%<omp::%s%> darf in diesem Kontext nicht angegeben werden"
 msgid "%q+D is usually a function"
 msgstr "%q+D ist üblicherweise eine Funktion"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "keine vorherige Deklaration für %qD"
@@ -47994,7 +48035,7 @@ msgstr "Objekt mit volatile-Feld kann nicht in Register geladen werden"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "nicht initialisiertes %<const %D%> ist in C++ ungültig"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%q+D in »declare target«-Direktive hat keinen zuordenbaren Typ"
@@ -48194,7 +48235,7 @@ msgstr "Speicherklasse für Parameter %qE angegeben"
 msgid "storage class specified for unnamed parameter"
 msgstr "Speicherklasse für unbenannten Parameter angegeben"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "Speicherklasse für Typnamen angegeben"
@@ -48367,7 +48408,7 @@ msgstr "Typname als Funktion, die ein Array zurückgibt, deklariert"
 msgid "function definition has qualified void return type"
 msgstr "Funktionsdefinition hat qualifizierten void-Rückgabetypen"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "Typkennzeichner an Funktions-Rückgabewert ignoriert"
@@ -48494,7 +48535,7 @@ msgstr "ISO-C verbietet const- oder volatile-Funktionstypen"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "Ein Element einer Struktur oder Union kann nicht variabel modifizierten Typ haben"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "Variable oder Feld %qE als »void« deklariert"
@@ -48706,7 +48747,7 @@ msgstr "Typdefinition in Ausdruck %qs ist in C++ ungültig"
 msgid "%qT defined in underspecified object initializer"
 msgstr "%qT wurde in unvollständig angegebenem Objektinitialisierer definiert"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "Deklaration deklariert nichts"
@@ -48771,7 +48812,7 @@ msgstr "struct hat keine benannten Elemente"
 msgid "struct has no members"
 msgstr "struct hat keine Elemente"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "flexibles Arrayelement in Union ist eine GCC-Erweiterung"
@@ -48836,7 +48877,7 @@ msgstr "Redeklaration von %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr "%<enum%> deklariert aber ohne festen zugrundeliegenden Typen definiert"
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr "angegebener Modus zu klein für Aufzählungswerte"
@@ -48891,7 +48932,7 @@ msgstr "Aufzählungswert ist außerhalb des Gültigkeitsbereichs von %qs"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C vor C23 beschränkt Aufzählungswerte auf den Bereich von %<int%>"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "der inline-Funktion %qD wurde das Attribut %qs gegeben"
@@ -49041,12 +49082,12 @@ msgstr "Argument %qD passt nicht zu eingebautem Prototypen"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "Argument %qD passt nicht zum Prototypen"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "keine return-Anweisung in nicht void zurückgebender Funktion"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "Parameter %qD gesetzt, jedoch nicht verwendet"
@@ -49128,7 +49169,7 @@ msgstr "%<auto%> mit %<constexpr%> verwendet"
 msgid "two or more data types in declaration specifiers"
 msgstr "zwei oder mehr Datentypen in Deklaration"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> ist für GCC zu lang"
@@ -49232,7 +49273,7 @@ msgstr "ISO-C90 unterstützt keine booleschen Typen"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO-C unterstützt den Typen %<_Float%d%s%> erst ab C23"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<_Float%d%s%> wird für dieses Ziel nicht unterstützt"
@@ -49389,12 +49430,12 @@ msgstr "Argument für %<signed _BitInt%> muss mindestens 2 sein"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO-C unterstützt %<%s_BitInt(%d)%> erst ab C23"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr "%<#pragma omp declare reduction%>-Kombinierer verweist auf Variable %qD, die weder %<omp_out%> noch %<omp_in%> ist"
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr "%<#pragma omp declare reduction%>-Initialisierung verweist auf Variable %qD, die weder %<omp_priv%> noch %<omp_orig%> ist"
@@ -49454,37 +49495,37 @@ msgstr "der Operand %qE der %<break%>-Anweisung bezieht sich auf eine %<switch%>
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs ist ab %qs ein Schlüsselwort"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "left shift of negative value"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "Links-Schiebe-Weite ist negativ"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "Rechts-Schiebe-Weite ist negativ"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "Links-Schiebe-Weite >= Breite des Typs"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "Rechts-Schiebe-Weite >= Breite des Typs"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "Links-Schiebe-Weite >= Breite des Vektorelements"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "Rechts-Schiebe-Weite >= Breite des Vektorelements"
@@ -49504,7 +49545,7 @@ msgstr "Konfliktmarker für Versionskontrolle in Datei"
 msgid "to match this %qs"
 msgstr "andere Fundstelle von %qs ist hier"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "Zeilenende erwartet"
@@ -49514,7 +49555,7 @@ msgstr "Zeilenende erwartet"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO-C verbietet eine leere Quelldatei"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49561,8 +49602,8 @@ msgid "unknown type name %qE"
 msgstr "unbekannter Typname: %qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "Deklarationsspezifizierer erwartet"
@@ -49597,7 +49638,7 @@ msgstr "in der %<return%>-Anweisung ist das Attribut %<musttail%> mit anderen At
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "%<;%>, Bezeichner oder %<(%> erwartet"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "Präfixattribute werden für Methoden ignoriert"
@@ -49612,12 +49653,12 @@ msgstr "Präfixattribute werden für Implementierungen ignoriert"
 msgid "unexpected attribute"
 msgstr "unerwartetes Attribut"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "%<fallthrough%>-Attribut ohne darauffolgendes %<;%>"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "%<assume%>-Attribut ohne darauffolgendes %<;%>"
@@ -49660,7 +49701,7 @@ msgstr "%qs benötigt eine initialisierte Datendeklaration"
 msgid "%qs may only be used with a single declarator"
 msgstr "%qs kann nur mit einem einzelnen Deklarator verwendet werden"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "%<,%> oder %<;%> erwartet"
@@ -49694,7 +49735,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "%<__GIMPLE%>-Funktion kann keine geschachtelte Funktion sein"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "Zeichenkettenliteral erwartet"
@@ -49724,7 +49765,7 @@ msgstr "Ausdruck in statischer Behauptung ist nicht konstant"
 msgid "static assertion failed: %E"
 msgstr "statische Behauptung gescheitert: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "statische Behauptung gescheitert"
@@ -49778,8 +49819,8 @@ msgstr "das Schlüsselwort %qs kann nicht als Aufzählungskonstante verwendet we
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "Bezeichner erwartet"
@@ -49809,12 +49850,12 @@ msgstr "ungültiger Basistyp für %<enum%>"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "der auf %<enum%> basierende Typ ist zu der vorherigen Deklaration inkompatibel"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "Komma am Ende der Aufzählungsliste"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -49895,22 +49936,22 @@ msgstr "Deklarationsspezifizierer oder %<...%> erwartet"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "Klammern müssen weggelassen werden, wenn die Argumentenliste des Attributs leer ist"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "Name einer OpenMP-Direktive erwartet"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "%<directive%> oder %<sequence%> erwartet"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "Attribut %<omp::%E%> erfordert Argument"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "Attribut %qE akzeptiert keine Argumente"
@@ -49920,7 +49961,7 @@ msgstr "Attribut %qE akzeptiert keine Argumente"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO-C unterstützt %<[[]]%>-Attribute erst ab C23"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr "Objekt variabler Größe darf nicht initialisiert werden, außer mit einem leeren Initialisierer"
@@ -49950,17 +49991,17 @@ msgstr "ISO-C90 verbietet die Angabe von zu initialisierenden Unterobjekten"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "veraltete Verwendung einer bestimmten Initialisierung ohne %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "innere Schleifen müssen in %<#pragma acc loop%> perfekt geschachtelt sein"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "innere Schleifen müssen mit der %<ordered%>-Klausel perfekt geschachtelt sein"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr "innere Schleifen müssen mit der %<reduction%>-%<inscan%>-Klausel perfekt verschachtelt sein"
@@ -49970,44 +50011,44 @@ msgstr "innere Schleifen müssen mit der %<reduction%>-%<inscan%>-Klausel perfek
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr "innere Schleifen müssen in %<#pragma omp tile%> perfekt geschachtelt sein"
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr "Vermischung von OpenMP-Direktiven mit Attribut- und Pragma-Syntax in ein und derselben Anweisung"
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr "OpenMP-Attribut %<omp::decl%> an einer Anweisung"
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "unbekannter OpenMP-Direktiven-Name im Argument des Attributs %qs"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr "OpenMP-Konstrukt inmitten der %<omp::directive%>-Attribute erfordert, dass alle %<omp::directive%>-Attribute derselben Anweisung in derselben %<omp::sequence%> liegen"
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr "mehrere OpenMP-»standalone«-Direktiven unter den %<omp::directive%>-Attributen müssen sich alle innerhalb derselben %<omp::sequence%> befinden"
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr "OpenMP-»standalone«-Direktiven im Attribut %<omp::directive%> können nur in einer leeren Anweisung vorkommen"
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr "Vermischung von OpenMP-Direktiven mit Attribut- und Pragma-Syntax in derselben Deklaration"
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "Attribut %qs akzeptiert keine Argumente"
@@ -50038,7 +50079,7 @@ msgstr "ISO-C90 verbietet gemischte Deklarationen und Code"
 msgid "expected %<}%> before %<else%>"
 msgstr "%<}%> vor %<else%> erwartet"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> ohne vorheriges %<if%>"
@@ -50053,7 +50094,7 @@ msgstr "Marke am Ende einer Verbundanweisung"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "Anweisung erwartet"
@@ -50088,27 +50129,27 @@ msgstr "ISO-C unterstützt if-Deklarationen erst ab C2Y"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "Deklaration im steuernden Ausdruck muss einen Initialisierer haben"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "Deklaration erwartet"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "geschweifte Klammern um leeren Körper in einer %<if%>-Anweisung empfohlen"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "geschweifte Klammern um leeren Körper in einer %<else%>-Anweisung empfohlen"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "es wird empfohlen, explizite geschweifte Klammern zu setzen, um mehrdeutiges %<else%> zu vermeiden"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr "Schleife in dazwischenliegendem Code im OpenMP-Schleifenkörper nicht erlaubt"
@@ -50128,12 +50169,12 @@ msgstr "mehrere Schleifenvariablen in schneller Aufzählung"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "ungültiges Schleifenvariable in schneller Aufzählung"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr "fehlende Schleifenbedingung in Schleife mit %<GCC ivdep%>-Pragma"
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr "fehlende Schleifenbedingung in Schleife mit %<GCC unroll%>-Pragma"
@@ -50148,8 +50189,8 @@ msgstr "die Sammlung in schneller Aufzählung fehlt"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "doppelter %<asm%>-Qualifizierer %qE"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr "erstmals hier gesehen"
@@ -50171,12 +50212,12 @@ msgstr "ISO-C verbietet das Weglassen des mittleren Terms eines %<?:%>-Ausdrucke
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr "Division %<sizeof (%T) / sizeof (%T)%> berechnet nicht die Anzahl der Feldelemente"
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "der Operand des ersten %<sizeof%> wurde hier deklariert"
@@ -50348,7 +50389,7 @@ msgstr "ISO-C90 unterstützt den vordefinierten Bezeichner %<__func__%> nicht"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "Ausdruck erwartet"
@@ -50363,12 +50404,12 @@ msgstr "geklammerte Gruppe innerhalb eines Ausdrucks nur in einer Funktion erlau
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO-C verbietet geklammerte Gruppen innerhalb von Ausdrücken"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "der optionale zweite Parameter von %<va_start%> ist nicht das letzte benannte Argument"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr "das Makro %<va_start%> wird mit zusätzlichen Argumenten außer dem Bezeichner des letzten benannten Arguments verwendet"
@@ -50513,7 +50554,7 @@ msgstr "das Argument für %<__builtin_counted_by_ref%> muss ein Array oder Zeige
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "das Argument für %<__builtin_counted_by_ref%> muss ein Feld einer Struktur sein"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "falsche Anzahl der Argumente für %<__builtin_shuffle%>"
@@ -50553,7 +50594,7 @@ msgstr "Argument 1 in Aufruf der Funktion %qs hat den Typ %<char%>"
 msgid "rotate count is negative"
 msgstr "Rotationsanzahl ist negativ"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr "%<omp_all_memory%> darf nur in OpenMP-%<depend%>-Klausel verwendet werden"
@@ -50663,7 +50704,7 @@ msgstr "die Funktion %qD berechnet den Betrag einer dezimalen Gleitkommazahl, be
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr "die Betragsfunktion %qD bekommt hier ein Argument vom Typ %qT, erwartet jedoch einen Parameter vom Typ %qT; dadurch kann der übergebene Wert abgeschnitten werden"
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr "Aufrufe an die OpenMP-Laufzeit-API sind in dazwischenliegendem Code nicht zulässig"
@@ -50703,12 +50744,12 @@ msgstr "Methodendeklaration in Objective-C erwartet"
 msgid "no type or storage class may be specified here,"
 msgstr "hier darf kein Typ oder Speicherklasse angegeben werden,"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "leere Liste von Eigenschaftsattributen"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, gcc-internal-format
 msgid "missing property attribute"
 msgstr "Eigenschaftsattribut fehlt"
@@ -50718,57 +50759,57 @@ msgstr "Eigenschaftsattribut fehlt"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "unbekanntes Eigenschaftsattribut %<%s%s%>"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "unbekanntes Eigenschaftsattribut"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "nach dem Objective-C-Attribut %qE wird ein %<=%> erwartet"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "Selektorname für %qE erwartet"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "Methodennamen von Settern müssen mit %<:%> aufhören"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr "%<#pragma GCC unroll%> erfordert einen Zuweisungsausdruck, der zu einer nichtnegativen Ganzzahlkonstante kleiner als %u evaluiert"
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr "dazwischenliegender Code darf keine ausführbaren OpenMP-Direktiven enthalten"
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma %s%> darf nur in Verbundanweisungen verwendet werden"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> darf nur im Datei-Gültigkeitsbereich auftreten"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp scan%> darf nur in einem Schleifenkonstrukt mit %<inscan%>-%<reduction%>-Klausel verwendet werden"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> darf nur in %<#pragma omp sections%>-Konstrukt verwendet werden"
@@ -50778,12 +50819,12 @@ msgstr "%<#pragma omp section%> darf nur in %<#pragma omp sections%>-Konstrukt v
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma %s%> darf nur im Gültigkeitsbereich einer Datei verwendet werden"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "for-, while- oder do-Anweisung erwartet"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> muss zuerst kommen"
@@ -50793,11 +50834,11 @@ msgstr "%<#pragma GCC pch_preprocess%> muss zuerst kommen"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "zu viele %qs-Klauseln"
@@ -50812,58 +50853,58 @@ msgstr "Ausdruck muss ganzzahlig sein"
 msgid "%qD is not a variable"
 msgstr "%qD ist keine Variable"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD ist keine Zeigervariable"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "Collapse-Argument erfordert positiven konstanten Ganzzahlausdruck"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "%<none%> oder %<present%> erwartet"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "%<none%>, %<shared%>, %<private%> oder %<firstprivate%> erwartet"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "Interner Fehler: expected constant logical expression"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "%<data%>, %<update%>, %<enter%> oder %<exit%> erwartet"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "%<data%> erwartet"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "zu viele %<if%>-Klauseln mit %qs-Modifizierer"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "zu viele %<if%>-Klauseln"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "zu viele %<if%>-Klauseln ohne Modifizierer"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr "wenn eine der %<if%>-Klauseln einen Modifizierer verwendet, müssen alle %<if%>-Klauseln Modifizierer verwenden"
@@ -50886,22 +50927,22 @@ msgstr "Wert von %<num_threads%> muss positiv sein"
 msgid "%<num_tasks%> value must be positive"
 msgstr "Wert von %<num_tasks%> muss positiv sein"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "Wert von %<grainsize%> muss positiv sein"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "Wert von %<priority%> muss positiv sein"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "konstanter Ganzzahlausdruck mit gültigem sync-hint-Wert erwartet"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "%<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> oder %<default%> erwartet"
@@ -50911,99 +50952,99 @@ msgstr "%<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> oder
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "%<scalar%>, %<aggregate%>, %<pointer%> oder %<all%> erwartet"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "zu viele %<defaultmap%>-Klauseln mit %qs-Kategorie"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "zu viele %<defaultmap%>-Klauseln mit nicht angegebener Kategorie"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "%qs-Ausdruck muss ganzzahlig sein"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "Wert %qs muss positiv sein"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "zu viele %<static%>-Argumente"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "unerwartetes Argument"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%<tile%>-Argument muss eine positive, ganzzahlige Konstante sein"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "zu viele %<self%>-Klauseln"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "%<reproducible%> oder %<unconstrained%> erwartet"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "%<concurrent%> erwartet"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "%<teams%>, %<parallel%> oder %<thread%> erwartet"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "Argument für %<ordered%> muss ein positiver, ganzzahliger Ausdruck sein"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr "der Operator %<-%> für Reduktionen ist in OpenMP 5.2 veraltet"
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "%<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> oder Bezeichner erwartet"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "widersprüchliche Modifizierer %<monotonic%> und %<nonmonotonic%> angegeben"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "Ablauf %<runtime%> akzeptiert keinen Parameter %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "Ablauf %<auto%> akzeptiert keinen Parameter %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "Wert der Chunkgröße muss positiv sein"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "ungültige Ablaufart"
@@ -51013,38 +51054,38 @@ msgstr "ungültige Ablaufart"
 msgid "%<num_teams%> value must be positive"
 msgstr "Wert von %<num_teams%> muss positiv sein"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr "untere Grenze %qE von %<num_teams%> ist größer als obere Grenze %qE"
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "Wert von %<thread_limit%> muss positiv sein"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "Ausdruck für %<aligned%>-Klausel erfordert positiven konstanten Ganzzahlausdruck"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "%<allocator%> oder %<align%> erwartet"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr "doppelter %qs-Modifizierer"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr "Allokationsausdruck in %<allocate%>-Klausel ist vom Typ %qT statt des erwarteten %<omp_allocator_handle_t%>"
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "in der %<allocate%>-Klausel muss das Argument des %<align%>-Modifizierers eine positive konstante Zweierpotenz eines ganzzahligen Ausdrucks sein"
@@ -51059,22 +51100,22 @@ msgstr "%<traits%> oder %<memspace%> erwartet"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr "die veraltete %<%s(%s)%>-Merkmalssyntax ist in %<uses_allocators%>-Klauseln mit Modifikatoren nicht erlaubt"
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr "die Angabe von Argumenten für %<uses_allocators%>, wobei jedes Element die Form %<allocator(traits)%> hat, ist seit OpenMP 5.2 veraltet"
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr "die Klausel %<uses_allocators%> akzeptiert bei Verwendung von Modifikatoren nur einen einzigen Allokator"
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "mehrere »linear«-Modifizierer"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "mehrere %<step%>-Modifizierer"
@@ -51084,7 +51125,7 @@ msgstr "mehrere %<step%>-Modifizierer"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "Schrittweite der %<linear%>-Klausel muss ganzzahlig sein"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr "die Angabe der Listenelemente als Argumente für die Modifikatoren ist seit OpenMP 5.2 veraltet"
@@ -51099,312 +51140,312 @@ msgstr "Ausdruck der %<safelen%>-Klausel erfordert positiven konstanten Ganzzahl
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "Ausdruck der %<simdlen%>-Klausel erfordert positiven konstanten Ganzzahlausdruck"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr "der Modifikator %<sink%> mit der Klausel %<depend%> ist seit OpenMP 5.2 veraltet; verwenden Sie stattdessen %<doacross%>"
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr "der Modifikator %<source%> mit der Klausel %<depend%> ist seit OpenMP 5.2 veraltet; verwenden Sie stattdessen %<doacross%>"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79924
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "Modifizierer %<iterator%> ist unverträglich mit %qs"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "ungültige Abhängigkeitsart"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "ungültige »doacross«-Art"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "Modifizierer %<fallback%> erwartet"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "%<abort%>, %<default_mem%> oder %<null%> als Fallback-Modus erwartet"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "Wert von %<dyn_groupprivate%> muss 0 oder positiv sein"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr "unerlaubtes Komma"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "zu viele %<always%>-Modifizierer"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "zu viele %<close%>-Modifizierer"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr "zu viele %<iterator%>-Modifizierer"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr "zu viele %<mapper%>-Modifizierer"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr "in %<declare mapper%>-Direktiven muss der Parameter für den Modifikator %<mapper%> %<default%> sein"
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr "Bezeichner oder %<default%> erwartet"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "zu viele %<present%>-Modifizierer"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "%<map%>-Klausel mit einem anderen map-type-Modifikator als %<always%>, %<close%>, %<iterator%>, %<mapper%> oder %<present%>"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr "%<map%>-Klauselmodifikatoren ohne Komma-Trennung sind seit OpenMP 5.2 veraltet"
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "ungültige Zuordnungsart"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr "%<ancestor%>-Gerätemodifikator, dem keine %<requires%>-Direktive mit %<reverse_offload%>-Klausel vorausgeht"
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "%<ancestor%> oder %<device_num%> erwartet"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "der Ausdruck der %<device%>-Klausel muss den Wert %<1%> haben"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "ungültige »dist_schedule«-Art"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr "%<master%>-Affinität ist seit OpenMP 5.1 veraltet, verwenden Sie %<primary%>"
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "ungültige »proc_bind«-Art"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "%<host%>, %<nohost%> oder %<any%> erwartet"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "%qs-Klausel mit einem anderen Modifikator als %<iterator%> oder %<present%>"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "Argument für %<partial%> muss ein positiver, ganzzahliger Ausdruck sein"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr "Ereignishandle in %<detach%>-Klausel ist vom Typ %qT statt des erwarteten %<omp_event_handle_t%>"
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr "das String-Literal darf kein %<\\0%> enthalten"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "unbekannter fremder Laufzeit-Bezeichner %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "Stringliteral oder Ganzzahlkonstante erwartet"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr "unbekannter fremder Laufzeit-Bezeichner %qwd"
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "Präferenzselektor %<fr%> oder %<attr%> erwartet"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr "doppelter %<fr%>-Präferenzselektor"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr "Stringliteral für %<attr%> muss mit %<ompx_%> beginnen"
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr "Stringliteral für %<attr%> darf kein Komma enthalten"
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr "nichtleeres Stringliteral erwartet"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "doppelter %<targetsync%>-Modifizierer"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "doppelter %<target%>-Modifizierer"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "doppelter %<prefer_type%>-Modifizierer"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "%<prefer_type%>, %<target%> oder %<targetsync%> erwartet"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr "fehlender erforderlicher Modifikator %<target%> und/oder %<targetsync%>"
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "OpenACC-Klausel erwartet"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs ist für %qs ungültig"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr "Klauseln in %<simd%>-Eigenschaft sollten durch %<,%> getrennt werden"
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs muss die erste Klausel von %qs sein"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr "die Klausel %<to%> mit %<declare target%> ist seit OpenMP 5.2 veraltet; verwenden Sie stattdessen %<enter%>"
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "OpenMP-Klausel erwartet"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "keine gültigen Klauseln in %<#pragma acc declare%> angegeben"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "Arrayabschnitt in %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "In %<#pragma acc declare link%> muss %qD eine globale Variable sein"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "ungültige OpenACC-Klausel im Datei-Gültigkeitsbereich"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "ungültige Verwendung der %<extern%>-Variable %qD in %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "ungültige Verwendung der %<global%>-Variable %qD in %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "%qD muss eine Variable sein, die im selben Gültigkeitsbereich wie %<#pragma acc declare%> deklariert ist"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "Variable %qD wird in %<#pragma acc declare%> mehr als einmal verwendet"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "hinter %<#pragma acc %s%> wird %<data%> erwartet"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma acc %s data%> hat keine Datenverschiebeklausel"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr "das %<host_data%>-Konstrukt erfordert eine %<use_device%>-Klausel"
@@ -51419,7 +51460,7 @@ msgstr "%qE wurde nicht deklariert"
 msgid "expected function name"
 msgstr "Funktionsname erwartet"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD bezeichnet keine Funktion"
@@ -51429,22 +51470,22 @@ msgstr "%qD bezeichnet keine Funktion"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma acc routine%> muss direkt vor einer Funktionsdeklaration oder -definition auftreten"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma acc routine%> muss direkt vor einer Deklaration oder Definition einer einzelnen Funktion auftreten"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> muss vor Verwendung angewendet werden"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> muss vor Definition angewendet werden"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> muss mindestens eine %<device%>- oder %<host%>- or %<self%>-Klausel enthalten"
@@ -51469,7 +51510,7 @@ msgstr "die in der %<allocator%>-Klausel verwendete Variable %qD darf zwischen d
 msgid "modified here"
 msgstr "hier verändert"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "in der %<align%>-Klausel muss das Argument eine positive konstante Zweierpotenz eines ganzzahligen Ausdrucks sein"
@@ -51504,110 +51545,110 @@ msgstr "%<allocator%>-Klausel für statische Variable %qD erforderlich"
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr "die %<allocator%>-Klausel erfordert einen vordefinierten Allokator, da %qD statisch ist"
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "eine der Klauseln %<read%>, %<write%>, %<update%> oder %<capture%> erwartet"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "%<seq_cst%>, %<acquire%> oder %<relaxed%> erwartet"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "eine der Klauseln %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> oder %<hint%> erwartet"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "zu viele atomare Klauseln"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "zu viele Speicherreihenfolge-Klauseln"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "Klausel %qs ist unverträglich mit den Klauseln %<read%> oder %<write%>"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "%qs-Klausel erfordert %qs-Klausel"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic write%> inkompatibel mit %<acquire%>-Klausel, die implizit von einer %<requires%>-Direktive bereitgestellt wird"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic read%> inkompatibel mit %<release%>-Klausel, die implizit von einer %<requires%>-Direktive bereitgestellt wird"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp atomic read%> ist unverträglich mit der Klausel %<release%>"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp atomic write%> ist unverträglich mit der Klausel %<acquire%>"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "in der %<if%>-Bedingung wird ein Vergleich mit %<==%> erwartet"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr "in der %<if%>-Bedingung wird ein Vergleich mit %<==%>, %<<%> oder %<>%> erwartet"
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "ungültige Form von %<#pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "unerwartetes %<else%> gefunden"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "ungültige Form von %<#pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "ungültige Form von %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "ungültiger Operator für %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr "%<weak%>-Klausel erfordert atomaren Gleichheitsvergleich"
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> verwendet zwei unterschiedliche Ausdrücke für Speicher"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "Ausdruck %<depobj%> ist kein lvalue-Ausdruck"
@@ -51617,27 +51658,27 @@ msgstr "Ausdruck %<depobj%> ist kein lvalue-Ausdruck"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "%<destroy%>-Ausdruck ist kein Lvalue-Ausdruck"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr "der %<destroy%>-Ausdruck %qE sollte mit dem %<depobj%>-Argument %qE identisch sein"
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "%<in%>, %<out%>, %<inout%>, %<mutexinoutset%> oder %<inoutset%> erwartet"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "eine der Klauseln %<depend%>, %<destroy%> oder %<update%> erwartet"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "%<seq_cst%>, %<acq_rel%>, %<release%> oder %<acquire%> erwartet"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr "%<flush%>-Liste wurde zusammen mit Speicherreihenfolge-Klausel angegeben"
@@ -51647,32 +51688,32 @@ msgstr "%<flush%>-Liste wurde zusammen mit Speicherreihenfolge-Klausel angegeben
 msgid "expected %<(%> or end of line"
 msgstr "%<(%> oder Zeilenende erwartet"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr "%<[[omp::directive(%s)]]%> muss das einzige angegebene Attribut in einer Anweisung sein"
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp scan%> mit 0 vorhergehenden ausführbaren Anweisungen"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "%<inclusive%>- oder %<exclusive%>-Klausel erwartet"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "%<#pragma omp scan%> erwartet"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp scan%> mit 0 nachfolgenden ausführbaren Anweisungen"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "für Anweisung erwartet"
@@ -51680,68 +51721,68 @@ msgstr "für Anweisung erwartet"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, gcc-internal-format
 msgid "loop nest expected"
 msgstr "Schleifenschachtelung erwartet"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr "andere Attribute als OpenMP-Direktiven sind für %<for%> in Schleifenschachtelungen nicht zulässig"
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr "%<unroll%>-Konstrukt mit %<partial%>-Klausel erzeugt nur eine Schleife mit kanonischer Form, aber %d Schleifen werden benötigt"
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr "die generierte Schleife des %<unroll%>-Konstrukts ohne %<partial%>-Klausel hat keine kanonische Form"
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr "%<tile%>-Konstrukt erzeugt %d Schleifen mit kanonischer Form, aber %d Schleifen werden benötigt"
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr "%<for%>-Schleife oder OpenMP-Schleifenumwandlungskonstrukt erwartet"
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "Schleifendeklaration oder Initialisierung erwartet"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "nicht genügend geschachtelte Schleifen"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "%<ordered%>-Klauselparameter ist weniger als %<collapse%>"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "Schleifenvariable %qD sollte nicht »firstprivate« sein"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr "das Konstrukt %<master%> ist seit OpenMP 5.1 veraltet; verwenden Sie stattdessen %<masked%>"
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp ordered%> mit %qs-Klausel darf nur in Verbundanweisungen verwendet werden"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "%<for%> hinter %qs erwartet"
@@ -51751,7 +51792,7 @@ msgstr "%<for%> hinter %qs erwartet"
 msgid "expected a function name"
 msgstr "ein Funktionsname erwartet"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, gcc-internal-format
 msgid "expected target-function call"
 msgstr "Zielfunktionsaufruf erwartet"
@@ -51761,47 +51802,47 @@ msgstr "Zielfunktionsaufruf erwartet"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma omp dispatch%> kann nur vor einem Funktionsaufruf mit optionaler Zuweisung stehen"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "%<point%> erwartet"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target data%> mit Zuordnungstyp außer %<to%>, %<from%>, %<tofrom%> oder %<alloc%> an %<map%>-Klausel"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp target data%> muss mindestens eine %<map%>-, %<use_device_ptr%>- oder %<use_device_addr%>-Klausel enthalten"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp target update%> muss mindestens eine %<from%>- oder %<to%>-Klausel enthalten"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target enter data%> mit Zuordnungstyp außer %<to%>, %<tofrom%> oder %<alloc%> an %<map%>-Klausel"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target enter data%> muss mindestens eine %<map%>-Klausel enthalten"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp target exit data%> mit Zuordnungstyp außer %<from%>, %<tofrom%>, %<release%> oder %<delete%> an %<map%>-Klausel"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target exit data%> muss mindestens eine %<map%>-Klausel enthalten"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target%> mit Zuordnungstyp außer %<to%>, %<from%>, %<tofrom%> oder %<alloc%> an %<map%>-Klausel"
@@ -51816,57 +51857,57 @@ msgstr "%<#pragma omp declare %s%> muss von einer Funktionsdeklaration oder -def
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> muss vor der Deklaration oder Definition einer Funktion auftreten"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "Name des Merkmalsselektors erwartet"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "unbekannter Selektor %qs für Kontextselektormenge %qs"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "Selektor %qs akzeptiert keine Eigenschaften"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<score%> kann nicht in Traits in der Trait-Selektor-Menge %qs angegeben werden"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "das %<score%>-Argument muss ein konstanter ganzzahliger Ausdruck sein"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "das %<score%>-Argument darf nicht negativ sein"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "Bezeichner oder Zeichenkettenliteral erwartet"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "Eigenschaft muss ein ganzzahliger Ausdruck sein"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "Eigenschaften für %<simd%>-Selektor dürfen nicht in %<metadirective%> angegeben werden"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "der %<requires%>-Selektor wird noch nicht unterstützt"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "Name der Kontextselektormenge erwartet"
@@ -51876,27 +51917,27 @@ msgstr "Name der Kontextselektormenge erwartet"
 msgid "variant %qD is not a function"
 msgstr "Variante %qD ist keine Funktion"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr "die Variante %qD ist eine eingebaute"
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "Variante %qD ist dieselbe wie die Basisfunktion"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "eine der Klauseln %<match%>, %<adjust_args%> oder %<append_args%> erwartet"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "zu viele %<match%>-Klauseln"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "%qD ist mehrfach angegeben"
@@ -51906,7 +51947,7 @@ msgstr "%qD ist mehrfach angegeben"
 msgid "%qD is not of pointer type"
 msgstr "%qD hat keinen Zeigertyp"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "%<nothing%> oder %<need_device_ptr%> erwartet"
@@ -51916,17 +51957,17 @@ msgstr "%<nothing%> oder %<need_device_ptr%> erwartet"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%<need_device_addr%> ist für C ungültig"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "%<nothing%> oder %<need_device_ptr%> erwartet, gefolgt von %<:%>"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "%<interop%> erwartet"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "%<match%>-Klausel erwartet"
@@ -51946,12 +51987,12 @@ msgstr "%<append_args%> mit prototyploser Basisfunktion wird noch nicht unterst
 msgid "base function %qD declared here"
 msgstr "Basisfunktion %qD ist hier deklariert"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "Argument %d von %qD muss vom Typ %<omp_interop_t%> sein"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "%<append_args%> ist hier angegeben"
@@ -51961,7 +52002,7 @@ msgstr "%<append_args%> ist hier angegeben"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "Variante %qD und Basis %qD haben unverträgliche Typen nach %<append_args%>-Anpassung"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "Variante %qD und Basis %qD haben unverträgliche Typen"
@@ -51971,7 +52012,7 @@ msgstr "Variante %qD und Basis %qD haben unverträgliche Typen"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "hinter %<#pragma omp declare %s%> muss direkt eine Funktionsdeklaration oder -definition stehen"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "hinter %<#pragma omp declare %s%> muss direkt eine einzelne Funktionsdeklaration oder -definition stehen"
@@ -51986,84 +52027,84 @@ msgstr "%<#pragma omp declare %s%> kann nicht zusammen mit Multiversionierung vo
 msgid "no declaration of base function %qs"
 msgstr "keine Deklaration der Basisfunktion %qs"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "Definition der Funktionsvariante entspricht nicht der Deklaration von %qE"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr "die Verwendung von %<omp declare target%> als Synonym für %<omp begin declare target%> ist seit OpenMP 5.2 veraltet"
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD ist sowohl in %<link%>- als auch %qs-Klauseln des Deklarationsziels angegeben"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "%qD ist sowohl im Deklarationsziel %<link%> als auch in %<to%>- oder %<enter%>-Klauseln angegeben"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr "Direktive mit nur %<device_type%>- oder %<indirect%>-Klauseln"
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "die %<device_type%>-Klausel muss 'any' angeben, wenn sie mit einer %<indirect%>-Klausel verwendet wird"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "%<match%> erwartet"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "%<target%> oder %<variant%> erwartet"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "%<declare target%>, %<declare variant%> oder %<assumes%> erwartet"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma omp end declare target%> ohne zugehöriges %<#pragma omp declare target%> oder %<#pragma omp begin declare target%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr "%qs beginnt in der Attributsyntax, wird aber mit %qs in der Pragmasyntax abgeschlossen"
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%qs beginnt in der Pragmasyntax, wird aber mit %qs in der Attributsyntax abgeschlossen"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma omp end declare variant%> ohne zugehöriges %<#pragma omp begin declare variant%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr "%<begin declare variant%> beginnt in der Attributsyntax, endet aber mit %<end declare variant%> in der Pragmasyntax"
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr "%<begin declare variant%> beginnt in der Pragmasyntax, endet aber mit %<end declare variant%> in der Attributsyntax"
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "%<declare%> oder %<assumes%> erwartet"
@@ -52088,12 +52129,12 @@ msgstr "Redeklaration von %qs %<#pragma omp declare mapper%> für Typ %qT"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%<#pragma omp declare mapper%> wurde vorher hier deklariert"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, gcc-internal-format
 msgid "unexpected clause"
 msgstr "unerwartete Klausel"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "fehlende %<map%>-Klausel"
@@ -52153,32 +52194,32 @@ msgstr "eins der Argumente für den Initialisierungsaufruf sollte %<&omp_priv%>
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "%<simd%>, %<reduction%>, %<target%> oder %<variant%> erwartet"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "%<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> oder %<seq_cst%> erwartet"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr "eine der Klauseln %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> oder %<atomic_default_mem_order%> erwartet"
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr "%qs-Klausel wird lexikalisch nach dem ersten Zielkonstrukt oder nach der ersten Auslagerungs-API verwendet"
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr "mehr als eine %<atomic_default_mem_order%>-Klausel in einer einzigen Übersetzungseinheit"
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr "%<atomic_default_mem_order%>-Klausel wird lexikalisch nach dem ersten %<atomic%>-Konstrukt ohne Speicherreihenfolge-Klausel verwendet"
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr "%<#pragma omp requires%> erfordert mindestens eine Klausel"
@@ -52193,160 +52234,160 @@ msgstr "Typ %qT mit Größe 0 in %<reduction%>-Klausel"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "Typ %qT mit variabler Länge in %<reduction%>-Klausel"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "%<sizes%> erwartet"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%<sizes%>-Argument muss eine positive, ganzzahlige Konstante sein"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "eine der Klauseln %<at%>, %<severity%> oder %<message%> erwartet"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "%qs oder %qs erwartet"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp error%> mit %<at(execution)%>-Klausel darf nur in Verbundanweisungen verwendet werden"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp error%> mit %<at(execution)%>-Klausel darf nicht in intervenierendem Code verwendet werden"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr "%<#pragma omp error%> gefunden: %s"
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr "%<#pragma omp error%> gefunden"
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "mindestens eine Annahme-Klausel erwartet"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr "Name einer Direktive erwartet"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr "ungültiger Name einer OpenMP-Direktive im Argument der %qs-Klausel: deklarative, informative und Meta-Direktiven sind nicht erlaubt"
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr "unbekannter OpenMP-Direktiven-Name im Argument der %qs-Klausel"
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr "%<%s%s%s%s%s%>-Direktive wird sowohl in %<absent%>- als auch %<contains%>-Klauseln erwähnt"
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr "%<%s%s%s%s%s%>-Direktive wird mehrfach in %qs-Klauseln erwähnt"
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "unbekanntes Annahme-Klausel %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "Annahme-Klausel erwartet"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "eine der Klauseln %<when%>, %<otherwise%> oder %<default%> erwartet"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr "die Klausel %<default%> in Metadirektiven ist seit OpenMP 5.2 veraltet; verwenden Sie stattdessen %<otherwise%>"
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "zu viele %<otherwise%>- oder %<default%>-Klauseln in %<metadirective%>"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "die Klauseln %<otherwise%> oder %<default%> müssen als letztes in %<metadirective%> angegeben werden"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, gcc-internal-format
 msgid "unknown directive name"
 msgstr "Unbekannte Direktivenname"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr "Metadirektiven können nicht als Varianten von %<metadirective%> verwendet werden"
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr "deklarative Direktivenvarianten von %<metadirective%> werden nicht unterstützt"
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr "%<omp groupprivate%>"
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE nach erster Verwendung als %<threadprivate%> deklariert"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "automatische Variable %qE kann nicht %<threadprivate%> sein"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE hat unvollständigen Typen"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%> ohne eingeschaltete Unterstützung für transaktionsgebundenen Speicher"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%> ohne eingeschaltete Unterstützung für transaktionsgebundenen Speicher"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%> ohne eingeschaltete Unterstützung für transaktionsbasierten Speicher"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> innerhalb eines %<__transaction_relaxed%>"
@@ -52356,7 +52397,7 @@ msgstr "%<__transaction_cancel%> innerhalb eines %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "Funktionsaufruf von %<__transaction_cancel%> nicht innerhalb von äußerer %<__transaction_atomic%>- oder %<transaction_may_cancel_outer%>-Funktion"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> nicht innerhalb von %<__transaction_atomic%>"
@@ -52371,7 +52412,7 @@ msgstr "fehlende schließende geschweifte Klammer"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD hat unvollständigen Typ %qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "falsche Verwendung eines void-Ausdruckes"
@@ -52402,167 +52443,167 @@ msgstr "falsche Verwendung des unvollständigen typedef %qT"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT und %qT sind in disjunkt benannten Adressräumen"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "Attribut %qs gilt nur für variadische Funktionen"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "Funktionstypen nicht wirklich kompatibel in ISO-C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "Operanden von dezimalen Gleitkomma- und Vektortypen können nicht gemischt werden"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "Operanden von dezimalen Gleitkomma- und komplexen Typen können nicht gemischt werden"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "Operanden von dezimalen und anderen Gleitkommatypen können nicht gemischt werden"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr "%<_Complex _BitInt(%d)%> wird nicht unterstützt"
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "ungültige Verwendung von Zeigern auf Arrays mit unterschiedlichen Qualifizierern in ISO C vor C23"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "Typen nicht ganz kompatibel"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "Zeiger-Zieltypen sind in C++ inkompatibel"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "Funktionsrückgabetypen nicht kompatibel wegen %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "Umwandlung eines zusammengesetzten Arrayliterals in einen Zeiger führt in C++ zu einem baumelnden Zeiger"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "das Attribut %<counted_by%> ist für einen Zeiger auf eine Struktur oder Union mit flexiblen Array-Elementen nicht zulässig"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT hat kein Element namens %qE; meinten Sie %qE?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT hat kein Element namens %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "Zugriff auf ein Element %qE einer atomaren Struktur %qE"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "Zugriff auf ein Element %qE einer atomaren Union %qE"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qE ist ein Zeiger auf einen Zeiger; wollten Sie ihn dereferenzieren, bevor Sie %<->%> darauf anwenden?"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qE ist ein Zeiger; meinten Sie %<->%>?"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "Anfrage nach Element %qE in etwas, was keine Struktur oder Variante ist"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "Dereferenzierung eines %<void *%>-Zeigers"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "indizierter Wert ist weder Array noch Zeiger noch Vektor"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "Arrayindex ist keine Ganzzahl"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "indizierter Wert ist Zeiger auf Funktion"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, gcc-internal-format
 msgid "array subscript is negative"
 msgstr "Arrayindex ist negativ"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO-C verbietet vor C2Y, ein %<register%>-Array zu indizieren"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO-C90 verbietet, ein Nicht-L-Wert-Array zu indizieren"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr "unvollständig angegebenes %qD wird in seinem Initialisierer referenziert"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "die Aufzählungskonstante ist in C++ nicht sichtbar, da sie in einer Struktur oder Union definiert ist"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "enum-Konstante hier definiert"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr "%<sizeof%> auf Array-Funktionsparameter %qE gibt die Größe von %qT zurück"
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "gerufenes Objekt %qE ist keine Funktion oder Funktionszeiger"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "gerufenes Objekt %qD ist keine Funktion oder Funktionszeiger"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "gerufenes Objekt ist keine Funktion oder Funktionszeiger"
@@ -52570,1850 +52611,1850 @@ msgstr "gerufenes Objekt ist keine Funktion oder Funktionszeiger"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "Funktion über nicht kompatiblen Typen aufgerufen"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "Funktion mit qualifiziertem void-Rückgabetypen aufgerufen"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "Typ des formalen Parameters %d ist unvollständig"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als Ganzzahl statt Gleitkomma aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als Ganzzahl statt komplex aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als komplex statt Gleitkomma aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als Gleitkomma statt Ganzzahl aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als komplex statt Ganzzahl aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als Gleitkomma statt komplex aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als %<float%> statt %<double%> aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als %qT statt %qT aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "Übergabe des Arguments %d von %qE mit anderer Breite aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als vorzeichenlos aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "Übergabe des Arguments %d von %qE als vorzeichenbehaftet aufgrund des Prototyps"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "zu viele Argumente für Methode %qE; %i erwartet, %i bekommen"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "zu viele Argumente für Funktion %qE; %i erwartet, %i bekommen"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "zu viele Argumente für eingebaute Funktion %qE, nur %d erwartet"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr "ISO-C23 erlaubt keine Argumente für die Methode %qE, die ohne Parameter deklariert ist"
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "ISO-C23 erlaubt keine Argumente für die Funktion %qE, die ohne Parameter deklariert ist"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "implizite Umwandlung von %qT in %qT bei Übergabe von Argument an Funktion"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "zu wenige Argumente für Funktion %qE; mindestens %i erwartet, %i bekommen"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "zu wenige Argumente für Funktion %qE; %i erwartet, %i bekommen"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "zu wenige Argumente für eingebaute Funktion %qE, %u erwartet"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "Vergleich mit Zeichenkettenliteral führt zu unspezifiziertem Verhalten"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "Vergleich zwischen Zeiger und '\\0'"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "wollten Sie vielleicht den Zeiger dereferenzieren?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "Null als Nullzeigerkonstante"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "Vergleich zwischen %qT und %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "Zeiger des Typs %<void *%> in Subtraktion verwendet"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "Zeiger auf eine Funktion in Subtraktion verwendet"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "Arithmetik mit Zeiger auf unvollständigen Typen"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "Arithmetik mit Zeiger auf leeres Aggregat"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> auf booleschem Ausdruck"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "meinten Sie ein logisches Nicht (%<!%>)?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO-C unterstützt nicht %<~%> für komplexe Konjugation"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "falsches Typargument für »absu«"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "Argument falschen Typs für unäres Ausrufungszeichen"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "Schrittweite von Aufzählungswerten (enum) ist in C++ ungültig"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "Verringerung von Aufzählungswerten (enum) ist in C++ ungültig"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "Inkrementieren eines booleschen Ausdrucks"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "Dekrementieren eines booleschen Ausdrucks"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO-C unterstützt %<++%> und %<--%> für komplexe Typen erst ab C2Y"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "Argument falschen Typs für Inkrementierung"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "Argument falschen Typs für Dekrementierung"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "Inkrementieren eines Zeigers auf unvollständigen Typ %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "Dekrementieren eines Zeigers auf unvollständigen Typ %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "Adresse des Ausdrucks des Typs %<void%> wird genommen"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "die Adresse des Bit-Feldes %qD kann nicht ermittelt werden"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "Adresse eines Skalars mit umgekehrter Speicherreihenfolge kann nicht ermittelt werden"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "Adresse eines Arrays mit umgekehrter Speicherreihenfolge angefordert"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr "Adresse des mit »register« deklarierten zusammengesetzten Literals angefordert"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "globale Register-Variable %qD in verschachtelter Funktion verwendet"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "Register-Variable %qD in verschachtelter Funktion verwendet"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "Adresse der globalen Variablen %qD angefordert"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "Adresse der Register-Variablen %qD angefordert"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "Nicht-L-Wert-Array in bedingtem Ausdruck"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "unterschiedliche Aufzählungstypen in Bedingung sind in C++ ungültig: %qT gegenüber %qT"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "implizite Umwandlung von %qT in %qT um an anderes Ergebnis von Bedingung anzupassen"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr "Operand von %<?:%> wechselt das Vorzeichen von %qT nach %qT, aufgrund der Vorzeichenlosigkeit des anderen Operanden"
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO-C verbietet bedingten Ausdruck mit nur einer void-Seite"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "Zeiger auf disjunkte Adressräume in bedingtem Ausdruck verwendet"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "Zeiger auf Array verliert durch den Bedingungsausdruck Qualifizierer, in ISO C vor C23"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO-C verbietet bedingten Ausdruck zwischen %<void *%> und Funktionszeiger"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "Zeigertyp passt nicht in bedingtem Ausdruck"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "der erste Ausdruck hat den Typ %qT"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "der zweite Ausdruck hat den Typ %qT"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "Zeiger-/Ganzzahltyp passt nicht in bedingtem Ausdruck"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "Typ passt nicht in bedingtem Ausdruck"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "der Rückgabewert von %qD (mit %<nodiscard%>-Attribut deklariert) wird ignoriert: %E"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "der Rückgabewert von %qD (mit %<nodiscard%>-Attribut deklariert) wird ignoriert"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "der Rückgabewert vom Typ %qT (mit %<nodiscard%>-Attribut deklariert) wird ignoriert: %E"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "der Rückgabewert vom Typ %qT (mit %<nodiscard%>-Attribut deklariert) wird ignoriert"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "im Aufruf von %qD, hier deklariert"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "linker Operand des Komma-Ausdrucks hat keinen Effekt"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "rechter Operand des Komma-Ausdrucks hat keinen Effekt"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr "Typumwandlung fügt Qualifizierer %q#v zu Funktionstyp hinzu"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "Typumwandlung streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "zur Sicherheit müssen alle vorübergehenden Zeiger in Umwandlung von %qT in %qT mit %<const%> qualifiziert sein"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "Typkonvertierung gibt Arraytyp an"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "Typkonvertierung gibt Funktionstyp an"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO-C verbietet Typkonvertierung von Nicht-Skalar auf selben Typen"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "nutzlose Umwandlung in Typ %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO-C verbietet Typkonvertierung auf union-Typ"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "Typkonvertierung in union-Typ von nicht in union vorhandenem Typen"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "Umwandlung in %qs-Adressraumzeiger aus getrenntem allgemeinen Adressraumzeiger"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "Umwandlung in allgemeinen Adressraumzeiger aus getrenntem %qs-Adressraumzeiger"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "Umwandlung in %qs-Adressraumzeiger aus getrenntem %qs-Adressraumzeiger"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "Typkonvertierung erfordert Ausrichtung des Zieltyps"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "Typkonvertierung von Zeiger auf Ganzzahl anderer Breite"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "Typumwandlung von Funktionsaufruf des Typs %qT in unpassenden Typen %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "Typkonvertierung in Zeiger von Ganzzahl anderer Breite"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO-C verbietet Konvertierung von Funktionszeigern in Objektzeigertyp"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO-C verbietet Konvertierung von Objektzeigertypen in Funktionszeigertyp"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "unvollständiger Funktionstyp %qT kann nicht nach %qT umgewandelt werden"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "Definition eines Typs in einer Umwandlung ist in C++ ungültig"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "Zuweisung an Ausdruck von Arraytyp"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "enum-Umwandlung in Zuweisung ist in C++ ungültig"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(nahe der Initialisierung für %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "Array mit geklammerter Zeichenkettenkonstante initialisiert"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 msgid "expected %e but argument is of type %e"
 msgstr "%e erwartet, aber Argument hat Typ %e"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "der Typ von %qD Argument %d ist %qT, der Aufruf der eingebauten Funktion, die ohne Prototyp deklariert wurde, erwartet jedoch %qT"
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "der Typ von %qD Argument %d wird zu %qT befördert, der Aufruf der eingebauten Funktion, die ohne Prototyp deklariert wurde, erwartet jedoch %qT"
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "eingebaute %qD ist hier deklariert"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 msgid "%e declared here"
 msgstr "%e wird hier deklariert"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "Enum-Umwandlung bei Übergabe des Arguments %d von %qE ist in C++ ungültig"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "%qT erwartet, aber Argument hat Typ %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "enum-Umwandlung von %qT nach %qT in Zuweisung ist in C++ ungültig"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "enum-Umwandlung von %qT nach %qT in Initialisierung ist in C++ ungültig"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "enum-Umwandlung von %qT nach %qT in Rückgabe ist in C++ ungültig"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "implizite Umwandlung von %qT nach %qT"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "Übergabe des Arguments %d von %qE erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "Zuweisung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "Initialisierung erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "return erzeugt aus unqualifiziertem einen qualifizierten Funktionszeiger %q#v"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "Übergabe des Arguments %d von %qE entfernt Kennzeichner %qv von Zeiger-Ziel-Typ"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "Zuweisung streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "Initialisierung streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "return streicht Qualifizierer %qv von Zeiger-Zieltyp"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO-C verbietet Argumentkonvertierung in union-Typ"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "Anfrage zur impliziten für Umwandlung von %qT in %qT ist in C++ nicht erlaubt"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "Übergabe des Arguments %d von %qE von Zeiger auf nicht eingeschlossenen Adressbereich"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "Zuweisung von Zeiger auf nicht eingeschlossenen Adressbereich"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "Initialisierung von Zeiger auf nicht enthaltenen Adressraum"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "Rückgabe von Pointer auf nicht enthaltenen Adressraum"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "%qT erwartet, aber Zeiger hat Typ %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "Argument %d von %qE könnte Kandidat für Formatattribut sein"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "Links-Zuweisung könnte Kandidat für Formatattribut sein"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "Linke-Initialisierung könnte Kandidat für Formatattribut sein"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "Rückgabetyp könnte Kandidat für Formatattribut sein"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "Übergabe des Arguments %d von %qE von inkompatibler Speicherreihenfolge für Skalare"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "Zuweisung an %qT von Zeigertyp %qT mit inkompatibler Speicherreihenfolge für Skalare"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "Initialisierung von %qT von Zeigertyp %qT mit inkompatibler Speicherreihenfolge für Skalare"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "Rückgabe von %qT von Zeigertyp %qT mit inkompatibler Speicherreihenfolge für Skalare"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO-C verbietet Übergabe des Arguments %d von %qE zwischen Funktionszeiger und %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO-C verbietet Zuweisung zwischen Funktionszeiger und %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO-C verbietet Initialisierung zwischen Funktionszeiger und %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO-C verbietet return zwischen Funktionszeiger und %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr "Array mit Qualifizierer auf dem Element wird vor C23 nicht qualifiziert"
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "Zeigerziele bei Übergabe des Arguments %d von %qE unterscheiden sich im Vorzeichenbesitz"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "Zeigerziele in Zuweisung von %qT nach %qT unterscheiden sich im Vorzeichenbesitz"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "Zeigerziele in Initialisierung von %qT nach %qT unterscheiden sich im Vorzeichenbesitz"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "Zeigerziele in Rückgabe von %qT aus einer Funktion mit Rückgabetyp %qT unterscheiden sich im Vorzeichenbesitz"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "Übergabe des Arguments %d von %qE von inkompatiblem Zeigertyp"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "Zuweisung an %e von Zeiger auf %qD mit inkompatiblem Typ %e"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "Zuweisung an %e von inkompatiblem Zeigertyp %e"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "Initialisierung von %e von Zeiger auf %qD mit inkompatiblem Typ %e"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "Initialisierung von %e von inkompatiblem Zeigertyp %e"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "Rückgabe von Zeiger auf %qD vom Typ %e aus einer Funktion mit inkompatiblem Typ %e"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "Rückgabe von %e aus einer Funktion mit inkompatiblem Rückgabetyp %e"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "Übergabe des Arguments %d von %qE wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "Zuweisung an %qT von %qT wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "Initialisierung von %qT von %qT wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "Rückgabe von %qT aus einer Funktion mit Rückgabetyp %qT wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "Übergabe des Arguments %d von %qE wandelt eine Zahl in einen Zeiger um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "Zuweisung an %qT aus %qT wandelt einen Zeiger in eine Ganzzahl um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "Initialisierung eines %qT aus %qT wandelt einen Zeiger in eine Zahl um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "Rückgabe von %qT aus einer Funktion mit Rückgabetyp %qT wandelt einen Zeiger in eine Zahl um, ohne explizite Typkonvertierung"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "Inkompatibler Typ für Argument %d von %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "unverträgliche Typen bei Zuweisung an Typ %qT von Typ %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "inkompatible Typen bei Initialisierung von Typ %qT mit Typ %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "unverträgliche Typen bei Rückgabe von Typ %qT, aber %qT wurde erwartet"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "traditionelles C lehnt automatische Gesamt-Initialisierung ab"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr "Initialisierer für %<constexpr%>-Zeiger ist nicht null"
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "%<constexpr%>-Initialisierer ist nicht im Typen des Objekts darstellbar"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "Initialisierer für %<constexpr%>-Ganzzahl ist kein konstanter Ganzzahlausdruck"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "Initialisierer für %<constexpr%> ist kein konstanter arithmetischer Ausdruck"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr "%<constexpr%>-Initialisierer für einen reellen Typen hat komplexen Typ"
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr "%<constexpr%>-Initialisierer für einen binären Gleitkommatypen hat dezimalen Typ"
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "Initialisierung eines flexiblen Array-Elements"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "Array von %qT kann nicht aus einem Zeichenkettenliteral mit Typ %<Array von %T%> initialisiert werden"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "Initialisierungs-Zeichenkette für Array von %qT ist zu lang (%wu Zeichen passen nicht in %wu verfügbare)"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "Initialisierungs-Zeichenkette für Array von %qT ist zu lang für C++ (%wu Zeichen passen nicht in %wu verfügbare)"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr "Initialisierer-Zeichenkette für Array von %qT schneidet NUL-Terminator ab, aber dem Ziel fehlt das %qs-Attribut (%wu Zeichen passen nicht in %wu verfügbare)"
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "Array unpassenden Typs mit Zeichenkettenkonstante initialisiert"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "ungültige Verwendung eines Nicht-L-Wert-Arrays"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "ungültige Initialisierung"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "Initialisierungselement ist nicht konstant"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "Array mit nicht konstantem Arrayausdruck initialisiert"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "Initialisierungselement ist kein konstanter Ausdruck"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "Umwandlung von %qT in %qT ändert Wert von %qd nach %qd"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "Initialisierungs-Element ist zur Lade-Zeit nicht berechenbar"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "opake Vektortypen können nicht initialisiert werden"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "zusätzliche geschweifte Klammern am Ende der Initialisierung"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "geschweifte Klammern um Skalar-Initialisierung"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "Initialisierung eines flexiblen Array-Elements in geschachteltem Kontext"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "geschweifte Klammern fehlen um Initialisierung"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "fehlende Initialisierung für Feld %qD von %qT fehlt"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "zusätzliche Elemente in Skalar-Initialisierung"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "Arrayindex in Nicht-Array-Initialisierung"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "Feldname nicht in Datensatz- oder union-Initialisierung"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "Arrayindex in Initialisierung hat nicht Ganzzahltyp"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "Arrayindex in Initialisierung ist kein konstanter Ganzzahlausdruck"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "nichtkonstanter Arrayindex in Initialisierung"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "Arrayindex in Initialisierung überschreitet Arraygrenzen"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "leerer Indexbereich in Initialisierung"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "Arrayindexbereich in Initialisierung überschreitet Arraygrenzen"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "initialisiertes Feld überschrieben"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "initialisiertes Feld mit Seiteneffekten überschrieben"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "enum-Umwandlung in Initialisierung ist in C++ ungültig"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr "überzählige Elemente in %qT-Initialisierer"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "Elementüberschreitung in struct-Initialisierung"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "positionelle Initialisierung eines Feldes in %<struct%>, die mit dem %<designated_init%>-Attribut deklariert wurde"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "nicht-statische Initialisierung eines flexiblen Arrayelements"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "Elementüberschreitung in union-Initialisierung"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "traditionelles C lehnt Initialisierung von unions ab"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "Elementüberschreitung in Arrayinitialisierung"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "Elementüberschreitung in Vektorinitialisierung"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "Elementüberschreitung in Skalarinitialisierung"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr "Einschränkung erlaubt Register außerhalb einer Funktion"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr "Nebenwirkungen im Ausgabeoperanden außerhalb einer Funktion"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr "Ausgabeoperand außerhalb einer Funktion ist nicht konstant"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "%<-%>-Modifikator wird innerhalb einer Funktion verwendet"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr "Operand der %<:%>-Einschränkung ist weder die Adresse einer Funktion noch einer nichtautomatischen Variable"
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr "Nebenwirkungen im Eingabeoperanden außerhalb einer Funktion"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr "Eingabeoperand außerhalb einer Funktion ist nicht konstant"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO-C verbietet %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "das berechnete Goto muss von einem Zeigertyp sein"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "als %<noreturn%> deklarierte Funktion hat %<return%>-Anweisung"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> ohne Wert in nicht-void zurückgebender Funktion"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> mit Wert in void zurückgebender Funktion"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO-C verbietet %<return%> mit Ausdruck, in void zurückgebender Funktion"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "Funktion liefert Adresse einer Sprungmarke zurück"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, gcc-internal-format
 msgid "function returns address of nested function referencing local context"
 msgstr "Funktion liefert Adresse einer geschachtelten Funktion, die auf lokalen Kontext verweist"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch-Größe ist keine Ganzzahl"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "%<long%> switch-Ausdruck nicht nach %<int%> konvertiert in ISO C"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "»case«-Marke ist kein konstanter Ganzzahlausdruck"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case-Marke nicht innerhalb einer switch-Anweisung"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "%<default%>-Marke nicht innerhalb einer switch-Anweisung"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break-Anweisung nicht innerhalb einer Schleife oder »switch«"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "ungültiger Ausgang von strukturiertem OpenMP-Block"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "break-Anweisung mit OpenMP für Schleife verwendet"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue-Anweisung nicht innerhalb einer Schleife"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "Anweisung ohne Effekt"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "Ausdrucksanweisung hat unvollständigen Typ"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "der Vergleich wird immer als %<false%> ausgewertet, da der Zeigeroperand in %qE nicht NULL sein darf"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "der Vergleich wird immer als %<true%> ausgewertet, da der Zeigeroperand in %qE nicht NULL sein darf"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "der Vergleich wird immer als %<false%> ausgewertet, da die Adresse von %qE niemals NULL sein wird"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "der Vergleich wird immer als %<true%> ausgewertet, da die Adresse von %qE niemals NULL sein wird"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "Vergleich von Vektoren mit verschiedenen Element-Typen"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "Vergleich von Vektoren mit unterschiedlicher Elementanzahl"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "Vergleich zwischen den Typen %qT und %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "kein ganzzahliger Typ mit derselben Größe wie %qT gefunden"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "Vergleich von Gleitkomma mit %<==%> oder %<!=%> ist unsicher"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "Vergleich von Zeigern auf disjunkte Adressräume"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO-C verbietet Vergleich von %<void *%> mit Funktionszeiger"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "in Vergleich verschiedener Zeigertypen fehlt Typkonvertierung"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "Vergleich zwischen Zeiger und Ganzzahl"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "Vergleich von vollständigen und unvollständigen Zeigern"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO-C verbietet geordnete Vergleiche zwischen Zeigern auf Funktionen"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "geordneter Vergleich von Zeiger mit Null-Zeiger"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "geordneter Vergleich von Zeiger mit Ganzzahlnull"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "implizite Umwandlung von %qT in %qT zur Anpassung an anderen Operanden des Binärausdrucks"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "Array, das nicht in Zeiger umgewandelt werden kann, anstelle des geforderten Skalars verwendet"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "Wert eines struct-Typs anstelle des geforderten Skalars verwendet"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "Wert eines union-Typs anstelle des geforderten Skalars verwendet"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "Vektortyp verwendet, wo Skalars benötigt wird"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancel%> muss eine der Klauseln %<parallel%>, %<for%>, %<sections%> oder %<taskgroup%> angeben"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "Klauselmodifizierer %<cancel%> %<if%> erwartet"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancellation point%> muss eine der Klauseln %<parallel%>, %<for%>, %<sections%> oder %<taskgroup%> angeben"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD in %qs-Klausel muss eine Variable sein"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE in %qs-Klausel muss eine Variable sein"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%<_Atomic%>-Deklaration %qD in %qs-Klausel"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD in %qs-Klausel ist eine threadprivate Variable"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "Untere Grenze %qE des Arrayabschnitts muss Ganzzahltyp haben"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "Länge %qE des Arrayabschnitts muss Ganzzahltyp haben"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "einelnen Zeiger in %qs-Klausel erwartet"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "Arrayabschnitt der Länge 0 in %qs-Klausel"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr "für Arraytyp mit unbekannten Grenzen muss ein Längenausdruck angegeben werden"
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "negative untere Grenze in Arrayabschnitt in %qs-Klausel"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "Arrayabschnitt mit negativer Länge in %qs-Klausel"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "untere Grenze %qE geht über Abschnittsgröße in %qs-Klausel hinaus"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "Länge %qE geht über Abschnittsgröße in %qs-Klausel hinaus"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "obere Grenze %qE geht über Abschnittsgröße in %qs-Klausel hinaus"
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "für Funktionsparameter vom Typ Array muss die Länge angegeben sein"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "für Zeigertyp muss der Längenausdruck angegeben werden"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "Arrayabschnitt ist in %qs-Klausel nicht zusammenhängend"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE hat weder Zeiger- noch Arraytyp"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "Typ des Iterators %qD ist weder ganzzahlig noch ein Zeiger"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "Iterator %qD hat %<_Atomic%>-qualifizierten Typ"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "Iterator %qD hat %<const%>-qualifizierten Typ"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "Iterator-Schrittweite mit nichtganzzahligem Typ"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr "Iterator %qD hat Schrittweite 0"
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr "Typ des Iterators %qD verweist auf äußeren Iterator %qD"
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr "Anfangsausdruck verweist auf äußeren Iterator %qD"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "Endausdruck verweist auf äußeren Iterator %qD"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "Ausdruck für die Schrittweite verweist auf äußeren Iterator %qD"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "Zeiger in %qs-Klausel erwartet"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "die Klausel %<inscan%> darf nicht zusammen mit nicht-%<inscan%>-%<reduction%> am selben Konstrukt vorkommen"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "%<inscan%>-%<reduction%>-Klausel mit Arrayabschnitt"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD in %<reduction%>-Klausel ist ein Array der Länge 0"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE in %<reduction%>-Klausel"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "Typ %qT mit Größe 0 in %qs-Klausel"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "Typ %qT mit variabler Größe in %qs-Klausel"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE hat ungültigen Typ für %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "benutzerdefinierte Reduktion für %qE nicht gefunden"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "Elementtyp variabler Länge in %<reduction%>-Klausel eines Arrays"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "%<nowait%>-Klausel darf nicht zusammen mit %<copyprivate%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE muss für %<copyin%> %<threadprivate%> sein"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr "Modifizierer sollte an %<simd%>- oder %<for%>-Konstrukten nicht in %<linear%>-Klausel angegeben werden, außer wenn OpenMP 5.2 verwendet wird"
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr "»linear«-Klausel auf Variable vom Typ %qT angewendet, die weder Ganzzahl noch Zeiger ist"
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr "%<_Atomic%> %qD in %<linear%>-Klausel"
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "Schrittweite %qE der %<linear%>-Klausel muss konstant oder ein Parameter sein"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE ist in Klausel %qs keine Variable"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD kommt mehr als einmal in Datenfreigabeklauseln vor"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD tritt in Reduktionsklauseln mehrfach auf"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE tritt in dieser Datenklausel mehrfach auf"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD tritt in Datenklausel mehrfach auf"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD tritt in Daten- und Zuordnungsklauseln mehrfach auf"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE ist in Klausel %<firstprivate%> keine Variable"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE ist in Klausel %<lastprivate%> keine Variable"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE ist %<aligned%>-Klausel keine Variable"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "%qE in %<aligned%>-Klausel ist weder Zeiger noch Array"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%<_Atomic%> %qD in %<aligned%>-Klausel"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE tritt in %<aligned%>-Klausel mehrfach auf"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE ist in %<nontemporal%>-Klausel keine Variable"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE tritt in %<nontemporal%>-Klausel mehrfach auf"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE in %<allocate%>-Klausel ist keine Variable"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE kommt mehr als einmal in %<allocate%>-Klauseln vor"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr "Allokator %qE muss vom Typ %<omp_allocator_handle_t%> sein"
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr "Allokator %qE muss entweder eine Variable oder ein vordefinierter Allokator sein"
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "Modifikatoren können nicht mit dem vordefinierten Allokator %qE verwendet werden"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr "der Speicherplatzmodifikator %qE muss eine Aufzählungskonstante vom Typ %<omp_memspace_handle_t%> sein"
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr "das Merkmalsarray %qE muss in demselben Gültigkeitsbereich definiert sein wie das Konstrukt, in dem die Klausel vorkommt"
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr "das Merkmalsarray %qE muss vom Typ %<const omp_alloctrait_t []%> sein"
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr "das Merkmalsarray muss vom Typ %<const imp_alloctrait_t []%> sein"
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr "das Merkmalsarray muss mit Konstanten initialisiert sein"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr "%<depend%>-Klausel mit %<depobj%>-Abhängigkeitstyp auf Arrayabschnitt"
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr "%<omp_all_memory%> wird mit %<depend%>-Art außer %<out%> oder %<inout%> verwendet"
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE ist weder ein lvalue-Ausdruck noch ein Arrayabschnitt in %qs-Klausel"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr "%qE hat nicht den Typ %<omp_depend_t%>, in der %<depend%>-Klausel mit %<depobj%>-Abhängigkeitstyp"
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr "%qE sollte einen anderen Typ haben als %<omp_depend_t%>, in der %<depend%>-Klausel mit von %<depobj%> verschiedenem Abhängigkeitstyp"
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "Arrayabschnitt in %qs-Klausel hat keinen zuordenbaren Typ"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "nicht unterstützter Map-Ausdruck %qE"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD tritt in Bewegungsklausel mehrfach auf"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD tritt in Zuordnungsklauseln mehrfach auf"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD in %qs-Klausel hat keinen zuordenbaren Typ"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE in %qs-Klausel ist weder Variablen- noch Funktionsname"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE tritt in derselben %<declare target%>-Direktive mehrfach auf"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD in %<uniform%>-Klausel ist kein Argument"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE in %<uniform%>-Klausel ist kein Argument"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "Variable %qs muss ein Zeiger sein"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "Variable %qs ist weder Zeiger noch Array"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "%<order%>-Klausel darf nicht zusammen mit %<ordered%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "zu viele %qs-Klauseln an einem Task-Konstrukt"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "%<inbranch%>-Klausel ist inkompatibel mit %<notinbranch%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD kommt in Aktionsklausel mehrfach vor"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD muss vom Typ %<omp_interop_t%> sein"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "%qD darf nicht const sein"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE ist vorbestimmt %qs für %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "%<const%>-qualifiziertes %qE darf nur in %<shared%>- oder %<firstprivate%>-Klauseln vorkommen"
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr "%<simdlen%>-Klauselwert ist größer als %<safelen%>-Klauselwert"
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr "%<nonmonotonic%>-Planungsmodifizierer zusammen mit %<ordered%>-Klausel angegeben"
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "%qs-Klausel darf nicht zusammen mit %<inscan%>-%<reduction%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr "%<linear%>-Klauselschritt ist ein Parameter %qD, der nicht in der %<uniform%>-Klausel angegeben ist"
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "%<nogroup%>-Klausel darf nicht zusammen mit %<reduction%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "%<grainsize%>-Klausel darf nicht zusammen mit %<num_tasks%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "%<full%>-Klausel darf nicht zusammen mit %<partial%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "%<detach%>-Klausel darf nicht zusammen mit %<mergeable%>-Klausel verwendet werden"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr "das Ereignishandle einer %<detach%>-Klausel sollte nicht in einer data-sharing-Klausel sein"
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr "%<depend%>-Klausel erfordert Aktionsklauseln mit %<targetsync%>-Interop-Typ"
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "der %<init%>-Klausel fehlt der %<targetsync%>-Modifikator"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "%<va_arg%> kann nicht zusammen mit umgedreher Speicherreihenfolge verwendet werden"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "zweites Argument für %<va_arg%> ist vom unvollständigen Typ %qT"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "zweites Argument für %<va_arg%> ist ein Funktionstyp %qT"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "zweites Argument für %<va_arg%> ist ein Arraytyp %qT"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "C++ erfordert weitergegebenen Typ, nicht Enum-Typ, in %<va_arg%>"
@@ -54680,253 +54721,248 @@ msgstr "In cobol1.c sollte niemals ein ungleiches dash-main erscheinen"
 msgid "no such exception: 0x%x"
 msgstr "keine solche Ausnahme: 0x%x"
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr "Wahrscheinliche Ursache: Es wurde darauf verwiesen, ist aber nicht definiert."
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr "Diese Zeichenkette sollte nicht so lang sein."
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "Interner Fehler: %s should not be null"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "Interner Fehler: %s: Knows not the variable type %s for %s"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "Interner Fehler: %s: Invalid field type %s:"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr "Interner Fehler: Not valid for ACCEPT statement."
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr "Interner Fehler: Attempting to send to an input device."
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr "Interner Fehler: Not valid for DISPLAY statement."
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr "Interner Fehler: %<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr "Interner Fehler: %<parser_relop%> was called with variable %qs, which is not a FldConditional"
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr "Interner Fehler: %<parser_relop()%> was called with variable %s, which is not a FldConditional"
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr "Interner Fehler: %<parser_if()%> was called with variable %s, which is not a FldConditional"
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr "Interner Fehler: candidate %s has unimplemented %<CVT_type%> %d(%s)"
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "Interner Fehler: unknown %<setop_t%> code %d"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr "Interner Fehler: %s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr "Interner Fehler: %s:%d: ignoring subscripts"
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr "Interner Fehler: %s: called with NULL *file"
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr "Interner Fehler: %s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr "Interner Fehler: %<parser_file_open%> called with NULL *file"
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr "Interner Fehler: %<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr "Interner Fehler: EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr "Interner Fehler: %<parser_file_close%> called with NULL *file"
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr "Interner Fehler: %<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr "Interner Fehler: %s:%d file %s 'where' is zero in %s"
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr "Interner Fehler: %<parser_file_read%> called with NULL *file"
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr "Interner Fehler: %<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr "Interner Fehler: %<parser_file_read%> called with NULL *field"
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr "Interner Fehler: %<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr "Interner Fehler: %s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr "Interner Fehler: %s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr "Interner Fehler: %s:%d file %s 'sequentially' is %d in %s"
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr "Interner Fehler: %s: for %s called with NULL %<file->var_decl_node%>"
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr "Interner Fehler: %s: called with NULL *field"
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr "Interner Fehler: %s: for %s called with NULL %<field->var_decl_node%>"
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr "Interner Fehler: The file pointer should not be null"
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr "Interner Fehler: %s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "Interner Fehler: %s: asked to sort %s, which is not a table"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr "Interner Fehler: %s: syntax error: both (or neither) USING and input-proc are specified"
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr "Interner Fehler: %s: syntax error: both (or neither) GIVING and output-proc are specified"
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr "Interner Fehler: %s: syntax error: both (or neither) files and output-proc are specified"
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr "CALL USING BY CONTENT <temporary> würde REPOSITORY PROTOTYPES erfordern."
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "Interner Fehler: %s: What in the name of Nero are we doing here?"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr "Interner Fehler: In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr "Interner Fehler: In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr "Interner Fehler: LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr "Interner Fehler: %<parser_symbol_add()%> was called with a NULL %<new_var%>"
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr "Interner Fehler: %s: %d %s is a table, but it improperly has a capacity of zero"
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr "Interner Fehler: %s: %s is its own ancestor"
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr "Interner Fehler: %s: %d %qs has NULL ancestor"
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr "Interner Fehler: %s(%s) improperly has a non-null %<var_decl_node%>"
@@ -54935,72 +54971,82 @@ msgstr "Interner Fehler: %s(%s) improperly has a non-null %<var_decl_node%>"
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr "%<our_index%> ist unter unvorhergesehenen Umständen NULL"
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr "Interner Fehler: %s: %d %s<%s> improperly has a data.capacity of zero"
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr "Interner Fehler: %<bytes_to_allocate%> is zero for %s (symbol number "
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr "Interner Fehler: The given type is NULL, and that is just not fair"
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "Interner Fehler: The given type is not a declaration or a TYPE"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "Interner Fehler: Unknown type %d"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr "Interner Fehler: Attempting an assignment of differing types."
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr "Interner Fehler: Somebody asked for the field %s.%s, which does not exist"
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%s:%d: Darf nicht mit %s aufgerufen werden"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr "%s:%d: Darf nicht mit nicht-%s aufgerufen werden"
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr "Interner Fehler: You *must* be joking"
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr "Interner Fehler: You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr "Interner Fehler: You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr "Interner Fehler: %d parameters? Really? Are you insane?"
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr "Interner Fehler: Residual context count"
@@ -55010,12 +55056,12 @@ msgstr "Interner Fehler: Residual context count"
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr "Interner Fehler: %<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, gcc-internal-format
 msgid "Too many subscripts"
 msgstr "Interner Fehler: Too many subscripts"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "Interner Fehler: cannot get %<float%> value from %s"
@@ -55030,62 +55076,62 @@ msgstr "»%s« mit PID %ld wurde beendet durch %s"
 msgid "%s exited with status %d"
 msgstr "»%s« mit Status %d beendet"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr "Interner Fehler: %s:%d: LblNone '%s' has parent #%zu"
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr "Interner Fehler: %s: data item %s #"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%s: Schlüssel muss Feld sein"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s: %s %s hat ungültige Zeichencodierung"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr "%s:%d: »%s« konnte nicht hinzugefügt werden"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s %lu %s %lu"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr "%s: nbytes %lu %s %lu"
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr "%s:%d: type %s, who woulda thunk?"
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr "Interner Fehler: logic error: MOVE %s %s invalid type:"
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr "%s: regcomp: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr "Interner Fehler: logic error: missing inode for %s"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104876
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "Fehler beim Kompilieren von »%s«"
@@ -55522,7 +55568,7 @@ msgstr "kein geeignetes %<operator %s%> für %qT"
 msgid "%q#D is private within this context"
 msgstr "%q#D ist in diesem Zusammenhang »private«"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr "hier als »private« deklariert"
@@ -55532,7 +55578,7 @@ msgstr "hier als »private« deklariert"
 msgid "%q#D is protected within this context"
 msgstr "%q#D ist in diesem Zusammenhang »protected«"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr "hier als »protected« deklariert"
@@ -55856,7 +55902,7 @@ msgstr "Argument %u in Aufruf von %qE darf kein Zeiger auf nicht-trivial kopierb
 msgid "constructor delegates to itself"
 msgstr "Konstruktor verweist auf sich selbst"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr "%qH kann nicht nach %qI umgewandelt werden"
 
@@ -55875,7 +55921,7 @@ msgstr "keine passende Funktion für Aufruf von %<%T::%s%E(%A)%#V%>"
 msgid "call to non-function %qD"
 msgstr "Aufruf der Nicht-Funktion %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "Konstruktor %<%T::%D%> kann nicht direkt aufgerufen werden"
@@ -56469,7 +56515,7 @@ msgstr "flexibles Arrayelement %qD in ansonsten leerem %q#T ist eine GCC-Erweite
 msgid "next member %q#D declared here"
 msgstr "nächstes Feld %q#D hier deklariert"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "Redefinition von %q#T"
@@ -56479,7 +56525,7 @@ msgstr "Redefinition von %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr "%qT wird definiert, war jedoch vorher in einem SFINAE-Kontext nicht vollständig"
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr "hier; verwenden Sie %qs für eine Diagnosemeldung an dieser Stelle"
@@ -56610,7 +56656,7 @@ msgstr "ungültiger Typ für Parameter %d der %<constexpr%>-Funktion %q+#D"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr "Lambdas sind erst ab C++17 implizit %<constexpr%>"
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%>-Destruktoren sind erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
@@ -56661,7 +56707,7 @@ msgstr "%<-fimplicit-constexpr%> betrifft nur %<inline%>-Funktionen"
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%qD ist nicht als %<constexpr%>-Funktion verwendbar, denn:"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr "%qE wird außerhalb seiner Lebensdauer zerstört"
@@ -56696,839 +56742,839 @@ msgstr "unbehandelte Ausnahme %qE"
 msgid "uncaught exception of type %qT"
 msgstr "unbehandelte Ausnahme vom Typ %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "Aufruf der Funktion %qD mit falscher Anzahl von Argumenten"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "%qD wurde aufgerufen, obwohl es keine ausstehenden Ausnahmen gibt"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "Fehler beim Zuweisen von Speicher: Größe nicht konstant"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr "das erste Argument der Funktion %qD ist nicht das Ergebnis von %<__cxa_allocate_exception%>"
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "%qD wurde aufgerufen, obwohl keine gefangene Ausnahme aktiv ist"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr "%qD wurde aufgerufen, obwohl %<std::%D%> nicht definiert ist"
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr "%qD wurde aufgerufen, obwohl %qs nicht unterstützbar ist"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr "%qD wurde mit unerwartetem Argument %qs aufgerufen"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr "%qD wurde mit einem zweiten Argument außer 1 oder -1 aufgerufen"
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "falsche Anzahl an Argumenten für den Aufruf von %qs"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr "das erste Argument des Aufrufs von %qs sollte 0, 1, 2, 16, 17 oder 18 sein"
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr "die Zeichenfolge des Tags %qs enthält das Zeichen %qc, das weder Buchstabe, Ziffer noch %<_%> ist"
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr "constexpr-Meldung: %.*s [%r%.*s%R]"
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr "constexpr-Meldung: %.*s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "Kontrollfluss für %<constexpr%>-Aufruf fällt hinten aus der Funktion"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "Aufruf der nicht-%<constexpr%>-Funktion %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "Dereferenzierung eines Null-Zeigers"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "der Vergleich wird zu %qE reduziert"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr "%qE wird zu »false« ausgewertet"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr "%<assume%>-Attribut-Annahme fehlgeschlagen"
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "Aufruf für interne Funktion %qE"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "in einem konstanten Ausdruck ist es nicht erlaubt, das %<const%>-Objekt %qE zu verändern"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "wurde ursprünglich hier als %<const%> deklariert"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr "%<dynamic_cast%> auf Referenz fehlgeschlagen"
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "dynamischer Typ %qT seines Operanden hat keine Basisklasse vom Typ %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "Zeiger auf Virtuelle Tabelle wird uninitialisiert verwendet"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr "der statische Typ %qT des Operanden ist eine nicht öffentliche Basisklasse des dynamischen Typs %qT"
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT ist eine mehrdeutige Basisklasse des dynamischen Typen %qT seines Operanden"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr "der dynamische Typ %qT des Operanden hat keine eindeutige öffentliche Basisklasse %qT"
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "»constexpr«-Elementfunktion %qD kann nicht vom virtuellen Basisobjekt aus aufgerufen werden"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr "%qT konnte nicht geworfen werden"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "Ausdruck %qE bezeichnet keine %<constexpr%>-Funktion"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr "Array kann nicht alloziert werden: Größe nicht konstant"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "Array-Deallokation eines Objekts, das mit einer Nicht-Array-Allokation alloziert wurde"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr "die Allokation ist hier"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "Nicht-Array-Deallokation eines Objekts, das mit Array-Allokation allokiert wurde"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr "Versuch, bereits freigegebenen Speicher freizugeben"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "Speicher, der vorher nicht angefordert wurde, wird freigegeben"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD in konstantem Ausdruck aufgerufen, bevor die Definition vollständig war"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD in konstantem Ausdruck aufgerufen"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD vor seiner Definition verwendet"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "Aufruf hat ringförmige Abhängigkeit"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "Auswertungstiefe von %<constexpr%> überschreitet Höchstwert %d (%<-fconstexpr-depth=%> verwenden, um dies zu erhöhen)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "Referenz auf %qD ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "Zeiger auf %qD ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr "die Adresse der nicht-statischen constexpr-Variablen %qD kann sich bei jedem Aufruf der umschließenden Funktion ändern; fügen Sie %<static%> hinzu, um ihr eine konstante Adresse zu geben"
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "rechter Operand des Schiebeausdrucks %q+E ist negativ"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "rechter Operand des Schiebeausdrucks %q+E ist mindestens so groß wie die Genauigkeit %wu des linken Operanden"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "linker Operand des Schiebeausdrucks %q+E ist negativ"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "Schiebeausdruck %q+E läuft über"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr "Arithmetik mit Nullzeiger in %qE"
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "Arrayindexwert %qE ist außerhalb der Grenzen des Arrays %qD vom Typ %qT"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "Arrayindex %qE ist ungleich 0 und wird mit Array %qD vom Typ %qT mit unbekannten Grenzen verwendet"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "Arrayindexwert %qE ist außerhalb der Grenzen des Arraytyps %qT"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "Arrayindex %qE ist ungleich 0 und wird mit Array vom Typ %qT mit unbekannten Grenzen verwendet"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "Zugriff auf uninitialisiertes Arrayelement"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "Dereferenzierung eines Nullzeigers in %qE"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "veränderliches %qD ist in konstantem Ausdruck nicht verwendbar"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "Zugriff auf uninitialisiertes Element %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "Zugriff auf Element %qD statt auf aktives Element %qD in Konstantenausdruck"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "Zugriff auf Element %qD statt auf initialisiertes Element %qD in Konstantenausdruck"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT ein union-Typ ist"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT einen union-Typen enthält"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT ein Zeigertyp ist"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT einen Zeigertyp enthält"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT ein Referenztyp ist"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT einen Referenztypen enthält"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT ein Zeiger-auf-Element-Typ ist"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT einen Zeiger-auf-Element-Typen enthält"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT %<volatile%> ist"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qs ist kein konstanter Ausdruck, da %qT ein %<volatile%>-Teilobjekt enthält"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%qs kann auf diesem Ziel nicht als konstanter Ausdruck ausgewertet werden"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr "%qs kann nicht als konstanter Ausdruck ausgewertet werden, da der Typ zu groß ist"
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "%qs kann nicht als konstanter Ausdruck ausgewertet werden, da das Argument nicht codiert werden kann"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "%qs greift auf das uninitialisierte Byte an Offset %d zu"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "%qs kann nicht als konstanter Ausdruck ausgewertet werden, da das Argument nicht interpretiert werden kann"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "auf den Wert vom Typ %qT wird über ein Glvalue vom Typ %qT in einem Konstantenausdruck zugegriffen"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, gcc-internal-format
 msgid "%qT object created here"
 msgstr "Objekt vom Typ %qT wird hier erzeugt"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D hier deklariert"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "angeforderter Speicher wird in konstantem Ausdruck verwendet, nachdem er wieder freigegeben wurde"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr "wurde hier deklariert"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr "Zugriff auf %qE außerhalb seiner Lebensdauer"
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "der Wert von uninitialisiertem Speicher ist in konstantem Ausdruck nicht verwendbar"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "der Wert von %qD ist in konstantem Ausdruck nicht verwendbar"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD in seiner eigenen Initialisierung verwendet"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D ist nicht konstant"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D ist volatile"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD wurde nicht mit konstantem Ausdruck initialisiert"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD wurde nicht als %<constexpr%> definiert"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD hat keinen Ganzzahl- oder Aufzählungstyp"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "die Änderung des zugewiesenen Speichers nach der Freigabe ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "Modifikation von %qE außerhalb seiner Lebenszeit ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "das Zerstören von %qE außerhalb der aktuellen Auswertung ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "Modifikation von %qE von außerhalb der aktuellen Auswertung ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "Änderung des aktiven Elements einer union von %qD zu %qD ist vor C++20 kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr "%qD beginnt seine Lebensdauer nicht implizit, da %qT keinen nicht gelöschten trivialen Standardkonstruktor hat; verwenden Sie stattdessen %<std::construct_at%>"
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr "die Initialisierung von %qD erfordert einen Ausdruck für den Memberzugriff als linken Operanden der Zuweisung"
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "Änderung des aktiven Elements einer union von %qD zu %qD während der Initialisierung"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "Anzahl der Schleifendurchläufe in %<constexpr%> überschreitet Höchstwert %d (%<-fconstexpr-loop-limit=%> verwenden, um diesen zu erhöhen)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "Inline-Assembler ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr "in einer %<constexpr%>-Funktion in C++20 darf Inline-Assemblercode nur vorkommen, wenn er nicht im Auswertungspfad liegt"
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, gcc-internal-format
 msgid "use of %qD"
 msgstr "Verwendung von %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr "der Wert kann zwischen Compiler-Versionen oder mit verschiedenen %<-mtune%> oder %<-mcpu%> Flags variieren"
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr "wenn diese Verwendung Teil eines öffentlichen ABI ist, ändern Sie sie so, dass stattdessen eine konstante Variable verwendet wird, die Sie definieren"
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr "der Vorgabewert für die aktuelle CPU-Feineinstellung ist %d Bytes"
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr "Sie können diesen Wert mit %<--param hardware_destructive_interference_size=%d%> stabilisieren, oder diese Warnung mit %<-Wno-interference-size%> deaktivieren"
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "Destruktor ist mit einer Ausnahme ausgestiegen"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "Wert %qE vom Typ %qT ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "Anzahl der Evaluierungsoperationen in %<constexpr%> überschreitet Höchstwert %wd (%<-fconstexpr-ops-limit=%> verwenden, um diesen zu erhöhen)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr "der Programmfluss geht durch die Definition von %qD mit thread-lokaler Speicherdauer"
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "der Programmfluss geht durch die Definition von %qD mit statischer Speicherdauer"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "Zwischenergebnis des nicht-literalen Typs %qT in konstantem Ausdruck"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "unerwartete Ausnahme aus der %<noexcept%>-Funktion %qD"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr "der Destruktor wurde nach der Initialisierung des Ausnahmeobjekts mit einer Ausnahme beendet"
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr "der Konstruktor wurde beim Aufruf des Handlers mit einer weiteren Ausnahme beendet"
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "Ein %<reinterpret_cast%> ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "Umwandlung von Zeigertyp %qT in arithmetischen Typ %qT in Konstantenausdruck"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "der Cast von %qT ist in einem konstanten Ausdruck nicht zulässig, da der Typ %qT, auf den gezeigt wird, %qT nicht ähnlich ist"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "der Typ, auf den gezeigt wird, ist hier deklariert"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "der Cast von %qT ist in einem konstanten Ausdruck vor C++26 nicht erlaubt"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "%qE ist kein konstanter Ausdruck, solange die Klasse %qT noch unvollständig ist"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%<reinterpret_cast<%T>(%E)%> ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "Ausdruck %qE ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%<goto%> ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "Adresse des Aufrufs von %qs ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "Anweisung ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "unexpected expression %qE of kind %s"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr "%qE greift auf ein Objekt außerhalb dessen Lebensdauer zu"
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr "Vertragsbedingung ist nicht konstant"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "Vertragsbedingung ist false in konstantem Ausdruck"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "%<break%>-Anweisung außerhalb einer Schleife oder %<switch%>"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr "%<continue%> außerhalb einer Schleife"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "%<return%> in einem Anweisungsausdruck"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qE ist kein Konstantenausdruck, da er auf veränderliche Teilobjekte von %qT verweist"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qE ist kein konstanter Ausdruck, da er auf ein Ausnahmeobjekt verweist, das mit %<__cxa_allocate_exception%> alloziert wurde"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qE ist kein konstanter Ausdruck, da er auf das Ergebnis von %<operator new%> verweist"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qE ist kein konstanter Ausdruck, da der angeforderte Speicher nicht vollständig freigegeben wurde"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr "unmittelbare Auswertung liefert die Adresse der unmittelbaren Funktion %qD"
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "Konstantenauswertung liefert Adresse der unmittelbaren Funktion %qD"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr "ein Verweis auf ein Objekt eines Consteval-Only-Typs ist kein konstanter Ausdruck, es sei denn, er ist ebenfalls von einem Consteval-Only-Typ"
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr "ein Zeiger in ein Objekt eines Consteval-Only-Typs ist kein konstanter Ausdruck, es sei denn, er ist ebenfalls von einem Consteval-Only-Typ"
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qE ist kein Konstantenausdruck, da er auf eine unvollständig initialisierte Variable verweist"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qE ist kein konstanter Ausdruck, da er %qT statt %qT initialisiert"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "Umwandlung lvalue-in-rvalue eines volatile-lvalue %qE mit Typ %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "Lambda-Einfangen von %qE ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr "da er als glvalue verwendet wird"
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "%<reinterpret_cast%> von Ganzzahl zu Zeiger"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "Adresse eines Objektes %qE mit thread-lokalem oder automatischem Speicher ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "Lambda-Ausdruck ist erst ab C++17 ein konstanter Ausdruck"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "new-expression ist erst ab C++20 ein konstanter Ausdruck"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "virtuelle Funktionen können erst mit C++20 %<constexpr%> sein"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "%<typeid%> ist kein konstanter Ausdruck, da %qE polymorphen Typ hat"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "Umwandlung in Nicht-Ganzzahltyp %qT in konstantem Ausdruck"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qD in %<constexpr%>-Kontext als %<thread_local%> definiert"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%qD in %<constexpr%>-Kontext als %<static%> definiert"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "Division durch Null ist kein konstanter Ausdruck"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%<delete[]%> ist kein Konstantenausdruck"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "keiner der Zweige des %<if%> ist ein Konstantenausdruck"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "nicht konstante Arrayinitialisierung"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Definition einer Sprungmarke innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "unerwarteter AST der Art %s"
@@ -57662,352 +57708,352 @@ msgstr "kein Operand der Disjunktion ist erfüllt"
 msgid "the operand %qE is unsatisfied because"
 msgstr "der Operand %qE ist nicht erfüllt, da"
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qT ist nicht per %<nothrow%> als Kopie zuweisbar"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%qT kann nicht per %<nothrow%> mit dem Standardkonstruktor erzeugt werden"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qT ist nicht per %<nothrow%> als Kopie erzeugbar"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr "%qT ist nicht trivial als Kopie zuweisbar"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "%qT ist nicht trivial mit dem Standardkonstruktor erzeugbar"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%qT ist nicht trivial als Kopie erzeugbar"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "%qT ist nicht trivial zerstörbar"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qT hat keine eindeutigen Objektrepräsentationen, denn"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "%qT hat keinen virtuellen Destruktor"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "%qT ist keine abstrakte Klasse"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, gcc-internal-format
 msgid "%qT is not an aggregate"
 msgstr "%qT ist kein Aggregat"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, gcc-internal-format
 msgid "%qT is not an array"
 msgstr "%qT ist kein Array"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qT ist nicht vom Typ %qT zuweisbar, denn"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT ist keine Basis von %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qT ist kein begrenztes Array"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "%qT ist keine Klasse"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "%qT ist kein const-Typ"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "%qT kann nicht mit dem Standardkonstruktor erzeugt werden, denn"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qT ist nicht aus %qT konstruierbar, denn"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "%qT ist nicht zerstörbar, denn"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "%qT ist keine leere Klasse"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "%qT ist keine Aufzählung"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "%qT ist keine finale Klasse"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "%qT ist keine Funktion"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT ist kein Typ mit impliziter Lebenszeit"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "%qT ist nicht aufrufbar, denn"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qT ist nicht von %qT aufrufbar, denn"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "das Layout von %qT nicht zu %qT kompatibel, denn"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "%qT ist kein literaler Typ"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "%qT ist kein Member-Funktionszeiger"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "%qT ist kein Member-Objektzeiger"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "%qT ist kein Member-Zeiger"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qT ist nicht per %<nothrow%> als Kopie von %qT zuweisbar, denn"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%qT ist nicht per %<nothrow%> mit dem Standardkonstruktor erzeugbar, denn"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qT ist nicht per %<nothrow%> von %qT erzeugbar, denn"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qT ist nicht per %<nothrow%> von %qT umwandelbar, denn"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qT ist nicht per %<nothrow%> zerstörbar, denn"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qT ist nicht mit %<nothrow%> aufrufbar, denn"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qT ist nicht mit %<nothrow%> von %qT aufrufbar, denn"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "%qT ist kein Objekttyp"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT ist keine Zeiger-konvertierbare Basis von %qT, denn"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "%qT ist kein POD-Typ"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "%qT ist kein Zeiger"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "%qT ist kein polymorpher Typ"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "%qT ist keine Referenz"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "%q#T ist nicht derselbe Typ wie %q#T"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "%qT ist keine Aufzählung mit Gültigkeitsbereich"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "%qT ist kein Typ mit Standardlayout"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "%qT ist kein trivialer Typ"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qT ist nicht trivial von %qT zuweisbar, denn"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "%qT ist nicht trivial mit dem Standardkonstruktor erzeugbar, denn"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%qT ist nicht trivial von %qT erzeugbar, denn"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "%qT ist nicht trivial kopierbar"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "%qT ist nicht trivial zerstörbar, denn"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "%qT ist kein unbegrenztes Array"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "%qT ist kein Vereinigungstyp"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT ist keine virtuelle Basis von %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "%qT ist kein %<volatile%>-Typ"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "%qT ist nicht nur consteval"
+msgid "%qT is not a structural type"
+msgstr "%qT ist kein struktureller Typ"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "%qT kann keinen Rang ergeben"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "%qT und %qT können nicht geordnet werden"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "%qT ist nicht zerstörbar"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr "%qT ist keine Referenz, die mit einem temporären Objekt vom Typ %qT verbunden ist (direct-initialization)"
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr "%qT ist keine Referenz, die mit einem temporären Objekt vom Typ %qT verbunden ist (copy-initialization)"
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "%qD ist nicht schlussfolgerbar von %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, gcc-internal-format
 msgid "invalid constraints"
 msgstr "ungültige Einschränkungen"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr "Einschränkung %qE ist vom Typ %qT, muss aber %<bool%> sein"
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "der Ausdruck %qE wird zu %<false%> ausgewertet"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "Einschränkungen sind nicht erfüllt"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr "legen Sie %qs auf mindestens %d fest, um mehr Details zu sehen"
@@ -58037,47 +58083,47 @@ msgstr "Deklaration hat abweichende Anzahl von Verträgen gegenüber der vorheri
 msgid "previous declaration with fewer contracts here"
 msgstr "vorherige Deklaration mit weniger Verträgen ist hier"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr "ein Wertparameter, der in einer Nachbedingung verwendet wird, muss const sein"
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, gcc-internal-format
 msgid "parameter declared here"
 msgstr "der Parameter ist hier deklariert"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr "der Wertparameter %qE wird in einer Nachbedingung verwendet und muss daher const sein"
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr "der Name des Ergebnisses der Nachbedingung des Vertrags verdeckt einen Funktionsparameter"
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "Deklaration fügt Verträge zu %q#D hinzu"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, gcc-internal-format
 msgid "first declared here"
 msgstr "hier zuerst deklariert"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr "Konstruktor gibt keinen Wert zurück, der getestet werden könnte"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr "Destruktor gibt keinen Wert zurück, der getestet werden könnte"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr "Funktion gibt keinen Wert zurück, der getestet werden könnte"
@@ -58147,7 +58193,7 @@ msgstr "der Versprechens-Typ %qT der Koroutine deklariert sowohl %<return_value%
 msgid "%<return_void%> declared here"
 msgstr "%<return_void%> wurde hier deklariert"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "kein Mitglied namens %qE in %qT"
@@ -58219,83 +58265,83 @@ msgstr "der abwartbare Typ %2$qT für %1$qs muss ein Strukturtyp sein"
 msgid "awaitable type %qT is not a structure"
 msgstr "der abwartbare Typ %qT muss ein Strukturtyp sein"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr "%<await_suspend%> muss %<void%>, %<bool%> oder ein Koroutine-Handle zurückgeben"
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs kann nur in einem ausgewerteten Kontext verwendet werden"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "eine mit %<noreturn%> deklarierte Funktion hat eine %<co_return%>-Anweisung"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "das align-Argument für %<__builtin_coro_promise%> muss eine Konstante sein"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "das Richtungsargument für %<__builtin_coro_promise%> muss eine Konstante sein"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "keine Informationen zum Aufschiebepunkt für %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "doppelte Informationen für %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr "Annahme ignoriert, weil sie einen await-Ausdruck enthält"
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr "await-Ausdrücke sind in Handlern nicht erlaubt"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "Arrays mit variabler Länge werden in Koroutinen noch nicht unterstützt"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr "%qE wird von %qT bereitgestellt, ist aber nicht mit der Funktionssignatur %qD verwendbar"
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr "%qE wird von %qT bereitgestellt, aber %qE ist nicht mit %<throw()%> oder %<noexcept%> gekennzeichnet"
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr "%qE ist mit %<throw()%> oder %<noexcept%> markiert, aber %qT liefert kein brauchbares %<get_return_object_on_allocation_failure%>"
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr "%qE wird von %qT bereitgestellt, aber %<std::nothrow%> wurde nicht gefunden"
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "%qE wird von %qT bereitgestellt, ist aber nicht mit der Funktion %qD verwendbar"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr "keine brauchbare Konvertierung von %<void%> durch %<get_return_object%> zu Rückgabetyp %qT"
@@ -58320,68 +58366,73 @@ msgstr "%qD wurde zu einer unmittelbaren Funktion befördert"
 msgid "%qs used outside of constant expressions"
 msgstr "%qs wird außerhalb von konstanten Ausdrücken verwendet"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "unerwartete Deklaration von %<std::%s%>"
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "Adresse der direkten Funktion %qD wird genommen"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "Aufruf der consteval-Funktion %qE ist kein konstanter Ausdruck"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%<throw%> wird immer %<terminate%> aufrufen"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "in C++11 sind Destruktoren standardmäßig %<noexcept%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr "in C++11 ruft dieses %<throw%> %<terminate%> auf, da Destruktoren standardmäßig %<noexcept%> sind"
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "Attribut %qE wird nach dem früheren %qE ignoriert"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "Packungsexpansion des Attributs %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "verwenden Sie stattdessen einen fold-Ausdruck im Attributargument"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD ist kein Typ"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qD ist kein Klassentyp"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qD hat nicht den Typ %<const char *%>"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qD hat keinen Ganzzahltyp"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr "%<std::source_location::__impl%> enthält nicht nur nicht-statische Datenelemente %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> und %<_M_column%>"
@@ -58422,7 +58473,7 @@ msgstr "Umwandlung in nicht-konstanten Referenztyp %q#T von R-Wert des Typs %qT"
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "Umwandlung von %qH in %qI löscht Qualifizierer"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "Umwandlung von %qT in %qT dereferenziert nicht den Zeiger"
@@ -58811,7 +58862,7 @@ msgstr "von vorheriger Deklaration %qF"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "Redeklaration %qD unterscheidet sich in %qs von vorheriger Deklaration"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "vorherige Deklaration %qD"
@@ -59032,12 +59083,12 @@ msgstr "Standardargument für Parameter %d von %q#D angegeben"
 msgid "previous specification in %q#D here"
 msgstr "bisherige Spezifikation in %q+#D hier"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "in Konflikt stehender Export für Deklaration %qD"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "vorher hier ohne Export deklariert"
@@ -59242,7 +59293,7 @@ msgstr "  überspringt Initialisierung von %q#D"
 msgid "  enters %<template for%> statement"
 msgstr "  betritt %<template for%>-Anweisung"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "%qD wird ohne Template-Argumente verwendet"
@@ -59287,2418 +59338,2428 @@ msgstr "%<typename %T::%D%> benennt %q#D, das ist jedoch kein Typ"
 msgid "template parameters do not match template %qD"
 msgstr "Template-Parameter passen nicht zum Template %qD"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "%<-faligned-new=%d%> ist keine Zweierpotenz"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr "%<--param destructive-interference-size=%d%> ist kleiner als %d"
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param destructive-interference-size=%d%> ist kleiner als %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr "%<--param constructive-interference-size=%d%> ist kleiner als %d"
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param constructive-interference-size=%d%> ist größer als %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q#D ungültig; eine anonyme Union kann nur nicht-statische Datenelemente haben"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr "diese Flexibilität ist veraltet und wird demnächst entfernt"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr "anonyme Struktur mit Basisklassen"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "Element %q+#D mit Konstruktor in anonymem Aggregat nicht erlaubt"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "Element %q+#D mit Destruktor in anonymem Aggregat nicht erlaubt"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "Element %q+#D mit Zuweisungsoperator ist in anonymem Aggregt nicht erlaubt"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "Attribut in Deklaration von %q#T ignoriert"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "Attribut für %q#T muss dem Schlüsselwort %qs folgen"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "mehrere Typen in einer Deklaration"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "Redeklaration des eingebauten C++-Typs %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> kann nur für Variablen oder Funktionsdeklarationen angegeben werden"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "fehlender Typname in typedef-Deklaration"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO-C++ verbietet anonyme structs"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "%<inline%> kann nur für Funktionen angegeben werden"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%<virtual%> kann nur für Funktionen angegeben werden"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> kann nur innerhalb einer Klasse angegeben werden"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> kann nur für Konstruktoren angegeben werden"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "eine Speicherklasse kann nur für Objekte und Funktionen angegeben werden"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%<const%> kann nur für Objekte und Funktionen angegeben werden"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%<volatile%> kann nur für Objekte und Funktionen angegeben werden"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%<__restrict%> kann nur für Objekte und Funktionen angegeben werden"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%<__thread%> kann nur für Objekte und Funktionen angegeben werden"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> wurde in dieser Deklaration ignoriert"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%qs kann nicht für Typdeklarationen verwendet werden"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "Attribut in expliter Instanziierung %q#T ignoriert"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "auf explizite Instanziierung kann kein Attribut angewendet werden"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "Attribut wird ignoriert"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "ein Attribut, das sich auf eine Typspezifizierung bezieht, wird ignoriert"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "auf Klassentyp %qT angewandte Attribute außerhalb einer Definition werden ignoriert"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "auf abhängigen Typ %qT angewandte Attribute ohne zugehörige Deklaration werden ignoriert"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD ist initialisiert (stattdessen %qs verwenden)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr "Nachbedingungen mit abgeleiteten Ergebnistypen dürfen nur in Funktionsdefinitionen vorkommen"
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "Deklaration von %q#D hat %<extern%> und ist initialisiert"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "Definition von %q#D ist als %<dllimport%> markiert"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q+#D ist kein static-Datenelement von %q#T"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "Nichtelement-Templatedeklaration von %qD"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "entspricht nicht der Element-Templatedeklaration hier"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO-C++ erlaubt nicht, %<%T::%D%> als %<%T::%D%> zu definieren"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "doppelte Initialisierung von %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "Deklaration von %q#D außerhalb einer Klasse ist keine Definition"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr "extern-Deklaration %q#D mit Gültigkeitsbereich Block darf nicht an ein benanntes Modul angehängt werden"
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++23%> oder %<-std=gnu++23%> als %<thread_local%> definiert werden"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD kann in einer %qs-Funktion erst ab %<-std=c++23%> oder %<-std=gnu++23%> als %<static%> definiert werden"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "Variable %q#D hat Initialisierung, aber unvollständigen Typ"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "Elemente des Arrays %q#D haben unvollständigen Typ"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "Aggregat %q#D hat unvollständigen Typ und kann nicht definiert werden"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD als Referenz deklariert, aber nicht initialisiert"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "Name in benannter Initialisierung im GNU-Stil für ein Array verwendet"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "Name %qD in benannter Initialisierung im GNU-Stil für ein Array verwendet"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "nicht-trivial markierte Initialisierungen nicht unterstützt"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "C99-Designator %qE ist kein konstanter Ganzzahlausdruck"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "Initialisierung gibt nicht die Größe von %qD an"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "Arraygröße fehlt in %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "Array %qD der Größe null"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "Speichergröße von %qD ist unbekannt"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "Speichergröße von %qD ist nicht konstant"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "Entschuldigung: Semantik der Inline-Variable %q#D ist falsch (mehrere Kopien wären die Folge)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "Entschuldigung: Semantik von static-Variable %q#D in inline-Funktion ist falsch (mehrere Kopien wären die Folge)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "dies kann durch das Löschen der Initialisierung umgangen werden"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "nicht initialisiertes %<const %D%>"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "uninitialisierte Variable %qD in %<constexpr%>-Funktion"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "uninitialisierte Variable %qD in %<constexpr%>-Kontext"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T hat keinen benutzerdefinierten Default-Konstruktor"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "Konstruktor ist nicht benutzerdefiniert, da er im Klassenkörper ausdrücklich standardisiert ist"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "und der implizit definierte Konstruktor initialisiert %q#D nicht"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "Ungültiger Typ %qT als Initialisierung für einen Vektor des Typs %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "Initialisierung für %qT muss geklammert sein"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%<[%E] =%> in benannter Initialisierung im GNU-Stil für Klasse %qT verwendet"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "Abfrage des Elementes %qD ist mehrdeutig"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT hat kein nicht-statisches Datenelement namens %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD ist kein direktes Element von %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "ungültige Initialisierung für %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "C99-Bezeichner %qE außerhalb von Aggregatinitialisierung"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "zu viele Initialisierer für %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "geschweifte Klammern um skalare Initialisierung für Typ %qT"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90182
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "zu viele geschweifte Klammern um skalare Initialisierung für Typ %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "geschweifte Klammern fehlen um Initialisierung für %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "Strukturierte Bindung hat unvollständigen Typen %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "Elemente des Arrays %q#T haben unvollständigen Typ"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "zusammengesetztes Literal variabler Größe"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D hat unvollständigen Typ"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "skalares Objekt %qD erfordert ein Element in Initialisierung"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "in C++98 muss %qD mit Konstruktor initialisiert werden, nicht mit %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "Array %qD mit geklammerter Zeichenkettenkonstante %qE initialisiert"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "Initialisierung ungültig für statisches Element mit Konstruktor"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "Initialisierung des nicht konstanten statischen Elements %qD in der Klasse ist ungültig"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "Initialisierung des nicht konstanten statischen Elements %qD in der Klasse ist ungültig"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(eine Initialisierung außerhalb der Klasse ist erforderlich)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "Adresse der Register-Variablen %qD angefordert"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "Referenz %qD wird mit sich selbst initialisiert"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "Argument %d von %qE muss vom Typ %<omp_interop_t%> sein"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "Variantendeklaration nicht gefunden"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%<declare variant%> für Konstruktor %qD"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "%<declare variant%> für Destruktor %qD"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "%<declare variant%> an %qD mit Vorgabewert"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr "%<declare variant%> an gelöschter %qD"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr "%<declare variant%> an virtueller %qD"
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "Zuweisung (nicht Initialisierung) in Deklaration"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO-C++17 erlaubt Speicherklassenangabe %<register%> nicht"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "%<register%>-Speicherklassenangabe verwendet"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "Deklaration von %q#D hat keine Initialisierung"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "Initialisierung für %<decltype(auto) %D%> hat Funktionstyp; %<()%> vergessen?"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "deduzierter Typ %qT für %qD ist unvollständig"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "%<::main%> kann nicht gelöscht werden"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "vorherige Typdeklaration von %q#D wird überschattet"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "Attribut %<constinit%> kann nur für Variablen verwendet werden, die »static« oder threadlokel sind"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<constinit%> kann erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> auf strukturierte Bindungen angewendet werden"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "Funktion %q#D ist wie eine Variable initialisiert"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "Lambda-Abschluss-Typ %qT kann nicht dekomponiert werden"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, gcc-internal-format
 msgid "lambda declared here"
 msgstr "Lambda ist hier deklariert"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "Klassentyp %qT kann nicht dekomponiert werden, da er ein unbenanntes Strukturelement hat"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr "Klassentyp %qT kann nicht dekomponiert werden, da er ein unbenanntes Unionelement hat"
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "unzugreifbares Element %qD von %qT kann nicht dekomponiert werden"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "in der Basisklasse von %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr "Klassentyp %qT kann nicht dekomponiert werden, da sowohl er als auch seine Basisklasse %qT nichtstatische Datenelemente haben"
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr "Klassentyp %qT kann nicht dekomponiert werden, da seine Basisklassen %qT und %qT nichtstatische Datenelemente haben"
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "Strukturierte Bindung verweist auf unvollständigen Typen %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "Array mit unbekannter Grenze %qT kann nicht in Komponenten zerlegt werden"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "Array mit variabler Länge %qT kann nicht dekomponiert werden"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "Vektor %qT variabler Länge kann nicht zerlegt werden"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "%<std::tuple_size<%T>::value%> ist kein konstanter Ganzzahlausdruck"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "Union-Typ %qT kann nicht dekomponiert werden"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "nicht-Array-nicht-Klassentyp %qT kann nicht dekomponiert werden"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "Strukturierte Bindung verweist auf unvollständigen Klassentypen %qT"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr "Array-Initialisierer für strukturierte Bindungsdeklaration in Bedingung"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "%u Name für strukturelle Bindung angegeben"
 msgstr[1] "%u Namen für strukturelle Bindung angegeben"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] "nur %u Name für strukturelle Bindung angegeben"
 msgstr[1] "nur %u Namen für strukturelle Bindung angegeben"
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] "während %qT in %wu Element zerlegt wird"
 msgstr[1] "während %qT in %wu Elemente zerlegt wird"
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr "während %qT in %E Elemente zerlegt wird"
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr "%<std::tuple_element<%wu, %T>::type%> ist %<void%>"
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "in Initialisierung der Packung %qD für strukturierte Bindung"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "in Initialisierung der Variable %qD für strukturierte Bindung"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "Klassentyp %qT ohne nicht-static-Datenelemente kann nicht dekomponiert werden"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr "nicht-lokale %<__thread%>-Variable %qD erfordert dynamische Initialisierung"
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "nicht-lokale %<__thread%>-Variable %qD hat einen nicht-trivialen Destruktor"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr "%<thread_local%> in C++11 erlaubt dynamische Initialisierung und Zerstörung"
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "Initialisierung gibt nicht die Größe von %qT an"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "Arraygröße fehlt in %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "Array %qT der Größe null"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "Destruktor für fremde Klasse %qT kann kein Element sein"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "Konstruktor für fremde Klasse %qT kann kein Element sein"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD als eine %<virtual%> Variable deklariert"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Variablendeklaration"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD als ein %<virtual%> Parameter deklariert"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD als ein %<inline%> Parameter deklariert"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Parameterdeklaration"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD als ein %<virtual%> Typ deklariert"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD als ein %<inline%> Typ deklariert"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Typdeklaration"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD als ein %<virtual%> Feld deklariert"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD als ein %<inline%> Feld deklariert"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "Funktionsspezifizierer %<const%> und %<volatile%> an %qD ungültig in Felddeklaration"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D als »friend« deklariert"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D mit einer Ausnahmespezifikation deklariert"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "Deklaration von %qD ist nicht in einem Namensbereich um %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "statische Elementfunktion %q#D mit Typqualifizierern deklariert"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "Funktionskonzepte werden nicht mehr unterstützt"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "Einschränkungen auf einer Funktion, die kein Template hat"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "eingeschränkte Nicht-Template-friend-Deklaration muss eine Definition sein"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr "friend-Funktionstemplate mit Einschränkungen, die von äußeren Templateparametern abhängen, muss eine Definition sein"
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "Definition der expliziten Spezialisierung %qD in friend-Deklaration"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "ungültige Verwendung der Template-ID %qD in Deklaration des ursprünglichen Templates"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "Standardargumente sind nicht in Deklaration der friend-Template-Spezialisierung %qD erlaubt"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> ist nicht in Deklaration der friend-Template-Spezialisierung %qD erlaubt"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "»friend«-Deklaration von %qD gibt Defaultargumente an und ist keine Definition"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "%<::main%> kann nicht als Template deklariert werden"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "%<::main%> kann nicht inline deklariert werden"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "%<::main%> kann nicht als %qs deklariert werden"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "%<::main%> kann nicht statisch deklariert werden"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "%<::main%> kann nur mit der Bindungsangabe %<extern \"C++\"%> deklariert werden"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "%<::main%> kann nicht an ein benanntes Modul angehängt werden"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr "verwenden Sie %<extern \"C++\"%>, um es stattdessen an das globale Modul anzuhängen"
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "Nicht-Elementfunktion %qD kann nicht CV-Qualifizierer haben"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "statische Elementfunktion %qD kann nicht CV-Qualifizierer haben"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "explizite Objekt-Member-Funktion %qD kann keine CV-Qualifizierer haben"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "Nicht-Elementfunktion %qD kann keinen ref-Qualifizierer haben"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "statische Elementfunktion %qD kann keinen ref-Qualifizierer haben"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "explizite Objekt-Member-Funktion %qD kann keinen ref-qualifier haben"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "expliziter Objektparameter wird hier deklariert"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "Herleitungshinweis %qD muss im selben Gültigkeitsbereich wie %qT deklariert sein"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "  hier deklariert"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "Herleitungshinweis %qD muss denselben Zugriff wie %qT haben"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "Herleitungshinweis %qD darf keinen Funktionskörper haben"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "literaler Operator mit C-Bindung"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD hat ungültige Argumentliste"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "Ganzzahl-Suffix %qs durch Implementierung überdeckt"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "Gleitkomma-Suffix %qs durch Implementierung überdeckt"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "Literale Operator-Suffixe ohne vorangehendes %<_%> sind für zukünftige Standardisierungen reserviert"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD muss eine Nicht-Elementfunktion sein"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> muss %<int%> zurückgeben"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "Definition des implizit deklarierten %qD"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "Definition des explizit standardisierten %q+D"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q#D wurde hat hier ausdrücklichen Standardwert bekommen"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "keine Elementfunktion %q#D in Klasse %qT deklariert"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "%<::main%> kann nicht als globale Variable deklariert werden"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr "eine Entität mit dem Namen %<main%> kann nicht mit C-Sprachbindung deklariert werden"
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "eine Nicht-Template-Variable kann nicht %<concept%> sein"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "Konzept muss im Gültigkeitsbereich des Namensbereiches definiert werden"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "Variablenkonzepte werden nicht mehr unterstützt"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit unvollständigem Typ"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "%<constexpr%> erforderlich für Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit nicht eingebautem Typ"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "Initialisierung innerhalb der Klasse des statischen Datenelements %q#D mit nicht eingebautem Typ"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "ungültige Initialisierung innerhalb der Klasse des statischen Datenelements vom nicht eingebauten Typen %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO-C++ verbietet Initialisierung des nicht konstanten statischen Elements %qD in der Klasse"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO-C++ verbietet Initialisierung der Elementkonstante %qD vom nicht eingebauten Typen %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "Arraygröße von %qD hat nicht-ganzzahligen Typen %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "Arraygröße hat nicht-ganzzahligen Typen %qT"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "Größe des Arrays %qD ist kein konstanter Ganzzahlausdruck"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "Größe des Arrays ist kein konstanter Ganzzahlausdruck"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO-C++ verbietet Array %qD der Größe null"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO-C++ verbietet Array der Größe null"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO-C++ verbietet Array %qD variabler Länge"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO-C++ verbietet Array variabler Länge"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "Array %qD variabler Länge wird verwendet"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "Array variabler Größe wird verwendet"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "Überlauf in Arraygröße"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD ist als Array vom Template-Platzhaltertyp %qT deklariert"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "Array des Template-Platzhaltertyps %qT wird erzeugt"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "Deklaration von %qD als Array von voids"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "Array von void wird erzeugt"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "Deklaration von %qD als Array von Funktionen"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "Array von Funktionen wird erzeugt"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "Deklaration von %qD als Array von Referenzen"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "Feld von Referenzen wird erzeugt"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "Deklaration von %qD als Feld von Funktionselementen"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "Feld von Funktionselementen wird erzeugt"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "Deklaration von %qD als multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "multidimensionales Feld muss für alle Dimensionen außer der ersten Grenzen haben"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr "Array variabler Größe von %<auto%>"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "Angabe des Rückgabetyps für Konstruktor ist ungültig"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "Qualifizierer sind bei Konstruktordeklarationen nicht erlaubt"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "Angabe des Rückgabetyps für Destruktor ist ungültig"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "Qualifizierer sind bei Destruktordeklarationen nicht erlaubt"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "Rückgabetyp für %<operator %T%> angegeben"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "Qualifizierer sind bei Deklaration von %<operator %T%> nicht erlaubt"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "Rückgabetyp für Herleitungshinweis angegeben"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "Qualifizierer sind bei Deklaration von Herleitungshinweis nicht erlaubt"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "Template-Template-Parameter %qT in Deklaration von Ableitungshinweis"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "%<decl-specifier%> in Deklaration von Ableitungshinweis"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "unbenannte Variable oder Feld als »void« deklariert"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "Variable oder Feld als »void« deklariert"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "%<inline%>-Spezifizierer ungültig für Variable %qD mit Gültigkeitsbereich Block"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "»inline«-Variablen sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr "anonymer, nicht C-kompatibler Typ, der durch die Deklaration %<typedef%> einen Namen für Bindungszwecke erhält"
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr "der Typ ist nicht C-kompatibel, da er eine Basisklasse hat"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr "der Typ ist nicht C-kompatibel, da %qD einen Standard-Member-Initialisierer hat"
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "der Typ ist nicht C-kompatibel, da er die Deklaration %qD enthält"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr "%qT als Typ statt als einfaches %<decltype(auto)%>"
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "%<decltype(auto)%> darf nicht CV-qualifiziert sein"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 msgid "%e and %e specified together"
 msgstr "%e und %e gleichzeitig angegeben"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "ungültige Verwendung des qualifizierten Namens %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "ungültige Verwendung des qualifizierten Namens %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "ungültige Verwendung des qualifizierten Namens %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%q#T ist weder Klasse noch Namensbereich"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "Deklaration von %qE als Nicht-Funktion"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "Deklaration von %qE als Nicht-Element"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "Deklarator-ID fehlt: reserviertes Wort %qD wird verwendet"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "Funktionsdefinition deklariert keine Parameter"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "Deklaration von %qD als Nicht-Funktion"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "Deklaration von %qD als %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "Deklaration von %qD als Parameter"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr "sowohl %qs als auch %qs angegeben"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%qs kann nicht in einer typedef-Deklaration auftreten"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr "höchstens einer der Spezifizierer %<constinit%> und %<constexpr%> kann verwendet werden"
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "zwei oder mehr Datentypen in Deklaration von %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO-C++ unterstützt nicht, dass einfaches %<complex%> %<double complex%> bedeutet"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO-C++ verbietet Deklaration von %qs ohne Typ"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int%d%> wird von diesem Ziel nicht unterstützt"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO-C++ unterstützt %<__int%d%> für %qs nicht"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qs mit %qT angegeben"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qs mit typedef-name %qD angegeben"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs mit %<decltype%> angegeben"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qs mit %<typeof%> angegeben"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "complex ungültig für %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr "fehlende Template-Argumentliste nach %qE; für die Deduktion muss auf den Template-Platzhalter eine einfache Deklarator-ID folgen"
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "Element %qD kann nicht gleichzeitig %<virtual%> und %<static%> sein"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Element %qD kann erst mit %<-std=c++20%> oder %<-std=gnu++20%> gleichzeitig %<virtual%> und %<constexpr%> sein"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "»typedef«-Deklaration in Parameterdeklaration ungültig"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "Speicherklasse für Template-Parameter %qs angegeben"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "Speicherklasse für Parameter %qs angegeben"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "ein Parameter kann nicht als %qs deklariert sein"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> außerhalb einer Klassendeklaration"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "Deklaration für strukturierte Bindung darf nicht als %qs deklariert werden"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturierte Bindungsdeklarationen können erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> %qs sein"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "strukturierte Bindungsdeklarationen können erst ab %<-std=c++20%> oder %<-std=gnu++20%> %qs sein"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "%<volatile%>-qualifizierte strukturierte Bindung ist veraltet"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "Deklaration für strukturierte Bindung darf nicht als %<auto%> (C++98) deklariert werden"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "Deklaration für strukturierte Bindung darf nicht vom Typen %qT sein"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr "Typ muss cv-qualifizierter %<auto%> oder Referenz auf cv-qualifizierten %<auto%> sein"
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "Deklaration für strukturierte Bindung darf nicht vom eingeschränkten %<auto%>-Typen %qT sein"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "mehrere Speicherklassen in Deklaration von %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "Speicherklasse %qs angegeben"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "geschachtelte Funktion %qs als %<extern%> deklariert"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "Deklaration höchster Ebene von %qs gibt %<auto%> an"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "Funktions-Gültigkeitsbereich %qs ist implizit auto und deklarierte %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "Speicherklassenangaben sind in friend-Funktionsdeklarationen ungültig"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "unnötige Klammern in Deklaration von %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr "entfernen Sie die Klammern"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "explizite Objekt-Member-Funktion ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "ein Funktionstyp kann keinen expliziten Objektparameter haben"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "ein Zeiger auf einen Funktionstyp kann keinen expliziten Objektparameter haben"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "ein Zeiger auf einen Memberfunktionstyp kann keinen expliziten Objektparameter haben"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr "der Typ eines Zeigers auf eine explizite Objekt-Member-Funktion ist ein normaler Funktionszeiger-Typ"
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "der Typ einer expliziten Objekt-Member-Funktion ist ein normaler Funktionstyp"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr "nur der erste Parameter einer Memberfunktion kann als expliziter Objektparameter deklariert werden"
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr "gültiger expliziter Objektparameter wird hier deklariert"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "»requires«-Klausel für Rückgabetyp"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "Funktion %qs verwendet Typspezifikation %<auto%> ohne folgenden Rückgabetypen"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "hergeleiteter Rückgabetyp nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "virtuelle Funktionen kann keinen hergeleiteten Rückgabetyp haben"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "Funktion %qs mit folgendem Rückgabetypen hat %qT als seinen Typ statt einfaches %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "Funktion %qs mit nachgestelltem Rückgabetyp hat %<decltype(auto)%> als Typ statt einfachem %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "ungültige Verwendung von %<decltype(auto)%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "Funktion %qs mit nachfolgendem Rückgabetypen hat eingeschränkte %<auto%>-Typangabe statt des einfachen %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "ungültige Verwendung eines eingeschränkten %<auto%>-Typs"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "hergeleiteter Klassentyp %qD in Rückgabetyp von Funktion"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "Herleitungshinweis für %qT muss angehängten Rückgabetyp haben"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr "angehängter Rückgabetyp %qT den Ableitungshinweises ist keine Spezialisierung von %qT"
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "nachgestellter Rückgabetyp nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "Funktion %qs mit folgendem Rückgabetypen nicht mit Typspezifikation %<auto%> deklariert"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "eine Umwandlungsfunktion darf keinen angehängten Rückgabetyp haben"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "%<volatile%>-qualifizierter Rückgabetyp ist veraltet"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs als Funktion, die eine Funktion zurückgibt, deklariert"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs als Funktion, die ein Feld zurückgibt, deklariert"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<constinit%> ist am Rückgabetyp einer Funktion nicht erlaubt"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "Destruktor kann keine statische Elementfunktion sein"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "Konstruktor kann keine statische Elementfunktion sein"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "Destruktoren dürfen nicht CV-qualifiziert sein"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "Konstruktoren dürfen nicht CV-qualifiziert sein"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "Destruktoren dürfen nicht ref-qualifiziert sein"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "Konstruktoren dürfen nicht ref-qualifiziert sein"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "Konstruktoren dürfen nicht als %<virtual%> deklariert sein"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "virtuelle Funktionen können keine friends sein"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "friend-Deklaration nicht in Klassendefinition"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "%<friend%>-Funktion %qs kann nicht in einer lokalen Klassendefinition definiert werden"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr "Definition der Freundfunktion %qs kann keinen Namen haben, der mit %<::%> qualifiziert ist"
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr "Definition der Freundfunktion %qs kann keinen Namen haben, der mit %<%D::%> qualifiziert ist"
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "eine Funktion, die kein Member ist, kann keinen expliziten Objektparameter haben"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "eine explizite Objekt-Member-Funktion kann nicht %<virtual%> sein"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "eine explizite Objekt-Member-Funktion kann nicht %<static%> sein"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD kann keine explizite Objektelementfunktion sein"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "Destruktoren dürfen keine Parameter haben"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "Zeiger auf %q#T kann nicht deklariert werden"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "Referenz auf %q#T kann nicht deklariert werden"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "Zeiger auf Element %q#T kann nicht deklariert werden"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "Referenz auf qualifizierten Funktionstypen %qT kann nicht deklariert werden"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "Zeiger auf qualifizierten Funktionstypen %qT kann nicht deklariert werden"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "Referenz auf %q#T kann nicht deklariert werden, da letzteres weder Typedef noch Templatetyp-Argument ist"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "Template-ID %qD als Deklarator verwendet"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "Elementfunktionen sind implizite »friends« ihrer Klasse"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "zusätzliche Qualifizierung %<%T::%> an Element %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "Elementfunktion %<%T::%s%> kann nicht innerhalb von %qT definiert werden"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "Elementfunktion %<%T::%s%> kann nicht innerhalb von %qT deklariert werden"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "Element %<%T::%s%> kann nicht in %qT deklariert werden"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "Nicht-Parameter %qs kann kein Parameterpack sein"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "Datenelement darf nicht variabel modifizierten Typ %qT haben"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "Parameter darf nicht variabel modifizierten Typ %qT haben"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<explicit%> außerhalb einer Klassendeklaration"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<explicit%> in »friend«-Deklaration"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "nur Deklarationen von Konstruktoren und Umwandlungsoperatoren können %<explicit%> sein"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "Nicht-Element %qs kann nicht als %<mutable%> deklariert sein"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "Nicht-Objekt-Element %qs kann nicht als %<mutable%> deklariert sein"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "Funktion %qs kann nicht als %<mutable%> deklariert sein"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "%qs ist %<static%> und darf daher nicht als %<mutable%> deklariert sein"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "%qs ist %<const%> und darf daher nicht als %<mutable%> deklariert sein"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "Referenz %qs kann nicht als %<mutable%> deklariert sein"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "mit %<typedef%> definierte Funktion darf keinen Rumpf %<{ … }%> haben"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "mit %<typedef%> definierte Elementfunktion darf keinen Rumpf %<{ … }%> haben"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<auto%> ist in Aliasdeklaration nicht erlaubt"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "»typedef« als %<auto%> deklariert"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr "requires-clause an Typedef"
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "typedef-Name darf kein Spezifizierer mit geschachteltem Namen sein"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO-C++ verbietet geschachtelten Typen %qD mit gleichem Namen wie umschließende Klasse"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> für friend-Klassen-Deklaration angegeben"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "Template-Parameter können keine »friends« sein"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "friend-Deklaration erfordert Klassenschlüssel, d.h. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "friend-Deklaration erfordert Klassenschlüssel, d.h. %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "Versuch, die Klasse %qT zu einem »friend« des globalen Gültigkeitsbereiches zu machen"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "ungültige Qualifizierer an Nicht-Element-Funktionstyp"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr "requires-clause an type-id"
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "abstrakter Deklarator %qT als Deklaration verwendet"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "»requires«-Klausel in Deklaration von Nichtfunktionstyp %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "%<::%> kann nicht in Parameterdeklaration verwendet werden"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "Parameter kann nicht mit %<decltype(auto)%> deklariert werden"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr "fehlende Template-Argumentliste nach %qE; Template-Platzhalter ist in Parameter nicht erlaubt"
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "oder verwenden Sie %<auto%> für ein abgekürztes Funktionstemplate"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%<auto%>-Parameter darf in diesem Kontext nicht verwendet werden"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "Parameter als %<auto%> deklariert"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "ungültige Verwendung des Template-Namens %qE ohne eine Argumentliste"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "nicht-statisches Datenelement mit Platzhalter %qT deklariert"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO-C++ verbietet flexibles Arrayelement %qs"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO-C++ verbietet flexible Arrayelemente"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "ungültige Verwendung von %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "Deklaration der Funktion %qD in ungültigem Kontext"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "Funktion %qD wurde innerhalb einer Union als %<virtual%> deklariert"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD kann nicht als %<virtual%> deklariert werden, da es immer statisch ist"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "Qualifizierten Namen in Friend-Deklaration für Destruktor %qD erwartet"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "Deklaration von %qD als Element %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "ein Destruktor kann nicht %qs sein"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "Qualifizierten Namen in Friend-Deklaration für Konstruktor %qD erwartet"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "ein Konstruktor kann nicht %<concept%> sein"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "ein Konzept kann keine Elementfunktion sein"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%qD kann nicht %qs sein"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "Spezialisierung des Variablentemplates %qD als Funktion deklariert"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr "Variablentemplate hier deklariert"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "Feld %qD hat unvollständigen Typen %qT"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "Name %qT hat unvollständigen Typen"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE ist weder eine Funktion noch Elementfunktion; kann nicht als »friend« deklariert werden"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "unbenanntes Feld ist weder eine Funktion noch Elementfunktion; kann nicht als %<friend%> deklariert werden"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "Annotation wird auf nicht-definierende Freund-Deklaration %qD angewendet"
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "Annotation wird auf Parameter %qD einer nicht-definierenden Freund-Deklaration angewendet"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "ein Attribut, das zu einer »friend«-Deklaration gehört, die keine Definition ist, wird ignoriert"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "statisches Datenelement %qE als %qs deklariert"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "statisches Datenelement %qD (%<constexpr%>) muss Initialisierung haben"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "nicht-statisches Datenelement %qE als %qs deklariert"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "Speicherklasse %<auto%> ungültig für Funktion %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "Speicherklasse %<register%> ungültig für Funktion %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "Speicherklasse %<__thread%> ungültig für Funktion %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "Speicherklasse %<thread_local%> ungültig für Funktion %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "%<constinit%>-Angabe ungültig für Funktion %qs"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "virt-Spezifikation in %qs ist außerhalb einer Klassendefinition nicht erlaubt"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "%<static%> ist für außerhalb des globalen Gültigkeitsbereiches deklarierte Funktion %qs ungültig"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "%<inline%> ungültig für außerhalb des globalen Gültigkeitsbereiches deklarierte Funktion %qs"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "virtuelle Nicht-Klassen-Funktion %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs nicht in Klassen-Gültigkeitsbereich definiert"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs in einem Nicht-Klassen-Gültigkeitsbereich definiert"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "Elementfunktion %qD kann nicht deklariert werden, statische Bindung zu haben"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "statische Funktion innerhalb anderer Funktion kann nicht deklariert werden"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> darf nicht bei der Definition (im Gegensatz zu Deklaration) eines statischen Datenelementes verwendet werden"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "statisches Element %qD als %<register%> deklariert"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "Element %q#D kann nicht explizit deklariert werden, externe Bindung zu haben"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "Deklaration der %<constexpr%>-Variable %qD ist keine Definition"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "eine Variable kann nicht als %<consteval%> deklariert sein"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs initialisiert und als %<extern%> deklariert"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs hat sowohl %<extern%> als auch Initialisierung"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "Standardargument %qE verwendet %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "Standardargument %qE verwendet lokale Variable %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "ungültige Verwendung von cv-qualifiziertem Typ %qT in Parameterdeklaration"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "ungültige Verwendung von Typ %<void%> in Parameterdeklaration"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "%<volatile%>-qualifizierter Parameter ist veraltet"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "Parameter %qD deklariert ungültigerweise Methodentyp"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "Parameter %qD bezieht Zeiger auf Feld mit unbekannter Grenze %qT ein"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "Parameter %qD bezieht Referenz auf Feld mit unbekannter Grenze %qT ein"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "ungültiger Konstruktor; wahrscheinlich war %<%T (const %T&)%> gemeint"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD darf nicht innerhalb eines Namensbereiches definiert werden"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD darf nicht als »static« deklariert werden"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "%qD muss eine nichtstatische Elementfunktion sein"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD muss eine Memberfunktion sein"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD darf erst ab %<-std=c++23%> oder %<-std=gnu++23%> eine statische Memberfunktion sein"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD muss entweder eine nichtstatische Elementfunktion oder eine Nicht-Element-Funktion sein"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD muss ein Argument von einem Klassen- oder Aufzählungstyp haben"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO-C++ verbietet Überladen von %<operator ?:%>"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "»%qD« darf keine variable Argumentanzahl haben"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "%qD muss entweder null oder ein Argument nehmen"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "%qD muss entweder ein oder zwei Argumente nehmen"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "Suffix-%qD muss %<int%> als sein Argument nehmen"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "Suffix-%qD muss %<int%> als sein zweites Argument nehmen"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "%qD darf keine Argumente nehmen"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "%qD muss genau ein Argument nehmen"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "%qD muss genau zwei Argumente nehmen"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD kann keine Standardargumente haben"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "Umwandlung von %qT in %<void%> wird nie einen Typumwandlungsoperator verwenden"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "Umwandlung von %qT in Referenz auf gleichen Typ wird nie einen Typumwandlungsoperator verwenden"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "Umwandlung von %qT in gleichen Typ wird nie einen Typumwandlungsoperator verwenden"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "Umwandlung von %qT in Referenz auf Basisklasse %qT wird nie einen Typumwandlungsoperator verwenden"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "Umwandlung von %qT in Basisklasse %qT wird nie einen Typumwandlungsoperator verwenden"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "benutzerdefiniertes %qD wertet immer beide Argumente aus"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "Präfix-%qD sollte %qT zurückgeben"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "Suffix-%qD sollte %qT zurückgeben"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD sollte Wert zurückgeben"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "Templatetyp-Parameter %qT wird nach %qs verwendet"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "Templatespezialisierung alias %qT hinter %qs wird verwendet"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "typedef-Name %qD wird nach %qs verwendet"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD hat eine vorherige Deklaration hier"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT als %qs verwendet"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%qT hat hier eine vorherige Deklaration"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT als enum verwendet"
@@ -61710,100 +61771,100 @@ msgstr "%qT als enum verwendet"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "Template-Argument für %<%s %T%> benötigt"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "Referenz auf %qD ist mehrdeutig"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "Klassentemplate %qD als Nicht-Template redeklariert"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD hat den gleichen Namen wie die Klasse, in der es deklariert wurde"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT ist kein Template"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr "Sie könnten ein explizites %<%T::%> hinzufügen"
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "Verwendung des enum %q#D ohne vorherige Deklaration"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "Redeklaration von %qT als Nicht-Template"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "abgeleitete Union %qT ist ungültig"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT ist mit mehreren direkten Basisklassen definiert"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT ist mit direkter virtueller Basisklasse definiert"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "Basistyp %qT ist kein struct- oder Klassentyp"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "rekursiver Typ %qT nicht definiert"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "doppelter Basistyp %qT ungültig"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "falsche Zuordnung zwischen innerhalb und außerhalb eines Gültigkeitsbereiches in enum %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "vorherige Definition hier"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "falsche Zuordnung des zugrunde liegenden Typs in enum %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "anderer zugrunde liegender Typ in enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "zugrunde liegender Typ %qT von %qT muss ein ganzzahliger Typ sein"
@@ -61812,87 +61873,92 @@ msgstr "zugrunde liegender Typ %qT von %qT muss ein ganzzahliger Typ sein"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "kein Ganzzahltyp kann alle Aufzählungswerte für %qT darstellen"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "Aufzählungswert für %qD muss ganzzahligen oder Aufzählungstyp ohne Gültigkeitsbereich haben"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "Aufzählungswert für %qD ist keine Ganzzahlkonstante"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "erhöhter Aufzählungswert ist zu groß für %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "erhöhter Aufzählungswert ist zu groß für %<long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "Überlauf in Aufzählungswerten bei %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "Aufzählungswert %qE ist außerhalb des Gültigkeitsbereichs des zugrundeliegenden Typen %qT"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "mehrfache Definition von %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "Rückgabetyp %q#T ist unvollständig"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> sollte eine Referenz auf %<*this%> zurückgeben"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "keine return-Anweisungen in %qT zurückgebender Funktion"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "nur einfacher Rückgabetyp %<auto%> kann zu %<void%> hergeleitet werden"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr "Definition von %qD, das zuvor in einem SFINAE-Kontext nicht abgeleitet werden konnte"
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "eine %<constexpr%>-Funktion, die etwas Anderes als %<void%> zurückgibt, muss eine return-Anweisung enthalten"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD ist bereits in Klasse %qT definiert"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr "%qs wird verwendet"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "%qs ohne %qs-Deklaration verwendet"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "Verwendung von %qD vor Herleitung von %<auto%>"
@@ -62322,336 +62388,336 @@ msgstr "Verwendung der Funktion %qD mit nicht erfüllten Einschränkungen"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "Verwendung von eingebautem Parameterpack %qD außerhalb eines Templates"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    eingefügt von %qD bei %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    eingefügt von %qD bei %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "    eingefügt von %qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "In statischer Elementfunktion %qD"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "In Kopierkonstruktor %qD"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "In Konstruktor %qD"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "In Destruktor %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "In Lambda-Funktion"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "In expliziter Objektelementfunktion %qD"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, gcc-internal-format
 msgid "In member function %qD"
 msgstr "In Elementfunktion %qD"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr "In Funktion %qD"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "aber %qE ist ein Typ"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "aber %qE ist ein Ausdruck"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "aber %qE ist eine strukturierte Bindung"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr "aber %qE ist eine Variable"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "aber %qE ist ein Parameter"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "aber %qE ist eine Funktion"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "aber %qE ist ein Datenmember"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr "aber %qE ist ein Funktionstemplate"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "aber %qE ist ein Klassentemplate"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "aber %qE ist ein Variablentemplate"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr "aber %qE ist ein Namensraum"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "aber %qE ist ein Aufzählungstyp"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s%s%sIn Instanziierung von %<template for%>-Iteration %E:\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s%s%sIn Ersetzung von %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s%s%sIn Instanziierung von %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "rekursiv erfordert von %<template for%>-Iteration %E\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr "erfordert von %<template for%>-Iteration %E\n"
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "rekursiv erforderlich durch Ersetzung von %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "erforderlich durch Ersetzung von %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "rekursiv erfordert von %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "erfordert durch %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "rekursiv erfordert von hier\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "von hier erfordert\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "[ %d Instanziierungskontexte werden übersprungen, »-ftemplate-backtrace-limit=0« zum Ausschalten verwenden ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "in %<constexpr%>-Ersetzung von %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "erforderlich durch die Beschränkungen von %q#D\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "erforderlich, um %qE zu erfüllen"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "erforderlich, um die Beschränkung zu erfüllen\n"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr "bei Anforderungen mit "
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93881
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, gcc-internal-format
 msgid "in requirements "
 msgstr "in Anforderungen "
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr "(kein Argument)"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr "[…]"
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "erweiterte Initialisierungslisten nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "explizite Umwandlungsoperatoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "variadische Templates nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Lambda-Ausdrücke nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 %<auto%> ist nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "enums mit Gültigkeitsbereich nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Standard- und gelöschte Funktionen nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "»inline«-Namensräume nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Überschreibsteuerung (override/final) nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "nicht-statische Initialisierungen für Datenelemente nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "benutzerdefinierte Literale nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "delegierende Konstruktoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "erbende Konstruktoren nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11-Attribute sind erst ab %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-Qualifizierer sind nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "unvollständiger Typ %qT in geschachtelter Namensangabe verwendet"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "Referenz auf %<%T::%D%> ist mehrdeutig"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD ist kein Element von %qT; meinten Sie %qs?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD ist kein Element von %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD ist kein Element von %qD; meinten Sie %qs?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD ist kein Element von %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> wurde nicht deklariert; meinten Sie %qs?"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> wurde nicht deklariert"
@@ -62872,7 +62938,7 @@ msgstr "die Referenz %qD ist noch nicht an einen Wert gebunden, wenn sie hier ve
 msgid "member %qD is used uninitialized"
 msgstr "Mitglied %qD ist nicht initialisiert, wird aber benutzt"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "Array muss mit Initialisierung mit umgebenden geschweiften Klammern initialisiert werden"
@@ -62988,7 +63054,7 @@ msgstr "Typ %qT ist keine direkte oder virtuelle Basis von %qT"
 msgid "type %qT is not a direct base of %qT"
 msgstr "Typ %qT ist keine direkte Basis von %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -63179,42 +63245,42 @@ msgstr "mögliches Problem bei Aufruf des Operators %<delete []%> erkannt"
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "weder der Destruktor noch der klassenspezifische Operator %<delete []%> wird aufgerufen, auch wenn sie bei der Klassendefinition deklariert werden"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "Initialisierung endet vorzeitig"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "unbekannte Arraygröße in »delete«"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, gcc-internal-format
 msgid "operator %<delete%> used on incomplete type"
 msgstr "Operator %<delete%> auf unvollständigem Typ verwendet"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "mögliches Problem bei Aufruf von %<operator delete%> erkannt"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "weder der Destruktor noch der klassenspezifische %<operator delete%> wird aufgerufen, auch wenn sie bei der Klassendefinition deklariert werden"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "Löschen des Objekts mit abstraktem Klassentyp %qT mit nicht-virtuellem Destruktor bewirkt undefiniertes Verhalten"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "Löschen des Objekts mit polymorphem Klassentyp %qT mit nicht-virtuellem Destruktor bewirkt möglicherweise undefiniertes Verhalten"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "Typ für Vektor-»delete« ist weder Zeiger- noch Arraytyp"
@@ -63249,82 +63315,90 @@ msgstr "Einfangen per Kopie von unvollständigem Typ %qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "eingefangene strukturierte Bindungen sind eine C++20-Erweiterung"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr "Versuch, %qD in Instanziierung eines generischen Lambdas einzufangen"
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr "implizites Einfangen von %qE via %<[=]%> ist in C++20 veraltet"
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr "fangen Sie %<this%> oder %<*this%> explizit ein"
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> wurde für diese Lambda-Funktion nicht aufgefangen"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "der gemangelte Name von %qT hat sich in %<-fabi-version=20%> (GCC 15.1) geändert"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "der gemangelte Name von %qT ändert sich in %<-fabi-version=20%> (GCC 15.1)"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr "%qD wird in ABI v21 (GCC 16) nicht mehr in noexcept-Lambda festgehalten."
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "ungültiges %<#pragma %s%>"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "%<#pragma vtable%> wird nicht mehr unterstützt"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%<#pragma implementation%> für %qs erscheint, nachdem Datei eingebunden wurde"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD nicht definiert"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<requires%> ist erst ab %<-std=c++20%> oder mit %<-fconcepts%> verfügbar"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD wurde in diesem Gültigkeitsbereich nicht deklariert; meinten Sie %qs?"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD wurde in diesem Gültigkeitsbereich nicht definiert"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "es gibt keine Argumente für %qD, die von einem Templateparameter abhängen, weshalb eine Deklaration von %qD verfügbar sein muss"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(mit %<-fpermissive%> wird G++ den Code akzeptieren, aber die Verwendung eines nicht deklarierten Namens ist veraltet)"
@@ -63334,64 +63408,57 @@ msgstr "(mit %<-fpermissive%> wird G++ den Code akzeptieren, aber die Verwendung
 msgid "  # %E"
 msgstr "  # %E"
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "mangling %<typeof%>, verwenden Sie stattdessen %<decltype%>"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr "Verwendung der eingebauten Eigenschaft %qT in Funktionssignatur; stattdessen sollten Bibliothekseigenschaften verwendet werden"
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr "mangling type pack index"
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr "Verwendung der eingebauten Eigenschaft %qE in Funktionssignatur; stattdessen sollten Bibliothekseigenschaften verwendet werden"
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "%C wird gemangelt"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "ausgelassener mittlerer Operand für Operator %<?:%> kann nicht verarbeitet werden"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr "gemangelter Name für %qD wird sich ich C++17 ändern, da die Exceptionangabe Teil des Funktionstyps ist"
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "der gemangelte Name von %qD hat sich zwischen %<%s=%d%> (%qD) und %<%s=%d%> (%qD) geändert"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "der gemangelte Name von %qD ändert sich zwischen %<%s=%d%> (%qD) und %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "der gemangelte Name eines Thunks für %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "der gemangelte Name von %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "der gemangelte Name der Initialisierungswächter-Variable für %qD ändert sich zwischen %<-fabi-version=%d%> und %<-fabi-version=%d%>"
@@ -63777,7 +63844,7 @@ msgstr "bestehende Deklaration ist hier ohne Tags"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "in Konflikt stehende Sprachbindung für importierte Deklaration %#qD"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "in Konflikt stehender Typ für importierte Deklaration %#qD"
@@ -63792,424 +63859,424 @@ msgstr "in Konflikt stehende Argumentliste für importierte Deklaration %#qD"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "in Konflikt stehende Argumenttypen für importierte Deklaration %#qD"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "in Konflikt stehende %<noexcept%>-Angabe für importierte Deklaration %#qD"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "in Konflikt stehender deduzierter Rückgabetyp für importierte Deklaration %#qD"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "in Konflikt stehendes %<constexpr%> für importierte Deklaration %#qD"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "in Konflikt stehende Deklaration %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "bestehende Deklaration %#qD"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "widersprüchliches Standardargument für %#qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, gcc-internal-format
 msgid "existing default declared here"
 msgstr "der bestehende Vorgabewert ist hier deklariert"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "widersprüchliches Standardargument für den Parameter %P von %#qD"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "Definition von %qD stimmt nicht überein"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "bestehende Definition %qD"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "der Aufzählungswert %qD passt nicht zu ..."
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "... diesem Aufzählungswert %qD"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr "zusätzliche Aufzählungswerte, die mit %qD beginnen"
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr "Aufzählungsbereich unterscheidet sich"
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qD ist ein Alias des TU-lokalen Typen %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%qD ist eine Spezialisierung des TU-lokalen Templates %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "%qD ist mit interner Bindung deklariert"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD hat keine Bindung und ist innerhalb eines anonymen Namensraums deklariert"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD hat keine Bindung und ist innerhalb der TU-lokalen Entität %qT deklariert"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD hat keine Bindung und ist innerhalb der TU-lokalen Entität %qD deklariert"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr "%qT hat keinen Namen und kann nicht von ähnlichen Lambdas in anderen TUs unterschieden werden"
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr "%qT hat keinen Namen und ist nicht innerhalb einer Klasse, Funktion oder eines Initialisierers definiert"
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD hat TU-lokales Template-Argument %qD"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qD hat TU-lokales Template-Argument %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr "%qD verweist auf das TU-lokale Objekt %qD"
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD verweist auf die TU-lokale Funktion %qD"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "die Instanziierung macht die TU-lokale Entität %qD sichtbar"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr "%qD macht die TU-lokale Entität %qD sichtbar"
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr "%qD ist ebenfalls TU-lokal, wurde jedoch an anderer Stelle offengelegt"
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr "%qD bezieht sich auf die TU-lokale Entität %qD und kann dadurch in anderen TUs zu Problemen führen"
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr "%qD bezieht sich auf die TU-lokale Entität %qD und kann nicht in anderen TUs instanziiert werden"
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD ist als %<constexpr%> deklariert und wird mit einem TU-lokalen Wert initialisiert"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr "%qD ist eine als %<inline%> deklarierte Referenz und wird mit einem TU-lokalen Wert initialisiert"
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr "rekursives verzögertes Laden"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr "das Modul %qs hat sich selbst als Abhängigkeit"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "das Modul %qs ist hier deklariert"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "der indirekte Import %qs ist noch nicht geladen"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr "der Import %qs hat eine falsche CRC-Prüfsumme"
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr "%<#define %E%> wird nicht exportiert, da es ein Schlüsselwort ist"
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "Makrodefinitionen von %qE sind kaputt"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "inkonsistente importierte Makrodefinition %qE"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr "%<#undef %E%>"
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr "%<#define %s%>"
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "die compilierte Moduldatei ist %qs"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "das kompilierte Modul ist %sVersion %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr "der Compiler ist %sVersion %s%s%s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr "Modul %qs gefunden"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr "Headermodul erwartet, Modul %qs gefunden"
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr "Modul %qs erwartet, Headermodul gefunden"
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr "CRC-Fehler in Modul %qs"
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr "Ziel und Gastgeber sind %qs:%qs, erwartet werden jedoch %qs:%qs"
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr "Sprachdialekt ist %qs, erwartet wird jedoch %qs"
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "Modul enthält OpenMP, verwenden Sie %<-fopenmp%>, um es einzuschalten"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr "Modul enthält OpenMP, verwenden Sie %<-fopenmp%> oder %<-fopenmp-simd%>, um es einzuschalten"
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "Modul enthält OpenACC, verwenden Sie %<-fopenacc%>, um es einzuschalten"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "reparierte Bäume sind unverträglich"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "Schnittstellenpartition wird nicht exportiert"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "Fehler beim Lesen des kompilierten Modul-Clusters %u: %s"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "Fehler beim Lesen des kompilierten Modus: %s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr "erwägen Sie die Verwendung von %<-fno-module-lazy%>, die Erhöhung des Wertes von %<-param-lazy-modules=%u%> oder die Erhöhung der prozessspezifischen Dateideskriptorgrenze"
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr "Importe müssen gebaut werden, bevor sie importiert werden können"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552#c26
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr "Zurück auf Los? (siehe https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104552#c26)"
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "die Deklaration von %qD im Modul %qs widerspricht dem eingebauten im globalen Modul"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "Deklaration %qD widerspricht der eingebauten Deklaration"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "Neudeklaration von %qD in Modul %qs widerspricht dem Import"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "Neudeklaration von %qD in globalem Modul widerspricht dem Import"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "der hier deklarierte Import wird an das Modul %qs angehängt"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr "in globalem Modul deklarierter Import"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "widersprüchliche Deklaration von %qD in Modul %qs"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "widersprüchliche Deklaration von %qD in globalem Modul"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "vorher in Modul %qs deklariert"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "vorher im globalen Modul deklariert"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr "externe Bindungsdefinition von %qD im Header-Modul muss als %<inline%> deklariert sein"
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "die Deklaration %qD, die in einem unbenannten Namensraum deklariert wurde, wird exportiert"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "die Deklaration %qD wird mit interner Bindung exportiert"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "CMI %qs wird gelesen"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "Fehler beim Laden der Bindung %<%E%s%E%>"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr "Fehler beim Laden der Bindung %<%E%s%E@%s%>"
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr "beim Lesen der Bindung %<%E%s%E%>"
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr "beim Lesen der Bindung %<%E%s%E@%s%>"
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "Fehler beim Laden der ausstehenden Einheiten für %<%E%s%E%>"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "beim Laden der ausstehenden Einheiten für %<%E%s%E%>"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "Import von %qs innerhalb seiner eigenen Implementierungseinheit"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, gcc-internal-format
 msgid "module declared here"
 msgstr "das Modul ist hier deklariert"
@@ -64221,107 +64288,107 @@ msgstr "das Modul ist hier deklariert"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr "Import eines benannten Moduls %qs innerhalb eines Sprachbindungsblocks"
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr "das Modul wurde bereits deklariert"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr "das Modul wurde bereits importiert"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "das Modul %qs wurde hier importiert"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr "nicht übereinstimmende kompilierte Modulschnittstelle: hatte %qs, bekam %qs"
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "unbekannte kompilierte Modulschnittstelle: %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr "Fehler beim Bestimmen der %<#include%>-Übersetzung von %s: %s"
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr "%<include %s%> wurde übersetzt zu »import«"
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr "Import von %qs fehlgeschlagen, Rückfall auf Include"
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr "%<include %s%> wurde textuell verarbeitet"
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "C++-Module sind nicht kompatibel mit vorkompilierten Headern"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "C++-Module sind nicht mit der traditionellen Vorverarbeitung kompatibel"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "ungültiger Headername %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "ungültiger Modulname %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr "%<-fmodule-only%> wird für Nicht-Schnittstelle verwendet"
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "CMI %qs wird geschrieben"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr "Modul %qs wird aufgrund von Fehlern in Templaterümpfen nicht geschrieben"
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr "schalten Sie %<-Wtemplate-body%> ein für weitere Details"
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "der erste Fehler in %qD trat hier auf"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "Fehler beim Schreiben des kompilierten Moduls: %s"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "unbekannte Header-Art %qs"
@@ -64336,7 +64403,7 @@ msgstr "die Menge der Überladungen für argumentabhängige Suche von %<%D::%D%>
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "%qD wird ignoriert, es wurde hier mit interner Bindung deklariert"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "namensunabhängige Deklarationen sind erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
@@ -64381,262 +64448,272 @@ msgstr "Deklaration von %q#D überdeckt einen Parameter"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "Deklaration von %qD überdeckt ein Element von %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr "Annotation bezieht sich auf eine block-externe Deklaration von %qD"
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "Annotation bezieht sich auf Parameter %qD einer block-externen Deklaration"
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "Friend-Deklaration %qD in lokaler Klasse ohne vorherige Deklaration"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %<%s(%E)%> %p %d"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "%q#D wird exportiert, hat jedoch keine externe Bindung"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q#D wird hier ohne Bindung deklariert"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%q#D wird hier mit interner Bindung deklariert"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q#D wird hier mit Modulbindung deklariert"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T%s%D%> benennt Destruktor"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "»using«-Deklaration für Nicht-Element im Gültigkeitsbereich der Klasse"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using%> mit Gültigkeitsbereich in enum-Typ %q#T ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT ist weder eine Klasse, noch ein Namensbereich oder eine Aufzählung"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "eine Using-Deklaration, die nicht-Member ist, benennt den Konstruktor von %qT"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "%<using%>-Deklaration für Element außerhalb des Gültigkeitsbereichs der Klasse"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "%qT ist keine direkte Basis von %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr "meinten Sie %<using enum %T::%D%>?"
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD wurde nicht innerhalb von %qD deklariert"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "%<using%>-Deklaration darf den Namensraum %qD nicht benennen"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> benennt Konstruktor in %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "Deklaration von %qD nicht in einem Namensbereich um %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "explizite Qualifizierung in Deklaration von %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD sollte innerhalb von %qD deklariert werden"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD wurde nicht innerhalb von %qD deklariert"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "sondern nur hier als %<friend%>"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "Attribut %qD erfordert ein einzelnes NTBS-Argument"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "Attribut %qD ist bedeutungslos, da die Elemente des anonymen Namensraums lokale Symbole erhalten"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "Attribut %qD an unbenanntem Namensraum wird ignoriert"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "Attribut %qD an nicht-»inline«-Namensraum wird ignoriert"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "Attribut-Anweisung %qD wird ignoriert"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "obere Grenze von %d Namensräumen für %qE durchsucht"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "empfohlene Alternative:"
 msgstr[1] "empfohlene Alternativen:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr "%<std::%s%> ist im Header %qs definiert; um das zu beheben, könnten Sie %<#include %s%> hinzufügen"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79869
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<std::%s%> ist erst ab %s verfügbar"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "das Makro %qs war noch nicht definiert"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr "es wurde später hier definiert"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "Deklaration von %<std::initializer_list%> entspricht nicht %<#include <initializer_list>%>, ist kein Template"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "die Direktive %<strong%>-%<using%> wird nicht mehr unterstützt"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr "Sie können stattdessen einen inline-Namensraum verwenden"
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<omp::%E%> darf in diesem Kontext nicht angegeben werden"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "Annotation an einer »using«-Direktive"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "es können maximal %d Namensräume geschachtelt werden"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%<namespace %E%> ist mehrdeutig"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "Namensbereich-Alias %qD ist hier nicht erlaubt, %qD angenommen"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "Namensraum %qD mit interner Bindung wird exportiert"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD hat interne Bindung, da es in einem anonymen Namensraum deklariert wurde"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr "anonymer Namensraum wird exportiert"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "ein %<inline%>-Namensraum muss bei der ersten Definition angegeben werden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99298
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%s-Namensraum %qD widerspricht der Erreichbarkeits-Definition"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "Erreichbarkeitsdefinition %s ist hier"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX %<pop_everything%> wird betreten"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr "XXX %<pop_everything%> wird verlassen"
@@ -64666,7 +64743,7 @@ msgstr "Bezeichner %qE wird in C++26 zum Schlüsselwort"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr "%<LEXER_DEBUGGING_ENABLED_P%> ist nicht auf true gesetzt"
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> muss direkt von einer Funktionsdeklaration oder -definition gefolgt sein"
@@ -64711,7 +64788,7 @@ msgstr "%<::%E%> wurde nicht deklariert"
 msgid "request for member %qE in non-class type %qT"
 msgstr "Abfrage des Elementes %qE in Nicht-Klassentyp %qT"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> wurde nicht deklariert"
@@ -64781,7 +64858,7 @@ msgstr "(vielleicht fehlt ein Semikolon hinter der Definition von %qT)"
 msgid "%qE is not a class template"
 msgstr "%qE ist kein Klassentemplate"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE ist kein Template"
@@ -65092,1694 +65169,1704 @@ msgstr "%<pack-index%> ist erst mit %<-std=c++2c%> oder %<-std=gnu++2c%> verfüg
 msgid "pack index missing"
 msgstr "%<pack index%> fehlt"
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr "Reflektion ist nur mit %<-freflection%> verfügbar"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "Reflexion eines Typs erwartet"
 
-#: cp/parser.cc:6341
-#, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "Reflexion eines Funktionstemplates erwartet"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr "zusätzliches %<template%> in einem Bereichsspleiß"
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "%<template%> fehlt in einem Bereichsspleiß mit Templateargumenten"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr "%<template%> darf nur weggelassen werden, wenn dem Bereichsspleiß %<typename%> vorangestellt ist"
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "Reflexion einer Klasse, eines Namensraums oder einer Aufzählung erwartet"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "Festkommatypen werden in C++ nicht unterstützt"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO-C++ verbietet Gruppen in geschweiften Klammern innerhalb von Ausdrücken"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "Anweisungs-Ausdrücke sind weder außerhalb von Funktionen noch in Template-Argumenten erlaubt"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "fold-expressions sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "übergeordneter Ausdruck erwartet"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> darf in diesem Kontext nicht verwendet werden"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "eine Template-Deklaration kann nicht im Block-Gültigkeitsbereich auftreten"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "Parameter %qD darf in diesem Kontext nicht auftauchen"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "lokale Variable %qD darf in diesem Kontext nicht auftauchen"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "Reflektion ist nur in C++26 mit %<-freflection%> verfügbar"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr "Schlüsselwort %qs vor dem Namen des abhängigen Templates erwartet"
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "ID-Ausdruck erwartet"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "Bereich %qT vor %<~%> ist kein Klassenname"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "das Schlüsselwort %<template%> ist im Destruktornamen nicht erlaubt"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr "template-id für Destruktor ist in C++20 nicht erlaubt"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr "entfernen Sie %qs"
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "Deklaration von %<~%T%> als Element von %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef-Name %qD als Destruktor-Deklarator verwendet"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "unqualifizierte ID erwartet"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD ist kein Template"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "%<:%> in Spezifikation mit geschachteltem Namen gefunden, %<::%> erwartet"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%<decltype%> wird zu %qT ausgewertet, und das ist weder eine Klasse noch ein Aufzählungstyp"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "Bezeichner %qD für Funktionstemplate ist geschachteltem Namens-Spezifizierer"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "Konzept-ID %qD in geschachteltem Namens-Spezifizierer"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "Bezeichner %qD für Variablentemplate ist geschachteltem Namens-Spezifizierer"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "Spezifikation mit geschachteltem Namen erwartet"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "Typen dürfen nicht in Typumwandlungen definiert werden"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "Typen dürfen nicht in einem %<typeid%>-Ausdruck definiert werden"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "falsche Anzahl von Argumenten für %<__builtin_addressof%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "falsche Anzahl von Argumenten für %<__builtin_launder%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "falsche Anzahl von Argumenten für %<__builtin_assoc_barrier%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "falsche Anzahl der Argumente für %<__builtin_shufflevector%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr "Aufruf von %<__builtin_operator_new%> wählt keine ersetzbare globale Allokationsfunktion"
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "Aufruf von %<__builtin_operator_delete%> wählt keine ersetzbare globale Deallokationsfunktion"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, gcc-internal-format
 msgid "selected function declared here"
 msgstr "die gewählte Funktion ist hier deklariert"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO-C++ verbietet zusammengesetzte Literale"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr "zwei aufeinander folgende %<[%> dürfen nur ein Attribut einführen"
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "Typen dürfen nicht innerhalb von %<__builtin_classify_type%>-Aufrufen definiert werden"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr "in einem OpenMP-Arrayabschnitt können keine mehrdimensionalen Arrayindizes verwendet werden"
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "ungültige Verwendung von %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> ist kein Klassenelement"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "nicht-skalarer Typ"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%<template%> muss auf einen nested-name-specifier folgen"
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "%<^^%> kann nicht auf einen Platzhaltertyp angewendet werden"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<^^%> ist auf diesen Operanden nicht anwendbar"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO-C++ erlaubt kein %<alignof%> mit einem Nicht-Typ"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "Typen dürfen nicht in %<noexcept%>-Ausdrücken definiert werden"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%<co_await%> kann nicht in Standardargumenten verwendet werden"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "Typen dürfen nicht in einem %qs-Ausdruck definiert werden"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "%<__builtin_has_attribute%> mit abhängigem Argument wird noch nicht unterstützt"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "Typen dürfen nicht in einem »new«-Ausdruck definiert werden"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "Arraygrenze hinter geklammerter type-id ist verboten"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "Klammern um die Type-ID sollten entfernt werden"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr "Initialisierung des new-Ausdrucks für Typ %<auto%> erfordert genau ein Element"
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "»expression-list« oder »type-id« erwartet"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "Typen dürfen nicht in einem »new-type-id« definiert werden"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "Attribute werden beim äußersten Array-Typ im %<new%>-Ausdruck ignoriert"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "Ausdruck in new-Deklarator muss Ganzzahl- oder Aufzählungstyp haben"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "Verwendung einer Typumwandlung nach %q#T im alten Stil"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "Operator %<>>%> wird in C++11 wie zwei spitze schließende Klammern behandelt"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "Klammern um %<>>%>-Ausdruck empfohlen"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "in ISO-C++ darf der mittlere Operand von %<?:%> nicht weggelassen werden"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "ungeklammerte Komma-Ausdrücke in Arrayindex-Ausdrücken sind veraltet"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "Typen dürfen nicht innerhalb von %<__builtin_offsetof%> definiert werden"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr "das letzte Argument von %<__type_pack_element%> ist kein Typ"
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Lambda-Ausdruck in nicht evaluiertem Kontext ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Lambda-Ausdruck in Template-Argument ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "nicht-lokaler Lambdaausdruck kann keinen »capture-default« haben"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "unerwartetes Ende der Auffangliste"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "explizites by-copy-Einfangen von %<this%> mit by-copy-Einfangvorgabe ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "%qD bereits in Lambda-Ausdruck erfasst"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<*this%>-Capture ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "%<this%> kann nicht per Referenz eingefangen werden"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<pack init-capture%> ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr "%<&%> sollte vor %<...%> kommen"
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "Initialisierungen für Lambda-Captures sind nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr "nicht-leere Initialisierung »init-capture« eines Lambdas"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "Erfassung von Nicht-Variable %qE"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "Erfassung der Variable %qD ohne automatische Speicherdauer"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr "zu viele %<...%> in Lambda-Capture"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "Explizite Erfassung (als Kopie) von %qD ist mit Standarderfassung (als Kopie) gedoppelt"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "Explizite Erfassung (als Referenz) von %qD ist mit Standarderfassung (als Referenz) gedoppelt"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Lambda-Templates sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "Standardargument für Lambda-Parameter angegeben"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Parameterdeklaration vor Lambdadeklarationsangaben ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> optional"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr "ein Lambda mit Captures darf keinen expliziten Objektparameter eines nicht verwandten Typs haben"
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "%<mutable%>-Lambdaangabe mit explizitem Objektparameter"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr "das hereingereichte Closureobjekt wird nicht verändert, da es als Wert übernommen wird"
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr "deklarieren Sie den expliziten Objektparameter stattdessen als Nicht-const-Referenz"
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr "der explizite Objektparameter ist bereits eine veränderbare Referenz"
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "Lambda-Spezifizierer %<static%> mit explizitem Objektparameter"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr "Lambda-Spezifizierer %<static%> mit Lambda-Fang"
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Parameterdeklaration vor einem Lambda-Transaktions-Qualifizierer ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> optional"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90183
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Parameterdeklaration vor einer Lambda-Exception-Angabe ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> optional"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Parameterdeklaration vor einem abschließenden Rückgabetyp ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> optional"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<constexpr%>-Lambda ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr "%qE wird nicht implizit von einer Vertragszusicherung erfasst"
+
+#: cp/parser.cc:13754
+#, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "%q#E ist hier deklariert"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Sprungmarke am Ende einer zusammengesetzten Anweisung ist erst ab %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "Attribute am Anfang der Anweisung werden ignoriert"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "benannte Anweisung erwartet"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case-Marke %qE nicht innerhalb einer switch-Anweisung"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr "Bezeichner-Sprungmarke %qE im Rumpf von %<template for%>"
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "%<typename%> vor %qE erforderlich, da %qT ein abhängiger Gültigkeitsbereich ist"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "%qE benennt den Konstruktor, nicht den Typ"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "zusammengesetzte Anweisung in %<constexpr%>-Funktion"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr "innere Schleifen müssen mit der %<tile%>-Klausel perfekt geschachtelt sein"
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<if constexpr%> ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<if consteval%> ist erst mit %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr "%<if consteval%> erfordert zusammengesetzte Anweisung"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "»init-statement in Auswahlanweisungen« ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "Auswahl-Anweisung erwartet"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr "Bedingung deklariert ein Array"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, gcc-internal-format
 msgid "condition declares a function"
 msgstr "Bedingung deklariert eine Funktion"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "Typen dürfen nicht in Bedingungen definiert werden"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "Initialisierung erwartet"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Bereichsbasierte %<for%>-Schleifen mit Initialisierer sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr "Schleifenvariable %qD vom Typ %qT bindet an temporäres Objekt, das aus dem Typen %qT konstruiert wurde"
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr "verwenden Sie den Nicht-Referenz-Typ %qT, um das Kopieren explizit zu machen, oder %qT um das Kopieren zu sparen"
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "Schleifenvariable %qD erzeugt eine Kopie vom Typ %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr "verwenden Sie einen Referenztyp, um das Kopieren zu sparen"
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "bereichsbasierter %<for%>-Ausdruck mit Typ %qT hat unvollständigen Typ"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "unvereinbare Anfang-/Ende-Typen in bereichsbasierter %<for%>-Anweisung: %qT und %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "Iterationsanweisung erwartet"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Alias-Deklaration in Init-Anweisung ist erst mit %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Bereichsbasierte %<for%>-Schleifen sind nur mit %<-std=c++11%> oder %<-std=gnu++11%> verfügbar"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<template for%> ist erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr "Designatoren in Initialisierer von %<template for%>"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "eine for-range-declaration kann nicht »constinit« sein"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<goto%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO-C++ verbietet berechnete Gotos"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "Sprunganweisung erwartet"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr "module-partition erwartet"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr "Modulname erwartet"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "%<module-declaration%> ist innerhalb von %<header-unit%> nicht erlaubt"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr "Modul-Deklaration muss im globalen Gültigkeitsbereich sein"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr "der Gültigkeitsbereich beginnt hier"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr "private-module-fragment"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr "%<private-module-fragment%> ist nur im Zuständigkeitsbereich eines Modulinterfaces oder einer Partition zulässig"
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr "Modul-Deklaration ist nur als erste Deklaration erlaubt, oder wenn sie das global-module-fragment beendet"
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr "post-module-declarations müssen zusammenhängend sein"
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr "vielleicht hilft ein Zeilenumbruch nach %<import%> oder eine andere Kenntlichmachung, damit dies nicht mehr als Modul-Steuerzeile angesehen wird"
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "Import-Deklaration muss im globalen Gültigkeitsbereich sein"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr "ein Import, der eine Modulpartition angibt, muss nach einer benannten Moduldeklaration erscheinen"
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr "%<post-module-declaration%>-Importe dürfen nicht %<include-translated%> sein"
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr "%<post-module-declaration%>-Importe dürfen nicht aus Header-Einbindung stammen"
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr "%qE darf erst nach einer Modul-Interface-Deklaration vorkommen"
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "%qE darf nur einmal pro Export-Deklaration vorkommen"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr "%<export%> ist kein Teil der folgenden module-directive"
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "zusätzliches %<;%> außerhalb einer Funktion ist erst ab C++11 erlaubt"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr "zusätzliches %<;%> außerhalb einer Funktion"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr "zusätzliches %<;%> innerhalb einer Struktur ist erst ab C++11 erlaubt"
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr "zusätzliches %<;%> innerhalb einer Struktur"
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "zusätzliches %<;%> hinter Funktionsdefinition innerhalb einer Klasse"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "Attribute dürfen an dieser Stelle nicht verwendet werden"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "Attribute dürfen hier eingesetzt werden"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "explizite Spezialisierungen sind hier nicht erlaubt"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr "eine Spezialisierung wird immer zusammen mit ihrem primären Template exportiert"
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "explizite Instanziierungen sind hier nicht erlaubt"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "Export-Deklarationen sind hier nicht erlaubt"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> nicht am Anfang eines Blocks"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr "Nicht-Variable %qD in Deklaration mit mehr als einem Deklarator mit Platzhaltertyp"
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "widersprüchliche Herleitung für %qT: %qT und dann %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "Vermischung von Deklarationen und Funktionsdefinitionen ist verboten"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "in einer for-Bereichs-Deklaration dürfen keine Typen definiert werden"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "Initialisierung in bereichsbasierter %<for%>-Schleife"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "mehrere Deklarationen in bereichsbasierter %<for%>-Schleife"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr "Packung einer strukturierten Bindung außerhalb eines Templates"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "mehrere Packungen in Deklaration für strukturierte Bindung"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "Packungen für strukturierte Bindungen sind erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturierte Bindungen mit attribuierten Bezeichnern sind erst mit %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr "Annotation an strukturierter Bindung"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturierte Bindungen in Bedingungen sind erst mit %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "strukturierte Bindungen sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "leere Deklaration für strukturierte Bindung"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "ungültige Initialisierung für strukturierte Bindungsdeklaration"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "eine for-range-declaration kann nicht %qs sein"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "%<this%> muss der erste Spezifizierer in einer Parameterdeklaration sein"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> außerhalb einer Klasse verwendet"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "das Schlüsselwort %<bool%> ist in einer Konzeptdefinition in C++20 nicht erlaubt"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr "Die Schreibweise der C++20-Konzeptdefinition ist %<concept <Name> = <Ausdruck>%>"
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "%<typedef%>-Angabe ist unverträglich mit %qs"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "Bedeutung von %<auto%> ändert in C++11 die Bedeutung; Bitte entfernen"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "%qD ungültig in Bedingung"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD ungültig in Lambda"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD ist in Lambda erst ab %<-std=c++23%> oder %<-std=gnu++23%> verfügbar"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "type-specifier ist in Lambda ungültig"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr "Standardattribute inmitten von Deklarationssymbolen"
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr "Standardattribute müssen vor den Deklarationsspezifizierern stehen, um für die Deklaration zu gelten, oder ihnen folgen, um für den Typ zu gelten"
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "Klassendefinition darf nicht als »friend« deklariert sein"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "Templates dürfen nicht %<virtual%> sein"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "Typen dürfen nicht in explicit-specifier definiert werden"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<explicit(bool)%> ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "ungültige Bindungsspezifikation"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<static_assert%> ohne Text ist erst ab %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<static_assert%> ohne Meldung, die keine Zeichenkette ist, ist erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "die Typangabe %<decltype(auto)%> ist erst mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "Typen dürfen nicht in %<decltype%>-Ausdrücken definiert werden"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "Typen dürfen nicht in einem »conversion-type-id« definiert werden"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "ungültige Verwendung von %<auto%> in Umwandlungsoperator"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "Verwendung von %<auto%> in Umwandlungsoperator von Elementtemplate kann niemals hergeleitet werden"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "nur Konstruktoren nehmen Elementinitialisierungen"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "Initialisierung für Element %qD kann nicht expandiert werden"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "Speicherinitialisierung für %qD folgt Konstruktordelegation"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "Konstruktordelegation folgt Speicherinitialisierung für %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "veraltete Basisklasseninitialisierung"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "Schlüsselwort %<typename%> in diesem Kontext nicht erlaubt (eine qualifizierte Elementinitialisierung ist implizit ein Typ)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "Leerzeichen zwischen Anführungszeichen und Suffix ist ab C++23 veraltet"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "unerwartetes Schlüsselwort; entfernen Sie Leerzeichen zwischen Anführungszeichen und Suffixbezeichner"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "Suffixbezeichner erwartet"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "hinter Schlüsselwort %<operator%> wird leere Zeichenkette erwartet"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "ungültiges Encoding-Präfix in Literal-Operator"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "Operator erwartet"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "Schlüsselwort %<export%> nicht implementiert, und wird ignoriert"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "das Schlüsselwort %<export%> ist veraltet und wird ignoriert"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "das Schlüsselwort %<export%> wird mit %<-fmodules%> eingeschaltet"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "ungültiger beschränkter Typparameter"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "cv-qualifizierter Typparameter"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "ungültige Verwendung von %<auto%> in Default-Templateargument"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "Templateparameterpack %qD kann kein Standardargument haben"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "Template-Parameterpacks können keine Standardargumente haben"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "Template-ID erwartet"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> kann keine Templateargumentliste einleiten"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> ist eine andere Schreibweise für %<[%>. Leerraum zwischen %<<%> und %<::%> einfügen"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(bei Verwendung von %<-fpermissive%>, %<-std=c++11%> oder %<-std=gnu++11%> wird G++ den Code akzeptieren)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "ungültige template-argument-list"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr "Funktionsname als linker Operand von %<<%> ist in C++20 verboten; klammern Sie den Funktionsnamen mit %<()%> ein"
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "%<(%> hinter template-argument-list erwartet"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "Syntaxfehler in Templateargumentliste"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "Templatename erwartet"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "Nicht-Template %qD als Template verwendet"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "%<%T::template %D%> verwenden, um dies als Template zu kennzeichnen"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "Parameterbündel vor %<...%> erwartet"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "Templateargument erwartet"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "ungültiges Templateargument ohne Typ"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "ein ungeklammerter Spleißausdruck kann nicht als Template-Argument verwendet werden"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "explizite Instanziierung darf kein %<inline%> verwenden"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "explizite Instanziierung darf kein %<constexpr%> verwenden"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "explizite Instanziierung darf kein %<consteval%> verwenden"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "Templatespezialisierung mit C-Bindung angegeben"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "Typspezifizierer erwartet"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "Verwendung von %<auto%> in Lambda-Parameterdeklaration ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104877
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "Verwendung von %<auto%> in Parameterdeklaration ist erst mit %<-std=c++20%> oder %<-fconcepts%> verfügbar"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "Verwendung von %<auto%> in Parameterdeklaration ist nur mit %<-std=c++14%> oder %<-std=gnu++14%> verfügbar"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "Verwendung von %<auto%> in Templateargument"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "Template-ID für Typ erwartet"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "Typ-Name erwartet"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "%qE schränkt keinen Typ ein"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr "das Konzept wurde hier definiert"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "ungültige Verwendung von %<concept-name%> %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "%<auto%> oder %<decltype(auto)%> nach %qE erwartet"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr "unerwarteter Platzhalter in eingeschränktem Ergebnistyp"
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "ausführliche Typ-Spezifikation für einen enum mit Gültigkeitsbereich darf nicht das Schlüsselwort %qD verwenden"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "Deklaration %qD deklariert nichts"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "Attribute an instanziiertem Typen ignoriert"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "Attribute an Templateinstanziierung ignoriert"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "Attribute an Spezifizierer ausführlichen Typs ignoriert, der keine Vorwärtsdeklaration ist"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD ist ein Aufzählungstemplate"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD benennt keinen Aufzählungstyp in %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "unbenanntes »enum« mit Gültigkeitsbereich ist nicht erlaubt"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "Typen dürfen nicht in enum-base definiert werden"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr "die Deklaration einer Aufzählung mit festem zugrundeliegenden Typ und ohne Aufzählungsliste ist nur als eigenständige Deklaration zulässig"
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "%<;%> oder %<{%> erwartet"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "Aufzählungsliste kann nicht zu Template-Instanziierung hinzugefügt werden"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "geschachtelter Namensgeber %qT für enum-Deklaration benennt weder Klasse noch Namensraum"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "Deklaration von %qD in Namensraum %qD, der nicht %qD einschließt"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "Deklaration von %qD in %qD, das nicht %qD einschließt"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "zusätzliche Qualifizierung nicht erlaubt"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO-C++ verbietet leere unbenannte Aufzählung"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "intransparente Enum-Spezifikation ohne Namen"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "intransparente Enum-Spezifikation muss einfachen Bezeichner verwenden"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr "unexpandierte Parameterpackunge in Aufzählungskonstante in Lambda"
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD bezeichnet Namensraum-Namen; meinten Sie %qs?"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD ist kein Namensbereichs-Name"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "Namensraumname erwartet"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90183
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "verschachtelte inline-Namensraumdefinitionen sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr "Standardattribute für Namensräume müssen vor dem Namen des Namensraums stehen"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90183
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "verschachtelte Namensraumdefinitionen sind nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "Name eines geschachtelten Namensraums erwartet"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr "Name eines Namensraums erwartet"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "eine verschachtelte Namensraum-Definition darf keine Attribute haben"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "eine verschachtelte Namensraumdefinition darf nicht inline sein"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "Namensbereich %qD betreten"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<namespace%>-Definition ist hier nicht erlaubt"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "Pack-Expansion in using-Deklaration ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "eine Template-ID darf nicht in »using«-Deklaration auftreten"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "kommagetrennte Liste in using-Deklaration ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "Zugriffsdeklarationen sind zugunsten von %<using%>-Deklarationen veraltet; Vorschlag: das Schlüsselwort %<using%> hinzufügen"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using enum%> ist nur mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "%<using enum%> des abhängigen Typen %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%<using enum%> an Nicht-Aufzählungstyp %q#T"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "%<using enum%> an unvollständigem Typ %qT"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr "%<using enum%> von %qT vor seinem enum-specifier"
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "opaque-enum-declaration ist hier"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "Typen dürfen nicht in Alias-Templatedeklarationen definiert werden"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "Stringliteral oder konstanter Ausdruck in Klammern erwartet"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<asm%> innerhalb einer %<constexpr%>-Funktion ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "doppelter %<asm%>-Qualifizierer %qT"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%<asm%>-Qualifizierer %qT wird ignoriert, da außerhalb des Funktionsrumpfes"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT ist kein %<asm%>-Qualifizierer"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%<asm%>-Qualifizierer außerhalb des Funktionsrumpfes"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "Attribute in %<asm%>-Deklaration werden ignoriert"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "leere Klammern sind mehrdeutig und werden als Funktionsdeklaration angesehen"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "entfernen Sie die Klammern, um stattdessen eine Variable mit ihrem Vorgabewert zu initialisieren"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr "oder ersetzen Sie die Klammern durch geschweifte Klammern, um die Variable als Aggregat zu initialisieren"
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr "oder ersetzen Sie die Klammern durch geschweifte Klammern, um die Variable mit einem einzelnen Wert zu initialisieren"
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "Klammern waren mehrdeutig und wurden als Funktionsdeklaration angesehen"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr "ersetzen Sie die Klammern durch geschweifte Klammern, um eine Variable zu deklarieren"
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "fügen Sie Klammern hinzu, um eine Variable zu deklarieren"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "ein qualifizierter Name kann nicht für eine Variantenfunktion verwendet werden"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr "Direktiven zur Deklaration von Varianten sind an Konstruktoren nicht erlaubt"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr "Direktiven zur Deklaration von Varianten sind an Destruktoren nicht erlaubt"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "Bezeichnername %s kann nicht verarbeitet werden"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "keine Deklaration der Basisfunktion %qs in diesem Gültigkeitsbereich"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "die Basisfunktion ist mehrdeutig"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr "die Variantenfunktion muss im selben Gültigkeitsbereich wie die Basisfunktion %qs sein"
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr "die Variantenfunktion muss im selben Gültigkeitsbereich wie die Basisfunktion %qE sein"
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "»declare variant«-Direktiven sind an virtuellen Funktionen nicht erlaubt"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "»declare variant«-Direktiven sind an Standardfunktionen nicht erlaubt"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "»declare variant«-Direktiven sind an gelöschten Funktionen nicht erlaubt"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "»declare variant«-Direktiven sind an direkten Funktionen nicht erlaubt"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "eine Funktionsdefinition ist hier nicht erlaubt"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "eine %<asm%>-Spezifikation ist bei Funktionsdefinition nicht erlaubt"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "bei einer Funktionsdefinition sind keine Attribute erlaubt"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "Konstruktor, Destruktor oder Typumwandlung erwartet"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "Initialisierung für Funktion bereitgestellt"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "Attribute hinter geklammerter Initialisierung werden ignoriert"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "Nicht-Funktion %qD als implizites Template deklariert"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "Arraygrenze ist keine Ganzzahlkonstante"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "Element des abhängigen Typedef %qT kann nicht definiert werden"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> ist kein Typ"
@@ -66788,275 +66875,275 @@ msgstr "%<%T::%E%> ist kein Typ"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "ungültiger Deklarator"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "ungültige Verwendung des Konstruktors als Template"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "%<%T::%D%> statt %<%T::%D%> verwenden, um den Konstruktor mit qualifiziertem Namen zu benennen"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "qualified-id in Deklaration"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "Deklarator erwartet"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD ist ein Namensbereich"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "Zeiger auf Element der Nicht-Klasse %q#T kann nicht erzeugt werden"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "Ptr-Operator erwartet"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "doppelter CV-Qualifizierer"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "mehrere ref-qualifier"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "%qE benötigt %<-fgnu-tm%>"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "doppelter Virt-Spezifizierer"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "fehlende Templateargumente nach %qE"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "%qT ist in einem Templateargument nicht erlaubt"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "ungültige Verwendung von %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "in Template-Argumenten dürfen keine Typen definiert werden"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "ungültige Verwendung von %<auto%> in Templateargument"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "Typspezifikation erwartet"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr "das Weglassen von %<,%> vor Varargs %<...%> ist ab C++26 veraltet"
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "%<,%> oder %<...%> erwartet"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "Typen dürfen nicht in Parametertypen definiert werden"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "%<this%>-Angabe in Template-Parameterdeklaration"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr "%<this%>-Angabe in einem %<requires-expression%>-Parameter"
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "ein expliziter Objektparameter kann kein Funktionsparameterpaket sein"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "Standardargumente sind nur für Funktionsparameter zugelassen"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "Parameterpack %qD kann kein Standardargument haben"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "Templateparameterpack kann kein Standardargument haben"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "Parameterpack kann kein Standardargument haben"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "ein expliziter Objektparameter darf kein Standardargument haben"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Rumpf eines function-try-block in einem %<constexpr%>-Konstruktor ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Rumpf eines function-try-block in einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr "wahrscheinlich fehlt davor ein Komma oder ein Operator"
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "designierte Initialisierer für C++ sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO-C++ erlaubt keine benannten Initialisierungen (GNU)"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO-C++ erlaubt keine benannten Initialisierungen von C99"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr "entweder sollten alle Initialisierer-Klauseln benannt sein oder gar keine"
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "%<...%> ist in benannten Initialisierungen nicht erlaubt"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr "%<.%s%>-Name wird mehrfach in derselben Initialisierungsliste verwendet"
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "Klassenname erwartet"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "%<;%> hinter Klassendefinition erwartet"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "%<;%> hinter Strukturdefinition erwartet"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "%<;%> hinter Uniondefinition erwartet"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "doppelter %qD-Spezifizierer"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "%<{%> oder %<:%> erwartet"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "globale Qualifizierung von Klassenname ist ungültig"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "qualifizierter Name benennt keine Klasse"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "Schlüsselwort %<template%> nicht innerhalb des Klassenkopfnamens erlaubt"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "ungültiger Klassenname in Deklaration von %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "Deklaration einer partiellen Spezialisierung in einer nicht umklammerten Exportdeklaration"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr "eine explizite Instanziierung kann keine Definition haben; verwenden Sie %<template <>%>, um eine Spezialisierung zu deklarieren"
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "einer expliziten Spezialisierung muss %<template <>%> vorausgehen"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "Funktions-Template %qD als Klassentemplate redeklariert"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "Typnamen-Typ kann nicht aufgelöst werden"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "vorherige Definition von %q#T"
@@ -67064,269 +67151,269 @@ msgstr "vorherige Definition von %q#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr "unexpandiertes Parameterpack in lokaler Klasse in Lambda"
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "Klassenschlüssel erwartet"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ISO-C++ verbietet typename-Schlüssel in Template-Template-Parameter; verwenden Sie %<-std=c++17%> oder %<-std=gnu++17%>"
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "%<class%> oder %<typename%> erwartet"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "in C++03 muss bei Deklaration eines »friend« ein Klassenschlüssel verwendet werden"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "variadische Friends oder Friend-Type-Deklarationen mit mehreren Typen sind erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "»friend«-Deklaration benennt keine Klasse oder Funktion"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr "Speicherklasse an anonymem Aggregat im Klassenbereich ist nicht erlaubt"
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Defaultinitialisierer für Bitfeld-Elemente sind erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "Defaultinitialisierer für unbenanntes Bitfeld-Element"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr "ISO C++ erlaubt Bitfeld-Attribute nur vor dem %<:%>-Token"
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "Bitfeld %qD mit Nicht-Ganzzahl-Typ %qT"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "reiner Spezifizierer bei Funktionsdefinition"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "überflüssiges %<,%> am Ende der Elementdeklaration"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "%<;%> am Ende von Elementdeklaration erwartet"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<delete%>-Grund ist erst mit %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "ungültige reine Spezifikation (nur %<= 0%> ist erlaubt)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "eine geschweift geklammerte Initialisierung ist hier nicht erlaubt"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "Attribute an Basisangaben werden ignoriert"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "%<virtual%> mehr als einmal in Basisspezifikation angegeben"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "mehr als ein Zugriff in Basisspezifikation angegeben"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "Schlüsselwort %<typename%> nicht erlaubt in diesem Kontext (die Basisklasse ist implizit ein Typ)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "Typen dürfen nicht in einer Ausnahmespezifikation definiert werden"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "ISO C++17 erlaubt keine dynamischen Ausnahmespezifikationen"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "dynamische Ausnahmespezifikationen sind in C++11 veraltet"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "ungültige Verwendung von %<auto%> in Ausnahmespezifikation"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<try%> innerhalb einer %<constexpr%>-Funktion ist erst mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "Typen dürfen nicht in Ausnahmedeklarationen definiert werden"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr "%<alignas%> an Exceptiondeklaration"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%<co_yield%> kann nicht in Standardargumenten verwendet werden"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "Attribut-Argument als ausbalancierte Tokenfolge erwartet"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "Attribut, das Präfix verwendet, wird zusammen mit Gültigkeitsbereich-Attribut-Token verwendet"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "Bezeichner für den Attributnamen erwartet"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr "Klammern müssen weggelassen werden, wenn die Argumentliste des %qE-Attributs leer ist"
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "Attribut %qs ist mehrfach angegeben"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr "Annotationen und Attribute sind in derselben Liste vermischt"
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "Attribut vor %<...%> erwartet"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "Attribut ohne Argumente enthält keine Parameterpakete"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "Bedingungausdruck erwartet"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "%qs ist nur mit %qs verfügbar"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, gcc-internal-format
 msgid "attributes are ignored on %qs"
 msgstr "an %qs werden Attribute ignoriert"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "an Funktionsvertragsangaben werden Attribute ignoriert"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr "Verträge sind nur mit %qs verfügbar"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "Annotationen sind erst ab %<-std=c++2c%> oder %<-std=gnu++2c%> verfügbar"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90184
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribute-using-prefix ist nur mit %<-std=c++17%> oder %<-std=gnu++17%> verfügbar"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "Ausdruck muss in runden Klammern eingeschlossen sein"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr "Fehlendes zusätzliches %<requires%>, um eine requires-expression zu beginnen"
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr "Prüfung, ob eine Konzept-ID ein gültiger Ausdruck ist; fügen Sie %<requires%> hinzu, um die Erfüllung zu prüfen"
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "Rückgabetyp ist keine einfache Typ-Einschränkung"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "%<return-type-requirement%> ist keine Typ-Einschränkung"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "spezialisierendes Element %<%T::%E%> erfordert Syntax %<template<>%>"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "ungültige Deklaration von %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "zu wenige Templateparameterlisten"
@@ -67335,433 +67422,433 @@ msgstr "zu wenige Templateparameterlisten"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "zu viele Templateparameterlisten"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr "template-id ist für Konstruktor in C++20 nicht erlaubt"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "benannte Rückgabewerte werden nicht mehr unterstützt"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90185
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr "ISO C++ unterstützt keine Operatortemplates in Zeichenkettenliteralen, die eine Argumentpackung von Zeichen bekommen"
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "literales Operatortemplate %qD hat ungültige Parameterliste; nicht-Typ-Templateargumentpack %<<char...>%> oder einzelner Nicht-Typ-Parameter von Klassentyp erwartet"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "literales Operatortemplate %qD hat ungültige Parameterliste; Template für Nicht-Typ Argumentpack %<<char...>%> erwartet"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "ungültige Deklaration eines Elementtemplates in lokaler Klasse"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "Template mit C-Bindung"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "ungültige explizite Spezialisierung"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "Templatedeklaration von %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "eine Klassen-Templatedeklaration darf nichts anderes deklarieren"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "explizite Template-Spezialisierung kann keine Speicherklasse haben"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%> sollte innerhalb einer geschachtelten Templateargumentliste %<> >%> sein"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "falsches %<>>%>; %<>%> verwenden, um eine Templateargumentliste zu beenden"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%qs sollte %qs sein, um eine Templateargumentliste zu beenden"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "Argument von %<sizeof...%> muss mit Klammern umschlossen werden"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "ungültige Verwendung von %qD in Spezifizierung der Bindung"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "%qD-Spezifizierer ist unverträglich mit %qs"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> vor %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%qD-Spezifizierer ist unverträglich mit %<typedef%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO-C++ 1998 unterstützt nicht %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "sowohl %<__thread%> als auch %<thread_local%> angegeben"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "doppeltes %qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "doppeltes %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "%<new%> erwartet"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "%<delete%> erwartet"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "%<return%> erwartet"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "%<extern%> erwartet"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "%<static_assert%> erwartet"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "%<decltype%> erwartet"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "%<operator%> erwartet"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "%<class%> erwartet"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "%<template%> erwartet"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "%<namespace%> erwartet"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "%<using%> erwartet"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "%<asm%> erwartet"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "%<try%> erwartet"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "%<catch%> erwartet"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "%<throw%> erwartet"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "%<auto%> erwartet"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "%<__label__%> erwartet"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "%<@try%> erwartet"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "%<@synchronized%> erwartet"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "%<@throw%> erwartet"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "%<__transaction_atomic%> erwartet"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "%<__transaction_relaxed%> erwartet"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "%<co_yield%> erwartet"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "%<::%> erwartet"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "%<...%> erwartet"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "%<*%> erwartet"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "%<~%> erwartet"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "%<:%> oder %<::%> erwartet"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "%<class%>, %<typename%> oder %<template%> erwartet"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "%<:]%> erwartet"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr "redundanter Aufzählungsschlüssel %<enum%s%> in Bezug auf %q#T"
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "Markierung %qs bei Benennung von %q#T verwendet"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T wurde vorher hier deklariert"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "redundanter Klassenschlüssel %qs in Verweis auf %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT mit nicht zusammenpassendem Klassenschlüssel %qs deklariert"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr "entfernen Sie den Klassenschlüssel oder ersetzen Sie ihn durch %qs"
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "Klassenschlüssel durch %qs ersetzen"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "%qT wurde hier als %qs definiert"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qT wurde erstmals hier als %qs deklariert"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD mit anderem Zugriff redeklariert"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "in C++98 ist %<template%> (zum eindeutig machen) nur innerhalb von Templates erlaubt"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "Datei endet in Standardargument"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "unpassendes Objective-C++-Konstrukt %<@%D%>"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "Objective-C++-Nachrichtenempfänger erwartet"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "Objective-C++ Nachrichtenargument(e) erwartet"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> muss als Argument einen Typen angeben"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "Ungültiger Objective-C++-Selektorname"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "Objective-C++ Methodendeklaration erwartet"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "Methodenattribute müssen am Ende angegeben werden"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "überflüssiges %qs zwischen Objective-C++ Methoden"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "ungültiger Typ für Instanzvariable"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "Bezeichner nach %<@protocol%> erwartet"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "Attribute dürfen nicht vor dem Objective-C++-Schlüsselwort %<@%D%> angegeben werden"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "Präfix-Attribute vor %<@%D%> werden ignoriert"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "ungültiger Typ für Eigenschaft"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "unbekanntes Eigenschaftsattribut %qE"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "Liste von Ganzzahlausdrücken erwartet"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "%<wait%>-Ausdruck muss ganzzahlig sein"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "%<scalar%>, %<aggregate%> oder %<all%> erwartet"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "ungültiger reduction-identifier"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr "die veraltete %<%E(%E)%>-Merkmalssyntax ist in %<uses_allocators%>-Klausel bei Verwendung von Modifikatoren nicht zulässig"
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "Typen dürfen nicht in Iteratortyp definiert werden"
@@ -67770,173 +67857,173 @@ msgstr "Typen dürfen nicht in Iteratortyp definiert werden"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "%<#pragma omp allocate%> wird nicht mehr unterstützt"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "geklammerte Initialisierung ist in OpenMP-%<for%>-Schleife nicht erlaubt"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "%<ordered%>-Klausel mit Parameter in %<for%>-Schleife über einen Bereich"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "Schleifenvariable %qD sollte keine Reduktion sein"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp declare %s%> gefolgt von %<#pragma omp declare %s%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma omp dispatch%> muss von einem direkten Funktionsaufruf mit optionaler Zuweisung gefolgt werden"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD ist kein C-Zeiger"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr "eine %qs-Klausel kann nur angegeben werden, wenn der %<dispatch%>-Selektor der Konstruktionsselektormenge in der %<match%>-Klausel vorkommt"
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr "eine andere OpenMP-Direktive als %<declare simd%> oder %<declare variant%> gehört zu einer Deklaration"
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "%<target%> erwartet"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "ungültige Initialisierungsklausel"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "»id-expression (arguments)« erwartet"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr "eins der Aufrufargumente für die Initialisierung sollte %<omp_priv%> oder %<&omp_priv%> sein"
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "neue Typen dürfen nicht in einem Rückgabetyp definiert werden"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr "vordeklarierter arithmetischer Typ %qT in %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr "Funktions- oder Arraytyp %qT in %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr "Referenztyp %qT in %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "%<const%>-, %<volatile%>- oder %<__restrict%>-qualifizierter Typ %qT in %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "Typen dürfen nicht innerhalb von %<declare mapper%> definiert werden"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "%<simd%>, %<reduction%>, %<target%>, %<mapper%> oder %<variant%> erwartet"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr "%<#pragma acc routine%> benennt eine Menge von Überladungen"
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD bezeichnet keine Funktion innerhalb eines Namensraum"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "OpenMP-Direktiven dürfen nicht in %<constexpr%>-Funktionen vorkommen"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr "%<atomic_cancel%>"
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "äußeres %<__transaction_cancel%> nicht innerhalb des äußeren %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  oder einer %<transaction_may_cancel_outer%>-Funktion"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "falsch geformtes %<#pragma GCC pch_preprocess%>"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp requires%> darf nur im Gültigkeitsbereich einer Datei oder eines Namensraums verwendet werden"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp assumes%> darf nur im Gültigkeitsbereich einer Datei oder eines Namensraums verwendet werden"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "%<#pragma GCC %s%> muss innerhalb einer Funktion sein"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "Compilieren von mehreren Quellen ist für C++ nicht implementiert"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "Platzhaltertyp ist in diesem Kontext nicht erlaubt"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "Implizite Templates dürfen nicht %<virtual%> sein"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr "%<extern \"C\"%>-Bindung beginnt hier"
@@ -68410,495 +68497,500 @@ msgstr "verwenden Sie %<template<>%> für eine explizite Spezialisierung"
 msgid "redeclaration of %qD with different constraints"
 msgstr "Redeklaration von %qD mit unterschiedlichen Einschränkungen"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "lokale Klasse in Lambda-Ausdruck in Template-Parameter-Liste"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT ist kein Template-Typ"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "keine Templatespezifizierer in Deklaration von %qD angegeben"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "mit %d Template-Parameter redeklariert"
 msgstr[1] "mit %d Template-Parametern redeklariert"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "vorherige Deklaration %qD verwendete %d Template-Parameter"
 msgstr[1] "vorherige Deklaration %qD verwendete %d Template-Parameter"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "Template-Parameter %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "hier als %q#D redeklariert"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr "hier erneut deklariert"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "Deklaration von Templateparameter %q+#D mit unterschiedlichen Einschränkungen"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "ursprüngliche Deklaration trat hier auf"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "Redeklaration von %q#D mit unterschiedlichen Einschränkungen"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "es muss die Adresse einer Funktion mit externer Bindung sein"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "es muss der Name einer Funktion mit externer Bindung sein"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, weil %qD keine Bindung hat"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, weil %qD keine externe Bindung hat"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "es muss ein Zeiger auf ein Element der Form %<&X::Y%> sein"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "da es ein Element von %qT ist"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  Template-Parameter %qD konnte nicht hergeleitet werden"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr " Typen %qT und %qT haben unverträgliche CV-Qualifizierer"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr " unpassende Typen %qT und %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr " Templateparameter %qD ist kein Parameterpack wie Argument %qD"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr " Templateargumente %qE passt nicht zum konstanten Zeiger auf Element %qE"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr " %qE entspricht nicht %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr " unpassende Herleitung von Parameterpack mit %qT und %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr " hergeleitete Typen für Parameter %qT stehen in Konflikt (%qT und %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr " hergeleitete Werte für Nicht-Typ-Parameter %qE stehen in Konflikt (%qE und %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr " Arraytyp %qT mit veränderlicher Größe ist kein gültiges Templateargument"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr " Typ %qT von Elementfunktion ist kein gültiges Templateargument"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  Kandidat erwartet mindestens %d Argument, %d angegeben"
 msgstr[1] "  Kandidat erwartet mindestens %d Argumente, %d angegeben"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  Kandidat erwartet %d Argument, %d angegeben"
 msgstr[1] "  Kandidat erwartet %d Argumente, %d angegeben"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr " %qE (Typ %qT) kann nicht in den Typ %qT umgewandelt werden"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr " %qT ist mehrdeutige Basisklasse von %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr " %qT ist nicht vom Typ %qT abgeleitet"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr " Templateparameter eines Template-Templatearguments sind mit anderen hergeleiteten Templateargumenten unverträglich"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  für %qT kann kein Template aus Nicht-Templatetyp %qT hergeleitet werden"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr " Template-Argument %qE passt nicht zu %qE"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE ist kein gültiges Templateargument vom Typ %qT, weil %qE weder eine Variable noch eine Funktion ist"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE ist in C++98 kein gültiges Templateargument des Typs %qT, weil %qD keine externe Bindung hat"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, weil %qD keine Bindung hat"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "die Adresse von %qD ist kein gültiges Templateargument"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "die Adresse des %qT-Teilobjekts von %qD ist kein gültiges Templateargument"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "die Adresse von %qD ist kein gültiges Templateargument, weil sie keine statische Lebensdauer hat"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD ist kein gültiges Templateargument, weil %qD eine Variable und nicht die Adresse einer Variable ist"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE ist kein gültiges Templateargument für %qT, da es keine Adresse einer Variable ist"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, da Zeichenkettensymbole in diesem Zusammenhang nicht verwendet werden können"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "in Templateargument für Typ %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "Templateargument %qE für Typ %qT ist keine Übersetzungszeit-Konstante"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, da es in CV-Qualifikation in Konflikt steht"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, weil es kein L-Wert ist"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D ist kein gültiges Templateargument für Typ %qT, weil eine Referenzvariable keine konstante Adresse hat"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, weil es ein Zeiger ist"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "stattdessen %qE verwenden"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE ist kein gültiges Templateargument für Typ %qT, weil es vom Typ %qT ist"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "Attribute an Templateargument %qT werden ignoriert"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "Attribute an Templateargument %qE werden ignoriert"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "eingegebener Klassenname %qD als Template-Templateargument verwendet"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "ungültige Verwendung des Destruktors %qE als Typ"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "um auf ein Typelement eines Templateparameters zu verweisen, %<typename %E%> verwenden"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "Typ/Wert des Arguments %d passt nicht in Template-Parameterliste für %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  Konstante des Typs %qT erwartet, %qT erhalten"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "  mehrdeutiges Templateargument für Nichttyp-Templateparameter wird wie ein Funktionstyp behandelt"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  Klassentemplate erwartet, %qE erhalten"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  einen Typ erwartet, %qE erhalten"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  einen Typ erwartet, %qT erhalten"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  Klassentemplate erwartet, %qT erhalten"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  ein Template des Typs %qD erwartet, %qT erhalten"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "unpassende Beschränkungen für Argument %d in Template-Parameterliste für %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  %qD erwartet, %qD erhalten"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "Templateargument %qE konnte nicht von %qT in %qT umgewandelt werden"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "Templateargument %d ist ungültig"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "falsche Anzahl der Templateargumente (%d, sollte %d sein)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "falsche Anzahl der Templateargumente (%d, sollte mindestens %d sein)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr "für %qD bereitgestellt"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "gepacktes Expansionsargument für Parameter %qD ohne »pack« von Alias-Template %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "gepacktes Expansionsargument für Parameter %qD ohne »pack« von Konzept %qD"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr "jegliche Instanziierung mit nichtleerer Parameterpackung wäre unzulässig"
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D ist kein Funktionstemplate"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "Nicht-Template-Typ %qT als Template verwendet"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "Für Template-Deklaration %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "Template-Einschränkung für %qD fehlgeschlagen"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "Verwendung des ungültigen Variablentemplates %qE"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "Instanziierungstiefe für Templates überschreitet Höchstwert %d (%<-ftemplate-depth=%> verwenden, um dies zu erhöhen)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "das Score-Argument muss ein konstanter ganzzahliger Ausdruck sein"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "das Score-Argument darf nicht negativ sein"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "Eigenschaft muss ein konstanter ganzzahliger Ausdruck oder ein Zeichenkettenliteral sein"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "Eigenschaft muss ein konstanter ganzzahliger Ausdruck sein"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "Instanziierung eines fehlerhaften Templates"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr "der erste Fehler trat hier auf"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "flexibles Arrayelement %qD in Union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr "Falten einer leeren Expansion über %O"
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE ist nicht das vollständige Muster einer Packexpansion"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "Argumentpacklängen passen nicht bei Expansion von %qT"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "Argumentpacklängen passen nicht bei Expansion von %qE"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr "ein leeres Pack kann nicht indexiert werden"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "  bei Instanziierung des Standardarguments für Aufruf von %qD"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "Erzeugung eines Zeigers auf Elementfunktion des Nicht-Klassentyps %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr "Argumentpacklängen %d und %d sind unverträglich"
@@ -68916,122 +69008,122 @@ msgstr "Argumentpacklängen %d und %d sind unverträglich"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "Variable %qD hat Funktionstyp"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "ungültiger Parametertyp %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "in Deklaration %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "Funktion gibt ein Array zurück"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "Funktion gibt eine Funktion"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "%qE ist nicht als ein Spleißtyp verwendbar"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE ist nicht in einem Spleißtyp verwendbar"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "Referenz auf »void« wird gebildet"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "Zeiger auf Referenztyp %qT wird geformt"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "Referenz auf Referenztyp %qT wird geformt"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "Zeiger auf qualifizierten Funktionstypen %qT wird geformt"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "Referenz auf qualifizierten Funktionstypen %qT wird geformt"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "Zeiger auf Element des Nicht-Klassentypen %qT wird erzeugt"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "Zeiger auf Elementreferenztyp %qT wird erzeugt"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "Zeiger auf Element mit Typ »void« wird erzeugt"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "Array von %qT wird erzeugt"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr "%qD expandierte zu mehr als einem Element"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr "%qD wird für ein leeres Pack instanziiert"
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT ist kein Klassen-, Struktur- oder Union-Typ"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT wird in %qT aufgelöst, aber das ist kein Aufzählungstyp"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT wird in %qT aufgelöst, aber das ist kein Nicht-Union-Klassentyp"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT wird in %qT aufgelöst, aber das ist kein Union-Klassentyp"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "Reflexion eines Typtemplates erwartet"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "Verwendung von %qs in Template"
@@ -69039,206 +69131,206 @@ msgstr "Verwendung von %qs in Template"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "die Deklaration von %<%T::%D%> hängt von sich selbst ab"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "qualifizierender Typ %qT passt nicht zum Destruktornamen ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "Abhängigenname %qE wird als Nicht-Typ erkannt, aber die Instanziierung liefert einen Typ"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "%<typename %E%> sagen, wenn ein Typ gemeint ist"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "Initialisierer für %q#D expandiert zu einer leeren Ausdrucksliste"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "falsche Verwendung eines Packauflösungs-Ausdruckes"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "%<...%> verwenden, um Argumentpack aufzulösen"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "leere Initialisierung in »init-capture« für Lambda"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD wurde in diesem Gültigkeitsbereich nicht deklariert, und bei argumentabhängiger Suche am Ort der Instanziierung wurden keine Deklarationen gefunden"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "Deklarationen in abhängiger Basis %qT wurden bei unqualifizierter Suche nicht gefunden"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "stattdessen %<this->%D%> verwenden"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "stattdessen %<%T::%D%> verwenden"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qD hier deklariert, später in der Übersetzungseinheit"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "falsche Anzahl von Argumenten für %<__builtin_convertvector%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "Falsche Anzahl an Argumenten für das Attribut %<assume%> angegeben"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT ist keine Klasse oder Namensbereich"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD ist keine Klasse oder Namensbereich"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "ungültiges Feld %qD wird verwendet"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT ist/verwendet anonymen Typen"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "Templateargument für %qD verwendet lokalen Typ %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT ist ein variabel modifizierter Typ"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "Ganzzahlausdruck %qE ist nicht konstant"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  Versuch, %qD zu instanziieren"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "mehrdeutige Template-Instanziierung für %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "mehrdeutige Template-Instanziierung für %q#D"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr "%s %#qS"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "explizite Instanziierung des Nicht-Templates %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD ist kein statisches Datenelement eines Klassentemplates"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "kein passendes Template für %qD gefunden"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "Typ %qT für explizite Instanziierung %qD passt nicht zum deklarierten Typ %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "explizite Instanziierung von %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "doppelte explizite Instanziierung von %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO-C++ 1998 verbietet die Verwendung von %<extern%> bei expliziten Instanziierungen"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "Speicherklasse %qD auf Templateinstanziierung angewendet"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "explizite Instanziierung des Nicht-Klassen-Templates %qD"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "explizite Instanziierung des Nicht-Templatetyps %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "explizite Instanziierung von %q#T vor Definition des Templates"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO-C++ verbietet die Verwendung von %qE bei expliziten Instanziierungen"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "doppelte explizite Instanziierung von %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "Ausnahmen-Angabe von %qD hängt von sich selbst ab"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "Exception-Angabe von %qD erst am Ende der Klassendefinition verfügbar"
@@ -69250,512 +69342,567 @@ msgstr "Exception-Angabe von %qD erst am Ende der Klassendefinition verfügbar"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "explizite Instanziierung von %qD, aber keine Definition verfügbar"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "Instanziierungstiefe für Templates überschreitet Höchstwert %d beim Instanziieren von %q+D, möglicherweise wegen Generierung der virtuellen Tabelle (%<-ftemplate-depth=%> verwenden, um den Höchstwert zu erhöhen)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Nichttypen-Templateparameter von hergeleitetem Klassentyp sind erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%qT ist kein gültiger Typ für einen Nichttyp-Templateparameter, da er nicht strukturell ist"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Nichttypen-Templateparameter von Klassentyp sind nur mit %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "ungültiger Nicht-Typ-Parameter für Template"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T ist kein gültiger Typ für einen Nicht-Typ-Parameter eines Templates"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "Schlüsselwort %<template%> nicht innerhalb der declarator-id erlaubt"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "ein Konzept kann nicht eingeschränkt werden"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "das Konzept %qE ist nicht im Gültigkeitsbereich des Namensraums"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "das Konzept %qE hat mehrere Vorlagenparameterlisten"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "Ermittlung aus geschweift geklammerter Initialisierungsliste erfordert %<#include <initializer_list>%>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "nicht herleitbares Templates %qT wird ohne Template-Argumente verwendet"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Alias-Template-Herleitung ist erst ab %<-std=c++20%> oder %<-std=gnu++20%> verfügbar"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "verwenden Sie stattdessen %qD"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr "Templateargumente für die Kopierinitialisierung von %qT können nicht abgeleitet werden, da es keine expliziten Ableitungshinweise oder benutzerdeklarierten Konstruktoren gibt"
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "Templateargumente für %qT können nicht abgeleitet werden, da es keine Ableitungshinweise gibt"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "Argumentherleitung für Klassentemplate gescheitert:"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "Explizite Herleitungshinweise werden nicht für »copy-initialization« berücksichtigt"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "Argumentherleitung für Klassentemplate von %qT fehlgeschlagen: expliziter Herleitungshinweis in copy-list-initialization ausgewählt"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "der explizite Herleitungshinweis ist hier deklariert"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "%qT beabsichtigt möglicherweise nicht, Argumentherleitung für Klassentemplates zu unterstützen"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr "fügen Sie einen Herleitungshinweis hinzu, um diese Warnung zu unterdrücken"
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr "direct-list-initialization von %<auto%> erfordert genau ein Element"
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr "um %<std::initializer_list%> herzuleiten, verwenden Sie einen copy-list-initialization (also mit %<=%> vor dem %<{%>)"
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "Lambda-Rückgabewert von %qE kann nicht hergeleitet werden"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "%qT kann nicht aus %qE hergeleitet werden"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "Platzhalter-Beschränkungen nicht erfüllt"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "hergeleiteter Initialisierer erfüllt die Platzhalter-Beschränkungen nicht"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "hergeleiteter Rückgabetyp erfüllt die Platzhalter-Beschränkungen nicht"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "hergeleiteter Ausdruckstyp erfüllt die Platzhalterbeschränkungen nicht"
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "%<^^%> kann nicht auf einen Platzhaltertyp angewendet werden"
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "%<^^%> kann nicht auf einen Packungsindex angewendet werden"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%<^^%> kann nicht auf einen Nichttyp-Template-Parameter %qD angewendet werden"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "%<^^%> kann nicht auf eine Capture %qD angewendet werden"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr "%<^^%> kann nicht auf einen lokalen Parameter eines requires-Ausdrucks %qD angewendet werden"
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr "%<^^%> kann nicht auf eine lokale Entität angewendet werden, für die ein dazwischenliegender Lambda-Ausdruck vorhanden ist"
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "%<^^%> kann nicht auf eine using-Deklaration angewendet werden"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "%<^^%> kann nicht auf eine Konzeptprüfung angewendet werden"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr "die Reflexion einer Überlagerungsmenge ist nicht übernehmbar"
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "fehlerhafter Typ %qT an Argument %d, stattdessen %qT erwartet"
+
+#: cp/reflect.cc:476
 #, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<std::ranges%> ist kein Namensraum"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr "%<reflect_constant_string%> wurde mit %qT statt mit %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> oder %<char32_t%> aufgerufen"
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "%<reflect_constant_array%>-Argument mit %qT, aber das ist kein Strukturtyp"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr "%<reflect_constant_array%>-Argument mit %qT, aber das ist nicht kopiererzeugbar"
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr "%<reflect_constant_array%>-Argument mit %qT, aber das ist nicht kompatibel mit %qT %<std::ranges::range_reference_t%>"
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr "%<reflect_constant_array%>-Argument mit %qT, aber das ist nicht von %qT %<std::ranges::range_reference_t%> erzeugbar"
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr "%<std::ranges::data%> oder %<std::ranges::size%> sind keine Anpassungspunkt-Objekte"
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr "fehlendes %<std::ranges::begin%> oder %<std::ranges::end%>"
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr "falscher Typ %qT von %<std::ranges::begin(arg)%>"
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr "falscher Typ %qT von %<std::ranges::end(arg)%>"
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr "%qD sollte %qs werfen; %<what()%>: %qs"
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr "Exceptions sind deaktiviert, sie werden als nicht-konstant behandelt"
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr "Fehler beim Werfen von %qs"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr "unerwartetes %<std::meta::operators%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr "konnte %<%D::%D%> nicht nachschlagen"
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, gcc-internal-format
 msgid "couldn%'t look up %qs"
 msgstr "konnte %qs nicht nachschlagen"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr "unerwarteter Rückgabetyp von %qs"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr "%qT muss ein cv-unqualifizierter Strukturtyp sein, der kein Referenztyp ist"
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr "%qT muss ein Objekttyp sein"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "%qT muss ein Funktionstyp sein"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr "konnte %<std::%s<%T>%> nicht instanziieren"
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "Unerwartetes %<data_member_options%>-Argument"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "das erste %<define_aggregate%>-Argument ist keine Reflektion eines Klassentyps"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr "das erste %<define_aggregate%>-Argument ist eine Reflektion eines Typalias"
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr "das erste %<define_aggregate%>-Argument ist eine Reflektion eines cv-qualifizierten Klassentyps"
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr "das erste %<define_aggregate%>-Argument ist eine Reflektion eines vollständigen Klassentyps"
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr "das erste %<define_aggregate%>-Argument ist eine Reflektion eines Klassentyps %qT, der gerade definiert wird"
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr "%<define_aggregate%>-Argument ist keine Datenelementbeschreibung"
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr "die Datenelementbeschreibung des %<define_aggregate%>-Arguments hat keinen vollständigen Typ"
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr "der Name %qD wird in mehreren Datenelementbeschreibungen verwendet"
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "in einem %<warn_if_not_aligned%>-Typ kann kein Bitfeld deklariert werden"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr "%<define_aggregate%> wird nicht aus dem %<consteval%>-Block ausgewertet"
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr "%<define_aggregate%> wird aus dem %<consteval%>-Block heraus ausgewertet, der %qT definiert, und dieser Typ wird gerade definiert"
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "der %<consteval%>-Block ist hier definiert"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr "%qD interveniert zwischen dem Gültigkeitsbereich von %qT und dem %<consteval%>-Block, aus dem heraus %<define_aggregate%> ausgewertet wird"
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr "%qT interveniert zwischen dem Gültigkeitsbereich von %qT und dem %<consteval%>-Block, aus dem heraus %<define_aggregate%> ausgewertet wird"
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr "%qD interveniert zwischen dem %<consteval%>-Block, aus dem heraus %<define_aggregate%> ausgewertet wird, und dem Gültigkeitsbereich von %qT"
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr "%qT interveniert zwischen dem %<consteval%>-Block, aus dem heraus %<define_aggregate%> ausgewertet wird, und dem Gültigkeitsbereich von %qT"
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr "das %<define_aggregate%>, das aus dem %<consteval%>-Block heraus ausgewertet wird und von %qD umschlossen ist, während Typ %qT gerade definiert wird, ist von %qD umschlossen"
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr "das %<define_aggregate%>, das aus dem %<consteval%>-Block heraus ausgewertet wird und von %qD umschlossen ist, während Typ %qT gerade definiert wird, ist von %qT umschlossen"
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr "das %<define_aggregate%>, das aus dem %<consteval%>-Block heraus ausgewertet wird und von %qT umschlossen ist, während Typ %qT gerade definiert wird, ist von %qD umschlossen"
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr "das %<define_aggregate%>, das aus dem %<consteval%>-Block heraus ausgewertet wird und von %qT umschlossen ist, während Typ %qT gerade definiert wird, ist von %qT umschlossen"
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
-msgstr "%<access_context::current%> wird außerhalb der manifesten Konstantenauswertung verwendet"
+msgid "%qs used outside of manifestly constant-evaluation"
+msgstr "%qs wird außerhalb der manifesten Konstantenauswertung verwendet"
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "ungültiges %<access_context%>-Argument"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr "unerwartetes %<access_context::scope()%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr "unerwartetes %<access_context::designating_class()%>"
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "unerwartetes Argument für %qs"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "fehlerhafter Typ %qT an Argument %d, stattdessen %qs erwartet"
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "fehlerhafter Rückgabetyp %qT, stattdessen %qs erwartet"
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "fehlerhafter Rückgabetyp %qT, stattdessen %qT erwartet"
+
+#: cp/reflect.cc:7826
 #, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "unbekannte Metafunktion %qD"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "das %<splice%>-Argument muss ein Ausdruck vom Typ %qs sein"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "eine Nullreflexion kann nicht gespleißt werden"
+
+#: cp/reflect.cc:8540
+#, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "eine Reflektion des Funktionsparameters %qD kann nicht in einem Spleißausdruck verwendet werden"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr "wenden Sie %<std::meta::variable_of%> darauf an, vor dem Spleißen"
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr "die consteval-only-Variable %qD ist nicht als %<constexpr%> deklariert und wird außerhalb eines konstant ausgewerteten Kontexts verwendet"
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "fügen Sie %<constexpr%> hinzu"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "»consteval-only«-Ausdrücke sind nur in einem konstant ausgewerteten Kontext zulässig"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "Funktion mit Nur-consteval-Typ muss als %qs deklariert werden"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr "Reflektion eines Ausdrucks erwartet"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "fügen Sie %<typename%> hinzu, um einen Typ außerhalb eines Nur-Typ-Kontexts zu bezeichnen"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "in einem Spleißausdruck kann der Konstruktor oder Destruktor %qD nicht verwendet werden"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "in einem Spleißausdruck kann das Bitfeld %qD nicht verwendet werden"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "das Klassenelement %qD kann nicht implizit aus einem Spleißausdruck heraus referenziert werden"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "ungültiger Zugriff auf Klassenmember vom Typ Template %qE"
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr "%qE kann nicht verwendet werden, um auf ein Klassenmember zuzugreifen"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr "unäres %<&%>, angewendet auf ein anonymes Unionsmitglied %qD, das kein direktes Mitglied einer benannten Klasse ist"
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "in einem Spleißausdruck wird eine lokale Variable mit automatischer Speicherdauer aus der umschließenden Funktion verwendet"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "die Annotation %qE kann nicht in einem Spleißausdruck verwendet werden"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr "eine Datenelementangabe kann nicht in einem Spleißausdruck verwendet werden"
 
+#: cp/reflect.cc:9114
+#, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "Reflexion eines Funktionstemplates erwartet"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr "Reflektion eines Templates für eine Funktion oder eine Variable erwartet"
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -70086,584 +70233,584 @@ msgstr "ungültige Definition des qualifizierten Typen %qT"
 msgid "invalid base-class specification"
 msgstr "ungültige Spezifizierung der Basisklasse"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "Element %qD von unbenannter Union kann nicht eingefangen werden"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD ist nicht eingefangen"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "das Lambda hat keinen »capture-default«"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr "Lambda in lokaler Klasse %q+T kann Variablen aus dem umschließenden Kontext nicht einfangen"
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "Verwendung lokaler Variable mit automatischer Speicherklasse aus enthaltender Funktion"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "Verwendung eines Parameters aus enthaltender Funktion"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "Verwendung eines Parameters außerhalb des Funktionskörpers"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr "fehlende Templateargumente"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "Templateparameter %qD vom Typ %qT ist in ganzzahligem Konstantenausdruck nicht erlaubt, da er nicht Ganzzahl- oder Aufzählungstyp hat"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "Verwendung des Klassentemplates %qT als Ausdruck"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "Abfrage des Elementes %qD ist im Gitter der Mehrfachvererbung mehrdeutig"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD kann nicht in Konstanten-Ausdruck auftreten"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr "%qD »this« erforderlich beim Zugriff auf ein Element innerhalb einer Konstruktor-Vorbedingung oder einer Destruktor-Nachbedingung zur Vertragsüberprüfung"
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "Typ von %qE ist unbekannt"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT ist kein Aufzählungstyp"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "Packungsindex hat nicht-ganzzahligen Typen %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "Packindex ist keine Ganzzahlkonstante"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "Packungsindex %qE ist negativ"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr "Packungsindex %qE liegt außerhalb des Bereichs einer Packung der Länge %qd"
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "Parameterpack %<__bases%> ist nur in Templatedeklaration gültig"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "%<offsetof%> kann nicht auf Destruktor %<~%T%> angewandt werden"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "%<offsetof%> kann nicht auf Elementfunktion %qD angewandt werden"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "%<offsetof%> kann nicht auf Elementfunktion angewandt werden"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "%<offsetof%> kann nicht auf Aufzähler %qD angewandt werden"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "%<offsetof%> innerhalb von Typ %qT (der kein Standardlayout hat) ist bedingt unterstützt"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "Pointer-to-Member-Mapping %qE wird nicht unterstützt"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "benutzerdefinierte Reduktionsauflösung ist mehrdeutig"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %#qD"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "%qE in %<reduction%>-Klausel ist ein Array der Länge 0"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE hat konstanten Typ für %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr "benutzerdefinierte Reduktion mit Konstruktorinitialisierung für Basisklasse %qT"
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "%qT ist weder Struktur noch Union noch Klassentyp in %<#pragma omp declare mapper%>"
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "%qT darf keine virtuelle Basisklasse in %<#pragma omp declare mapper%> sein"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "String-Literal oder konstanter ganzzahliger Ausdruck anstelle von %qE erwartet"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr "Modifizierer außer %<val%> ist in %<linear%>-Klausel an %<simd%>- oder %<for%>-Konstrukten angegeben, zusammen mit OpenMP-5.2-Modifizierern"
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr "»linear«-Klausel mit Modifizierer %qs wird auf Nicht-Referenz-Variable mit Typ %qT angewandt"
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr "»linear«-Klausel wird auf Variable vom Typ %qT angewandt, die weder ganzzahlig noch Zeiger ist"
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "Ausdruck für »linear«-Schrittweite muss ganzzahlig sein"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr "%<this%> ist in OpenMP nur innerhalb von %<declare simd%>-Klauseln erlaubt"
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD ist in Klausel %qs keine Variable"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD ist in Klausel %<firstprivate%> keine Variable"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD ist in Klausel %<lastprivate%> keine Variable"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "statischer %<gang%>-Ausdruck muss ganzzahlig sein"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "statischer %<gang%>-Ausdruck muss positiv sein"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "Ausdruck für %<gang%>-Nummer muss ganzzahlig sein"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "Ausdruck für %<vector%>-Länge muss ganzzahlig sein"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "Ausdruck für %<worker%>-Nummer muss ganzzahlig sein"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "Wert von %<gang%> muss positiv sein"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "Wert der %<vector%>-Länge muss positiv sein"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "Wert der %<worker%>-Nummer muss positiv sein"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "Plan-Teilgrößenausdruck muss bestimmt sein"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "Ausdruck für %qs-Länge muss ganzzahlig sein"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "Ausdruck für %qs-Länge muss ganzzahlig, positiv und konstant sein"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "%<async%>-Ausdruck muss ganzzahlig sein"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "%<thread_limit%>-Ausdruck muss ganzzahlig sein"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "%<device%>-ID muss ganzzahlig sein"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "Ausdruck für %<dist_schedule%>-Chunkgröße muss ganzzahlig sein"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD ist in %<aligned%>-Klausel keine Variable"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr "%qE in %<aligned%>-Klausel ist weder Zeiger noch Array noch Referenz auf Zeiger oder Array"
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD tritt in %<aligned%>-Klausel mehrfach auf"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "Ausdruck für Ausrichtung der %<aligned%>-Klausel muss ganzzahlig sein"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD ist in %<nontemporal%>-Klausel keine Variable"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD tritt in %<nontemporal%>-Klauseln mehrfach auf"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%<this%> ist in %<allocate%>-Klausel nicht erlaubt"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD ist in %<allocate%>-Klausel keine Variable"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD kommt in %<allocate%>-Klausel mehrfach vor"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "Klassenelement %qE wird in der Klausel %<uses_allocators%> noch nicht unterstützt"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "Modifikatoren können nicht mit vordefinierten Allokatoren verwendet werden"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr "Arrays von Merkmalen mit variabler Länge werden nicht unterstützt"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD ist in %qs-Klausel weder lvalue-Ausdruck noch Arrayabschnitt"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "Template %qE in Klausel %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr "überladener Funktionsname %qE in Klausel %qs"
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "Ausdruck für %<grainsize%> muss ganzzahlig sein"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "Ausdruck für %<priority%> muss ganzzahlig sein"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "%<hint%>-Ausdruck muss ganzzahlig sein"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%<hint%>-Ausdruck muss ganzzahlig und konstant sein"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "%<filter%>-Ausdruck muss ganzzahlig sein"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "Variable %qs ist weder Zeiger noch Referenz auf Zeiger"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "Variable %qs ist weder Zeiger noch Array noch Referenz auf Zeiger oder Array"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "Argument für %<tile%> erfordert ganzzahligen Typ"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "%<const%>-qualifiziertes %qE ohne %<mutable%>-Element darf nur in %<shared%>- oder %<firstprivate%>-Klauseln vorkommen"
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD ist weder Datei-, Namens- noch Blockbereichsvariable"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%<threadprivate%> Direktive %qE nicht in Definition von %qT"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "Unterschied zwischen %qE und %qD hat keinen Ganzzahltyp"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<#pragma omp simd%> zusammen mit Iterationsvariable %qE verwendet"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic update%> verwendet zwei unterschiedliche Ausdrücke für Speicher"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr "%<constexpr%>-String muss ein Stringliteral oder ein Objekt mit den Membern %<size%> und %<data%> sein"
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr "%<size()%> des %<constexpr%>-Strings muss implizit in %<std::size_t%> umwandelbar sein"
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr "%<data()%> des %<constexpr%>-Strings muss implizit in %<const char*%> umwandelbar sein"
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "%<size()%> des %<constexpr%>-Strings muss ein konstanter Ausdruck sein"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr "%<size()%> des %<constexpr%>-Strings ist %qE und damit zu groß"
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr "unverarbeiteter Rückgabewert von %<data()%>"
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "%<data()[%d]%> des %<constexpr%>-Strings muss ein konstanter Ausdruck sein"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "%<data()%> des %<constexpr%>-Strings muss ein Kernkonstantenausdruck sein"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr "die constexpr-Zeichenkette konnte nicht von UTF-8 in den Quellzeichensatz konvertiert werden"
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr "die constexpr-Zeichenkette konnte nicht von der normalen Literalkodierung in den Quellzeichensatz konvertiert werden"
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "statische Assertion fehlgeschlagen: %.*s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "Nicht-konstante Bedingung für statische Behauptung"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "Argument für %<decltype%> muss ein Ausdruck sein"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%<decltype%> kann die Adresse der überladenen Funktion nicht auflösen"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "%qT ist ein Klassentyp, der aber keine Union ist"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "%qT ist kein Typ mit Standardlayout"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr "%<__builtin_is_pointer_interconvertible_with_class%> benötigt ein einziges Argument"
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr "Argument von %<__builtin_is_pointer_interconvertible_with_class%> muss ein Zeiger auf Member sein"
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr "%<__builtin_is_corresponding_member%> nicht wohldefiniert für anonyme Vereinigungen"
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_is_corresponding_member%> benötigt zwei Argumente"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr "Argument von %<__builtin_is_corresponding_member%> muss ein Zeiger auf Member sein"
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_is_string_literal%> benötigt ein einziges Argument"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr "das Argument für %<__builtin_is_string_literal%> ist weder %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> noch %<const char32_t*%>"
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr "Überprüfung von %qs auf Typ %qT mit einem Destruktor, der nicht aufrufbar ist"
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "das Argument %2$qT für %1$qs ist eine Referenz"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qD ist weder ein Klassen- noch ein Alias-Template"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "Operand des Faltungsausdrucks hat keine unexpandierten Parameterpackungen"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "beide Argumente in binärer Faltung haben unexpandierte Parameterpackungen"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr "keine unexpandierten Parameterpackungen in binärer Faltung"
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "Typ %qT des Arguments für %<__builtin_launder%> muss ein Objektzeiger sein"
@@ -70671,342 +70818,342 @@ msgstr "Typ %qT des Arguments für %<__builtin_launder%> muss ein Objektzeiger s
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr "Zieltyp %qT von %<__builtin_bit_cast%> ist ein Arraytyp"
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr "Zieltyp %qT von %<__builtin_bit_cast%> ist nicht trivial kopierbar"
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "%<__builtin_bit_cast%> kann nicht mit consteval-only-Typen verwendet werden"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr "Quelltyp %qT von %<__builtin_bit_cast%> ist nicht trivial kopierbar"
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr "in %<__builtin_bit_cast%> ist die Quellgröße %qE ungleich der Zieltypgröße %qE"
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV-Qualifizierer können nicht auf %qT angewendet werden"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr "%<-fabi-version=13%> (GCC 8.2) korrigiert die Aufrufkonvention für %qT, die in 8.1 versehentlich geändert wurde"
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr "%<-fabi-version=12%> (GCC 8.1) ändert versehentlich die Aufrufkonvention für %qT"
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr " hier deklariert"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "die Aufrufkonvention für %qT ändert sich mit %<-fabi-version=13%> (GCC 8.2)"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr " da alle seine Kopier- und Verschiebekonstruktoren gelöscht sind"
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "%qT ist ein Gleitkommatyp"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "%qT ist ein Festkommatyp"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qD füllt nicht alle Bits von %q#T"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr "%qD hat den Typ %qT, der hat jedoch keine eindeutigen Objektdarstellungen"
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr "%q#T hat keine Datenfelder"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr "%<std::nullptr_t%> hat Füllbits und keine Wertbits"
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr "der Basistyp %qT hat keine eindeutigen Objektdarstellungen"
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr "%qD vom Typ %qT hat keine eindeutigen Objektdarstellungen"
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr "Auffüllung passiert zwischen %qD und %qD"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr "unbenanntes Bitfeld fügt vor %qD eine Auffüllung ein"
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr "Auffüllung passiert vor %qD"
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr "Auffüllung passiert hinter %qD"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "%qT hat Auffüllung und keine Datenfelder"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "Basisklasse %qT ist nicht %<public%>"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%qD ist nicht %<public%>"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD ist veränderlich"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qD ist kein nicht-struktureller Typ"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "Attribut %qE kann nur auf Funktionen oder Parameter angewendet werden"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "Argument des Attributs %qE muss eine Zeichenkettenkonstante sein"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "Attribut %qE kann nur auf Funktionen oder auf Klasse- oder Aufzählungstypen angewendet werden"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "Attribut %qE kann nur auf nicht-statische Datenelemente angewendet werden"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "Attribut %qE kann nicht auf Bitfeld angewendet werden"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "Attribut %qE erwartet keine Argumente"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "Attribut %qE aus ISO C++ ist nicht auf Funktionen anwendbar; wird als %<[[gnu::%E]]%> behandelt"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "%<alignas%> in Funktionsdeklaration"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%<alignas%> in Aufzählungstyp"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr "%<alignas%> bei einem anderen Typ als %<class%>"
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr "%<alignas%> in Bitfeld"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr "%<alignas%> in Typalias"
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qE bei einem anderen Typ als einer Klassen- oder Aufzählungsdefinition"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "%qE in unbenanntem Bitfeld"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr "%qE in %<case%>- oder %<default%>-Label"
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "%qE bei einer Deklaration außer Parameter oder automatischer Variable"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "angeforderte %<init_priority%> muss ganzzahlig und konstant sein"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "nur Attribut %qE kann für Definitionen von Objekten eines Klassentyps im Datei-Gültigkeitsbereich verwendet werden"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "angeforderte %<init_priority%> %i liegt außerhalb des Bereichs [0, %i]"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "angeforderte %<init_priority%> %i ist für interne Verwendung reserviert"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "Redeklaration von %qD fügt ABI-Marke %qE hinzu"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "Attribut %qE erfordert Argumente"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "Argumente für Attribut %qE müssen enge Zeichenkettenliterale sein"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "Argumente für Attribut %qE müssen gültige Bezeichner enthalten"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%c%> ist kein gültiges Anfangszeichen für einen Bezeichner"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%c%> ist kein gültiges Zeichen in einem Bezeichner"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "Attribut %qE auf Nicht-Klassen-, Nicht-Enum-Typ %qT angewendet"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "Attribut %qE auf %qT nach seiner Definition angewendet"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "%qE-Attribut wird für Templateinstanziierung %qT ignoriert"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "%qE-Attribut wird für Templatespezialisierung %qT ignoriert"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%qE-Attribut wird auf %qD angewendet, das weder Funktion noch Variable ist"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "Attribut %qE wird auf »extern \"C\"«-Deklaration %qD angewendet"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "Argument %qE des Attributs muss ein Ausdruck sein, der zu true oder false auswertet"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "Annotation an einem anderen Typ als einer Klassen- oder Aufzählungsdefinition"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, gcc-internal-format
 msgid "annotation applied to a label"
 msgstr "Annotation bezieht sich auf eine Sprungmarke"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "Annotation an einem unbenannten Bitfeld"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, gcc-internal-format
 msgid "annotation on void parameter"
 msgstr "Annotation an einem »void«-Parameter"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr "die Annotation hat keinen Strukturtyp"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, gcc-internal-format
 msgid "annotation does not have copy constructible type"
 msgstr "die Annotation hat keinen kopier-erzeugbaren Typ"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "%<lang_*%> check: failed in %s, at %s:%d"
@@ -71206,796 +71353,801 @@ msgstr "%q#T hat kein Element namens %qE; meinten Sie %q#D? (aus diesem Kontext
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%q#T hat kein Element namens %qE; meinten Sie %qE?"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> ist kein Element von %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "%q#D ist kein Element von %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD ist keine Elementtemplatefunktion"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT ist kein Zeiger auf Objekt"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "ungültige Verwendung von Arrayindizierung bei Zeiger auf Element"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "ungültige Verwendung des unären %<*%> bei Zeiger auf Element"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "ungültige Verwendung impliziter Umwandlung bei Zeiger auf Element"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr "linker Operand von %<->*%> muss Zeiger auf Klasse sein, ist aber ein Zeiger auf Element des Typs %qT"
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "Index fehlt in Arrayreferenz"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "Indizierung eines als %<register%> deklarierten Arrays"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "indizierter Wert ist weder ein Array noch ein Zeiger"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "bei Verwendung von %qE fehlt Objekt"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr "keine Standardversion im Geltungsbereich"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO-C++ verbietet den Aufruf von %<::main%> vom Programm aus"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "%<.*%> oder %<->*%> muss verwendet werden, um Zeiger auf Element als Funktion in %<%E (...)%> aufzurufen, z.B. %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "%qT kann nicht als Funktion verwendet werden"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE kann nicht als Funktion verwendet werden"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD kann nicht als Funktion verwendet werden"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "Ausdruck kann nicht als Funktion verwendet werden"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "zu viele Argumente für Konstruktor %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "zu wenige Argumente für Konstruktor %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "zu viele Argumente für Elementfunktion %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "Zu wenige Argumente für Elementfunktion %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "zu viele Argumente für Funktion %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "zu wenige Argumente für Funktion %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "zu viele Argumente für Methode %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "zu wenige Argumente für Methode %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "zu viele Argumente für Funktion"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "zu wenige Argumente für Funktion"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "Parameter %P von %qD hat unvollständigen Typen %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "Parameter %P hat unvollständigen Typen %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "die Adresse %qE ist niemals NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "die Adresse von %qD ist niemals NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "der Compiler kann annehmen, dass die Adresse von %qE niemals NULL ist"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr "Vergleich des Ergebnisses der Zeigeraddition %qE mit NULL"
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "der Compiler kann annehmen, dass die Adresse von %qD niemals NULL ist"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "bitweise Operation zwischen den unterschiedlichen Aufzählungstypen %qT und %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "bitweise Operation zwischen den unterschiedlichen Aufzählungstypen %qT und %qT ist veraltet"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "Arithmetik zwischen den unterschiedlichen Aufzählungstypen %qT und %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "Arithmetik zwischen den unterschiedlichen Aufzählungstypen %qT und %qT ist veraltet"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "Vergleich zwischen Aufzählungstyp %qT und Gleitkommatyp %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "Vergleich zwischen Gleitkommatyp %qT und Aufzählungstyp %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr "Vergleich zwischen Aufzählungstyp %qT und Gleitkommatyp %qT ist veraltet"
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "Vergleich zwischen Gleitkommatyp %qT und Aufzählungstyp %qT ist veraltet"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "Arithmetik zwischen Aufzählungstyp %qT und Gleitkommatyp %qT"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "Arithmetik zwischen Gleitkommatyp %qT und Aufzählungstyp %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr "Arithmetik zwischen Aufzählungstyp %qT und Gleitkommatyp %qT ist veraltet"
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr "Arithmetik zwischen Gleitkommatyp %qT und Aufzählungstyp %qT ist veraltet"
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "Umwandlung in Typ %qT von überladener Funktion wird angenommen"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL in Arithmetik verwendet"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO-C++ verbietet Vergleich zwischen Zeiger und Ganzzahl"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "Operandentypen sind %qT und %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr "Drei-Wege-Vergleich von Vektoren"
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "geordneter Vergleich von Zeiger mit der Zahl 0 (%qT und %qT)"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "ungeordneter Vergleich mit Nicht-Gleitkomma-Argument"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "implizite Umwandlung von %qH in %qI zur Anpassung an anderen Operanden des Binärausdrucks"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "ungültige Operanden der Typen %qT und %qT für binäres %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO-C++ verbietet die Verwendung eines Zeigers des Typs %<void *%> in Subtraktion"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO-C++ verbietet die Verwendung eines Zeigers auf eine Funktion in Subtraktion"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO-C++ verbietet die Verwendung eines Zeigers auf Methode in Subtraktion"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "ungültige Verwendung eines Zeigers auf einen unvollständigen Typen in Zeigerarithmetik"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "Adresse des Konstruktors %qD wird genommen"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "Adresse des Destruktors %qD wird genommen"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "ungültige Verwendung von %qE um Zeiger auf Elementfunktion zu erzeugen"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  eine qualifizierte ID ist erforderlich"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "Klammern um %qE können nicht verwendet werden, einen Zeiger auf Elementfunktion zu erzeugen"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO-C++ verbietet das Ermitteln der Adresse einer nicht qualifizierten oder geklammerten nicht-statischen Elementfunktion, um einen Zeiger auf Elementfunktion zu erzeugen. Stattdessen %<&%T::%D%> verwenden"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO-C++ verbietet das Ermitteln der Adresse einer nicht qualifizierten oder geklammerten nicht-statischen Memberfunktion, um einen Zeiger auf eine explizite Memberfunktion zu erzeugen"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO-C++ verbietet das Ermitteln der Adresse einer gebundenen Elementfunktion, um einen Zeiger auf Elementfunktion zu erzeugen. Stattdessen %<&%T::%D%> verwenden"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO-C++ verbietet es, die Adresse einer gebundenen Memberfunktion zu nehmen, um einen Zeiger auf eine explizite Objekt-Memberfunktion zu bilden"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "ein Zeiger auf eine explizite Objektelementfunktion kann nur mit %<&%T::%D%> erzeugt werden"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "Adresse eines Rvalues wird ermittelt"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO-C++ verbietet das Ermitteln der Adresse der Funktion %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "Zeiger auf Referenzelement %qD kann nicht erzeugt werden"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "Versuch, die Adresse eines Bitfelds zu bestimmen"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<~%> auf einem Ausdruck vom Typ %<bool%>"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr "meinten Sie ein logisches Nicht (%<!%>)?"
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO-C++ verbietet erhöhen einer Aufzählung"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO-C++ verbietet verringern einer Aufzählung"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "Zeiger auf unvollständigen Typen %qT kann nicht erhöht werden"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "Zeiger auf unvollständigen Typen %qT kann nicht verringert werden"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO-C++ verbietet Erhöhen eines Zeigers vom Typ %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO-C++ verbietet Verringern eines Zeigers vom Typ %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr "%qs-Ausdruck von %<volatile%>-qualifiziertem Typ ist veraltet"
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr "Verwendung eines Operanden vom Typ %qT in %<operator--%> ist verboten"
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr "Verwendung eines Operanden vom Typ %qT in %<operator++%> ist in C++17 verboten"
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr "Verwendung eines Operanden vom Typ %qT in %<operator++%> ist veraltet"
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "Adresse von %<this%> kann nicht ermittelt werden, das ein R-Wert-Ausdruck ist"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "Adresse für %qD angefordert, was als %<register%> deklariert ist"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "Listeninitialisierung für Nicht-Klassentyp darf nicht geklammert sein"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "Ausdrucksliste als zusammengesetzten Ausdruck in Initialisierung behandelt"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "Ausdrucksliste als zusammengesetzten Ausdruck in Speicherinitialisierung behandelt"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "Ausdrucksliste als zusammengesetzten Ausdruck in funktionaler Umwandlung behandelt"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80191
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "Ausdrucksliste für »%s« wird als zusammengesetzten Ausdruck behandelt"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "kein Kontext, um Typ von %qE aufzulösen"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "Umwandlung des Typs %qT in Typ %qT entfernt Qualifizierer"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%<static_cast%> von Typ %qT in Typ %qT entfernt Qualifizierer"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%<reinterpret_cast%> von Typ %qT in Typ %qT entfernt Qualifizierer"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "nutzlose Umwandlung in Typ %q#T"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "Typkennzeichner an Umwandlungs-Rückgabetyp ignoriert"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "ungültiges %<static_cast%> von Typ %qT in Typ %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "Klassentyp %qT ist unvollständig"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr "Umwandlung von %qH nach %qI"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "ungültige Typumwandlung eines prvalue-Ausdrucks des Typs %qT in Typ %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr "Typumwandlung von %qH nach %qI verliert Genauigkeit"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr "Umwandlung zwischen inkompatiblen Funktionstypen von %qH nach %qI"
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "Umwandlung zwischen inkompatiblen Elementzeigertypen von %qH nach %qI"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "Umwandlung von %qH in %qI erhöht erforderliche Ausrichtung des Zieltyps"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "Umwandlung zwischen Zeiger auf Funktion und Zeiger auf Objekt ist bedingt unterstützt"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "ungültige Umwandlung von Typ %qT in Typ %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "ungültige Verwendung von %<const_cast%> mit Typ %qT, der weder Zeiger, Referenz, noch Zeiger auf ein Datenelement ist"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "ungültige Verwendung von %<const_cast%> mit Typ %qT, der ein Zeiger oder Referenz auf Funktionstyp ist"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "ungültiges %<const_cast%> eines R-Wertes des Typs %qT in Typ %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "ungültiges %<const_cast%> von Typ %qT in Typ %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO-C++ verbietet Umwandlung in Arraytyp %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "ungültige Umwandlung in Funktionstyp %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr "%qE vom Typ %qT wird auf sich selbst verschoben"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  in Auswertung von %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "Zuweisung an Array von Initialisierungsliste"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "unverträgliche Typen in Zuweisung von %qT an %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "Array als Initialisierung verwendet"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "Ungültige Arrayzuweisung"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   in Umwandlung in Zeiger auf Elementfunktion"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "Umwandlung in Zeiger auf Element über virtuelle Basis %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   in Umwandlung in Zeiger auf Element"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "ungültige Umwandlung in Typ %qT von Typ %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "%qH kann nicht nach %qI im Standardargument umgewandelt werden"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "%qH kann nicht nach %qI bei Argumentübergabe umgewandelt werden"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "%qH kann nicht nach %qI in Initialisierung umgewandelt werden"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr "%qH kann nicht nach %qI in Rückgabe umgewandelt werden"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "%qH kann nicht nach %qI in Zuweisung umgewandelt werden"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "Parameter %qP von %qD könnte Kandidat für Formatattribut sein"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "Parameter könnte ein Kandidat für ein Formatattribut sein"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "Ziel der Umwandlung könnte Kandidat ein für ein Formatattribut sein"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "Ziel der Initialisierung könnte ein Kandidat für Formatattribut sein"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "linke Seite der Zuweisung könnte ein Kandidat für ein Formatattribut sein"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "bei Übergabe des Arguments %P von %qD"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "Referenz auf temporären Wert wird zurückgegeben"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "Zeiger auf temporäre Variable wird zurückgegeben"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr "das Zurückgeben einer temporären %<initializer_list%> verlängert nicht die Lebenszeit des zugrundeliegenden Arrays"
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "Referenz auf lokale Variable %qD zurückgegeben"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr "das Zurückgeben der lokalen %<initializer_list%>-Variable %qD verlängert nicht die Lebenszeit des zugrundeliegenden Arrays"
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "Adresse der lokalen Variable %qD zurückgegeben"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "Adresse der lokalen Variable %qD zurückgegeben"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr "das Verschieben eines temporären Objekts verhindert das Einsparen der Kopie"
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr "entfernen Sie den Aufruf von %<std::move%>"
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr "das Verschieben eines lokalen Objekts in einer return-Anweisung verhindert das Einsparen der Kopie"
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "redundantes Verschieben in Rückgabeanweisung"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "redundantes Verschieben in Initialisierung"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "Wert von Destruktor zurückgegeben"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "vom Behandler eines Funktions-try-Blocks eines Konstruktors kann nicht zurückgekehrt werden"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "Rückgabe eines Wertes von einem Konstruktor"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "Return-Anweisung ohne Wert, in %qT zurückgebender Funktion"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr "Initialisierungsliste wird zurückgegeben"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "widersprüchliche Typen %qT und %qT für Lambda-Rückgabetypen hergeleitet"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "widersprüchliche Herleitung für automatischen Rückgabetyp: %qT und dann %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "Return-Anweisung mit Wert, in Funktion mit Rückgabetyp %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> darf nicht NULL zurückgeben, außer er ist mit %<throw%> deklariert (oder %<-fcheck-new%> ist eingeschaltet)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "bei der Rückkehr von %qD wird das Kopieren nicht eingespart"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr "bei der Rückkehr in %qD wird das Kopieren nicht eingespart"
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "Rvalue wird als Lvalue verwendet"
@@ -72399,17 +72551,17 @@ msgstr "Logdatei %<vtv_set_ptr_data.log%> kann nicht geöffnet werden: %m"
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "Logdatei %<vtv_count_data.log%> kann nicht geöffnet werden: %m"
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "unbekanntes Attribut %qs"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%q+D als schwach deklariert, nachdem es verwendet wurde"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr "nur die Schalter %<inbranch%> und %<notinbranch%> sind für das %<simd%>-Attribut erlaubt"
@@ -72434,43 +72586,43 @@ msgstr "überlappender Initialisierer für das Feld %qT.%qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "die Adresse von %qD ist niemals %<null%>"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr "Zugriff auf das Member %qE erfordert %<this%>"
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr "es wurde versucht, eine Gleitkommadivision mit Rest an %qT durchzuführen"
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "Zugriff auf den Rahmenzeiger von %qs ist nicht möglich"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr "die geschachtelte Funktion muss einen Rumpf haben"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qs ist eine geschachtelte Funktion, Zugriff von %qs aus ist nicht möglich"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr "Variable %qs hat bereichsbasierte Destruktion, daher kann kein Funktionsabschluss gebaut werden"
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "explizite Register-Variable %qs kann nicht in verschachtelter Funktion verwendet werden"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "Vorwärtsbezug zum Rahmen von %qs"
@@ -72548,32 +72700,32 @@ msgstr "falsches Argument für %<-fmodule-file=%>: %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "falsches Argument für %<-fversion=%>: %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "»%s« kann nicht zum Schreiben geöffnet werden: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "beim Schreiben in »%s«: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "»%s« kann nicht zum Lesen geöffnet werden: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "beim Lesen der ddoc-Datei »%s«: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr "das Argument %<-fonly=%> unterscheidet sich vom Namen der ersten Eingabedatei"
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr "die Vorwärtsreferenz in der Definition kann nicht aufgelöst werden"
@@ -72670,7 +72822,7 @@ msgstr "es ist unklar, wie %qs zu löschen ist"
 msgid "%qs is not an associative array"
 msgstr "%qs ist kein assoziatives Array"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr "für den Zugriff auf Member %qs wird %<this%> benötigt"
@@ -72685,22 +72837,22 @@ msgstr "Delegation ist nur bei nicht-statischen Funktionen möglich"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs ist kein Feld, sondern ein %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "rekursive Referenz %qs"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr "nicht konstanter Ausdruck %qs"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%qs ist kein Ausdruck"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "Typ %qs ist kein Ausdruck"
@@ -72791,17 +72943,17 @@ msgstr "COM-Objekte können nicht geworfen werden"
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "D-Inline-Assembler-Anweisungen werden in GDC nicht unterstützt."
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr "Ausdruck %qs erfordert %<object.TypeInfo%> und kann nicht mit %<-fno-rtti%> verwendet werden"
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<object.TypeInfo%> kann nicht mit %<-fno-rtti%> verwendet werden"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr "%<object.TypeInfo%> konnte nicht gefunden werden, wird aber implizit verwendet"
@@ -73136,8 +73288,8 @@ msgstr "Feldreferenz bei %C kann nicht mehr als %d Dimensionen haben"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "Coarrays bei %C ausgeschaltet, %<-fcoarray=%> schaltet sie ein"
@@ -73421,7 +73573,7 @@ msgstr "Die BOZ-Literalkonstante bei %L darf kein tatsächliches Argument für %
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "Argumente von %qs bei %L und %L können nicht beide literale BOZ-Konstanten sein"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "Ungültige Verwendung der BOZ-Literalkonstante bei %L"
@@ -73496,7 +73648,7 @@ msgstr "Argument %qs des intrinsischen %qs bei %L muss REAL oder COMPLEX sein"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "Argument %qs für intrinsisches %qs bei %L muss INTEGER oder PROCEDURE sein"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss eine Konstante sein"
@@ -73636,7 +73788,7 @@ msgstr "Die BOZ-Literalkonstante bei %L darf nicht in einem ACHAR-intrinsischen
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "Argumente %qs und %qs des intrinsischen %qs bei %L müssen denselben Typ haben"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "Verschiedene Typ-Arten bei %L"
@@ -73651,7 +73803,7 @@ msgstr "NULL bei %L ist nicht als tatsächliches Argument der intrinsischen Funk
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss ein POINTER sein"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "Argument %qs des intrinsischen %qs bei %L darf keinen Koindex haben"
@@ -73792,8 +73944,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "Das Argument »errmsg=« bei %L muss eine standardartige Zeichenvariable sein"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "Koarrays bei %L ausgeschaltet, %<-fcoarray=%> schaltet sie ein"
@@ -73892,9 +74044,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "BOZ-Konstante bei %L kann nicht innerhalb eines COMPLEX-intrinsischen Unterprogramms vorkommen"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "intrinsisches %qs mit KIND-Argument bei %L"
@@ -73909,12 +74061,12 @@ msgstr "Argument %qs des intrinsischen %qs bei %L hat ungültige Form in Dimensi
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss Rang %d haben oder ein Skalar sein"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss numerisch oder LOGICAL sein"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "Argumenttypen des intrinsischen %qs bei %L müssen passen (%s/%s)"
@@ -74009,620 +74161,620 @@ msgstr "Argument %qs des intrinsischen %qs bei %L muss eine Datenentität sein"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Das intrinsische %qs bei %L muss mindestens zwei Argumente haben"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Fehlendes %qs-Argument für %qs bei %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Doppeltes Argument %qs bei %L für intrinsisches %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Unbekanntes Argument %qs bei %L für intrinsisches %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "Verschiedene Zeichenarten bei %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "Argument %<a%d%> des intrinsischen %qs bei %L muss %s(%d) sein"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "intrinsisches %qs mit CHARACTER-Argument bei %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "Argument %<a1%> des intrinsischen %qs bei %L muss INTEGER, REAL, CHARACTER oder UNSIGNED sein"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "Argument %<a1%> des intrinsischen %qs bei %L muss INTEGER, REAL oder CHARACTER sein"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Andere Form bei Dimension 1 für Argumente %qs und %qs bei %L für intrinsisches matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Andere Form bei Dimension 2 für Argument %qs und Dimension 1 für Argument %qs bei %L für intrinsisches matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss vom Rang 1 oder 2 sein"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss typkonform zu Argument %qs bei %L sein"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss INTEGER oder UNSIGNED sein"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss ein INTEGER sein"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr "STAT= oder ERRMSG= bei %L wird nicht unterstützt"
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Das FROM-Argument für MOVE_ALLOC bei %L darf keinen Koindex haben"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Das TO-Argument für MOVE_ALLOC bei %L darf keinen Koindex haben"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "Die TO-Argumente in MOVE_ALLOC bei %L müssen polymorph sein, wenn FROM polymorph ist"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "Die FROM- und TO-Argumente des intrinsischen MOVE_ALLOC bei %L müssen den selben Rang %d/%d haben"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "Die FROM- und TO-Argumente des intrinsischen MOVE_ALLOC bei %L müssen den selben Ko-Rang %d/%d haben"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr "Die FROM- und TO-Argumente bei %L verletzen die Aliasing-Beschränkungen (F2003 12.4.1.7)"
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "Argument %<S%> von NEAREST bei %L darf nicht Null sein"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss POINTER, ALLOCATABLE oder Prozedurzeiger sein"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "intrinsisches NULL mit reservierbarem MOLD bei %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "%qs-Argument des intrinsischen %qs bei %L darf nur vorkommen, wenn %qs vom Typ REAL und %qs vom Typ INTEGER oder UNSIGNED ist"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss mindestens so viele Elemente haben wie es .TRUE.-Werte %qs (%ld/%d) gibt"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss eine Scheinvariable sein"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss eine OPTIONALe Scheinvariable sein"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "Argument %qs des intrinsischen %qs bei %L darf kein Unterobjekt von %qs sein"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "Argument des intrinsischen RANK bei %L muss ein Datenobjekt sein"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "Das Feld-Argument bei %L von REDUCE darf nicht polymorph sein"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "Das Argument »DIM« bei %L muss ganzzahlig und skalar sein"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr "Das MASK-Argument bei %L muss, falls vorhanden, ein logisches Feld mit demselben Rang wie ARRAY sein"
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr "MASK kommt bei %L ohne IDENTITY vor"
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "Das Argument ORDERED bei %L muss, falls vorhanden, logisch und skalar sein"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr "Das IDENTITY-Argument bei %L muss, falls vorhanden, ein Skalar mit demselben Typ wie ARRAY sein"
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "Argument %<shape%> des intrinsischen %<reshape%> bei %L muss ein Feld konstanter Größe sein"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "Argument %qs des intrinsischen %qs bei %L ist leer"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "Argument »shape« des intrinsischen »reshape« bei %L hat mehr als %d Elemente"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "Argument %qs des intrinsischen %qs bei %L hat negatives Element (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "Argument %qs des intrinsischen %qs bei %L hat falsche Anzahl der Elemente (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "Argument %qs des intrinsischen %qs bei %L hat Dimension außerhalb des Wertebereiches (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "Argument %qs des intrinsischen %qs bei %L hat ungültige Permutation der Dimensionen (Dimension %qd doppelt)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Ohne Auffüllen gibt es nicht genügend Elemente in intrinsischer RESHAPE-Quelle bei %L, um zur Form zu passen"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "Argument %qs des intrinsischen %qs bei %L kann nicht Typ %s haben"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss erweiterbaren Typ haben"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "SELECTED_REAL_KIND ohne Argument %<P%> oder %<R%> bei %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "intrinsisches %qs mit RADIX-Argument bei %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "Argument %<source%> des intrinsischen %<shape%> bei %L darf kein Feld impliziter Größe sein"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "Argument %qs des intrinsischen %qs bei %L darf keine Prozedur sein"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "Argument %qs des intrinsischen %qs bei %L darf nicht TYPE(*) sein"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "Argument %qs des intrinsischen %qs bei %L darf kein Feld impliziter Größe sein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr "is_c_interoperable(): gfc_simplify_expr failed"
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss austauschbare Datenentität sein: %s"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr "Argument C_PTR_1 bei %L für C_ASSOCIATED muss den Typ TYPE(C_PTR) oder TYPE(C_FUNPTR) haben"
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr "Argument C_PTR_2 bei %L für C_ASSOCIATED muss denselben Typ wie C_PTR_1 haben, %s statt %s gefunden"
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr "Argument CPTR bei %L für C_F_POINTER muss den Typen TYPE(C_PTR) haben"
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Argument FPTR bei %L für C_F_POINTER muss ein Zeiger sein"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "Argument FPTR für C_F_POINTER bei %L darf nicht polymorph sein"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "Argument FPTR für C_F_POINTER bei %L darf nicht koindiziert sein"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Unerwartetes SHAPE-Argument bei %L für C_F_POINTER mit skalarem FPTR"
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr "SHAPE-Argument für C_F_POINTER mit Array-FPTR bei %L erwartet"
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "SHAPE-Argument bei %L für C_F_POINTER muss dieselbe Größe haben wie der RANK des FPTR"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "LOWER-Argument bei %L für C_F_POINTER"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Unerwartetes LOWER-Argument bei %L für C_F_POINTER mit skalarem FPTR"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "LOWER-Argument bei %L für C_F_POINTER muss dieselbe Größe haben wie der RANK des FPTR"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr "Polymorpher FPTR bei %L für C_F_POINTER"
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "FPTR-Argument für C_F_POINTER bei %L ist eine Funktion, die einen Zeiger zurückgibt"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Unverträgliches Feld-FPTR-Argument für C_F_POINTER bei %L: %s"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr "Argument CPTR bei %L für C_F_PROCPOINTER muss den Typen TYPE(C_FUNPTR) haben"
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "Argument FPTR bei %L für C_F_PROCPOINTER muss ein Prozedurzeiger sein"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "Argument FPTR bei %L für C_F_PROCPOINTER darf nicht koindiziert sein"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr "Unverträglicher Prozedurzeiger bei %L für C_F_PROCPOINTER"
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "Argument X bei %L für C_FUNLOC darf nicht koindiziert sein"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "Funktionsergebnis %qs bei %L ist als X-Argument für C_FUNLOC ungültig"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr "Argument X bei %L für C_FUNLOC muss eine Prozedur oder ein Prozedurzeiger sein"
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Unverträgliche Prozedur bei %L für C_FUNLOC"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "Argument X bei %L für C_LOC darf nicht koindiziert sein"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "X-Argument bei %L für C_LOC darf nicht polymorph sein"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "Argument X bei %L für C_LOC muss entweder POINTER- oder TARGET-Attribut haben"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "Argument X bei %L für C_LOC darf keine Zeichenkette der Länge 0 sein"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "Argument bei %L für C_LOC darf nicht polymorph sein"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "Unverträgliches Feld bei %L als Argument für C_LOC: %s"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr "Feld von interoperablem Typ bei %L für C_LOC; es ist nichtallozierbar und hat weder angenommene noch explizite Größe"
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "Feldabschnitt bei %L für C_LOC"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "REAL-Argument ohne doppelte Genauigkeit für intrinsisches %s bei %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "Argument %qs für intrinsisches %qs bei %L muss geringer als Rang %d sein"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "Argument %qs des intrinsischen %qs bei %L ist kein gültiger Dimensionsindex"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss mindestens die Länge 1 haben"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "Argument »%s« für IMAGE_INDEX muss Feld mit Rang 1 bei %L sein"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "Die Anzahl der Feldelemente des SUB-Arguments für IMAGE_INDEX bei %L muss %d (Korang) sein, nicht %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Argument %<team%> oder %<team_number%> für %qs bei %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr "Das erste Argument des intrinsischen %<this_image%> bei %L muss eine Kofeld-Variable oder ein Objekt vom Typ %<team_type%> aus dem intrinsischen Modul %<ISO_FORTRAN_ENV%> sein"
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr "Das zweite Argument des intrinsischen %<this_image%> bei %L muss ein Skalar vom Typ %<INTEGER%> oder ein Objekt vom Typ %<team_type%> aus dem intrinsischen Modul %<ISO_FORTRAN_ENV%> sein"
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "Das Argument %<dim%> ohne das Argument %<coarray%> ist für die intrinsische Funktion %<this_image%> bei %L nicht erlaubt"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Argument %<team%> für %<this_image%> bei %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr "Höchstens ein Argument vom Typ %<team_type%> aus dem intrinsischen Modul %<ISO_FORTRAN_ENV%> zu %<this_image%> bei %L erlaubt"
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr "Argument %<MOLD%> des intrinsischen %<TRANSFER%> bei %L ist ein Array und darf nicht die Speichergröße 0 haben, da das %<SOURCE%>-Argument größer als 0 ist"
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "Argument %<SOURCE%> des intrinsischen %<TRANSFER%> bei %L darf kein %s sein"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "Argument %<MOLD%> des intrinsischen %<TRANSFER%> bei %L darf kein %s sein"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "Argument %<MOLD%> des intrinsischen %<TRANSFER%> bei %L darf nicht %s sein"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "Intrinsisches TRANSFER bei %L hat teilweise undefiniertes Ergebnis: Quellgröße %zd < Ergebnisgröße %zd"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "Argument %qs des intrinsischen %qs bei %L muss den selben Rang wie %qs haben oder skalar sein"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "Argumente %qs und %qs des intrinsischen %qs bei %L müssen gleiche Form haben."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "Das VALUES-Argument für DATE_AND_TIME bei %L hat nicht-Standard-Art"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Das VALUES-Argument von DATE_AND_TIME bei %L muss einen dezimalen Exponentenbereich von mindestens 4 haben"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Größe des Arguments %qs des intrinsischen %qs bei %L ist zu klein (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Zu viele Argumente für %s bei %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr "fe_runtime_error string must be null terminated"
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Das COUNT-Argument für SYSTEM_CLOCK bei %L hat nicht-Standard-Art"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Das COUNT-Argument für SYSTEM_CLOCK bei %L hat eine Ganzzahl, die kleiner als der Standard ist"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr "Reelles COUNT_RATE-Argument für SYSTEM_CLOCK bei %L"
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Das COUNT_RATE-Argument für SYSTEM_CLOCK bei %L hat nicht-Standard-Art"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Das COUNT_RATE-Argument für SYSTEM_CLOCK bei %L hat eine Art, die kleiner als die Standard-Ganzzahl ist"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Das COUNT_MAX-Argument für SYSTEM_CLOCK bei %L hat nicht-Standard-Art"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Das COUNT_MAX-Argument für SYSTEM_CLOCK bei %L hat eine Art, die kleiner als die Standard-Ganzzahl ist"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "Ganzzahlige Argumente für SYSTEM_CLOCK bei %L mit Parametern unterschiedlicher Art"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "Argument %qs des intrinsischen %qs bei %L darf von der Art nicht breiter als der Standard (%d) sein"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "Argument bei %L von der intrinsischen Funktion %qs muss ein verbundener Zeiger sein"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "Argument %qs der intrinsischen Funktion %qs bei %L muss INTEGER, LOGICAL oder ein BOZ-Literal sein"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr "Intrinsische Funktion NULL bei %L kann kein tatsächliches Argument für STORAGE_SIZE sein, da es einen disassoziierten Zeiger zurückgibt"
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "Höchste Erweiterungsstufe mit Typ %qs bei %L erreicht"
@@ -74687,12 +74839,12 @@ msgstr "Unbenutzte Initialisierungszeichenkette bei %L, da die Variable die Län
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "Initialisierungszeichenkette bei %L wurde abgeschnitten, um zur Variable zu passen (%wd/%wd)"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Anfangs-Index der Teilzeichenkette bei %L ist kleiner als Eins"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "End-Index der Teilzeichenkette bei %L überschreitet Zeichenkettenlänge"
@@ -74742,2062 +74894,2062 @@ msgstr "Nichtzeiger-Objekt %qs mit Standard-Initialisierung darf nicht in einer
 msgid "Simplification error"
 msgstr "Interner Fehler: Simplification error"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr "Befragungsparameter darf nicht in einer data-stmt-object-list bei %C vorkommen"
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Mit Host verbundene Variable %qs darf nicht in DATA-Anweisung bei %C stehen"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Initialisierung der allgemeinen Blockvariable %qs in DATA-Anweisung bei %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Symbol %qs muss ein PARAMETER in DATA-Anweisung bei %C sein"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Ungültige Initialisierung %s in Data-Anweisung bei %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "BOZ bei %L kann nicht in einer Initialisierung alten Stils vorkommen"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr "Die BOZ-Literalkonstante in der Nähe von %L kann bei einer Initialisierung alten Stils nicht einer %qs-Variablen zugewiesen werden"
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "Initialisierung bei %C ist in PURE-Prozedur nicht erlaubt"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "DATA-Anweisung bei %C kann nicht innerhalb von INTERFACE auftreten"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Ungültige Teilzeichenkette in data-implied-do in DATA-Anweisung bei %L"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr "Allozierbare Komponente oder deferred-shaped-Feld bei %C in DATA-Anweisung"
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "Die BOZ-Literalkonstante bei %L darf nicht in einem Strukturkonstruktor vorkommen"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "DATA-Anweisung bei %C ist in PURE-Prozedur nicht erlaubt"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr "part-ref mit Zeigerattribut bei %L ist nicht das rechteste part-ref des data-stmt-objects"
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "Leere Initialisierungsliste im alten Stil bei %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Feld in der Initialisierungsliste bei %L muss eine explizite Form haben"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "Ungültige Wiederholungsangabe in Skalar-Initialisierung bei %C"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "Wiederholungsangabe bei %C muss eine Ganzzahl sein"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Datenkonstante nach Wiederholungsangabe bei %C erwartet"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "Ende der skalaren Initialisierung bei %C erwartet"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "Nicht genug Element in Feldinitialisierung bei %C"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "Zu viele Elemente in Feldinitialisierung bei %C"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Syntaxfehler in Initialisierungsliste im alten Stil bei %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "Das Feld vermuteten Ranges bei %C darf keine Kodimension haben"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr "Die Summe aus Feldrang %d und Korang %d bei %C übersteigt die Höchstanzahl %d an Dimensionen"
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Falsche INTENT-Spezifikation bei %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "Parameter mit zurückgestelltem Typ bei %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr "Skalarer INTEGER-Ausdruck bei %L erwartet"
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Zeichenlänge alten Stils bei %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Syntaxfehler in Zeichenlängenangabe bei %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Prozedur %qs bei %C wurde bereits bei %L definiert"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Enthaltene Prozedur %qs bei %C steht in Konflikt mit Prozedur, die bei %L definiert wurde"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Name %qs bei %C ist bereits als eine allgemeine Schnittstelle bei %L definiert"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Prozedur %qs bei %C hat eine explizite Schnittstelle aus einer vorherigen Deklaration"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr "Die Prozedur %qs, die im Interface-Körper bei %L definiert ist, passt nicht zu der internen Prozedur bei %C"
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Prozedur %qs bei %L muss das BIND(C)-Attribut haben, um mit C interoperabel zu sein"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, jedoch nicht interoperabel mit C, da der abgeleitete Typ %qs nicht mit C interoperabel ist"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, jedoch nicht interoperabel mit C, da sie polymorph ist"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Variable %qs bei %L ist ein Scheinargument für die BIND(C)-Prozedur %qs, könnte jedoch unverträglich mit C sein"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "Das Dummy-Argument %qs bei %L kann kein Zeiger mit dem Attribut CONTIGUOUS sein, da die Prozedur %qs BIND(C) ist"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "Das durch Vorgabe initialisierte Dummy-Argument %qs mit dem Attribut %qs bei %L ist in der BIND(C)-Prozedur %qs nicht erlaubt"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Das allozierbare Zeichen-Dummy-Argument %qs bei %L muss eine verzögerte Länge haben, da die Prozedur %qs BIND(C) ist"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Das Zeichenzeiger-Dummy-Argument %qs bei %L muss eine verzögerte Länge haben, da die Prozedur %qs BIND(C) ist"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Das Zeichen-Dummy-Argument %qs bei %L hat verzögerte Länge und gehört zur Prozedur %qs mit dem Attribut BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "Das Zeichen-Dummy-Argument %qs bei %L muss die Länge 1 haben, da es das Attribut VALUE hat"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Das Zeichen-Dummy-Argument %qs bei %L hat eine angenommene Länge und gehört zur Prozedur %qs mit Attribut BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr "Das Zeichen-Dummy-Argument %qs bei %L muss entweder die konstante Länge 1 haben oder eine angenommene Länge, es sei denn, es hat eine angenommene Form oder einen angenommenen Rang, da die Prozedur %qs das Attribut BIND(C) hat"
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Variable %qs bei %L mit OPTIONAL-Attribut in Prozedur %qs, die BIND(C) ist"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Variable %qs bei %L mit OPTIONAL-Attribut in Prozedur %qs, die BIND(C) ist"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "Variable %qs bei %L kann nicht gleichzeitig die Attribute OPTIONAL und VALUE haben, da Prozedur %qs BIND(C) ist"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Variable %qs bei %L mit OPTIONAL-Attribut in Prozedur %qs, die jedoch BIND(C) ist"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Feld mit angenommener Form %qs bei %L als Scheinargument für die BIND(C)-Prozedur %qs bei %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr "F2018: C8102 %s bei %L wurde bereits durch eine %s-Anweisung importiert und darf nicht erneut deklariert werden"
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Symbol %qs bei %C ist bereits bei %L als ein Typ deklariert"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "Variable %qs in gemeinsamem Block %qs bei %C muss mit einer mit C interoperablen Art deklariert sein, da der gemeinsame Block %qs BIND(C) ist"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "CHARACTER-Länge bei %L muss konstant sein"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "CHARACTER-Ausdruck bei %L wird abgeschnitten (%ld/%ld)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Die CHARACTER-Elemente des Feldkonstruktors bei %L müssen dieselbe Länge haben (%ld/%ld)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Initialisierer nicht erlaubt für PARAMETER %qs bei %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "Fehlende Initialisierung für PARAMETER bei %L"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Variable %qs bei %C mit Initialisierung tritt bereits in einer DATA-Anweisung auf"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Parameter-Feld bei %L kann nicht mit Elementen variabler Länge initialisiert werden"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Rangabweichung zwischen dem Array bei %L und seinem Initialisierer (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "Das implied-shape-Feld bei %L kann nicht mit Skalar initialisiert werden"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "Falsche Form des Initialisierers bei %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "Form des Initialisierers bei %L kann nicht bestimmt werden"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Nicht-konstante untere Grenze in Deklaration mit impliziter Form bei %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "Entität %qs bei %L ist inkompatibel zu einer BOZ-Literal-Konstante"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Komponente bei %C muss ein POINTER-Attribut haben"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Komponente %qs mit CLASS bei %C muss allozierbar oder Zeiger sein"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Feldkomponente der Struktur bei %C muss explizite oder aufgeschobene Form haben"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Komponente %qs bei %C bereits bei %L deklariert"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Zeigerfeld-Komponente der Struktur bei %C muss eine aufgeschobene Form haben"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Allozierbare Komponente der Struktur bei %C muss eine aufgeschobene Form haben"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Feldkomponente der Struktur bei %C muss eine explizite Form haben"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "Typparameter %qs bei %C hat keinen zugehörigen Eintrag in der Typparameter-Namensliste bei %L"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "NULL()-Initialisierung bei %C ist mehrdeutig"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "NULL()-Initialisierung bei %C könnte kein MOLD haben"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Initialisierung des Zeigers bei %C ist nicht in einer PURE-Prozedur erlaubt"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Fehler in Zeigerinitialisierung bei %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "Nicht-NULL-Zeigerinitialisierung bei %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr "Die RESULT-Variable %qs bei %L verbietet, dass der FUNCTION-Name %qs bei %C in einer Spezifikationsanweisung auftritt"
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "%qs ist außerhalb der STRUCTURE bei %C nicht erlaubt"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%qs bei %C ist eine DEC-Erweiterung, muss mit %<-fdec-structure%> eingeschaltet werden"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "Entität %qs bei %C kann keine Argumente haben"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Ungültiges Zeichen %qc in Variablenname bei %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Nicht-PARAMETER-Symbol %qs bei %L kann nicht implied-shape sein"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Feld mit impliziter Form bei %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Explizite Arrayform bei %C muss eine Konstante vom Typ INTEGER sein, nicht %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr "Feld mit expliziter Form, aber nichtkonstanten Grenzen bei %C"
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr "%qs bei %L ist eine Redefinition der Deklaration in der entsprechenden Schnittstelle für MODUL PROCEDURE %qs"
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Entität %qs bei %L kann keine Initialisierung haben"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Doppelte Feldspezifikation für Cray-Zeigerende bei %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "Interner Fehler: Cannot set pointee array spec."
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Initialisierung im alten Stil bei %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "Ungültige Initialisierung im alten Stil für abgeleitete Typkomponente bei %C"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Syntaxfehler in Initialisierung im alten Stil von %s bei %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Initialisierung bei %C ist nicht für eine Zeigervariable"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Zeigerinitialisierung bei %C benötigt %<=>%>, nicht %<=%>"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Initialisierungsausdruck bei %C erwartet"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Initialisierung einer Variablen bei %C ist in einer PURE-Prozedur nicht erlaubt"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Initialisierung einer allozierbaren Komponente bei %C ist nicht erlaubt"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "Initialisierung einer Strukturkomponente mit einer HOLLERITH-Konstante bei %L ist nicht erlaubt"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr "Die Komponente bei %C mit KIND- oder LEN-Attribut erscheint nicht in der Typparameterliste bei %L"
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr "Die Komponente bei %C, die in der Typparameterliste bei %L erscheint, hat weder KIND- noch LEN-Attribut"
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Die Komponente bei %C, die ein Typparameter ist, muss ein Skalar sein"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Die BOZ-Literalkonstante bei %L darf nicht als Initialisierer vorkommen"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr "Inkompatible Initialisierung zwischen einer abgeleiteten Typentität und einer Entität mit Typ %qs bei %C"
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Deklaration %s*%d im alten Stil wird bei %C nicht unterstützt"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Nicht-Standard Typ-Deklaration %s*%d bei %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Fehlende rechte Klammer bei %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Initialisierungsausdruck bei %C erwartet"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Skalaren Initialisierungsausdruck bei %C erwartet"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Die Art %d wird für Typ %s bei %C nicht unterstützt"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Typ-Parameter nach C-Art ist für Typ %s, aber Typ bei %L ist %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Fehlende rechte Klammer oder Komma bei %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Die Art %d wird für CHARACTER bei %C nicht unterstützt"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Syntaxfehler in CHARACTER-Deklaration bei %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "RECORD bei %C ist eine Erweiterung, muss mit %<-fdec-structure%> eingeschaltet werden"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Strukturname nach RECORD bei %C erwartet"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr "Die Typparameter-Angabenliste bei %C kann nicht gleichzeitig ASSUMED- und DEFERRED-Parameter enthalten"
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "Die Typparameter-Angabenliste bei %C enthält nicht genug Parameterausdrücke"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "Der abgeleitete Parameter %qs bei %C hat keinen Vorgabewert"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Der Typparameterausdruck bei %L muss vom Typ INTEGER sein, nicht %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "Der Parameterausdruck bei %C muss vom Typ INTEGER sein, nicht %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "Der Parameterausdruck bei %C lässt sich nicht zu einer INTEGER-Konstante vereinfachen"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr "Der KIND-Parameter %qs bei %C darf weder ASSUMED noch DEFERRED sein"
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "Der Wert für den KIND-Parameter %qs bei %C lässt sich nicht auf einen konstanten Ausdruck reduzieren"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr "Die Typparameter-Angabenliste bei %C enthält zu viele Parameterausdrücke"
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "Der parametrisierte abgeleitete Typ bei %C ist mehrdeutig"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "BYTE-Typ bei %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "Bei %C verwendeter BYTE-Typ ist auf der Zielmaschine nicht verfügbar"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Vermuteter Typ bei %C ist für Komponenten nicht erlaubt"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "Vermuteter Typ bei %C"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "TYPE mit intrinsischer Typspezifikation bei %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "Falsch geformte Typspezifikation bei %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "DOUBLE COMPLEX bei %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Typname %qs bei %C ist mehrdeutig"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "CLASS-Anweisung bei %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "Typname %qs bei %C in Konflikt mit vorher deklarierter Entität bei %L, die den gleichen Namen hat"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr "Der Typ %qs ist nicht parametrisiert, daher darf die Typparameterspezifikationsliste bei %C nicht erscheinen"
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Doppelte IMPLICIT NONE-Anweisung bei %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "IMPLICIT NONE mit Angabenliste bei %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Fehlender Zeichenbereich in IMPLICIT bei %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Buchstaben in IMPLICIT-Anweisung bei %C müssen in alphabetischer Reihenfolge sein"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "IMPLICIT-Anweisung bei %C folgt auf IMPLICIT NONE (Typ-)Anweisung"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Leere IMPLICIT-Anweisung bei %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "IMPORT-Anweisung bei %C ist nur in einem INTERFACE-Körper erlaubt"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "F2008: C1210 IMPORT-Anweisung bei %C ist im Körper einer Schnittstelle für Modulprozedur nicht erlaubt"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "IMPORT-Anweisung bei %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr "Import-Name %qs bei %C ist im lokalen Gültigkeitsbereich"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "IMPORT %qs aus Host-Sichtbarkeitseinheit bei %C nicht möglich - existiert nicht."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "%qs bereits aus Host-Sichtbarkeitseinheit bei %C IMPORTiert"
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Syntaxfehler in IMPORT-Anweisung bei %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "F2018: C897 Die IMPORT-Anweisung bei %C darf nicht in einem Hauptprogramm, einem externen Unterprogramm, einem Modul oder Blockdaten vorkommen"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr "F2018: C898 IMPORT-Anweisung bei %C ist nicht erlaubt, da eine Bereichseinheit eine ONLY-Angabe hat und nur IMPORT eine ONLY-Angabe haben kann"
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr "F2018: C899 IMPORT, NONE darf nicht in der Scoping-Einheit eines Submoduls wie bei %C vorkommen"
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "F2018: C8100 IMPORT-Anweisung bei %C ist nicht erlaubt, da %s bereits deklariert wurde und in der Gültigkeitsbereichseinheit eindeutig sein muss"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Liste benannter Entitäten bei %C erwartet"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Fehlende Kodimensionsangabe bei %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Fehlende Dimensionsangabe bei %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Doppeltes Attribut %s bei %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s bei %L ist eine DEC-Erweiterung, muss mit %<-fdec-static%> eingeschaltet werden"
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Attribut ALLOCATABLE bei %C in einer TYPE-Definition"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Attribut ALLOCATABLE bei %C in einer STRUCTURE-Definition"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "KIND-Attribut bei %C in einer TYPE-Definition"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "KIND-Attribut bei %C in einer STRUCTURE-Definition"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "Komponente mit KIND-Attribut bei %C muss ein INTEGER sein"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "LEN-Attribut bei %C in einer TYPE-Definition"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "LEN-Attribut bei %C in einer STRUCTURE-Definition"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "Komponente mit LEN-Attribut bei %C muss INTEGER sein"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Attribut bei %L ist in TYPE-Definition nicht erlaubt"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Attribut bei %L ist in STRUCTURE-Definition nicht erlaubt"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Attribut %s bei %L in einer TYPE-Definition"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "Attribut %s bei %L ist außerhalb des Spezifikationsabschnitts eines Moduls nicht erlaubt"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "Attribut bei %L ist außerhalb einer TYPE-Definition nicht erlaubt"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "ASYNCHRONOUS-Attribut bei %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "CONTIGUOUS-Attribut bei %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "PROTECTED bei %C nur in Spezifikationsabschnitts eines Moduls erlaubt"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "PROTECTED-Attribut bei %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "VALUE-Attribut bei %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "VOLATILE-Attribut bei %C"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr "match_attr_spec(): Bad attribute"
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Mehrere Bezeichner mit einzelner Spezifikation NAME= bei %C angegeben"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "Implizit deklarierte BIND(C)-Funktion %qs bei %L ist möglicherweise nicht interoperabel mit C"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "Variable %qs in gemeinsamem Block %qs bei %L könnte inkompatibel mit C sein, obwohl gemeinsamer Block %qs BIND(C) ist"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "Typdeklaration %qs bei %L ist nicht C-kompatibel, aber sie ist BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "Variable %qs bei %L könnte mit C inkompatibel sein, aber sie ist BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "Variable %qs in gemeinsamem Block %qs bei %L kann nicht mit BIND(C) deklariert werden, da sie nicht global ist"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Variable %qs bei %L kann nicht gleichzeitig die Attribute POINTER und BIND(C) haben"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "Variable %qs bei %L kann nicht gleichzeitig die Attribute ALLOCATABLE und BIND(C) haben"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Rückgabetyp der BIND(C)-Funktion %qs bei %L kann kein Feld sein"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Rückgabetyp der BIND(C)-Funktion %qs von Zeichentyp bei %L muss die Länge 1 haben"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "Symbol %qs bei %L ist als PRIVATE markiert, ist aber über den Standardbindungsnamen %qs zugreifbar"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Entweder Entität oder Name eines gemeinsamen Blocks für Attribut-Spezifikationsanweisung bei %C erforderlich"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Entität oder Name eines gemeinsamen Blocks für Attribut-Spezifikationsanweisung bei %C fehlt"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Fehlendes Symbol"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "BIND(C)-Anweisung bei %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "CLASS-Entität bei %C kann nicht das PARAMETER-Attribut haben"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Abgeleiteter Typ bei %C wurde vorher nicht definiert und kann daher nicht in einer abgeleiteten Typdefinition auftreten"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Syntaxfehler in anonymer Struktur-Deklaration bei %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Syntaxfehler in Daten-Deklaration bei %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "MODULE-Präfix bei %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "MODULE-Präfix bei %C muss innerhalb eines Moduls, Teilmoduls oder Interfaces sein"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "IMPURE-Prozedur bei %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE und IMPURE dürfen bei %C nicht gleichzeitig stehen"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "ELEMENTAL-Präfix fehlt in MODULE-PROCEDURE-Schnittstelle bei %L"
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "PURE-Präfix fehlt in MODULE-PROCEDURE-Schnittstelle bei %L"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "RECURSIVE-Präfix fehlt in MODULE-PROCEDURE-Schnittstelle bei %L"
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "Bei %C wird eine Typparameterliste erwartet"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "Argument für Alternativrückgabe bei %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "Bei %C wird ein Parametername erwartet"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Name %qs bei %C ist der Name der Prozedur"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Parameterliste in Typdeklaration bei %C erwartet"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Unerwartete Angaben in formaler Argumentliste bei %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Doppelter Name %qs in Parameterliste bei %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Doppeltes Symbol %qs in formaler Argumentliste bei %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "Formales Argument %qs für MODULE PROCEDURE widerspricht alternativer Rückgabe bei %C"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr "Formales Argument für MODULE PROCEDURE ist alternative Rückgabe und widerspricht %qs in der separaten Deklaration bei %C"
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr "Konflikt in formalen Argumentnamen (%s/%s) von MODULE PROCEDURE bei %C"
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Konflikt in Anzahl der formalen Argumente von MODULE PROCEDURE bei %C"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "RESULT-Variable bei %C muss vom Funktionsnamen verschieden sein"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Unerwartete Angaben hinter Funktionsdeklaration bei %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "BIND(C)-Attribut bei %L kann nicht für eine interne Prozedur angegeben werden"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "BIND(C)-Attribut bei %C erfordert eine Schnittstelle mit BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "BIND(C)-Prozedur mit NAME darf kein POINTER-Attribut bei %C haben"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Scheinprozedur bei %C kann kein BIND(C)-Attribut mit NAME haben"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Prozedur %qs bei %L hat bereits grundlegenden Typen %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Syntaxfehler in PROCEDURE-Anweisung bei %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "%<::%> nach Bindeattributen bei %C erwartet"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "NOPASS oder explizite Schnittstelle bei %C erforderlich"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Prozedurzeiger-Komponente bei %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Syntaxfehler in Prozedurzeiger-Komponente bei %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE bei %C muss in einer allgemeinen Schnittstelle sein"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "»::« in MODULE PROCEDURE-Anweisung bei %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "PROCEDURE-Anweisung bei %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Formale Argumentliste in Funktionsdefinition bei %C erwartet"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "BIND(C)-Attribut bei %L kann nur für Variablen oder gemeinsame Blöcke verwendet werden"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr "Unverträglichkeit in BIND(C)-Namen (%qs/%qs) bei %C"
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "ENTRY-Anweisung bei %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines PROGRAMmes auftreten"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines MODULEs auftreten"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines SUBMODULEs auftreten"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb von BLOCK DATA auftreten"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb von INTERFACE auftreten"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines STRUCTURE-Blockes auftreten"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines DERIVED TYPE Blockes auftreten"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines IF-THEN-Blockes auftreten"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines DO-Blockes auftreten"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines SELECT-Blockes auftreten"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines FORALL-Blockes auftreten"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines WHERE-Blockes auftreten"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "ENTRY-Anweisung bei %C kann nicht innerhalb eines enthaltenen Subprogrammes auftreten"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Unerwartete ENTRY-Anweisung bei %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "ENTRY-Anweisung bei %C kann nicht in einer enthaltenen Prozedur auftreten"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Erforderte Klammern vor BIND(C) bei %C fehlen"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "ENTRY-Anweisung bei %L mit BIND(C) ist in einer elementaren Prozedur verboten"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "Alternatives Rückgabe-Dummyargument kann nicht in einer SUBROUTINE mit BIND(C)-Attribut bei %L auftreten"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Ungültiger C-Name in NAME=-Spezifizierung bei %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Syntaxfehler in NAME=-Spezifikation für Bindungsmarke bei %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "Spezifikation NAME= bei %C sollte ein konstanter Ausdruck sein"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr "NAME=-Angabe bei %C sollte ein Skalar der Standardzeichenart sein"
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Schließende Klammer für Bindungsmarke bei %C fehlt"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "In BIND(C) bei %C ist kein bindender Name erlaubt"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "For Schein-Prozedur %s in BIND(C) bei %C ist kein bindender Name erlaubt"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "NAME nicht erlaubt bei BIND(C) für ABSTRACT INTERFACE bei %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Unerwartete END-Anweisung bei %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "END-Anweisung statt %s-Anweisung bei %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "%s-Anweisung bei %L erwartet"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "»%s«-Anweisung bei %L erwartet"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Blocknamen von %qs in »%s«-Anweisung bei %L erwartet"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Beendenden Namen bei %C erwartet"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Marke %qs für »%s«-Anweisung bei %C erwartet"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Fehlende Feldspezifikation bei %L in DIMENSION-Anweisung"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Für %s bei %L wurden Dimensionen nach dessen Initialisierung angegeben"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Feldspezifikation bei %L in CODIMENSION-Anweisung fehlt"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Feldspezifikation muss bei %L aufgeschoben werden"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Unerwartetes Zeichen in Variablenliste bei %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "%<(%> bei %C erwartet"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Variablennamen bei %C erwartet"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Cray-Zeiger bei %C muss eine Ganzzahl sein"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Cray-Zeiger bei %C hat %d Bytes Genauigkeit; Speicheradressen benötigen %d Bytes"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "»,« bei %C erwartet"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "Interner Fehler: Cannot set Cray pointee array spec."
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Doppelte Feldspezifikation für Cray-Zeigerende bei %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "»)« bei %C erwartet"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "%<,%> oder Ende der Anweisung bei %C erwartet"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT ist in BLOCK bei %C nicht erlaubt"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "OPTIONAL ist in BLOCK bei %C nicht erlaubt"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Cray-Zeiger-Deklaration bei %C benötigt den Schalter %<-fcray-pointer%>"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "CONTIGUOUS-Anweisung bei %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "Zugriffsspezifikation des Operators %s bei %C wurde bereits spezifiziert"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "Zugriffsspezifikation des Operators .%s. bei %C wurde bereits spezifiziert"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "PROTECTED-Anweisung bei %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Syntaxfehler in PROTECTED-Anweisung bei %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "PRIVATE-Anweisung bei %C ist nur in Spezifikationsteil eines Moduls erlaubt"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "PUBLIC-Anweisung bei %C ist nur in Spezifikationsteil eines Moduls erlaubt"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Variablennamen bei %C in PARAMETER-Anweisung erwartet"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Zeichen »=« in PARAMETER-Anweisung bei %C erwartet"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Ausdruck bei %C in PARAMETER-Anweisung erwartet"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Initialisierung einer bereits initialisierten Variablen bei %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr "PARAMETER ohne »()« bei %C"
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Unerwartete Zeichen in PARAMETER-Anweisung bei %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s bei %C ist eine DEC-Erweiterung, muss mit %<-fdec-static%> eingeschaltet werden"
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "In AUTOMATIC-Anweisung bei %C wird eine »entity-list« erwartet"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Syntaxfehler in AUTOMATIC-Anweisung bei %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "»entity-list« in STATIC-Anweisung bei %C erwartet"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Syntaxfehler in STATIC-Anweisung bei %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Umfassende SAVE-Anweisung bei %C folgt vorheriger SAVE-Anweisung"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "SAVE-Anweisung bei %C folgt umfassender SAVE-Anweisung"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "SAVE des COMMON-Blocks %qs bei %C ist in einem BLOCK-Konstrukt nicht erlaubt"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Syntaxfehler in SAVE-Anweisung bei %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "VALUE ist in BLOCK bei %C nicht erlaubt"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "VALUE-Anweisung bei %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Syntaxfehler in VALUE-Anweisung bei %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "VOLATILE-Anweisung bei %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "VOLATILE für Coarray-Variable %qs bei %C angegeben, die use-/host-assoziiert ist"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Syntaxfehler in VOLATILE-Anweisung bei %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "ASYNCHRONOUS-Anweisung bei %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Syntaxfehler in ASYNCHRONOUS-Anweisung bei %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "MODULE-PROCEDURE-Deklaration bei %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE bei %C muss in einer generischen Modulschnittstelle sein"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "Intrinsische Prozedur bei %L kann keine MODULE PROCEDURE sein"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Mehrdeutiges Symbol in TYPE-Definition bei %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Symbol %qs bei %C wurde vorher noch nicht definiert"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "%qs in EXTENDS-Ausdruck bei %C ist kein abgeleiteter Typ"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "%qs kann bei %C nicht erweitert werden, da es BIND(C) ist"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qs kann bei %C nicht erweitert werden, da es ein SEQUENCE-Typ ist"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Abgeleiteter Typ bei %C kann nur PRIVATE im Spezifikationsteil eines Moduls sein"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Abgeleiteter Typ bei %C kann nur PUBLIC im Spezifikationsteil eines Moduls sein"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "ABSTRACT-Typ bei %C"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Failed to create structure type '%s' at %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Typdefinition von %qs bei %C wurde bereits bei %L definiert"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "Ausschuss hinter MAP-Anweisung bei %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Ausschuss hinter UNION-Anweisung bei %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%s bei %C ist eine DEC-Erweiterung, muss mit %<-fdec-structure%> eingeschaltet werden"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Strukturname erwartet in unverschachtelter Strukturdeklaration bei %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Ausschuss hinter unverschachtelter STRUCTURE-Anweisung bei %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Strukturname %qs bei %C kann nicht der gleiche wie ein intrinsischer Typ sein"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "»::« in TYPE-Definition bei %C erwartet"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "Gemangelte abgeleitete Typdefinition bei %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Typname %qs bei %C kann nicht der gleiche wie ein intrinsischer Typ sein"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Abgeleiteter Typname %qs bei %C hat bereits einen Basistypen von %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Abgeleiteter Typname %qs bei %C hat bereits einen Basistyp"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Scheinargument %qs bei %L darf kein abgeleiteter Typ bei %C sein"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "Abgeleitete Typdefinition von %qs bei %C wurde bereits definiert"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Syntaxfehler hinter PARAMETERIZED-TYPE-Deklaration bei %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Cray-Zeigerende bei %C kann nicht Feld mit impliziter Form sein"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "ENUM und ENUMERATOR bei %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Zähler übersteigt den C-Ganzzahltyp bei %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L nicht mit Ganzzahlausdruck initialisiert"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "Anweisung zur ENUM-Definition vor %C erwartet"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Syntaxfehler in ENUMERATOR-Definition bei %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Doppelte Zugriffsspezifikation bei %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Bindeattribute legen bereits Durchleitung fest, unzulässiges NOPASS bei %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Bindeattribute legen bereits Durchleitung fest, unzulässiges PASS bei %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Doppeltes POINTER-Attribut bei %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Doppeltes NON_OVERRIDABLE bei %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "Doppeltes DEFERRED bei %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Zugriffsspezifikation bei %C erwartet"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Bindeattribut bei %C erwartet"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE und DEFERRED können nicht gleichzeitig bei %C auftreten"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "POINTER-Attribut ist für Prozedurzeiger-Komponente bei %C erforderlich"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Schnittstellenname nach %<(%> bei %C erforderlich"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "%<)%> bei %C erwartet"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Schnittstelle muss für DEFERRED-Bindung bei %C angegeben werden"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDURE(Schnittstelle) bei %C sollte als DEFERRED deklariert sein"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Bindungsname bei %C erwartet"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "PROCEDURE-Liste bei %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%<=> target%> ist ungültig für DEFERRED-Bindung bei %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "%<::%> in PROCEDURE-Bindung mit explizitem Ziel bei %C erforderlich"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Bindungsziel hinter %<=>%> bei %C erforderlich"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "Typ %qs mit DEFERRED-Bindung bei %C ist nicht ABSTRACT"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Es gibt bereits eine Prozedur mit Bindungsname %qs für den abgeleiteten Typ %qs bei %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "%<::%> bei %C erwartet"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Generischer Name oder Operatordeskriptor bei %C erwartet"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Kaputte GENERIC-Anweisung bei %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "%<=>%> bei %C erwartet"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr "Die Zugriffsangabe bei %L ist nicht in einem Modul"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr "Der Generic-Spec-Name %qs bei %C widerspricht dem Namen der bei %L deklarierten Entität, die keine Prozedur ist"
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Es gibt bereits eine nicht-generische Prozedur namens %qs bei %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "Die Zugriffsangabe bei %L widerspricht der bereits für %qs angegebenen"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "Die Zugriffsangabe bei %L wiederholt die bereits für %qs angegebene"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr "Das generic-spec in der generischen Anweisung bei %C hat einen Typ aus der Deklaration bei %L"
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "Der benutzerdefinierte Operator bei %L muss dieselbe Zugriffsangabe wie der bereits definierte benutzerdefinierte Operator %qs haben"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr "Der Benutzeroperator bei %L wiederholt die Zugriffsangabe des bereits definierten Benutzeroperators %qs"
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr "Ein spezifischer Prozedurname wird bei %C erwartet"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr "Der Name %qs der spezifischen Prozedur bei %C widerspricht dem der generic-spec"
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%qs ist bereits als spezifische Prozedur für das generische %qs bei %C definiert"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "Ausschuss hinter GENERIC-Anweisung bei %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "GENERIC bei %C muss innerhalb eines CONTAINS eines abgeleiteten Typs sein"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Es gibt bereits eine nicht-generische Prozedur mit Bindungsname %qs für den abgeleiteten Typ %qs bei %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "Bindung bei %C muss denselben Zugriff wie bereits definierte Bindung %qs haben"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Spezifischer Bindungsname bei %C erwartet"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%qs bereits als spezifische Bindung für das generische %qs bei %C definiert"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Ausschuss hinter GENERIC-Bindung bei %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "FINAL-Deklaration bei %C muss innerhalb eines CONTAINS-Abschnitts eines abgeleiteten Typs stehen"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "Deklaration abgeleiteten Typs mit FINAL bei %C muss im Spezifikationsteil eines Moduls sein"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "Leeres FINAL bei %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Prozedurname im Modul bei %C erwartet"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "%<,%> bei %C erwartet"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Unbekannter Prozedurname %qs bei %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "%qs bei %C ist bereits als FINAL-Prozedur definiert"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Unbekanntes Attribut in !GCC$ ATTRIBUTES-Anweisung bei %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Syntaxfehler in !GCC$ ATTRIBUTES-Anweisung bei %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr "Direktive %<GCC unroll%> verlangt eine konstante Anzahl (maximal %u), bei %C"
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Syntaxfehler in !GCC$-UNROLL-Direktive bei %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Syntaxfehler in !GCC$-IVDEP-Direktive bei %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Syntaxfehler in !GCC$-VECTOR-Direktive bei %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "Syntaxfehler in !GCC$-NOVECTOR-Direktive bei %C"
@@ -76952,413 +77104,413 @@ msgstr "RE-part_ref bei %C"
 msgid "IM part_ref at %C"
 msgstr "IM-part_ref bei %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "elementare Funktionsargumente bei %C sind nicht konform"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Numerische oder CHARACTER-Operanden benötigt in Ausdruck bei %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Verkettungsoperator in Ausdruck bei %L muss zwei CHARACTER-Operanden haben"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Verkettungsoperator bei %L muss Zeichenketten der gleichen Sorte verketten"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ".NOT.-Operator in Ausdruck bei %L muss einen LOGICAL-Operanden haben"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "LOGICAL-Operanden werden in Ausdruck bei %L benötigt"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Nur intrinsische Operatoren können in Ausdruck bei %L verwendet werden"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "In Ausdruck bei %L werden numerische Operanden benötigt"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Ungültiger Initialisierungsausdruck für ALLOCATABLE-Komponente %qs in Strukturkonstruktor bei %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Variable %qs mit vermuteter oder aufgeschobener Zeichenlänge in konstantem Ausdruck bei %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "Transformierende intrinsische Routine %qs bei %L ist in einem Initialisierungs-Ausdruck nicht erlaubt"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Auswertung des nicht standardisierten Initialisierungsausdrucks bei %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "Funktion %qs in Initialisierungs-Ausdruck bei %L muss eine intrinsische Funktion sein"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "Intrinsische Funktion %qs bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "PARAMETER %qs wird bei %L verwendet, bevor dessen Definition vollständig ist"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "Feld %qs mit vermuteter Größe bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89938
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Feld %qs mit vermuteter Form bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89938
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Feld %qs mit vermuteter Form bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "Aufgeschobenes Feld %qs bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Feld %qs bei %L ist eine Variable, die nicht zu konstantem Ausdruck reduziert"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89938
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "Feld %qs mit vermutetem Rang bei %L ist nicht in einem Initialisierungs-Ausdruck erlaubt"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Parameter %qs bei %L wurde nicht deklariert oder ist eine Variable, die nicht zu konstantem Ausdruck reduziert"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "check_init_expr(): Unknown expression type"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Spezifikationsfunktion %qs bei %L kann keine Anweisungsfunktion sein"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Spezifikationsfunktion %qs bei %L kann keine interne Funktion sein"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Spezifikationsfunktion %qs bei %L muss PURE sein"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Spezifikationsfunktion %qs bei %L kann nicht RECURSIVE sein"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Scheinargument %qs ist im Ausdruck bei %L nicht erlaubt"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Scheinargument %qs bei %L kann nicht OPTIONAL sein"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Scheinargument %qs bei %L kann nicht INTENT(OUT) sein"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Variable %qs kann nicht im Ausdruck bei %L auftreten"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "check_restricted(): Unknown expression type"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Ausdruck bei %L muss INTEGER-Typ haben, %s gefunden"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "Funktion %qs bei %L muss PURE sein"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Ausdruck bei %L muss skalar sein"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr "Interner Fehler: optype_msgid overflow: %d"
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Unverträgliche Ränge in %s (%d und %d) bei %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Andere Form für %s bei %L für Dimension %d (%d und %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "Unpassige Typparameter %qs(%d/%d) %s bei %L/%L"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "Die Zuweisung zu einer KIND- oder LEN-part_ref bei %L ist nicht erlaubt"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs bei %L ist kein VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Unzulässige Zuweisung an externe Prozedur bei %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Unverträgliche Ränge %d und %d in Zuweisung bei %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Unbekannter Variablentyp in Zuweisung bei %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "Auf rechter Seite in Zuweisung bei %L tritt NULL auf"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "POINTER-wertige Funktion tritt auf rechter Seite der Zuweisung bei %L auf"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr "BOZ-Literalkonstante in der Nähe von %L kann nicht einer %qs-Variablen zugewiesen werden"
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "Die Zuweisung zu einer KIND- oder LEN-Komponente eines parametrisierten Typs bei %L ist nicht erlaubt"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Unverträgliche Typen in DATA-Anweisung bei %L; versuchte Umwandlung von %s an %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Zeiger-Zuweisungsziel ist kein POINTER bei %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "%qs in Zeigerzuweisung bei %L kann kein L-Wert sein, da es eine Prozedur ist"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Grenzen für %qs bei %L erwartet"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Grenzenangabe für %qs in Zeigerzuweisung bei %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "Bei %L darf kein Schritt vorhanden sein"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Das Umordnen des Rangs erfordert eine Liste von %<untere-Grenze : obere-Grenze%>-Angaben bei %L"
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Liste von %<untere-Grenze :%> oder Liste von %<untere-Grenze : obere-Grenze%>-Angaben bei %L erwartet"
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Zeigerobjekt bei %L darf keinen Koindex haben"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Ungültige Zuweisung eines Prozedurzeigers bei %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Funktionsergebnis %qs ist als Prozedurziel in Zuweisung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Abstrakte Schnittstelle %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Anweisungsfunktion %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Interne Prozedur %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Eingebautes %qs bei %L ist in Zuweisung des Prozedurzeigers ungültig"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Nichtintrinsische elementare Prozedur %qs ist in Zuweisung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "Unpassende Zuweisung des Prozedurzeigers bei %L: Unpassende Aufrufkonvention"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Unpassende Schnittstellen bei Zuweisung des Prozedurzeigers bei %L: %qs ist kein Unterprogramm"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Explizite Schnittstelle für Komponente %qs bei %L erforderlich: %s"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Explizite Schnittstelle für %qs bei %L erforderlich: %s"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Unpassende Schnittstellen bei Zuweisung des Prozedurzeigers bei %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr "Prozedurzeigerziel %qs bei %L muss entweder eine intrinsische Funktion, host- oder use-assoziiert oder referenziert sein, oder aber das EXTERNAL-Attribut haben"
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Zeiger-Zuweisungsziel darf keine Konstante sein bei %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr "Datenzeigerobjekt bei %L muss unbegrenzt polymorph oder von einem Typ mit BIND- oder SEQUENCE-Attribut sein, um zum unbegrenzt polymorphen Ziel zu passen"
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Verschiedene Typen in Zeigerzuweisung bei %L; Versuch der Zuweisung von %s an %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Parameter verschiedener Typen in Zeigerzuweisung bei %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Verschiedene Ränge in Zeigerzuweisung bei %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "Ziel der Rang-Neuzuordnung ist kleiner als die Größe des Zeigers (%ld < %ld) bei %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr "Das angenommene Rangziel bei %L ist ein experimentelles Merkmal von F202y. Verwenden Sie die Option »-std=f202y« zum Einschalten"
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "Ziel der Rang-Neuzuordnung muss Rang 1 oder einfach fortlaufend bei %L sein"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Ziel der Rang-Neuzuordnung ist nicht Rang 1 bei %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr "Das data-target bei %L ist ein Objekt von angenommenem Rang, daher muss das data-pointer-object %s eine Liste zur Neuzuordnung der Grenzen haben (Liste von lbound:ubound für jede Dimension)"
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "Das angenommene Rangdaten-Ziel bei %L muss zusammenhängend sein"
@@ -77366,197 +77518,197 @@ msgstr "Das angenommene Rangdaten-Ziel bei %L muss zusammenhängend sein"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "Datenziel bei %L darf keinen Koindex haben"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "Zielausdruck in Zeigerzuweisung bei %L muss ein Zeigerergebnis liefern"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr "Array der Größe 0 bei %L gefunden, an dieser Stelle wird eine Entität mit TARGET-Attribut erwartet"
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "Ziel der Zeigerzuweisung in Initialisierungsausdruck bei %L muss das TARGET-Attribut haben"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Jeder Feldindex der Zielspezifikation bei %L muss ein konstanter Ausdruck sein"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr "Start- und Endposition der Teilzeichenkette der Zielspezifikation bei %L müssen konstante Ausdrücke sein"
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Zeiger-Zuweisungsziel bei %L ist weder TARGET noch POINTER"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Falsches Ziel in Zeigerzuweisung in PURE-Prozedur bei %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Zeigerzuweisung mit Vektorindex für rhs bei %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Zeiger-Zuweisungsziel hat PROTECTED-Attribut bei %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr "Zuweisung an zusammenhängenden Zeiger von nichtzusammenhängendem Ziel bei %L"
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "Zeiger bei %L in Zeigerzuweisung könnte Zeigerziel überdauern"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr "Die Komponente %qs bei %L vom abgeleiteten Typ %qs hat parametrisierte Typ- oder Arraylängenparameter, und das ist nicht mit einem Standardinitialisierer kompatibel"
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "Ziel der Zeigerinitialisierung bei %L darf nicht ALLOCATABLE sein"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "Ziel der Zeigerinitialisierung bei %L muss das TARGET-Attribut haben"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Ziel der Zeigerinitialisierung bei %L muss das SAVE-Attribut haben"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "Ziel der Zeigerinitialisierung für Prozedur bei %L darf kein Prozedurzeiger sein"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Interne Prozedur %qs ist in Initialisierung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Dummyprozedur %qs ist in Initialisierung des Prozedurzeigers bei %L ungültig"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr "Interner Fehler: generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008: Zeigerfunktionen in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Nicht-variabler Ausdruck in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "Benannte Konstante %qs in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%qs in Variablen-Definitionskontext (%s) bei %L ist keine Variable"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Nicht-POINTER in Zeiger-Verbindungskontext (%s) bei %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "Typ nicht zugreifbar in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "Parameterabfrage %qs für %qs in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "Scheinargument %qs mit INTENT(IN) in Zeiger-Verbindungskontext (%s) bei %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "Scheinargument %qs mit INTENT(IN) in Variablen-Definitionskontext (%s) bei %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Variable %qs ist PROTECTED und kann nicht in einem Zeigerzuordnungskontext (%s) bei %L vorkommen"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "Variable %qs ist PROTECTED und kann nicht in Variablen-Definitionskontext (%s) bei %L auftreten"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Variable %qs kann nicht in Variablen-Definitionskontext (%s) bei %L in PURE-Prozedur auftreten"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "%qs ist bei %L mit vektorindiziertem Ziel verbunden und kann nicht in Variablen-Definitionskontext (%s) verwendet werden"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "%qs ist bei %L mit Ausdruck verbunden und kann nicht in Variablen-Definitionskontext (%s) verwendet werden"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "%qs bei %L ist mit einer Zeigerfunktion verbunden, die in einem Variablendefinitionskontext verwendet wird (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Associate-Name %qs kann nicht in Variablen-Definitionskontext (%s) bei %L auftreten, da sein Ziel bei %L es auch nicht kann"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "Elemente mit demselben Wert bei %L und %L in Vektorindex in einem Variablen-Definitionskontext (%s)"
@@ -77577,7 +77729,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr "Illegal id in copy_walk_reduction_arg"
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -77638,43 +77790,43 @@ msgstr "Variable %qs bei %L wird auf undefinierten Wert gesetzt, innerhalb der b
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "Variable %qs bei %L kann nicht innerhalb der bei %L beginnenden Schleife als INTENT(INOUT)-Argument für Unterprogramm %qs definiert werden"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "Feldreferenz bei %L ist außerhalb der Grenzen (%ld < %ld) in Schleife, die bei %L beginnt"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "Feldreferenz bei %L ist außerhalb der Grenzen (%ld > %ld) in Schleife, die bei %L beginnt"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "Variable %qs bei %L auf undefinierten Wert innerhalb der bei %L beginnenden Schleife gesetzt, als INTENT(OUT)-Argument für Funktion %qs"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "Variable %qs bei %L kann nicht innerhalb der bei %L beginnenden Schleife als INTENT(INOUT)-Argument für Funktion %qs definiert werden"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr "Code zur Neu-Reservierung des reservierbaren Feldes bei %L wird hinzugefügt"
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr "Scalarization using DIMEN_RANGE unimplemented"
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr "Schleifen bei %L werden getauscht"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99302
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "%s zwischen %L und %L"
@@ -77799,12 +77951,12 @@ msgstr "Erstes Argument der definierten Zuweisung bei %L muss INTENT(OUT) oder I
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Zweites Argument der definierten Zuweisung bei %L muss INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Erstes Argument der Operatorschnittstelle bei %L muss INTENT(IN) sein"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Zweites Argument der Operatorschnittstelle bei %L muss INTENT(IN) sein"
@@ -78230,312 +78382,317 @@ msgstr "Effektives Argument für %qs muss ALLOCATABLE bei %L sein"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr "Das tatsächliche Argument für %qs bei %L ist ein Funktionsergebnis und das Dummy-Argument ist ALLOCATABLE"
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "Feldbereich mit Vektorindex als effektives Argument bei %L ist unverträglich mit INTENT(OUT), INTENT(INOUT), VOLATILE- und ASYNCHRONOUS-Attribut des Scheinarguments %qs"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Effektives Argument mit vermuteter Form bei %L ist wegen VOLATILE-Attribut unverträglich mit dem Scheinargument ohne vermutete Form %qs"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Feldbereich als effektives Argument bei %L ist wegen VOLATILE-Attribut unverträglich mit dem Scheinargument ohne vermutete Form %qs"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "Zeigerfeld als effektives Argument bei %L erfordert wegen VOLATILE-Attribut ein Scheinargument %qs mit vermuteter Form oder als Zeigerfeld"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "Das tatsächliche Argument der ISO_C_BINDING-Funktion an Position %L erfordert, dass das Dummy-Argument %qs einen passenden Typ gemäß ISO_C_BINDING hat"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Fehlende alternative Rückgabespezifikation in Unterprogrammaufruf bei %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Fehlendes effektives Argument für Argument %qs bei %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "compare_actual_expr(): Bad component code"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr "check_some_aliasing(): List mismatch"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr "check_some_aliasing(): corrupted data"
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Gleiches effektives Argument mit INTENT(%s)-Argument %qs und INTENT(%s)-Argument %qs bei %L verbunden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr "check_intents(): List mismatch"
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Prozedurargument bei %L ist lokal für PURE-Prozedur und hat das POINTER-Attribut"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Effektives koindiziertes Argument bei %L in PURE-Prozedur wird an INTENT(%s)-Argument übergeben"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Effektives koindiziertes Argument bei %L in PURE-Prozedur wird an POINTER-Scheinargument übergeben"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Koindiziertem polymorphen effektiven Argument bei %L wird polymorphes Scheinargument %qs übergeben"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Prozedur %qs, die bei %L aufgerufen wird, ist nicht explizit deklariert; meinen Sie %qs?"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Prozedur %qs, die bei %L aufgerufen wird, ist nicht explizit deklariert"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Prozedur %qs mit einer impliziten Schnittstelle bei %L aufgerufen"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Das Zeigerobjekt %qs bei %L muss eine explizite Funktionsschnittstelle haben oder als Feld deklariert sein"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Das reservierbare Objekt %qs bei %L muss eine explizite Funktionsschnittstelle haben oder als Feld deklariert sein"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Reservierbare Funktion %qs bei %L muss eine explizite Funktionsschnittstelle haben"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Explizite Schnittstelle für polymorphes Argument bei %L erforderlich"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Schlüsselwort-Argument erfordert explizite Schnittstelle für Prozedur %qs bei %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Argument »%s« bei %L vermuteten Typs erfordert eine explizite Schnittstelle"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Effektives Argument mit LOCK_TYPE oder mit LOCK_TYPE-Komponente bei %L erfordert eine explizite Schnittstelle für Prozedur %qs"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Effektives Argument mit EVENT_TYPE oder mit EVENT_TYPE-Komponente bei %L erfordert eine explizite Schnittstelle für Prozedur %qs"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "MOLD-Argument an NULL bei %L erforderlich"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Das Übergeben des eingebauten NULL als tatsächliches Argument bei %L erfordert eine explizite Schnittstelle"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Argument vermuteten Ranges erfordert eine explizite Schnittstelle bei %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Prozedurzeiger-Komponente %qs mit einer impliziten Schnittstelle bei %L aufgerufen"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "Schlüsselwortargument erfordert explizite Schnittstelle für Prozedurzeigerkomponente %qs bei %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "In NULL()-Argument bei %L wird MOLD= benötigt: Mehrdeutig zwischen spezifischen Funktionen %s und %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "Symbol %qs kann nicht gefunden werden"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Entität %qs bei %L ist bereits in der Schnittstelle vorhanden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "gfc_add_interface(): Bad interface type"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "GENERIC %qs bei %L kann nicht überschrieben werden"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%qs bei %L überschreibt eine Prozedurbindung, die als NON_OVERRIDABLE deklariert ist"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "%qs bei %L darf nicht DEFERRED sein, da es eine Nicht-DEFERRED-Bindung überschreibt"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%qs bei %L überschreibt eine PURE-Prozedur und muss auch PURE sein"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%qs bei %L überschreibt eine ELEMENTAL-Prozedur und muss auch ELEMENTAL sein"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%qs bei %L überschreibt eine Nicht-ELEMENTAL-Prozedur und darf ebenfalls nicht ELEMENTAL sein"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%qs bei %L überschreibt eine SUBROUTINE und muss auch eine SUBROUTINE sein"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%qs bei %L überschreibt eine FUNCTION und muss auch eine FUNCTION sein"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Unpassendes Ergebnis für die überschreibende Prozedur %qs bei %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%qs bei %L überschreibt eine PUBLIC-Prozedur und darf nicht PRIVATE sein"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "Scheinargument %qs von %qs bei %L sollte %qs genannt werden, um zum zugehörigen Argument der überschriebenen Prozedur zu passen"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Unpassende Argumente für die überschreibende Prozedur %qs bei %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "%qs bei %L muss die gleiche Anzahl formaler Argumente wie die überschriebene Prozedur haben"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%qs bei %L überschreibt eine NOPASS-Bindung und muss ebenfalls NOPASS sein"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%qs bei %L überschreibt eine Bindung mit PASS und muss ebenfalls PASS sein"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "Scheinargument des übergebenen Objektes von %qs bei %L muss an der gleichen Stelle wie das Scheinargument des übergebenen Objektes der überschriebenen Prozedur stehen"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "DTIO-Scheinargument bei %L muss vom Typ %s sein"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "DTIO-Scheinargument bei %L muss von KIND = %d sein"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "DTIO-Scheinargument bei %L muss ein Skalar sein"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "DTIO-Scheinargument bei %L muss ein ASSUMED SHAPE ARRAY sein"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "DTIO-Zeichenargument bei %L muss angenommene Länge haben"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "DTIO-Scheinargument bei %L muss INTENT %s haben"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "Alternativer Rücksprung bei %L ist in einer DTIO-Prozedur nicht erlaubt"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "DTIO-Prozedur %qs bei %L muss ein Unterprogramm sein"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Zu wenige Scheinargumente in DTIO-Prozedur %qs bei %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "Zu viele Scheinargumente in DTIO-Prozedur %qs bei %L"
@@ -78730,7 +78887,7 @@ msgstr "Umwandlung von %s in %s bei %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "%s kann nicht nach %s bei %L umgewandelt werden"
@@ -79276,7 +79433,7 @@ msgstr "NAMELIST %qs in READ-Anweisung bei %L enthält Symbol %qs, das im Kontex
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "NAMELIST-Objekt %qs in Namensliste %qs bei %L ist polymorph und erfordert eine definierte Ein-/Ausgabeprozedur"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "NAMELIST-Objekt %qs in Namensliste %qs bei %L mit ALLOCATABLE- oder POINTER-Komponenten"
@@ -79448,12 +79605,12 @@ msgstr "identifier overflow: %d"
 msgid "check_charlen_present(): length not set"
 msgstr "Interner Fehler: check_charlen_present(): length not set"
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr "GET_TEAM bei %L benötigt USE des intrinsischen Moduls ISO_FORTRAN_ENV, um seinen Ergebnistyp TEAM_TYPE zu definieren"
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
@@ -79957,7 +80114,7 @@ msgstr "STOP-Code bei %L muss Standardzeichentyp KIND=%d sein"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "STOP-Code bei %L muss Standardganzzahltyp KIND=%d sein"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "Der Spezifizierer QUIET bei %L muss ein skalarer LOGICAL sein"
@@ -80470,92 +80627,92 @@ msgstr "Blockname %qs des SELECT-Konstrukts bei %C erwartet"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "SELECT TYPE bei %C darf nicht in diesem Gültigkeitsbereich vorkommen"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Syntaxfehler in »SELECT TYPE«-Anweisung bei %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "Selektor in SELECT TYPE bei %C ist keine benannte Variable; associate-name=> verwendet"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "SELECT-RANK-Anweisung bei %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr "Der SELECT-RANK-Selektor bei %C muss eine angenommene Rangvariable sein"
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Syntaxfehler in SELECT-RANK-Anweisung bei %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Unerwartete CASE-Anweisung bei %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Syntaxfehler in CASE-Spezifikation bei %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Unerwartete TYPE IS-Anweisung bei %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr "Typspezifikation darf keinen Sequenz-abgeleiteten Typ oder Typ mit BIND-Attribut in SELECT TYPE bei %C beschreiben [F2003:C815]"
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr "Alle LEN-Typparameter in der TYPE-IS-Anweisung bei %C müssen ASSUMED sein"
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Syntaxfehler in TYPE IS-Spezifikation bei %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Syntaxfehler in CLASS IS-Spezifikation bei %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "Unerwartete RANK-Anweisung bei %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "Der SELECT-RANK-CASE-Ausdruck bei %C muss eine skalare, ganzzahlige Konstante sein"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr "Der Wert des SELECT-RANK-CASE-Ausdrucks bei %C darf nicht kleiner als Null oder größer als %d sein"
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "Syntaxfehler in RANK-Spezifikation bei %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "ELSEWHERE-Anweisung bei %C nicht eingeschlossen in WHERE-Block"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "Marke %qs bei %C passt nicht zur WHERE-Marke %qs"
@@ -81552,7 +81709,7 @@ msgstr "DEPEND-Klausel bei %L des OMP-DEPOBJ-Konstrukts darf nicht den Abhängig
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr "Die DEPEND-Klausel bei %L des OMP-DEPOBJ-Konstrukts darf nur einen einzigen Locator haben"
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "Die MESSAGE-Klausel bei %L erfordert einen skalaren CHARACTER-Ausdruck der Standardart"
@@ -81587,12 +81744,12 @@ msgstr "Liste wurde zusammen mit Speicherreihenfolge-Klausel angegeben, in FLUSH
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Unerwarteter Ausschuss inter $OMP FLUSH-Anweisung bei %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr "Redefinition der vordefinierten !$OMP DECLARE REDUCTION »%s« bei %L"
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr "Redefinition der vordefinierten !$OMP DECLARE REDUCTION bei %L"
@@ -82066,7 +82223,7 @@ msgstr "Unerwarteter Ausschuss hinter NOWAIT-Klausel bei %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "Klausel %s bei %L erfordert einen skalaren INTEGER-Ausdruck"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "INTEGER-Ausdruck von %s-Klausel bei %L muss positiv sein"
@@ -82086,7 +82243,7 @@ msgstr "Cray-Zeiger-Objekt von abgeleitetem Typ %qs in »%s«-Klausel bei %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Cray-Zeigerziel-Objekt %qs von abgeleitetem Typ in »%s«-Klausel bei %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "POINTER-Objekt %qs von polymorphem Typ in Klausel %s bei %L"
@@ -82116,17 +82273,17 @@ msgstr "Feld %qs mit vermutetem Rang in Klausel %s bei %L"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "POINTER-Objekt %qs in Klausel %s bei %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Cray-Zeiger-Objekt %qs in Klausel %s bei %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Cray-Zeigerziel-Objekt %qs in Klausel %s bei %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "ALLOCATABLE-Objekt %qs in Klausel %s bei %L"
@@ -82246,8 +82403,8 @@ msgstr "ORDERED-Parameter der Klausel bei %L ist weniger als COLLAPSE"
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "ORDER-Klausel bei %L darf nicht zusammen mit ORDERED verwendet werden"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "IF-Klausel bei %L erfordert einen skalaren LOGICAL-Ausdruck"
@@ -82327,7 +82484,7 @@ msgstr "Objekt %qs bei %L ist keine Variable; Parameter können nicht zugeordnet
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr "Die Klausel für das Objekt %qs bei %L wird ignoriert, da es ein Parameter ist"
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "Objekt %qs bei %L ist keine Variable"
@@ -82350,7 +82507,7 @@ msgstr "SCHEDULE-Klausel darf nicht zusammen mit %<inscan%>-REDUCTION-Klausel be
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "Symbol %qs bei %L in mehreren Klauseln vorhanden"
@@ -82390,7 +82547,7 @@ msgstr "Symbol %qs tritt bei %L sowohl in der DATA- als auch in der MAP-Klausel
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qs kommt mehr als einmal in %<allocate%> bei %L vor"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr "%qs ist in %<allocate%>-Klausel bei %L angegeben, aber nicht in einer expliziten Privatisierungs-Klausel"
@@ -82702,602 +82859,612 @@ msgstr "Nur DEFAULT ist als Reduktionsmodifizierer erlaubt, in der REDUCTION-Kla
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr "!$OMP DECLARE REDUCTION »%s« für Typ %s bei %L nicht gefunden"
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr "Sorry, das ALLOCATABLE-Objekt %qs in der LINEAR-Klausel des Worksharing-Loop-Konstrukts bei %L wird noch nicht unterstützt"
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr "Sorry, das Feld %qs in der LINEAR-Klausel im Worksharing-Loop-Konstrukt bei %L wird noch nicht unterstützt"
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr "LINEAR-Klauselmodifizierer wird bei %L an DO- oder SIMD-Konstrukt verwendet"
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr "LINEAR-Klauselmodifizierer außer VAL wird bei %L an DO- oder SIMD-Konstrukt verwendet"
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "LINEAR-Variable %qs bei %L muss INTEGER sein"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "LINEAR-Dummy-Argument %qs mit VALUE-Attribut mit %s-Modifizierer bei %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%qs in LINEAR-Klausel bei %L benötigt einen skalaren, ganzzahligen linear-step-Ausdruck"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%qs in LINEAR-Klausel bei %L benötigt einen konstanten, ganzzahligen linear-step-Ausdruck oder ein Dummy-Argument, das in der UNIFORM-Klausel angegeben ist"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "%s-Klausel-Variable %qs bei %L ist weder Zeiger- noch Feldtyp"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr "Untere Grenze von NUM_TEAMS bei %L ist größer als die obere Grenze bei %L"
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "Der Wert der HINT-Klausel bei %L muss ein gültiger konstanter Hinweisausdruck sein"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "Die chunk_size der DIST_SCHEDULE-Klausel bei %L erfordert einen skalaren INTEGER-Ausdruck"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "die %<GRAINSIZE%>-Klausel bei %L darf nicht zusammen mit der %<NUM_TASKS%>-Klausel verwendet werden"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "die %<REDUCTION%>-Klausel bei %L darf nicht zusammen mit der %<NOGROUP%>-Klausel verwendet werden"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "%<FULL%>-Klausel bei %C darf nicht zusammen mit %<PARTIAL%>-Klausel verwendet werden"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Unverträgliche Verwendung von TILE und COLLAPSE bei %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "TARGET DATA muss mindestens eine der Klauseln MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR enthalten, bei %L"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%s bei %L muss mindestens eine MAP-Klausel enthalten"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "SIZES bei %L erfordert konstanten Ausdruck"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr "%qs bei %L sollte ein Skalar vom Typ integer(kind=omp_event_handle_kind) sein"
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "Das Ereignishandle bei %L darf kein Element eines Feldes sein"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "Das Ereignishandle bei %L darf nicht Teil eines abgeleiteten Typs oder einer abgeleiteten Klasse sein"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "%<DETACH%>-Klausel bei %L darf nicht zusammen mit %<MERGEABLE%>-Klausel verwendet werden"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr "%<host_data%>-Konstrukt bei %L erfordert %<use_device%>-Klausel"
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr "IF bei %L erwartet, in atomarer Vergleichserfassung"
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr "ELSE bei %L erwartet, in atomarer Vergleichserfassung"
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr "Atomarer Vergleichsausdruck %<==%>, %<.EQ.%> oder %<.EQV.%> bei %L erwartet"
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr "Skalare intrinsische Variable bei %L erwartet, in atomarem Vergleich"
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Skalarer intrinsischer Ausdruck bei %L erwartet, in atomarem Vergleich"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "Anweisung !$OMP ATOMIC muss eine skalare Variable intrinsischen Typs bei %L setzen"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "Anweisung !$OMP ATOMIC muss einen skalaren Ausdruck intrinsischen Typs bei %L zuweisen"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "!$OMP ATOMIC mit ALLOCATABLE-Variable bei %L"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "Anweisung !$OMP ATOMIC READ muss bei %L von skalarer Variable intrinsischen Typs lesen"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "Ausdruck in !$OMP ATOMIC WRITE-Zuweisung »var = expr« muss skalar sein und kann keine Variable bei %L referenzieren"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "Erfassungsanweisung !$OMP ATOMIC bei %L muss eine skalare Variable intrinsischen Typs setzen"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "Erfassungsanweisung !$OMP ATOMIC bei %L erfordert eine skalare Variable intrinsischen Typs"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "!$OMP ATOMIC CAPTURE-Erfassungsanweisung liest bei %L von anderer Variable als die Update-Anweisung schreibt"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "Bei !$OMP ATOMIC COMPARE muss der erste Operand des Vergleichs bei %L die Variable %qs sein, in die die Aktualisierungsanweisung bei %L schreibt"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "Der Ausdruck bei %L in der !$OMP-ATOMIC-COMPARE-Zuweisung »Variable = Ausdruck« muss skalar sein und darf die Variable nicht referenzieren"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr "!$OMP ATOMIC UPDATE bei %L mit FAIL-Klausel erfordert entweder die COMPARE-Klausel oder die Verwendung der intrinsischen MIN/MAX-Prozedur"
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "Zuweisungsoperator »!$OMP ATOMIC« muss bei %L ein binäres +, *, -, /, .AND., .OR., .EQV. oder .NEQV. sein"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "Zuweisung !$OMP ATOMIC muss bei %L »var = var op expr« oder »var = expr op var« sein"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP ATOMIC »var op expr« bei %L ist nicht mathematisch äquivalent zu »var = var op (expr)«"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "Ausdruck in Zuweisung !$OMP ATOMIC »var = var op expr« muss skalar sein und kann keine Variable bei %L referenzieren"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "Eingebaute Zuweisung !$OMP ATOMIC IAND, IOR oder IEOR muss bei %L zwei Argumente haben"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "Eingebaute Zuweisung !$OMP ATOMIC muss bei %L MIN, MAX, IAND, IOR oder IEOR sein"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "Von den intrinsischen Argumenten für %<!$OMP ATOMIC%> bei %2$L darf höchstens eins auf %1$qs verweisen"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "!$OMP ATOMIC intrinsische Argumente müssen bei %L skalar sein"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Erstes oder letztes intrinsisches Argument zu !$OMP ATOMIC muss bei %2$L %1$qs sein"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "!$OMP ATOMIC Zuweisung muss auf der rechten Seite bei %L Operator oder Intrinsic haben"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Unerwarteter »!$OMP ATOMIC«Ausdruck bei %L"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr "Aufgrund des INSCAN bei %L wird ein Schleifenrumpf mit !$OMP SCAN zwischen zwei strukturierten Blockfolgen erwartet"
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr "!$OMP SCAN bei %L mit null ausführbaren Anweisungen in der vorangehenden strukturierten Blockfolge"
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr "!$OMP SCAN bei %L mit null ausführbaren Anweisungen in der darauffolgenden strukturierten Blockfolge"
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr "%s kann keine Schleife im dazwischenliegenden Code bei %L enthalten"
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr "%s kann keinen OpenMP-API-Aufruf im dazwischenliegenden Code bei %L enthalten"
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr "%s kann keine OpenMP-Direktive im dazwischenliegenden Code bei %L enthalten"
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr "Das Konstrukt !$OMP TILE bei %L erfordert eine SIZES-Klausel"
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%s kann weder DO WHILE noch DO sein, ohne Schleifensteuerung bei %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr "%s kann bei %L keine DO-CONCURRENT-Schleife sein"
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr "Die erzeugte Schleife des UNROLL-Konstrukts bei %L ohne PARTIAL-Klausel hat keine kanonische Form"
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr "UNROLL-Konstrukt bei %L mit PARTIAL-Klausel erzeugt nur eine Schleife mit kanonischer Form, aber %d Schleifen werden benötigt"
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr "TILE-Konstruktion bei %L erzeugt %d Schleifen mit kanonischer Form, aber %d Schleifen werden benötigt"
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr "Unvollkommen geschachtelte Schleife bei Verwendung von generierten Schleifen"
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "%s-Iterationsvariable bei %L muss vom Typ integer sein"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "%s-Iterationsvariable bei %L darf nicht THREADPRIVATE sein"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "%s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE oder ALLOCATE gefunden"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "%s-Iterationsvariable bei %L an anderer Klausel als PRIVATE, LASTPRIVATE, ALLOCATE oder LINEAR gefunden"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "%s-Iterationsvariable bei %L wird in mehr als einer Schleife verwendet"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "%s-Iterationsvariable bei %L ist im dazwischenliegenden Code gebunden"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr "Schleifenstartausdruck %s bei %L hat nicht die kanonische Form"
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr "%s-Schleifenstartausdruck bei %L verwendet im dazwischenliegenden Code gebundene Variable"
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "Endausdruck der »%s«-Schleife bei %L ist nicht in kanonischer Form"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr "Ausdruck %s bei %L für das Ende der Schleife verwendet eine im dazwischenliegenden Code gebundene Variable"
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "Grenzen der »%s«-Schleife bei %L verweisen auf unterschiedliche Iterationsvariablen"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr "Schleifeninkrement %s bei %L hat nicht die kanonische Form"
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr "%s-Schleifeninkrementausdruck bei %L verwendet eine im dazwischenliegenden Code gebundene Variable"
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr "Nichtrechteckige Schleifen aus generierten Schleifen werden nicht unterstützt"
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "zu wenige DO-Schleifen für zusammengefallenes %s (Stufe %d) bei %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79861
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "%s innere Schleifen müssen perfekt verschachtelt sein mit ORDERED-Klausel bei %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr "%s innere Schleifen müssen perfekt verschachtelt sein mit REDUCTION-INSCAN-Klausel bei %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79861
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "%s innere Schleifen bei %L müssen perfekt geschachtelt sein"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "Das %<score%>-Argument bei %L muss ein konstanter ganzzahliger Ausdruck sein"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "Das %<score%>-Argument bei %L darf nicht negativ sein"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "Eigenschaft bei %L muss ein logischer Ausdruck sein"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "Eigenschaft bei %L muss ein ganzzahliger Ausdruck sein"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "Eigenschaft bei %L muss ein konstanter logischer Ausdruck sein"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "Eigenschaft bei %L muss ein konstanter ganzzahliger Ausdruck sein"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr "Eigenschaft bei %L muss die Nummer eines konformen Geräts sein"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr "Die %1$s-Direktive bei %3$L darf nicht innerhalb einer %2$s-Region angegeben werden"
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$ACC LOOP darf ohne Schleifensteuerung bei %L kein DO WHILE oder DO sein"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "!$ACC LOOP kann bei %L keine DO-CONCURRENT-Schleife sein"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "!$ACC-LOOP-Iterationsvariable bei %L muss vom Typ integer sein"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "»%s !$ACC LOOP«-Schleifen bei %L formen keinen rechteckigen Wiederholungsraum"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79861
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "»%s !$ACC LOOP«-Schleifen bei %L nicht perfekt geschachtelt"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79861
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "zu wenige DO-Schleifen für »%s !$ACC LOOP« bei %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr "Gekachelte Schleife bei %L kann nicht über Gangs, Worker oder Vektoren übergreifend parallelisiert werden"
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "TILE bei %L erfordert konstanten Ausdruck"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "Objekt %qs bei %L wird ignoriert, da es nicht nötig ist, Parameter zu kopieren"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "Feldabschnitte: %qs ist in !$ACC DECLARE bei %L nicht erlaubt"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Name %qs verweist nicht auf eine Unterroutine oder Funktion in !$ACC ROUTINE ( NAME ) bei %L"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "NAME %qs ist in »!$ACC ROUTINE ( NAME )« bei %L ungültig"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "!$OMP-TARGET-Region bei %L mit einem verschachtelten TEAMS bei %L darf keine andere Anweisung, Deklaration oder Direktive außerhalb des einzelnen TEAMS-Konstrukts enthalten"
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "!$OMP-TARGET-Region bei %L mit einem verschachtelten TEAMS darf keine andere Anweisung, Deklaration oder Direktive außerhalb des einzelnen TEAMS-Konstrukts enthalten"
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr "Auf die Direktive %<OMP DISPATCH%> bei %L muss ein Prozeduraufruf mit optionaler Zuweisung folgen"
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr "Die Direktive %<OMP DISPATCH%> bei %L kann nicht von einem Prozedurzeiger gefolgt werden"
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr "OMP TARGET UPDATE bei %L erfordert mindestens eine TO- oder FROM-Klausel"
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr "OMP CRITICAL bei %L mit HINT-Klausel benötigt NAME, außer wenn omp_sync_hint_none verwendet wird"
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr "Unerwartetes !$OMP SCAN bei %L außerhalb eines Schleifenkonstrukts mit %<inscan%>-REDUCTION-Klausel"
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr "!$OMP DECLARE SIMD bei %2$L sollte auf die enthaltende Prozedur %1$qs verweisen"
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Konstanter nichtnegativer skalarer ganzzahliger Offset-Ausdruck bei %L erwartet"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr "Für bereichsbasierte %<adjust_args%> ist ein konstanter positiver skalarer ganzzahliger Ausdruck bei %L erforderlich"
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Dummyparametername oder eine positive Ganzzahl bei %L erwartet"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Variable außer OMP_PRIV oder OMP_ORIG wird bei %L in INITIALIZER-Klausel von !$OMP DECLARE REDUCTION verwendet"
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Variable außer OMP_OUT oder OMP_IN wird bei %L in Kombinierer von !$OMP DECLARE REDUCTION verwendet"
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr "Ungültiger Operator für !$OMP DECLARE REDUCTION %s bei %L"
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr "CHARACTER-Länge in !$OMP DECLARE REDUCTION %s ist bei %L nicht konstant"
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Unterprogrammaufruf mit alternativen Rückgaben in Kombinierer von !$OMP DECLARE REDUCTION bei %L"
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Unterprogrammaufruf mit alternativen Rückgaben in INITIALIZER-Klausel von !$OMP DECLARE REDUCTION bei %L"
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr "Eins der tatsächlichen Argumente in INITIALIZER-Klausel von !$OMP DECLARE REDUCTION bei %L muss OMP_PRIV sein"
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr "Fehlende INITIALIZER-Klausel für !$OMP DECLARE REDUCTION von abgeleitetem Typ ohne Defaultinitialisierer bei %L"
@@ -83961,62 +84128,62 @@ msgstr "Die Direktive %<GCC vector%> bei %C darf nur direkt vor einem Schleifenb
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr "Die Direktive %<GCC novector%> bei %C darf nur direkt vor einem Schleifenbeginn stehen"
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Enthaltene Prozedur %qs bei %C ist bereits mehrdeutig"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Unerwartete Anweisung %s in CONTAINS-Abschnitt bei %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "CONTAINS-Anweisung ohne FUNCTION- oder SUBROUTINE-Anweisung bei %L"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "%s-Anweisung bei %C darf nicht nach ausführbaren Anweisungen vorkommen"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "CONTAINS-Anweisung bei %C ist bereits in einer enthaltenen Programmeinheit"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Globaler Bindungs-Name %qs bei %L wird bereits als ein %s bei %L verwendet"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Globaler Name %qs bei %L wird bereits als ein %s bei %L verwendet"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Globaler Bindungs-Name %qs bei %L wird bereits bei %L verwendet"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Globaler Name %qs bei %L wird bereits bei %L verwendet"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "Leeres BLOCK DATA bei %C steht in Konflikt mit vorherigem BLOCK DATA bei %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Unerwartete Anweisung %s in BLOCK DATA bei %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Unerwartete Anweisung %s in MODULE bei %C"
@@ -84024,7 +84191,7 @@ msgstr "Unerwartete Anweisung %s in MODULE bei %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Zwei Haupt-PROGRAMme bei %L und %C"
@@ -84488,1089 +84655,1089 @@ msgstr "PARAMETER %qs darf nicht in einer DATA-Anweisung bei %C vorkommen"
 msgid "%qs at %C is not a variable"
 msgstr "%qs bei %C ist keine Variable"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs bei %L ist vom ABSTRACT-Typ %qs"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "ABSTRACT-Typ %qs bei %L verwendet"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "Schnittstelle %qs bei %L ist in späterer PROCEDURE-Anweisung deklariert"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "Schnittstelle %qs bei %L kann nicht allgemein sein"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Schnittstelle %qs bei %L darf keine Anweisungsfunktion sein"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Intrinsische Prozedur %qs ist in PROCEDURE-Anweisung bei %L nicht erlaubt"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "Schnittstelle %qs bei %L muss explizit sein"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROCEDURE %qs bei %L darf nicht als ihre eigene Schnittstelle verwendet werden"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Alternativer Rückgabespezifizierer in elementarem Unterprogramm %qs bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Alternativer Rückgabespezifizierer in Funktion %qs bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Selbstreferenzielles Argument %qs bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Scheinprozedur %qs der PURE-Prozedur bei %L muss auch PURE sein"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Argument %qs der reinen Funktion %qs bei %L mit VALUE-Attribut, aber ohne INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "Argument %qs der reinen Funktion %qs bei %L muss INTENT(IN) oder VALUE sein"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Argument %qs des reinen Unterprogrammes %qs bei %L mit VALUE-Attribut, aber ohne INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Für Argument %qs des reinen Unterprogrammes %qs bei %L muss INTENT oder das VALUE-Attribut angegeben werden"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "Argument %1$qs bei %3$L für die reine Prozedur %2$qs ist INTENT(OUT) und darf daher nicht polymorph sein"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Koarray-Scheinargument %qs bei %L für elementare Prozedur"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Argument %qs der elementaren Prozedur bei %L muss skalar sein"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Argument %qs der elementaren Prozedur bei %L kann kein ALLOCATABLE-Attribut haben"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Argument %qs der elementaren Prozedur bei %L kann kein POINTER-Attribut haben"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "Scheinprozedur %qs nicht in elementarer Prozedur %qs bei %L erlaubt"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Für Argument %qs des elementaren Unterprogrammes %qs bei %L muss INTENT oder das VALUE-Attribut angegeben werden"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Argument %qs der Anweisungs-Funktion %qs bei %L muss skalar sein"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Zeichenwertiges Argument %qs der Anweisungsfunktion bei %L muss konstante Länge haben"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Schnittstellenprozedur %qs bei %L hat denselben Namen wie die umgebende Prozedur"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Enthaltene Funktion %qs bei %L hat keinen IMPLICIT-Typ"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Ergebnis %qs der enthaltenen Funktion %qs bei %L hat keinen IMPLICIT-Typ"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Zeichenwertige Modulprozedur %qs bei %L darf keine vermutete Länge haben"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Zeichenwertige interne Funktion %qs bei %L darf keine angenommene Länge haben"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Funktion »%s« bei %L hat Einträge mit unpassenden Feldspezifikationen"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "Funktion »%s« bei %L hat Eintrag »%s« mit unpassenden Charakteristika"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "Funktion »%s« bei %L mit Einträgen, die Variablen mit verschiedenen Zeichenkettenlängen zurückgeben"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "FUNCTION-Ergebnis %s kann kein Feld in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "ENTRY-Ergebnis %s kann kein Feld in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "FUNCTION-Ergebnis %s kann kein POINTER in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "ENTRY-Ergebnis %s kann kein POINTER in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "FUNCTION-Ergebnis %s kann nicht ALLOCATABLE in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "ENTRY-Ergebnis %s kann nicht ALLOCATABLE in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "FUNCTION-Ergebnis %s kann nicht vom Typ %s in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "ENTRY-Ergebnis %s kann nicht vom Typ %s in FUNCTION %s bei %L sein"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Globale Entität %qs bei %L kann nicht in einem COMMON-Block bei %L vorkommen"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Globale Entität %qs bei %L darf nicht in einem COMMON-Block vorkommen"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr "COMMON-Block bei %L"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "Variable %qs bei %L ist in COMMON, aber Initialisierung ist nur in BLOCK DATA erlaubt"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "Initialisierte Variable %qs bei %L ist in leerem COMMON, aber Initialisierung ist nur in benannten COMMON-Blöcken erlaubt"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "%qs bei %L kann nicht in COMMON auftreten [F2008:C5100]"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Automatisches Objekt %qs bei %L kann nicht in COMMON bei %L vorkommen"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "Variable %qs abgeleiteten Typs in COMMON bei %L hat weder das SEQUENCE- noch das BIND(C)-Attribut"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "Variable %qs abgeleiteten Typs in COMMON bei %L hat eine endgültige Komponente, die allozierbar ist"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "Variable %qs abgeleiteten Typs in COMMON bei %L darf nicht Standardinitialisierung haben"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr "In Fortran 2003 ist der COMMON-Block %qs bei %L ein globaler Bezeichner und muss daher den selben Bindungsnamen haben wie der gleichbenannte COMMON-Block bei %L: %s vs. %s"
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "COMMON-Block %qs bei %L verwendet denselben globalen Bezeichner wie die Entität bei %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "Fortran 2008: COMMON-Block %qs mit Binde-Marke bei %L teilt sich Bezeichner mit gobaler nicht-COMMON-Blockentität bei %L"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "COMMON-Block bei %L mit Bindungsmarke %qs verwendet denselben globalen Bezeichner wie Entität bei %L"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "COMMON-Block %qs bei %L wird bei %L als PARAMETER verwendet"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "COMMON-Block %qs bei %L kann nicht das EXTERNAL-Attribut haben"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "COMMON-Block %qs bei %L ist auch eine intrinsische Prozedur"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "COMMON-Block %qs bei %L, der auch ein Funktionsergebnis ist"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "COMMON-Block %qs bei %L, der auch eine globale Prozedur ist"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr "Der KIND-Parameter %qs im PDT-Konstruktor bei %C hat keinen Wert"
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Der Rang des Elements im Strukturkonstruktor bei %L passt nicht zu dem der Komponente (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Das Element im Strukturkonstruktor bei %L für Zeigerkomponente %qs ist %s, sollte aber %s sein"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Ungleiche Zeichenlängen (%wd/%wd) für Zeigerkomponente %qs in Konstruktor bei %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "Das NULL im Strukturkonstruktor bei %L wird auf Komponente %qs angewandt, die aber weder ein POINTER noch ein ALLOCATABLE ist"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Unpassende Schnittstelle für Prozedurzeiger-Komponente %qs in Strukturkonstruktor bei %L: %s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Der Strukturkonstruktor bei %2$L verweist auf die falsche Feldangabe der Komponente %1$qs"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Die Form der Komponente %qs im Strukturkonstruktor bei %L unterscheidet sich von der Form der deklarierten Komponente für die Dimension %d (%ld/%ld)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Das Element im Strukturkonstruktor bei %L für Zeigerkomponente %qs sollte ein POINTER oder ein TARGET sein"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Ziel der Zeigerzuweisung bei %L hat Vektorindex"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Ungültiger Ausdruck im Strukturkonstruktor für Zeigerkomponente %qs bei %L in PURE-Prozedur"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Die obere Schranke in der letzten Dimension muss in der Referenz auf das Feld %qs vermuteter Größe bei %L auftreten"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%qs bei %L ist mehrdeutig"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "GENERIC-Prozedur %qs ist bei %L nicht als effektives Argument erlaubt"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Für intrinsische Funktion %qs angegebener Typ bei %L wird ignoriert"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Intrinsisches Unterprogramm %qs bei %L darf keine Typspezifizierung haben"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "INTRINSIC deklariertes %qs bei %L existiert nicht"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "Das bei %2$L deklarierte INTRINSIC %1$qs ist in den derzeitigen Standardeinstellungen nicht verfügbar, außer %3$s. Entsprechende Option %<-std=*%> verwenden, oder %<-fall-intrinsics%> einschalten, um es zu verwenden."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Nicht-RECURSIVE-Prozedur %qs aus Modul %qs ruft sich möglicherweise rekursiv selbst auf, in der Prozedur %qs. Deklarieren Sie die Prozedur als RECURSIVE oder verwenden Sie %<-frecursive%>"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Nicht-RECURSIVE Prozedur %qs bei %L ruft sich möglicherweise rekursiv selbst auf. Sollte als RECURSIVE oder mit %<-frecursive%> verwendet werden"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Marke %d wird bei %L referenziert, aber nirgendwo definiert"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Abgeleiteter Typ %qs wird als Argument bei %L verwendet"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Anweisungsfunktion %qs bei %L ist nicht als effektives Argument erlaubt"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Eingebautes %qs bei %L ist nicht als effektives Argument erlaubt"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Interne Prozedur %qs wird als effektives Argument bei %L verwendet"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL, nicht-INTRINSIC-Prozedur %qs ist nicht als effektives Argument bei %L erlaubt"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Spezifische INTRINSIC-Prozedur für Referenz %qs bei %L kann nicht gefunden werden"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Symbol %qs bei %L ist mehrdeutig"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Wertargument bei %L hat keinen numerischen Typ"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "Wertargument bei %L kann kein Feld oder Feldabschnitt sein"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Wertargument bei %L ist in diesem Kontext nicht erlaubt"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Übergabe der eingebauten Prozedur über die Speicherstelle ist bei %L nicht erlaubt"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL Prozedurzeigerkomponente %qs ist nicht als effektives Argument bei %L erlaubt"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Koindiziertes effektives Argument bei %L mit endgültiger Zeigerkomponente"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "Prozedur %qs bei %L wird als tatsächliches Argument verwendet, verfügt jedoch weder über eine explizite Schnittstelle noch über das Attribut EXTERNAL"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "%qs bei %L ist ein Feld und OPTIONAL; wenn es fehlt, kann es nicht das effektive Argument einer ELEMENTAL-Prozedur sein, es sei denn, es gibt ein nicht-optionales Argument mit demselben Rang (Fortran 2018, 15.5.2.12)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "Effektives Argument bei %L für INTENT(%s)-Dummy %qs von ELEMENTAL-Unterprogramm %qs ist skalar, aber ein anderes effektives Argument ist ein Feld"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Unpassender Rückgabetyp der Funktion %qs bei %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Schnittstelle in globaler Prozedur %qs bei %L passt nicht: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "Es gibt keine spezifische Funktion für das allgemeine %qs bei %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Generische Funktion %qs bei %L ist nicht mit spezifischer intrinsischer Schnittstelle vereinbar"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Funktion %qs bei %L ist INTRINSIC, aber nicht mit einer intrinsischen Funktion verträglich"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Spezifische Funktion %qs bei %L kann nicht aufgelöst werden"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr "Fehlende explizite Deklaration mit EXTERNAL-Attribut für Symbol %qs bei %L"
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Funktion %qs bei %L hat keinen IMPLICIT-Typ; meinen Sie %qs?"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Funktion %qs bei %L hat keinen IMPLICIT-Typ"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "Referenz auf Nicht-PURE-Funktion bei %L innerhalb eines DO CONCURRENT"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "Referenz auf Nicht-PURE-Funktion %qs bei %L innerhalb eines FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "Referenz auf Nicht-PURE-Funktion %qs bei %L innerhalb eines DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Referenz auf Nicht-PURE-Funktion %qs bei %L innerhalb einer PURE-Prozedur"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "Unerwarteter Ausschuss hinter %qs bei %L"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs bei %L ist keine Funktion"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ABSTRACT INTERFACE %qs darf bei %L nicht referenziert werden"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr "ABSTRACT INTERFACE %qs bei %L darf kein angenommenes Zeichenlängenergebnis haben (F2008: C418)"
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "Funktion %qs ist als CHARACTER(*) deklariert und kann nicht bei %L verwendet werden, da es kein Scheinargument ist"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Unterschiedliche Argumentlisten in externer Dummy-Funktion %s bei %L und %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "Interner Fehler: resolve_function(): bad function type"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr "Eine BOZ-Literalkonstante bei %L kann nicht als tatsächliches Argument in einer Funktionsreferenz verwendet werden"
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "Benutzerdefinierte nicht-ELEMENTAL-Funktion %qs bei %L ist in WORKSHARE-Konstrukt nicht erlaubt"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "ENTRY %qs bei %L kann nicht rekursiv aufgerufen werden, da Funktion %qs nicht RECURSIVE ist"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Funktion %qs bei %L kann nicht rekursiv aufgerufen werden, da sie nicht RECURSIVE ist"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "Verwendung der Funktion %qs bei %L ist veraltet"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "Scheinprozedur %qs bei %L erfordert das EXTERNAL-Attribut"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Unterprogrammaufruf bei %L in »DO CONCURRENT«-Block ist nicht PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Unterprogrammaufruf von %qs in FORALL-Block bei %L ist nicht PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Unterprogrammaufruf von %qs in »DO CONCURRENT«-Block bei %L ist nicht PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Unterprogrammaufruf von %qs bei %L ist nicht PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Es gibt kein spezifisches Unterprogramm für allgemeines %qs bei %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Generisches Unterprogramm %qs bei %L ist nicht mit intrinsischer Unterprogrammschnittstelle vereinbar"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Unterprogramm %qs bei %L ist INTRINSIC, aber nicht mit intrinsischer Funktion verträglich"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Spezifisches Unterprogramm %qs bei %L kann nicht aufgelöst werden"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr "F2018: C8102 %qs bei %L ist mit dem Host verbunden, erscheint jedoch nicht in einer IMPORT- oder »IMPORT, ONLY«-Liste"
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr "F2018: C8102 %qs bei %L ist mit einem Host in einem Bereich verbunden, der »IMPORT, NONE« hat"
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "%qs bei %L hat einen Typen, der nicht zum CALL bei %L passt"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "ENTRY %qs bei %L kann nicht rekursiv aufgerufen werden, da Unterprogramm %qs nicht RECURSIVE ist"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "SUBROUTINE %qs bei %L kann nicht rekursiv aufgerufen werden, da sie nicht RECURSIVE ist"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr "Unterschiedliche Argumentlisten im externen Dummy-Unterprogramm %s bei %L und %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "resolve_subroutine(): bad function type"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "Verwenden der Subroutine %qs bei %L ist veraltet"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Formen der Operanden bei %L und %L stimmen nicht überein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "logical_to_bitwise(): Bad intrinsic"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Unreine Funktion %qs bei %L wird möglicherweise nicht ausgewertet"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "Unreine Funktion bei %L wird möglicherweise nicht ausgewertet"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "BOZ-Literalkonstante bei %L kann kein Operand des einstelligen Operators %qs sein"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "Negation eines vorzeichenlosen Ausdrucks bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr "Operanden bei %L und %L können nicht als Operanden des binären Operators %qs verwendet werden"
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Ungültiger Kontext für NULL()-Zeiger bei %L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Operand des unären numerischen Operators %qs bei %L ist %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Operanden des binären numerischen Operators %qs bei %L sind %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Ränge für Operator bei %L und %L stimmen nicht überein"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "Unerwartete Entitäten mit abgeleitetem Typ im binären intrinsischen numerischen Operator %qs bei %L"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Operanden des Zeichenkettenverkettungsoperators bei %L sind %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Operanden des logischen Operators %qs bei %L sind %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Operand des Operators .not. bei %L ist %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "COMPLEX-Größen können nicht bei %L verglichen werden"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "BOZ-Literalkonstante bei %L kann nicht als Operand eines Vergleichsoperators vorkommen"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Inkonsistente Typen für Operator bei %L und %L: %s und %s"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr "Vergleich auf Gleichheit für %s bei %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr "Vergleich auf Ungleichheit für %s bei %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Logische Werte bei %L müssen mit %s statt mit %s verglichen werden"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Operanden des Vergleichsoperators %qs bei %L sind %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "Unbekannter Operator %qs bei %L; meinten Sie %qs?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "Unbekannter Operator %qs bei %L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Operand des Benutzeroperators %qs bei %L ist %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Operanden des Benutzeroperators %qs bei %L sind %s/%s"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "resolve_operator(): Bad intrinsic"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Die Bedingung in dem bedingten Ausdruck bei %L muss ein logischer Skalarwert sein"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "Die expr bei %L und die expr bei %L in bedingten Ausdrücken müssen denselben deklarierten Typ haben"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "Die expr bei %L und expr bei %L in bedingten Ausdrücken müssen denselben Artparameter haben"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "Die expr bei %L und expr bei %L in bedingten Ausdrücken müssen denselben Rang haben"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr "Sorry, nur ganzzahlige, logische, reelle, komplexe und Zeichen-Typen sind derzeit für bedingte Ausdrücke bei %L unterstützt"
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr "Sorry, Feld ist derzeit für bedingte Ausdrücke bei %L nicht unterstützt"
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Feldreferenz bei %L ist außerhalb der Grenzen (%ld < %ld) in Kodimension %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Feldreferenz bei %L ist außerhalb der Grenzen (%ld > %ld) in Kodimension %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Unzulässiger Schritt von Null bei %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Untere Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Untere Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Obere Feldreferenz bei %L ist außerhalb der Schranken (%ld < %ld) in Dimension %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Obere Feldreferenz bei %L ist außerhalb der Schranken (%ld > %ld) in Dimension %d"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "check_dimension(): Bad array reference"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Rechte obere Schranke des Feldabschnitts angenommener Größe nicht angegeben bei %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Unpassende Ränge in Feldreferenz bei %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Unpassende Ränge des Koindex in Feldreferenz bei %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Koindex der Kodimension %d muss bei %L ein Skalar sein"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Feldindex bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Feldindex bei %L muss INTEGER-Typ haben, %s gefunden"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "REAL-Feld-Index bei %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Argument dim bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Argument dim bei %L muss INTEGER-Typ haben"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Ungültige Feldreferenz der Nicht-Feld-Entität bei %L"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr "find_array_spec(): unused as(1)"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr "find_array_spec(): unused as(2)"
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Feldindex bei %L ist ein Feld mit Rang %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Argument TEAM_NUMBER bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Argument TEAM_NUMBER bei %L muss vom Typ INTEGER sein, ist jedoch %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "Argument TEAM bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr "Argument TEAM bei %L muss vom TEAM_TYPE des intrinsischen Moduls ISO_FORTRAN_ENV sein, ist jedoch %s"
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "Argument STAT bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Argument für STAT bei %L muss INTEGER-Typ haben, ist jedoch %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr "Der Ausdruck von STAT bei %L muss eine Variable sein"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Anfangs-Index der Teilzeichenkette bei %L muss INTEGER-Typ haben"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Anfangs-Index der Teilzeichenkette bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "End-Index der Teilzeichenkette bei %L muss INTEGER-Typ haben"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "End-Index der Teilzeichenkette bei %L muss skalar sein"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "End-Index der Teilzeichenkette bei %L ist zu groß"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "resolve_ref(): Bad array reference"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Komponente rechts einer Teilreferenz mit Rang größer Null darf kein POINTER-Attribut bei %L haben"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Komponente rechts einer Teilreferenz mit Rang ungleich Null darf bei %L kein Attribut ALLOCATABLE haben"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Zwei oder mehr Teilreferenzen mit Rang größer Null dürfen nicht bei %L angegeben werden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr "gfc_expression_rank(): Two array specs"
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "Ungültiger Index für Kofeld"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut kann nur als effektives Argument verwendet werden"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "Variable %s vermuteten Typs bei %L kann nur als effektives Argument verwendet werden"
@@ -85579,12 +85746,12 @@ msgstr "Variable %s vermuteten Typs bei %L kann nur als effektives Argument verw
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Variable %s vermuteten Typs bei %L als effektives Argument für Abfragefunktion muss das erste Argument sein"
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "Variable %s vermuteten Ranges bei %L kann nur als effektives Argument verwendet werden"
@@ -85593,415 +85760,415 @@ msgstr "Variable %s vermuteten Ranges bei %L kann nur als effektives Argument ve
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Variable %s vermuteten Ranges bei %L als effektives Argument für Abfragefunktion muss das erste Argument sein"
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut darf keine Referenz auf Subobjekt haben"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "Variable %s vermuteten Typs bei %L darf keine Referenz auf Subobjekt haben"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "Variable »%s« vermuteten Ranges bei %L darf keine Referenz auf Subobjekt haben"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "Skalare Variable %qs hat eine Array-Referenz bei %L"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "In Spezifikationsausdruck verwendete Variable %qs wird bei %L vor Anweisung ENTRY referenziert, in der sie ein Parameter ist"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "Variable %qs wird bei %L vor Anweisung ENTRY verwendet, in der sie ein Parameter ist"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Polymorphes Subobjekt des koindizierten Objektes bei %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Koindiziertes Objekt mit polymorpher reservierbarer Subkomponente bei %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "Verwendung der Variable %qs bei %L ist veraltet"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "Ungültige Feldreferenz bei %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr "%qs bei %L ist Host-verbunden bei %L in eine enthaltene Prozedur mit einer gleichnamigen internen Prozedur"
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "Fehler in Typbeschränktem Aufruf bei %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Weitergegebenes Objekt bei %L muss Skalar sein"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "Basisobjekt für Aufruf der Prozedurzeigerkomponente bei %L hat ABSTRACT-Typ %qs"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "Basisobjekt für Aufruf der typgebundenen Prozedur bei %L hat ABSTRACT-Typ %qs"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Basisobjekt für Aufruf der typgebundenen NOPASS-Prozedur bei %L muss skalar sein"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "Keine passende spezifische Bindung für Aufruf des GENERIC %qs bei %L gefunden"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%qs bei %L sollte eine SUBROUTINE sein"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs bei %L sollte eine FUNCTION sein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "gfc_resolve_expr(): Bad expression type"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s bei %L muss skalar sein"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s bei %L muss ganzzahlig sein"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s bei %L muss INTEGER sein"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "Schrittausdruck in DO-Schleife bei %L kann nicht Null sein"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "DO-Schleife bei %L wird null mal ausgeführt"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr "DO-Schleife bei %L ist undefiniert, da sie überläuft"
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr "DO-Schleife bei %L ist undefiniert, da sie unterläuft"
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr "Variable %qs, auf die in concurrent-header bei %L verwiesen wird, darf in LOCAL locality-spec bei %L nicht vorkommen"
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr "Variable %qs bei %L ist nicht in einer Ortsangabe von DO CONCURRENT bei %L angegeben, aber aufgrund von DEFAULT (NONE) erforderlich"
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Variablenname in %s Ortsangabe bei %L erwartet"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Variable %qs bei %L wurde bereits in einer Ortsangabe angegeben"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "Indexvariable %qs bei %L kann nicht in einer Ortsangabe angegeben werden"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "Attribut OPTIONAL nicht zulässig für %qs in %s Ortsangabe bei %L"
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Feld mit angenommener Größe ist für %qs in Ortsangabe %s bei %L nicht erlaubt"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "Attribut ALLOCATABLE nicht zulässig für %qs in %s Ortsangabe bei %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr "Polymorphes Nicht-Zeiger-Scheinargument nicht zulässig für %qs in %s Ortsangabe bei %L"
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Kofeld nicht zulässig für %qs in Ortsangabe %s bei %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr "Finalisierbarer Typ nicht zulässig für %qs in Ortsangabe %s bei %L"
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr "Typ mit ultimativer allozierbarer Komponente ist für %qs in Ortsangabe %s bei %L nicht erlaubt"
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr "ASYNCHRONOUS-Attribut nicht zulässig für %qs in REDUCE-Ortsangabe bei %L"
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr "VOLATILE-Attribut nicht zulässig für %qs in REDUCE-Ortsangabe bei %L"
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Numerischer Typ für %qs in REDUCE bei %L erwartet, %s bekommen"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "Logischer Typ für %qs in REDUCE bei %L erwartet, %s bekommen"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr "Typ INTEGER, REAL oder CHARACTER für %qs in REDUCE mit MIN/MAX bei %L erwartet, %s bekommen"
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr "Ganzzahltyp für %qs in REDUCE mit IAND/IOR/IEOR bei %L erwartet, %s bekommen"
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "Variable %qs in Ortsangabe bei %L wird nicht verwendet"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "FORALL-Indexname bei %L muss skalarer INTEGER sein"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "FORALL-Anfangsausdruck bei %L muss skalarer INTEGER sein"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "FORALL-Endausdruck bei %L muss skalarer INTEGER sein"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "FORALL-Schrittausdruck bei %L muss skalares %s sein"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "FORALL-Schrittausdruck bei %L kann nicht Null sein"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "FORALL-Index %qs kann nicht in Tripel-Spezifikation bei %L auftreten"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "ALLOCATE-Objekt bei %L muss ALLOCATABLE oder ein POINTER sein"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Koindiziertes reservierbares Objekt bei %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "Allocate-Objekt bei %L hat Rang %d, aber MOLD=-Ausdruck bei %L hat Rang %d"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "Quell-Ausdruck bei %L muss skalar sein oder den selben Rang wie das ALLOCATE-Objekt bei %L haben"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "Quell-Ausdruck bei %L und ALLOCATE-Objekt bei %L müssen dieselbe Form haben"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Das intrinsische NULL kann nicht als Quellausdruck bei %L verwendet werden"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "Typ der Entität bei %L ist mit Quellausdruck bei %L typunverträglich"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "Das ALLOCATE-Objekt bei %L und der Quellausdruck bei %L müssen Typparameter der gleichen Art haben"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "Der Quellausdruck bei %L darf weder vom Typ LOCK_TYPE sein noch eine LOCK_TYPE-Komponente haben, wenn ALLOCATE-Objekt bei %L ein Koarray ist"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "Der Quellausdruck bei %L darf weder vom Typ EVENT_TYPE sein noch eine EVENT_TYPE-Komponente haben, wenn ALLOCATE-Objekt bei %L ein Koarray ist"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "Reservierung von %s mit ABSTRACT-Basistyp bei %L erfordert Typspezifikation oder Quellausdruck"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr "Der Typ-Parameter in der ALLOCATE-Anweisung mit type-spec muss ein Sternchen sein, da das zugewiesene Objekt %qs bei %L ein Dummy-Argument mit angenommenem Typ-Parameter ist"
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "Reservierung von %s bei %L mit Typspezifikation erfordert den selben Zeichenkettenlängenparameter wie in der Deklaration"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "In ALLOCATE-Anweisung bei %L ist Feld-Spezifikation erforderlich"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Feldspezifikation oder feldwertiger SOURCE=-Ausdruck erforderlich in ALLOCATE-Anweisung bei %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Koarray-Spezifikation in ALLOCATE-Anweisung bei %L erforderlich"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Falsche Koarray-Spezifikation in ALLOCATE-Anweisung bei %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr "Obere Kogrenze ist kleiner als untere Kogrenze bei %L"
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr "Obere Kogrenze ist kleiner als untere Kogrenze von 1 bei %L"
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Falsche Feldspezifikation in ALLOCATE-Anweisung bei %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "%qs darf nicht bei %L in einer Feldspezifikation in der gleichen ALLOCATE-Anweisung auftreten, wo es selbst alloziert wird"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "In Koindex-Spezifikation in ALLOCATE-Anweisung bei %L wird %<*%> erwartet"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "Stat-Variable bei %L muss skalare INTEGER-Variable sein"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Stat-Variable bei %L darf nicht %s innerhalb der gleichen %s-Anweisung sein"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "ERRMSG bei %L ist ohne STAT-Marke nutzlos"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "»ERRMSG=«-Variable bei %L muss skalare Default-CHARACTER-Variable sein"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "ERRMSG-Variable bei %L darf nicht »%s« innerhalb der selben »%s«-Anweisung sein"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "ALLOCATE-Objekt bei %L tritt auch bei %L auf"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "ALLOCATE-Objekt bei %L ist Subobjekt des Objekts bei %L"
@@ -86010,314 +86177,314 @@ msgstr "ALLOCATE-Objekt bei %L ist Subobjekt des Objekts bei %L"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "CASE-Marke bei %L überschneidet sich mit CASE-Marke bei %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "Ausdruck in CASE-Anweisung bei %L muss Typ %s haben"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Ausdruck in CASE-Anweisung bei %L muss von der Art %d sein"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Ausdruck in CASE-Anweisung bei %L muss skalar sein"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Auswahlausdruck in berechneter GOTO-Anweisung bei %L muss ein skalarer Ganzzahlausdruck sein"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Argument der SELECT-Anweisung bei %L kann nicht %s sein"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Argument der SELECT-Anweisung bei %L muss ein skalarer Ausdruck sein"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Ausdruck in CASE-Anweisung bei %L ist nicht im Bereich von %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "Der DEFAULT CASE bei %L kann nicht von zweitem DEFAULT CASE bei %L gefolgt werden"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Logischer Bereich in CASE-Anweisung bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "Konstanter logischer Wert in CASE-Anweisung wird bei %L wiederholt"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Bereichsspezifikation bei %L kann nie passen"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Logischer SELECT CASE Block bei %L hat mehr als zwei Fälle"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "%s konnte nicht zu einer spezifischen Funktion aufgelöst werden, bei %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr "(F202y)Fehlende oder ungültige Grenze in der ASSOCIATE-Rangzuordnung des assoziierten Namens %s bei %L"
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "Zuordnende Entität %qs bei %L ist ein Prozedurzeiger"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Abgeleiteter Typ %qs kann bei %L nicht als Variable verwendet werden"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "Zuordnende Entität %qs bei %L ist ein Prozedurname"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr "Der zuordnende Selektor-Ausdruck bei %L ergibt eine Prozedur"
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "Selektor bei %L darf nicht NULL() sein"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "Selektor bei %L hat keinen Typ"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Zugeordneter Name %qs bei %L wird als Feld verwendet"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr "CLASS-Selektor bei %L erfordert Zwischenspeicher, was noch nicht implementiert ist"
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Selektor muss in SELECT TYPE-Anweisung bei %L polymorph sein"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "Selektor bei %L darf nicht koindiziert sein"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "TYPE IS bei %L überlappt sich mit TYPE IS bei %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Abgeleiteter Typ %qs bei %L muss erweiterbar sein"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Abgeleiteter Typ %qs bei %L muss eine Erweiterung von %qs sein"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Unerwarteter intrinsischer Typ %qs bei %L"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "Die Typspezifikation bei %L muss angeben, dass jeder Parameter mit Längentyp vermutet ist"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Doppelter CLASS IS-Block in SELECT TYPE-Anweisung bei %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr "RANK DEFAULT bei %L wird bei %L wiederholt"
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr "RANK (*) bei %L wird bei %L wiederholt"
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr "RANK (%i) bei %L wird bei %L wiederholt"
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr "RANK (*) bei %L kann nicht mit dem Zeiger oder dem allozierbaren Selektor bei %L verwendet werden"
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Ungültiger Kontext für NULL()-Zeiger bei %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "DTIO-%s-Prozedur bei %L muss rekursiv sein"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "Element zum Datenaustausch bei %L kann nicht polymorph sein, außer es wird von einer definierten E/A-Prozedur verarbeitet"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "Datenübertragungselement bei %L kann keine POINTER-Komponenten haben, außer es wird von einer definierten E/A-Prozedur verarbeitet"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "Datenübertragungselement bei %L kann keine Prozedurzeiger-Komponenten haben"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "Datenübertragungselement bei %L kann keine ALLOCATABLE-Komponenten haben, außer es wird von einer definierten E/A-Prozedur verarbeitet"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "Datenübertragungselement bei %L kann keine PRIVATE-Komponenten haben"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "Datenübertragungselement bei %L kann keine PRIVATE-Komponenten haben, außer es wird von einer definierten E/A-Prozedur verarbeitet"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Datenübertragungselement bei %L kann keine vollständige Referenz auf Feld vermuteter Größe sein"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "Lock-Variable bei %L muss Skalar mit LOCK_TYPE sein"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "Ereignis-Variable bei %L muss Skalar mit EVENT_TYPE sein"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "Argument für Ereignisvariable bei %L muss ein Koarray oder koindiziert sein"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "Argument für Ereignisvariable bei %L muss ein Koarray, aber nicht koindiziert sein"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "»STAT=«-Argument bei %L muss skalare INTEGER-Variable sein"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "»ERRMSG=«-Argument bei %L muss skalare CHARACTER-Variable sein"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "»ACQUIRED_LOCK=«-Argument bei %L muss skalare LOGICAL-Variable sein"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "Argument UNTIL_COUNT= bei %L muss ein skalarer INTEGER-Ausdruck sein"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr "Argument TEAM bei %L muss ein skalarer Ausdruck vom Typ TEAM_TYPE aus dem intrinsischen Modul ISO_FORTRAN_ENV sein"
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "Das Argument %s bei %L muss eine skalare %s-Variable mindestens von der Art %d sein"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Das Argument %s bei %L muss ein skalarer %s mindestens von der Art %d sein"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Argument für Imageset bei %L muss Skalar oder Rang-1-INTEGER-Ausdruck sein"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Argument für Imageset bei %L muss zwischen 1 und num_images() liegen"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Anweisung bei %L ist keine gültige Sprungzielanweisung für Sprungziel bei %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Sprung bei %L könnte Endlosschleife bewirken"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "GOTO-Anweisung bei %L hinterlässt CRITICAL-Konstrukt für Marke bei %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "GOTO-Anweisung bei %L hinterlässt DO CONCURRENT-Konstrukt für Marke bei %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "GOTO-Anweisung bei %L hinterlässt »CHANGE TEAM«-Konstrukt für Sprungmarke bei %L"
@@ -86325,215 +86492,215 @@ msgstr "GOTO-Anweisung bei %L hinterlässt »CHANGE TEAM«-Konstrukt für Sprung
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Marke bei %L ist nicht im gleichen Block wie GOTO-Anweisung bei %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "WHERE-Maske bei %L hat ungültige Form"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "WHERE-Zuweisungsziel bei %L hat ungültige Form"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Benutzerdefinierte Nicht-ELEMENTAL-Zuweisung in WHERE bei %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Nicht unterstützte Anweisung in WHERE bei %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Zuweisung an FORALL-Indexvariable bei %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "Das FORALL mit Index %qs wird nicht auf der linken Seite der Zuweisung bei %L verwendet und könnte somit mehrere Zuweisungen an dieses Objekt auslösen"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "FORALL-Konstrukt bei %L"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "FORALL-Indexname bei %L muss skalarer INTEGER sein"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Ein äußeres FORALL-Konstrukt hat bereits einen Index mit Namen %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr "Interner Fehler: Expected shadow variable name to start with _"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "Klausel WHERE/ELSEWHERE bei %L erfordert ein LOGICAL-Feld"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "gfc_resolve_blocks(): Bad block type"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "Die Variable in der gewöhnlichen Zuweisung bei %L ist eine Prozedurzeigerkomponente"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "Zuordnung von %s zu %s bei %L nicht möglich"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "CHARACTER-Ausdruck wird in Zuweisung (%wd/%wd) bei %L abgeschnitten"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Koindizierter Ausdruck bei %L wird einer Variable abgeleiteten Typs mit einer POINTER-Komponente in einer PURE-Prozedur zugewiesen"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr "In einem reinen Unterprogramm darf ein INTENT(IN)-Dummy-Argument nicht als »expr« bei %L einer intrinsischen Zuweisungsanweisung verwendet werden, in der die Variable von einem abgeleiteten Typ ist, wenn der abgeleitete Typ eine Zeigerkomponente auf irgendeiner Ebene der Komponentenauswahl hat."
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Zuweisung an koindizierte Variable bei %L in einer PURE-Prozedur"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "Zuweisung an polymorphes Koarray bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Zuweisung an allozierbare polymorphe Variable bei %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "Zuweisung an allozierbare polymorphe Variable bei %L erfordert %<-frealloc-lhs%>"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "Nicht allozierbare Variable darf in intrinsischer Zuweisung bei %L nicht polymorph sein – bitte prüfen, ob es ein passendes spezifisches Unterprogramm für den »=«-Operator gibt"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "Koindizierte Variable darf keine reservierbare endgültige Komponente in Zuweisung bei %L haben"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr "TODO: als typgebunden definierte Zuweisung(en) bei %L nicht durchgeführt, da Feldreferenzen mit mehreren Teilen in Ausdrücken als Zwischenergebnisse auftreten würden."
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "Zuweisung eines Prozedurzeigers bei %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "Funktionsergebnis auf der linken Seite der Zuweisung bei %L muss Zeiger-Attribut haben."
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "Anweisung ASSIGNED GOTO bei %L erfordert eine skalare INTEGER-Variable"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Variable %qs bei %L wurde keine Zielmarke zugewiesen"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Alternative RETURN-Anweisung bei %L erfordert einen SCALAR-INTEGER-Spezifizierer als Rückgabe"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Erwarteter intrinsischer Initialisierungsausdruck OMP WORKSHARE bei %L"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "ASSIGN-Anweisung bei %L erfordert eine skalare Standard-INTEGER-Variable"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "Ungültiges NULL bei %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Arithmetische IF-Anweisung bei %L erfordert einen skalaren REAL- oder INTEGER-Ausdruck"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "gfc_resolve_code(): No expression on DO WHILE"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Abbruchbedingung der DO WHILE-Schleife bei %L muss ein skalarer LOGICAL-Ausdruck sein"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "FORALL-Maskenklausel bei %L erfordert einen skalaren LOGICAL-Ausdruck"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_resolve_code(): Bad statement code"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Verwendung von Parameter %qs, der bei %L deklariert wurde, ist veraltet"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Variable %1$qs bei %3$L mit Binde-Marke %2$qs verwenden denselben globalen Bezeichner wie die Entität bei %4$L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "Variable %qs aus Modul %qs mit Bindungsmarke %qs bei %L verwendet denselben globalen Bezeichner wie Entität bei %L aus Modul %qs"
@@ -86541,1057 +86708,1057 @@ msgstr "Variable %qs aus Modul %qs mit Bindungsmarke %qs bei %L verwendet densel
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Prozedur %1$qs bei %3$L mit Binde-Marke %2$qs verwenden denselben globalen Bezeichner wie die Entität bei %4$L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "Zeichenkettenlänge bei %L ist zu groß"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Reservierbares Feld %qs bei %L muss aufgeschobene Form oder vermuteten Rang haben"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Skalares Objekt %qs bei %L kann nicht ALLOCATABLE sein"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Feldzeiger %qs bei %L muss aufgeschobene Form oder vermuteten Rang haben"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Feld %qs bei %L kann keine aufgeschobene Form haben"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "Typ %qs der CLASS-Variable %qs bei %L ist nicht erweiterbar"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "CLASS-Variable %qs bei %L muss Attrappe, reservierbar oder Zeiger sein"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Der Typ %qs bei %L darf nicht mit Wirt verbunden sein, da er von unverträglichem bei %L definierten Objekt mit gleichem Namen blockiert wird"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Einbezogenes SAVE für Modulvariable %qs bei %L, benötigt wegen Standardinitialisierung"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Entität %qs bei %L hat Parameter mit aufgeschobenem Typ und benötigt entweder das POINTER- oder ALLOCATABLE-Attribut"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "Automatisches Objekt %qs bei %L kann nicht das Attribut SAVE haben"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Das Feld %qs im Modul oder Hauptprogramm bei %L muss konstante Form haben"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "Entität mit vermuteter Zeichenlänge bei %L muss ein Scheinargument oder ein PARAMETER sein"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "%qs bei %L muss in diesem Zusammenhang konstante Zeichenlänge haben"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "COMMON-Variable %qs bei %L muss konstante Zeichenlänge haben"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Zuordnungsfähiges %qs bei %L kann keine Initialisierung haben"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Externes %qs bei %L kann keine Initialisierung haben"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Schein-%qs bei %L kann keine Initialisierung haben"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Intrinsisches %qs bei %L kann keine Initialisierung haben"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Funktionsergebnis %qs bei %L kann keine Initialisierung haben"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Automatisches Feld %qs bei %L kann keine Initialisierung haben"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s bei %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Zeichenwertige Anweisungsfunktion %qs bei %L muss konstante Länge haben"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "%qs hat PRIVATE-Typ und kann kein Scheinargument von %qs bei %L sein, das PUBLIC ist"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Prozedur %qs in PUBLIC-Schnittstelle %qs bei %L nimmt Scheinargumente von %qs, das PRIVATE ist"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Funktion %qs bei %L darf keinen Initialisierer haben"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Externes Objekt %qs bei %L darf keinen Initialisierer haben"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "ELEMENTAL-Funktion %qs bei %L muss ein skalares Ergebnis haben"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "Anweisungsfunktion %qs bei %L darf weder POINTER- oder ALLOCATABLE-Attribut haben"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*)-Funktion %qs bei %L darf nicht feld-wertig sein"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "CHARACTER(*)-Funktion %qs bei %L darf nicht zeiger-wertig sein"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*)-Funktion %qs bei %L darf nicht rein sein"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "CHARACTER(*)-Funktion %qs bei %L darf nicht rekursiv sein"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "CHARACTER(*)-Funktion %qs bei %L"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "Prozedurzeiger %qs bei %L darf nicht ELEMENTAL sein"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Scheinprozedur %qs bei %L darf nicht ELEMENTAL sein"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "Funktionsergebnisvariable %qs bei %L von elementarer Funktion %qs darf nicht die Attribute ALLOCATABLE oder POINTER haben"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr "Die Ergebnisvariable %qs der reinen Funktion bei %L ist polymorph allozierbar"
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Ergebnisvariable %qs der reinen Funktion bei %L hat eine polymorphe allozierbare Komponente %qs"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "Attribut PROCEDURE steht mit Attribut SAVE in %qs bei %L in Konflikt"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "Attribut PROCEDURE steht mit Attribut INTENT in %qs bei %L in Konflikt"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "Attribut PROCEDURE steht mit Attribut RESULT in %qs bei %L in Konflikt"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "Attribut EXTERNAL steht mit Attribut FUNCTION in %qs bei %L in Konflikt"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "Dem Ergebnis %qs als Prozedurzeiger bei %L fehlt das POINTER-Attribut"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Konflikt in ELEMENTAL-Attribut zwischen MODULE-PROCEDURE bei %L und seiner Schnittstelle in %s"
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Konflikt in PURE-Attribut zwischen MODULE-PROCEDURE bei %L und seiner Schnittstelle in %s"
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Konflikt in RECURSIVE-Attribut zwischen MODULE-PROCEDURE bei %L und seiner Schnittstelle in %s"
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr "%s zwischen der MODULE-PROCEDURE-Deklaration in Modul %qs und der Deklaration bei %L in (SUB)MODULE %qs"
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Schnittstelle von %qs bei %L muss explizit sein"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "FINAL-Prozedur %qs bei %L ist keine SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "FINAL-Prozedur bei %L muss genau ein Argument haben"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Argument der FINAL-Prozedur bei %L muss Typ %qs haben"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr "FINAL-Prozedur bei %L mit angenommenem Rangargument muss der einzige Finalisierer mit derselben Art/Typ sein (F2018: C790)"
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "Argument der FINAL-Prozedur bei %L darf kein POINTER sein"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "Argument der FINAL-Prozedur bei %L darf nicht ALLOCATABLE sein"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "Argument der FINAL-Prozedur bei %L darf nicht OPTIONAL sein"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "Argument der FINAL-Prozedur bei %L darf nicht INTENT(OUT) sein"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Nicht-skalare FINAL-Prozedur bei %L sollte Argument mit vermuteter Form haben"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "Bei %2$L deklarierte FINAL-Prozedur %1$qs hat denselben Rang (%3$d) wie %4$qs"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Für den abgeleiteten Typ %qs, der bei %L definiert ist, sind ausschließlich Array-FINAL-Prozeduren deklariert. Empfohlen ist auch eine skalare, es sei denn, ein Finalisierer mit angenommenem Rang wurde deklariert"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "%qs und %qs können nicht gemischte FUNCTION/SUBROUTINE für GENERIC %qs bei %L sein"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "%qs und %qs für GENERIC %qs bei %L sind mehrdeutig"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "Undefinierte spezifische Bindung %qs als Ziel des GENERIC %qs bei %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "GENERIC %qs bei %L muss auf spezifische Bindung abzielen, %qs ist ebenfalls GENERIC"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "GENERIC %qs bei %L kann nicht spezifische Bindung mit gleichem Namen überschreiben"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Typgebundener Operator bei %L kann nicht NOPASS sein"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "%qs bei %L muss eine Modulprozedur oder eine externe Prozedur mit expliziter Schnittstelle sein"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Prozedur %qs mit PASS(%s) bei %L hat kein Argument %qs"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Prozedur %qs mit PASS bei %L muss mindestens ein Argument haben"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Nicht-polymorphes Scheinargument von %qs für weitergegebenes Objekt bei %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Argument %qs von %qs mit PASS(%s) bei %L muss abgeleiteten Typ %qs haben"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Argument %qs von %qs mit PASS(%s) bei %L muss den parametrisierten abgeleiteten Typ %qs haben"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr "Alle LEN-Typparameter des hereingereichten Dummyarguments %qs von %qs bei %L müssen ASSUMED sein."
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Scheinargument von %qs für weitergegebenes Objekt bei %L muss ein Skalar sein"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Scheinargument von %qs für weitergegebenes Objekt bei %L darf nicht ALLOCATABLE sein"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Scheinargument von %qs für weitergegebenes Objekt bei %L darf nicht POINTER sein"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Prozedur %qs bei %L hat den gleichen Namen wie eine Komponente von %qs"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Prozedur %qs bei %L hat den selben Namen wie eine vererbte Komponente von %qs"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "Bei %2$L deklarierter abgeleiteter Typ %1$qs muss ABSTRACT sein, da %3$qs DEFERRED und nicht überschrieben ist"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Koarray-Komponente %qs bei %L muss reservierbar mit aufgeschobener Form sein"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Komponente %qs bei %L mit TYPE(C_PTR) oder TYPE(C_FUNPTR) darf kein Koarray sein"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "Komponente %qs bei %L mit Koarray-Komponente darf ein Nicht-Zeiger und nicht-reservierbares Skalar sein"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "Komponente %qs bei %L hat das CONTIGUOUS-Attribut, aber ist kein Feldzeiger"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Komponente %qs von BIND(C)-Typ bei %L muss Länge eins haben"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Prozedurzeiger-Komponente %qs mit PASS(%s) bei %L hat kein Argument %qs"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Prozedurzeiger-Komponente %qs mit PASS bei %L muss mindestens ein Argument haben"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Argument %qs von %qs mit PASS(%s) bei %L muss abgeleiteten Typ %qs haben"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Parameter %qs von %qs mit PASS(%s) bei %L muss skalar sein"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Argument %qs von %qs mit PASS(%s) bei %L darf kein POINTER-Attribut haben"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "Argument %qs von %qs mit PASS(%s) bei %L darf nicht ALLOCATABLE sein"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Komponente %qs von %qs bei %L hat den gleichen Namen wie eine geerbte typgebundene Prozedur"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Zeichenlänge der Komponente %qs muss ein konstanter Spezifikationsausdruck bei %L sein"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Ausdruck für Zeichenlänge der Komponente %qs bei %L muss vom Typ INTEGER sein, nicht %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "Zeichenkomponente %qs von %qs bei %L mit aufgeschobener Länge muss POINTER oder ALLOCATABLE sein"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Die Komponente %qs ist ein PRIVATE-Typ und kann nicht Komponente von %qs sein, die PUBLIC bei %L ist"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Polymorphe Komponente %s bei %L in SEQUENCE oder BIND(C)-Typ %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Komponente %s des bei %L deklarierten SEQUENCE-Typen hat kein SEQUENCE-Attribut"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "In Konflikt stehende Initialisierungen in Union bei %L und %L"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "Da der erweiterte Typ %qs bei %L eine Koarray-Komponente hat, muss der Elterntyp %qs auch eine haben"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Nicht-erweiterbarer abgeleiteter Typ %qs bei %L darf nicht ABSTRACT sein"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr "Parametrisierter Typ %1$qs hat bei %3$L keine Komponente, die zu Parameter %2$qs gehört"
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Allgemeiner Name %qs der Funktion %qs bei %L ist der gleiche wie der des abgeleiteten Typs bei %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Abgeleiteter Typ %qs bei %L wurde nicht deklariert"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr "Fehler beim Erstellen der PDT-Klassenkomponente bei %L"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Feld %qs mit vermuteter Größe in Namensliste %qs bei %L ist nicht erlaubt"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "NAMELIST-Feldobjekt %qs mit vermuteter Form in Namensliste %qs bei %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "NAMELIST-Feldobjekt %qs ohne konstante Form in Namensliste %qs bei %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "NAMELIST-Objekt %qs ohne konstante Zeichenlänge in Namensliste %qs bei %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST-Objekt %qs wurde als PRIVATE deklariert und kann kein Element der PUBLIC-Namensliste %qs bei %L sein"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "NAMELIST-Objekt %qs hat Verwendungs-verbundene PRIVATE-Komponenten und kann kein Element der Namensliste %qs bei %L sein"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST-Objekt %qs hat PRIVATE-Komponenten und kann kein Element der PUBLIC-Namensliste %qs bei %L sein"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "Attribut PROCEDURE steht mit Attribut NAMELIST in %qs bei %L in Konflikt"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Parameterfeld %qs bei %L kann nicht automatische oder vermutete Form haben"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Implizit angegebener PARAMETER %qs bei %L passt nicht zu früherem IMPLICIT-Typ"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Unverträglicher abgeleiteter Typ in PARAMETER bei %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "COMMON-Block %qs bei %L kann nicht das EXTERNAL-Attribut haben"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "Konstanter Ausdruck nahe %L erwartet"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Entität %qs bei %L hat verzögerten LEN-Parameter %qs und benötigt entweder das POINTER- oder ALLOCATABLE-Attribut"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr "Das AUTOMATIC-Objekt %qs bei %L darf kein SAVE-Attribut haben und dard auch keine Variable im main-Programm, einem Modul oder einem Teilmodus sein (F08/C513)"
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr "Das Objekt %qs bei %L mit ASSUMED-Typparametern muss ein Dummy oder ein SELECT-TYPE-Selektor sein (F08/4.2)"
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr "Sorry, allozierbare/Zeiger-Komponenten in polymorphen (CLASS-)getypten Koarrays bei %L werden nicht unterstützt"
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr "%<omp_all_memory%>, bei %L deklariert, darf nur in der OpenMP-DEPEND-Klausel verwendet werden"
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "Attribut PROTECTED steht mit Attribut EXTERNAL bei %L in Konflikt"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "Attribut PROCEDURE steht mit Attribut PROTECTED bei %L in Konflikt"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "%qs bei %L hat Attribut CONTIGUOUS, aber ist kein Feldzeiger oder Feld vermuteter Größe oder Rang"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "Falsche Spezifikation für Feld bei %L mit angenommener Größe"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Feld mit vermuteter Größe bei %L muss ein Schein-Argument sein"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Feld mit vermuteter Form bei %L muss ein Scheinargument sein"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Feld mit vermutetem Rang bei %L muss ein Scheinargument sein"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr "Feld mit vermutetem Rang bei %L darf kein Attribut VALUE oder CODIMENSION haben"
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Symbol bei %L ist keine Scheinvariable"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "%qs bei %L kann nicht das VALUE-Attribut haben, da es kein Scheinargument ist"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Zeichenwertige Scheinvariable %qs bei %L mit VALUE-Attribut muss konstante Länge haben"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "C-kompatible zeichenwertige Scheinvariable %qs bei %L mit VALUE-Attribut muss Länge eins haben"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Der abgeleitete Typ %qs bei %L hat Typ %qs, der nicht definiert wurde"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut muss ein Scheinargument sein"
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut muss vom Typ TYPE(*) oder von einem numerischen intrinsischen Typ sein"
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut darf nicht die Attribute ALLOCATABLE, CODIMENSION, POINTER oder VALUE haben"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut darf nicht das Attribut INTENT(OUT) haben"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "Variable %s bei %L mit NO_ARG_CHECK-Attribut muss entweder skalar sein oder ein Feld vermuteter Größe"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "Vermuteter Typ der Variable %s bei %L ist nur für Scheinvariablen erlaubt"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Variable %s vermuteten Typs bei %L darf nicht die Attribute ALLOCATABLE, CODIMENSION, POINTER oder VALUE haben"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "Variable %s vermuteten Typs bei %L darf nicht das Attribut INTENT(OUT) haben"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "Variable %s vermuteten Typs bei %L darf kein Feld mit ausdrücklicher Form sein"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "Variable %qs bei %L kann nicht BIND(C) sein, weil es weder ein COMMON-Block noch mit Sichtbarkeit auf Modulebene deklariert ist"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "BIND(C)-Variable %qs bei %L muss Länge eins haben"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "PUBLIC %s %qs bei %L mit abgeleitetem PRIVATE-Typen %qs"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "Variable %s bei %L mit LOCK_TYPE oder mit Subkomponente mit LOCK_TYPE muss ein Koarray sein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79866
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "Variable %s bei %L des Typs EVENT_TYPE oder mit Subkomponente des Typs EVENT_TYPE muss ein Koarray sein"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "Das INTENT(OUT)-Scheinargument %qs bei %L hat ASSUMED SIZE und kann damit keine Standardinitialisierung haben"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Scheinargument %qs bei %L mit LOCK_TYPE darf nicht INTENT(OUT) sein"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Scheinargument %qs bei %L mit EVENT_TYPE darf nicht INTENT(OUT) sein"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Funktionsergebnis %qs bei %L darf weder Koarray sein noch eine Koarray-Komponente haben"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Variable %qs bei %L mit TYPE(C_PTR) oder TYPE(C_FUNPTR) darf kein Koarray sein"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "Variable %qs bei %L mit Koarraykomponente muss ein Nichtzeiger, nichtallozierbares Skalar und damit kein Koarray sein"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "Variable %qs bei %L ist ein Koarray und ist weder ALLOCATABLE, SAVE, noch ein Scheinargument"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "Kofeld-Variable %qs bei %L darf keine Kodimensionen mit aufgeschobener Form ohne allozierbar haben"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Zuordnungsfähige Koarray-Variable %qs bei %L muss aufgeschobene Form haben"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "Variable %qs bei %L ist INTENT(OUT) und kann daher kein reservierbares Coarray sein oder Coarray-Komponenten haben"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Coarray-Scheinvariable %qs bei %L in BIND(C)-Prozedur %qs nicht erlaubt"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "LOGICAL-Scheinargument %qs bei %L mit Nicht-C_Bool-Art in BIND(C)-Prozedur %qs"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "LOGICAL-Rückgabevariable %qs bei %L mit Nicht-C_Bool-Art in BIND(C)-Prozedur %qs"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Namensliste %qs kann bei %L nicht als Argument für Unterprogramm oder Funktion verwendet werden"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Threadprivate bei %L ist nicht SAVEd"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "Die OpenMP-groupprivate-Variable %qs bei %L muss das SAVE-Attribut haben"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Die »!$OMP GROUPPRIVATE«-Variable %qs bei %L darf keinen Initialisierer haben"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr "»!$OMP DECLARE TARGET«-Variable %qs bei %L ist nicht gespeichert (SAVE)"
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "Definierbare Entität bei %L erwartet"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "BLOCK DATA Element %qs bei %L muss in COMMON sein"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "DATA-Feld %qs bei %L muss in vorheriger Deklaration angegeben werden"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "DATA-Element %qs bei %L kann keinen Coindex haben"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "DATA-Element %qs bei %L ist ein Zeiger und muss daher ein vollständiges Feld sein"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr "Das DATA-Objekt in der Nähe von %L hat das Zeiger-Attribut und der entsprechende DATA-Wert ist kein gültiges initial-data-target"
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Das DATA-Element %qs bei %L kann kein ALLOCATABLE-Attribut haben"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Abschnitt eines nicht konstanten Feldes bei %L in DATA-Anweisung"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "DATA-Anweisung bei %L hat mehr Variablen als Werte"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Nichtkonstante Zeichenlänge bei %L in DATA-Anweisung"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "Anfang der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "Ende der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "Schritt der Implied-do-Schleife bei %L konnte nicht zu einem konstanten Wert vereinfacht werden"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "Schrittweite der implied-do-Schleife bei %L darf nicht 0 sein"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "DATA-Anweisung bei %L hat mehr Werte als Variablen"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Marke %d bei %L definiert, aber nicht verwendet"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Marke %d bei %L definiert, kann aber nicht verwendet werden"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Variable %qs abgeleiteten Typs bei %L muss SEQUENCE-Attribut haben, um EQUIVALENCE-Objekt zu sein"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Variable %qs abgeleiteten Typs bei %L kann keine ALLOCATABLE-Komponenten haben, um EQUIVALENCE-Objekt zu sein"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Variable %qs abgeleiteten Typs bei %L mit Standardinitialisierung kann nicht in EQUIVALENCE mit einer Variablen in COMMON sein"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Variable %qs abgeleiteten Typs bei %L mit Zeigerkomponenten kann kein EQUIVALENCE-Objekt sein"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Syntaxfehler in EQUIVALENCE-Anweisung bei %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Entweder alle oder keines der Objekte in bei %L gesetztem EQUIVALENCE muss das Attribut PROTECTED haben"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "COMMON-Blockelement %qs bei %L darf in der PURE-Prozedur %qs kein EQUIVALENCE-Objekt sein"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Benannte Konstante %qs bei %L kann kein EQUIVALENCE-Objekt sein"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr "Sequenz %s mit gemischten Komponenten in EQUIVALENCE-Anweisung bei %L mit Objekten unterschiedlichen Typs"
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr "Objekt oder Sequenz %s vom Nicht-Standardtyp in EQUIVALENCE-Anweisung bei %L mit Objekten unterschiedlichen Typs"
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr "Nicht-CHARACTER-Objekt %qs in Standard-Anweisung CHARACTER EQUIVALENCE bei %L"
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Nicht-NUMERIC-Objekt %qs in Standard-Anweisung NUMERIC EQUIVALENCE bei %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Feld %qs bei %L mit nicht-konstanten Grenzen kann kein EQUIVALENCE-Objekt sein"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Strukturkomponente %qs bei %L kann kein EQUIVALENCE-Objekt sein"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Teilzeichenkette bei %L hat Länge Null"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Selbstreferenz im Zeichenlängenausdruck für %qs bei %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "PUBLIC-Funktion %qs bei %L mit PRIVATE-Typ %qs"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY %qs bei %L hat keinen IMPLICIT-Typ"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Prozedur für Benutzeroperator %qs bei %L muss eine FUNCTION sein"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Prozedur für Benutzeroperator %qs bei %L kann nicht vermutete Zeichenlänge haben"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Prozedur für Benutzeroperator %qs bei %L muss mindestens ein Argument haben"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Erstes Argument der Operatorschnittstelle bei %L kann nicht optional sein"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Zweites Argument der Operatorschnittstelle bei %L kann nicht optional sein"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Operatorschnittstelle bei %L darf höchstens zwei Argumente haben"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "Enthaltene Prozedur %qs bei %L einer PURE-Prozedur muss auch PURE sein"
@@ -87611,97 +87778,97 @@ msgstr "Include-Verzeichnis %qs ist nicht vorhanden"
 msgid "%qs is not a directory"
 msgstr "%qs ist kein Verzeichnis"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$ACC bei %C beginnt eine kommentierte Zeile, da es weder von Leerzeichen gefolgt wird noch eine Fortsetzungszeile ist"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP bei %C beginnt eine kommentierte Zeile, da es weder von Leerzeichen gefolgt wird noch eine Fortsetzungszeile ist"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr "Herstellererweiterungsmarkierung »!$omx« bei %C wird ignoriert"
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Zeile bei %L wird abgeschnitten"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Grenze von %d Fortsetzungen in Anweisung bei %C überschritten"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr "Falsche OpenACC-Fortsetzung bei %C: !$ACC erwartet, !$OMP gefunden"
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr "Falsche OpenMP-Fortsetzung bei %C: !$OMP erwartet, !$ACC gefunden"
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "In fortgesetzter Zeichenkonstante bei %C fehlt %<&%>"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Tab-Zeichen bei %C passt nicht"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "Ungültiges Zeichen 0x%s bei %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "in Zeile %d ist %<&%> für sich alleine nicht erlaubt"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Unpassendes Tab-Zeichen in Spalte %d der Zeile %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "Datei %qs verlassen, aber nicht betreten"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "Ungültige Präprozessordirektive"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr "Die Datei %qs wird rekursiv eingebunden"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "Datei %qs kann nicht geöffnet werden"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "Die eingebundene Datei %qs kann nicht geöffnet werden"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "Die vor-eingebundene Datei %qs kann nicht geöffnet werden"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "Die eingebundene Datei %qs ist keine reguläre Datei"
@@ -87878,223 +88045,223 @@ msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim(): Bad type"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "in gfc_simplify_exp(): Bad type"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor(): Bad kind"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Argument von IACHAR bei %L muss Länge Eins haben"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Argument der IACHAR-Funktion bei %L außerhalb des Wertebereiches 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "Summe des zweiten und dritten Arguments von IBITS überschreitet Bit-Größe bei %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr "IBITS: Bad bit"
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Argument von ICHAR bei %L muss Länge Eins haben"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Zweites Argument von %s ist bei %L negativ"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "Größe des zweiten Arguments von %s überschreitet Bit-Größe bei %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "Größenordnung des zweiten Arguments von ISHFTC überschreitet BIT_SIZE des ersten Arguments bei %C"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "Der absolute Wert von SHIFT muss kleiner oder gleich SIZE bei %C sein"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "DIM-Argument bei %L ist außerhalb der Grenzen"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "Argument von LOG bei %L kann nicht kleiner oder gleich Null sein"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "Komplexes Argument von LOG bei %L kann nicht Null sein"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "gfc_simplify_log: bad type"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "Argument von LOG10 bei %L kann nicht kleiner oder gleich Null sein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr "simplify_min_max(): Bad type in arglist"
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "Argument %qs von MOD bei %L darf nicht Null sein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_simplify_mod(): Bad arguments"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Argument %qs von MODULO bei %L darf nicht 0 sein"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr "gfc_simplify_modulo(): Bad arguments"
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Ergebnis von NEAREST ist NaN bei %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "Argument NCOPIES des intrinsischen REPEAT ist bei %L negativ"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "Argument NCOPIES des intrinsischen REPEAT ist bei %L zu groß"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr "Zeichenkette mit mehr als 2 hoch 28 Zeichen bei %L wird erst bei Ausführung des Programms ausgewertet werden, rechnen Sie mit Fehlern"
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr "Das SHAPE-Feld für das intrinsische RESHAPE bei %L hat den negativen Wert %d für die Dimension %d"
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr "Die Formen von ORDER bei %L und SHAPE bei %L sind unterschiedlich"
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr "Die Größen von ORDER bei %L und SHAPE bei %L sind unterschiedlich"
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr "Element mit einem Wert von %1$d in ORDER bei %2$L muss für das intrinsische RESHAPE in der Nähe von %4$L im Bereich [1, …, %3$d] liegen"
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr "ORDER bei %L ist keine Permutation der Größe von SHAPE bei %L"
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Umgeformtes Feld bei %C zu groß"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Ergebnis von SCALE überschreitet seine Art bei %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "DIM-Argument (%d) für intrinsisches SIZE bei %L außerhalb des Bereichs (1:%d)"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Bad type in gfc_simplify_sign"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "in gfc_simplify_sin(): Bad type"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr "Failure getting length of a constant array."
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "Die Anzahl der Elemente (%d) im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>."
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Vereinfachung von SPREAD bei %C ist noch nicht implementiert"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Argument von SQRT bei %L hat negativen Wert"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "Ungültiges Argument von SQRT bei %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "Außerhalb des Wertebereichs in IMAGE_INDEX bei %L für Dimension %d, SUB hat %ld und untere Grenze für COARRAY ist %ld"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "Außerhalb des Wertebereichs in IMAGE_INDEX bei %L für Dimension %d, SUB hat %ld und obere Grenze für COARRAY ist %ld"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "Zeichen %qs in Zeichenkette bei %L kann nicht in Zeichenart %d umgewandelt werden"
@@ -88303,7 +88470,7 @@ msgstr "Prozedur %s bei %L ist bereits als Prozedur %s deklariert"
 #: fortran/symbol.cc:1898
 #, gcc-internal-format
 msgid "F2008: A pointer function assignment is ambiguous if it is the first executable statement after the specification block.  Please add any other kind of executable statement before it"
-msgstr "F2008: Eine Zuweisung an eine Zeigerfunktion ist mehrdeutig, wenn dies die erste Anweisung nach dem Spezifikationsblock ist. Bitte fügen Sie davor irgend eine andere ausführbare Anweisung ein."
+msgstr "F2008: Eine Zuweisung an eine Zeigerfunktion ist mehrdeutig, wenn dies die erste Anweisung nach dem Spezifikationsblock ist. Bitte fügen Sie davor irgend eine andere ausführbare Anweisung ein"
 
 #: fortran/symbol.cc:1935
 #, gcc-internal-format, gfc-internal-format
@@ -88435,75 +88602,75 @@ msgstr "Gemeinsam genutzte DO-Abbruchmarke %d bei %C"
 msgid "Labeled DO statement at %L"
 msgstr "DO-Anweisung mit Label bei %L"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Name %qs bei %C ist eine mehrdeutige Referenz auf %qs vom Modul %qs"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Name %qs bei %C ist eine mehrdeutige Referenz auf %qs von aktueller Programmeinheit"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Symbol %qs bei %C wurde bereits mit Host verbunden"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Abgeleiteter Typ %qs, bei %L deklariert, muss BIND-Attribut haben, um C-kompatibel zu sein"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Abgeleiteter Typ %qs mit Attribut BIND(C) bei %L hat keine Komponenten"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "Abgeleiteter Typ %qs mit Attribut BIND(C) bei %L ist leer und könnte für entsprechenden C-Prozessor unzugreifbar sein"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponente %qs bei %L kann nicht POINTER-Attribut haben, da es Element des BIND(C)-abgeleiteten Typs %qs bei %L ist"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponente %qs des Prozedurzeigers bei %L kann kein Element des BIND(C)-abgeleiteten Typs %qs bei %L sein"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponente %qs bei %L kann nicht ALLOCATABLE-Attribut haben, da es Element des BIND(C)-abgeleiteten Typs %qs bei %L ist"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "Komponente %qs in abgeleitetem Typ %qs bei %L könnte nicht C-kompatibel sein, obwohl abgeleiteter Typ %qs BIND(C) ist"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "Komponente %qs in abgeleitetem Typ %qs bei %L könnte nicht C-kompatibel sein"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Abgeleiteter Typ %qs bei %L kann nicht das SEQUENCE-Attribut haben, da er BIND(C) ist"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "Symbol %qs wird bei %L verwendet, bevor es typisiert wird"
@@ -88533,29 +88700,34 @@ msgstr "Überlappende ungleiche Initialisierungen in EQUIVALENCE bei %L"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Überlappende ungleiche Initialisierungen in EQUIVALENCE bei %C"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr "Der Strukturkonstruktor bei %L wurde finalisiert. Dieses Feature wurde aus f08/0011 entfernt. Verwenden Sie »-std=f2018« oder »-std=gnu«, um die Finalisierung zu entfernen."
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr "Die Überprüfung der Grenzen des Elementindexes bei %L führt zu zwei Aufrufen von %qs, das weder als PURE deklariert ist noch implizit rein ist."
 
+#: fortran/trans-array.cc:7109
+#, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "Der Feldinitialisierer bei %L ist nicht zu einem konstanten Ausdruck reduzierbar"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "Die Anzahl der Elemente im Feldkonstruktor bei %L erfordert Erhöhung der erlaubten oberen Grenze %d. Siehe Option %<-fmax-array-constructor%>"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Bei %L wird ein vorübergehendes Feld für Argument %qs erzeugt"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "Falscher Ausdruckstyp beim Durchlaufen (%d)"
@@ -88659,113 +88831,113 @@ msgstr "Zuweisung eines anderen Wertes als 0 oder 1 an LOGICAL hat bei %L undefi
 msgid "non-constant initialization expression at %L"
 msgstr "Nicht-konstanter Initialisierungsausdruck bei %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr "Das Feld %qs bei %L ist größer als der Grenzwert, der durch %<-fmax-stack-var-size=%> festgelegt wurde, daher wurde es vom Stapel in den statischen Speicher verschoben. Dies macht die Prozedur unsicher, wenn sie rekursiv oder gleichzeitig von mehreren Threads aus aufgerufen wird. Erwägen Sie, die Grenze für %<-fmax-stack-var-size=%> anzuheben, verwenden Sie %<-frecursive%> (dadurch wird die Beschränkung von %<-fmax-stack-var-size%> aufgehoben), oder ändern Sie den Code so, dass er ein ALLOCATABLE-Feld verwendet. Wenn auf die Variable niemals nebenläufig zugegriffen wird, können Sie diese Warnung ignorieren, Sie könnten diese Variable auch mit dem Attribut SAVE deklarieren."
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr "Sorry, OMP GROUPPRIVATE ist nicht implementiert, wird von %qs verwendet, das bei %L deklariert ist"
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr "Sorry, OMP DECLARE TARGET mit LOCAL-Klausel ist nicht implementiert, wird von %qs verwendet, das bei %L deklariert ist"
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%s bei %L hat keinen Vorgabe-Typ"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "innere Variable, die keine Prozedur ist"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "Rückgabewert der Funktion %qs bei %L nicht gesetzt"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "Parameter aufgeschobenen Typs wird noch nicht unterstützt"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "Backend-Deklaration für Modulvariable %qs ist bereits vorhanden"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Ungenutzte PRIVATE-Variable %qs bei %L deklariert"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "Symbol %qs bei %L hat das Attribut WEAK, ist aber ein Scheinargument"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "Symbol %qs bei %L hat das Attribut WEAK, ist aber eine lokale Variable"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Scheinargument %qs bei %L war als INTENT(OUT) deklariert, aber nicht gesetzt"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "Scheinargument %qs abgeleiteten Typs bei %L war als INTENT(OUT) deklariert, aber nicht gesetzt und hat keine Standardinitialisierung"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Ungenutztes Dummyargument %qs bei %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Ungenutzte Modulvariable »%qs«, die bei %L ausdrücklich importiert wurde"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Ungenutzte Variable %qs, bei %L deklariert"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Ungenutzter Parameter %qs, bei %L deklariert"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Ungenutzter Parameter %qs, der bei %L ausdrücklich importiert wurde"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Rückgabewert %1$qs der bei %3$L deklarierten Funktion %2$qs nicht gesetzt"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr "Entschuldigung, !$ACC DECLARE bei %L ist in einem BLOCK-Konstrukt nicht erlaubt"
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Vorzeichenlos ist noch nicht implementiert"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr "Das Symbol %qs bei %L ist in einer BLOCK-DATA-Programmeinheit deklariert, befindet sich aber nicht in einem COMMON-Block"
@@ -88795,12 +88967,12 @@ msgstr "Sorry, der koindizierte Zugriff bei %L auf eine unbegrenzt polymorphe Ko
 msgid "Unknown intrinsic op"
 msgstr "Unbekannte eingebauter Operator"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Unbekannte Argumentlistenfunktion bei %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr "Wenn die Neuzuordnung von Grenzen bei %L angegeben wird, darf das Zeigerziel nicht NULL sein"
@@ -88816,12 +88988,12 @@ msgstr "Intrinsische Funktion %qs (%d) nicht erkannt"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "Argument %<dim%> des intrinsischen »%s« bei %L ist kein gültiger Dimensionsindex"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "Sorry, die Event-Komponente des abgeleiteten Typs bei %L wird noch nicht unterstützt"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "Event-Variable bei %L darf nicht koindiziert sein"
@@ -88846,184 +89018,184 @@ msgstr "Sorry, polymorphe Felder werden für firstprivate noch nicht unterstütz
 msgid "implicit mapping of assumed size array %qD"
 msgstr "Implizite Zuordnung von Feld %qD mit angenommener Größe"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr "Die Zuordnung des unbegrenzten polymorphen Listenelements %qD ist unspezifiziertes Verhalten und wird nicht unterstützt"
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr "Die Zuordnung des polymorphen Listenelements %qD ist unspezifiziertes Verhalten"
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, gcc-internal-format
 msgid "optional class parameter"
 msgstr "optionaler Klassenparameter"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "unbehandelter Ausdruckstyp"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr "unbehandelter Ausdruck"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr "%<uses_allocators%>-Klausel mit Traits und Speicherbereichen"
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr "%<!$OMP %s%> bei %L erfordert %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr "Alle Dateien, die eine solche Variable freigeben könnten, müssen mit %<-fopenmp-allocators%> kompiliert werden"
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr "Dazu gehören explizites DEALLOCATE, Neuzuweisung bei intrinsischer Zuweisung, INTENT(OUT) für allozierbare Dummy-Argumente und Neuzuweisung von allozierbaren Komponenten, die mit einem OpenMP-Allokator alloziert wurden"
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr "Nichtrechteckige Schleifenschachtelung mit nichtkonstanter Schrittweite für %qs"
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr "Hier verwendet"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79596
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Bad statement code"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "Der Basisname für %<declare variant%> bei %L muss angegeben werden"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Der Basisname bei %L passt nicht zum Namen der aktuellen Prozedur"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "Der Basisname bei %L darf kein Eintragsname sein"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "Der Basisname bei %L darf kein generischer Name sein"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "Der Basisname bei %L darf kein Prozedurzeiger sein"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "Die Basisprozedur bei %L muss eine explizite Schnittstelle haben"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "Das Symbol %qs kann bei %L nicht gefunden werden"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "Die Variante %qs bei %L muss eine Funktion oder Unterroutine sein"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "Die Variante %qs bei %L ist dieselbe wie die Basisfunktion"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "Die Variante %qs und die Basis %qs bei %L haben inkompatible Typen: %s"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr "die %<append_args%>-Klausel impliziert, dass %qs %d Dummy-Argumente vom Typ Ganzzahl mit der Art %<omp_interop_kind%> hat"
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr "%qs bei %L darf kein Zeiger sein und auch kein nichtallozierbares skalares ganzzahliges Scheinargument der Art %<omp_interop_kind%> sein, da es mit der %<append_args%>-Klausel bei %L verwendet wird"
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr "%qs bei %L mit OPTIONAL-Attribut nicht unterstützt, wenn es mit der %<append_args%>-Klausel bei %L verwendet wird"
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr "%qs bei %L hat %d, erfordert aber %d Scheinargumente der Art %<omp_interop_kind%>, da es mit der %<append_args%>-Klausel bei %L verwendet wird"
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr "die %qs-Klausel kann nur angegeben werden, wenn der %<dispatch%>-Selektor der Konstruktionsselektormenge in der %<match%>-Klausel bei %L vorkommt"
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "Positiver Argumentindex bei %L erwartet"
 
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93855
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Argumentindex bei %L übersteigt Anzahl der Argumente %d"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr "Oberer Argumentindex ist kleiner als der untere bei %L"
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Listeneintrag %qs bei %L ist bei %L deklariert, ist jedoch kein Scheinargument"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Das Argument %qs bei %L zum Listenelement in %<need_device_ptr%> bei %L muss ein Skalar vom TYP(C_PTR) sein"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr "Erwägen Sie, stattdessen %<need_device_addr%> zu verwenden"
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Argument %qs bei %L zu Listenelement in %<need_device_addr%> bei %L darf nicht das Attribut VALUE haben"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "%qs bei %L ist mehrfach angegeben"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "%<need_device_addr%> ist noch nicht unterstützt"
@@ -89364,7 +89536,7 @@ msgstr "close: %s"
 msgid "two or more sections for %s"
 msgstr "zwei oder mehr Abschnitte für %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr "Mindestgröße der Partition darf nicht größer als Höchstgröße der Partition sein"
@@ -89688,32 +89860,32 @@ msgstr "Interner Fehler: array type must be initialized"
 msgid "array element value must be the same type as its declaration"
 msgstr "Wert des Arrayelements muss vom selben Typ sein wie seine Deklaration"
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr "arithmetischer Überlauf in unterer Grenze des Teilbereichs"
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr "arithmetischer Überlauf in oberer Grenze des Teilbereichs"
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "verlangte Ausrichtung ist keine Konstante"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "verlangte Ausrichtung ist keine Zweierpotenz"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "Verlangte Ausrichtung ist zu groß"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "für %qD darf keine Ausrichtung angegeben werden"
@@ -90763,6 +90935,22 @@ msgstr "unverwendeter Name %qE"
 msgid "are you trying to break %s? how dare you?"
 msgstr "Wert »%s« kann in diesem Bereich nicht gefunden werden"
 
+#, no-c-format
+#~ msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+#~ msgstr "Der Skalierungsfaktor in Prozent, der bei der Durchführung einer Vektorisierungsrentabilitätsanalyse auf alle Kosten einer skalaren Schleife angewendet wird. Der Standardwert ist 100."
+
+#, gcc-internal-format, gfc-internal-format
+#~ msgid "%s:%d: ignoring subscripts"
+#~ msgstr "Interner Fehler: %s:%d: ignoring subscripts"
+
+#, gcc-internal-format
+#~ msgid "%qT is not consteval-only"
+#~ msgstr "%qT ist nicht nur consteval"
+
+#, gcc-internal-format
+#~ msgid "mangling type pack index"
+#~ msgstr "mangling type pack index"
+
 #, gcc-internal-format
 #~ msgid "expected a string but got something else or NULL"
 #~ msgstr "Zeichenkette erwartet, aber etwas anderes oder NULL gefunden"
@@ -91387,10 +91575,6 @@ msgstr "Wert »%s« kann in diesem Bereich nicht gefunden werden"
 #~ msgid "cannot import module in its own purview"
 #~ msgstr "ein Modul kann nicht in seinen eigenen Bereich importiert werden"
 
-#, gcc-internal-format
-#~ msgid "lambda-expression in template parameter type"
-#~ msgstr "Lambda-Ausdruck in Template-Parameter-Typ"
-
 #, gcc-internal-format
 #~ msgid "preconditions cannot be statements"
 #~ msgstr "Vorbedingungen können keine Anweisungen sein"
--- a/src/gcc/po/el.po
+++ b/src/gcc/po/el.po
@@ -6,7 +6,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 4.0-b20041128\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2004-12-15 18:53+0000\n"
 "Last-Translator: Simos Xenitellis <simos74@gmx.net>\n"
 "Language-Team: Greek <nls@tux.hellug.gr>\n"
@@ -1283,12 +1283,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr ""
@@ -2107,13 +2107,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2562,7 +2562,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr ""
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr ""
@@ -2637,7 +2637,7 @@ msgstr ""
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 msgid "Specify the code model."
@@ -2674,7 +2674,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Δεν βρέθηκαν ταιριάσματα στη μορφή `%s'.\n"
@@ -2784,7 +2784,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2830,7 +2830,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5094,7 +5094,7 @@ msgstr ""
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5449,7 +5449,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5754,212 +5754,217 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Αποτυχία δέσμευσης πόρων συστήματος"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Χρήση ξεχωριστής λανθάνουσας μνήμης για κάθε χρήστη"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 msgid "This option is deprecated."
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
@@ -11286,7 +11291,7 @@ msgstr "Ακατάλληλη εντολή"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18200,86 +18205,86 @@ msgstr ""
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 msgid "argument must be passed by copying"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
 # lib/argmatch.c:188
-#: calls.cc:2566
+#: calls.cc:2567
 #, fuzzy
 msgid "callee returns a structure"
 msgstr "Έγκυρα ορίσματα είναι:"
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 msgid "callee does not return"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 msgid "volatile function type"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "In function"
 msgid "nested function"
 msgstr "Στη συνάρτηση"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr ""
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 msgid "frontend does not support sibling call"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 msgid "variable size arguments"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr ""
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr ""
 
@@ -18399,12 +18404,12 @@ msgstr ""
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr ""
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, fuzzy, c-format
 msgid "invalid expression as operand"
@@ -19782,12 +19787,12 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 msgid "unable to reload address in "
 msgstr "Ακατάλληλη χρήση του διαμορφωτή διεύθυνσης"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 #, fuzzy
 msgid "unable to generate reloads for:"
 msgstr "Αδύνατη η δημιουργία διεργασίας στον εξυπηρετητή"
@@ -20008,7 +20013,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr ""
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, fuzzy, gcc-internal-format
 msgid "<anonymous>"
 msgstr "((ανώνυμο))"
@@ -20396,20 +20401,20 @@ msgstr "Μη έγκυρη επιλογή `%s'"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 msgid "invalid vector constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
@@ -20454,74 +20459,74 @@ msgstr "Μη έγκυρη επιλογή `%s'"
 msgid "invalid address mode"
 msgstr "Ακατάλληλη χρήση του διαμορφωτή διεύθυνσης"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 msgid "postincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 msgid "subscript operation not supported on svbool_t"
 msgstr "το -C δεν συνίσταται πια, χρησιμοποιήστε -Z"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr ""
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20538,13 +20543,13 @@ msgid "invalid %%r value"
 msgstr "μη έγκυρος χρήστης"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, fuzzy, c-format
 msgid "invalid %%R value"
 msgstr "μη έγκυρος χρήστης"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, fuzzy, c-format
 msgid "invalid %%N value"
 msgstr "μη έγκυρος χρήστης"
@@ -20559,7 +20564,7 @@ msgstr "μη έγκυρος χρήστης"
 msgid "invalid %%h value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, fuzzy, c-format
 msgid "invalid %%L value"
 msgstr "μη έγκυρος χρήστης"
@@ -20574,7 +20579,7 @@ msgstr "μη έγκυρος χρήστης"
 msgid "invalid %%M value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, fuzzy, c-format
 msgid "invalid %%U value"
 msgstr "μη έγκυρος χρήστης"
@@ -20920,7 +20925,7 @@ msgstr "Μη ορισμένο όνομα %s"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21199,131 +21204,131 @@ msgstr "μη τερματιζμένο αλφαριθμητικό σταθερά
 msgid "Expected register or constant integer."
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, fuzzy, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "μη έγκυρη μετατόπιση UTC"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 msgid "invalid use of register '%s'"
 msgstr "μη έγκυρος αριθμός από γραμμές"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 msgid "invalid use of asm flag output"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr ""
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr ""
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr ""
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr ""
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr ""
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr ""
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, fuzzy, c-format
 msgid "invalid operand code '%c'"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, fuzzy, c-format
 msgid "invalid constraints for operand"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 msgid "invalid vector immediate"
 msgstr "μη έγκυρο δικαίωμα"
 
 # src/grep.c:1133
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 #, fuzzy
 msgid "unknown insn mode"
 msgstr "άγνωστη μέθοδος καταλόγων"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21407,9 +21412,9 @@ msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, fuzzy, c-format
 msgid "invalid use of '%%%c'"
 msgstr "Μη έγκυρη ημερομηνία `%s'."
@@ -21477,7 +21482,7 @@ msgid "insn contains an invalid address !"
 msgstr "Ακατάλληλη χρήση του διαμορφωτή διεύθυνσης"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 #, fuzzy
 msgid "invalid address"
 msgstr "Ακατάλληλη χρήση του διαμορφωτή διεύθυνσης"
@@ -21553,7 +21558,7 @@ msgstr "Μη έγκυρη ημερομηνία `%s'."
 msgid "invalid %%H value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, fuzzy, c-format
 msgid "invalid %%d value"
 msgstr "μη έγκυρος χρήστης"
@@ -21603,32 +21608,32 @@ msgstr "Εμφάνιση έκδοσης προγράμματος"
 msgid "unsupported memory expression:"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 msgid "invalid vector operand"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 msgid "invalid register number for 'N' modifier"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr "το `%s' είναι πρόγονος του `%s'"
@@ -21687,7 +21692,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, fuzzy, c-format
 msgid "invalid %%D value"
 msgstr "μη έγκυρος χρήστης"
@@ -21727,7 +21732,7 @@ msgstr "μη έγκυρο δικαίωμα"
 msgid "invalid %%k value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, fuzzy, c-format
 msgid "invalid %%K value"
 msgstr "μη έγκυρος χρήστης"
@@ -21757,17 +21762,17 @@ msgstr "μη έγκυρος χρήστης"
 msgid "invalid %%u value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, fuzzy, c-format
 msgid "invalid %%v value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 msgid "invalid %%V value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, fuzzy, c-format
 msgid "invalid %%x value"
 msgstr "μη έγκυρος χρήστης"
@@ -21984,27 +21989,27 @@ msgstr "μη έγκυρος χρήστης"
 msgid "floating-point constant not a valid immediate operand"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, fuzzy, c-format
 msgid "'B' operand is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, fuzzy, c-format
 msgid "'o' operand is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 msgid "'h' operand is not SImode register"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr ""
@@ -22064,27 +22069,27 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr "Δεν μπόρεσα να ανοίξω το αρχείο %s"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 #, fuzzy
 msgid "bad test"
 msgstr "Εσφαλμένη διεύθυνση"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 #, fuzzy
 msgid "invalid mask"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, fuzzy, c-format
 msgid "invalid %%t/%%b value"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 #, fuzzy
 msgid "no register in address"
 msgstr "μη έγκυρος χρόνος έναρξης"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 #, fuzzy
 msgid "address offset not a constant"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
@@ -22117,7 +22122,7 @@ msgstr ""
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 #, fuzzy
 msgid "({anonymous})"
 msgstr "((ανώνυμο))"
@@ -22143,8 +22148,8 @@ msgstr "((ανώνυμο))"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22172,7 +22177,7 @@ msgstr ""
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22180,7 +22185,7 @@ msgstr "Μη ορισμένο όνομα %s"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22200,13 +22205,13 @@ msgstr ""
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22215,7 +22220,7 @@ msgstr "Μη ορισμένο όνομα %s"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, fuzzy, gcc-internal-format
 msgid "expected %<{%>"
@@ -22232,13 +22237,13 @@ msgstr "Μη ορισμένο όνομα %s"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22248,7 +22253,7 @@ msgstr "Μη ορισμένο όνομα %s"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22259,18 +22264,18 @@ msgid "expected %<.%>"
 msgstr "Μη ορισμένο όνομα %s"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "Μη ορισμένο όνομα %s"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr ""
@@ -22280,46 +22285,46 @@ msgstr ""
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "Μη ορισμένο όνομα %s"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr ""
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr ""
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 #, fuzzy
 msgid "(anonymous)"
 msgstr "((ανώνυμο))"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "Μη ορισμένο όνομα %s"
@@ -22346,7 +22351,7 @@ msgstr ""
 msgid "  after user-defined conversion:"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] ""
@@ -22457,7 +22462,7 @@ msgstr "διπλό όνομα χαρακτήρα `%s'"
 msgid "<statement>"
 msgstr ""
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr ""
@@ -22484,278 +22489,316 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 #, fuzzy
 #| msgid "parse error"
 msgid "<expression error>"
 msgstr "σφάλμα επεξεργασίας"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr ""
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-#, fuzzy
-msgid "array element not a constant integer"
-msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr ""
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+msgid "array element not a constant integer"
+msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
+
+#: cp/reflect.cc:1117
 #, fuzzy
 msgid "reflection does not represent a type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 msgid "reflection does not have template arguments"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 msgid "reflection does not represent a function or function type"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 msgid "operators argument is not a valid operator"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 msgid "reflection does not have a type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr ""
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 msgid "reflection does not represent parameter of current function"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr ""
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 msgid "reflection with incomplete type in size_of"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 msgid "reflection not suitable for alignment_of"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 msgid "alignment_of on function type"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 msgid "reflection with incomplete type in alignment_of"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr ""
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 msgid "value member missing"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr ""
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr ""
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 msgid "reflection does not represent a template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 msgid "invalid argument to can_substitute"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 msgid "type is not object or reference type"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 msgid "name is not a valid identifier"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 #, fuzzy
 msgid "name is a keyword"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 msgid "neither name nor bit_width specified"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+#, fuzzy
+msgid "no name and non-empty annotations specified"
+msgstr "Απαιτείται διεύθυνση προορισμού"
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 msgid "both alignment and bit_width specified"
 msgstr "μόνο ένα όρισμα μπορεί να δηλωθεί"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr ""
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr ""
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr ""
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr ""
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+msgid "reflection does not have non-array object type"
+msgstr ""
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr ""
+
+#: cp/reflect.cc:6526
+#, fuzzy
+msgid "current scope does not represent a class nor a member function"
+msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 msgid "incomplete parent class"
 msgstr "αποτυχία κατά την εγγραφή δεδομένων για την κατηγορία `%s'"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 msgid "neither complete class type nor namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 msgid "not a complete class type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 #, fuzzy
 #| msgid "close %d"
 msgid "closure type"
 msgstr "close %d"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 msgid "value cannot be extracted"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
@@ -22807,53 +22850,53 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr ""
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr ""
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr ""
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr ""
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, fuzzy, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr ""
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 msgid "in argument to unary !"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -22870,60 +22913,60 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr ""
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 msgid "BOZ literal constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr ""
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 msgid "Procedure unexpected as argument"
 msgstr ""
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr ""
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -22993,7 +23036,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 msgid "array assignment"
 msgstr "προσπέρασμα ορίσματος"
@@ -23003,17 +23046,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -23207,12 +23250,12 @@ msgstr ""
 msgid "implied END DO"
 msgstr ""
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 #, fuzzy
 msgid "assignment"
 msgstr "προσπέρασμα ορίσματος"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 #, fuzzy
 msgid "pointer assignment"
 msgstr "προσπέρασμα ορίσματος"
@@ -23221,149 +23264,149 @@ msgstr "προσπέρασμα ορίσματος"
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 #, fuzzy
 msgid "elemental procedure"
 msgstr "πολύ λίγα ορίσματα"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 msgid "allocatable argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 #| msgid "no arguments"
 msgid "asynchronous argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 #| msgid "no arguments"
 msgid "optional argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "no arguments"
 msgid "pointer argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 #| msgid "no arguments"
 msgid "target argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 msgid "value argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 msgid "assumed-shape argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 #| msgid "no arguments"
 msgid "assumed-rank argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 #| msgid "no arguments"
 msgid "coarray argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 msgid "parametrized derived type argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "χωρίς ορίσματα"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 msgid "assumed-type argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 #, fuzzy
 msgid "pointer or allocatable result"
 msgstr "Δεν είναι δυνατό να δεσμευτεί μνήμη"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr ""
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 msgid "End expression in DO loop"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -23372,31 +23415,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 #, fuzzy
 msgid "Assignment of scalar to unallocated array"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
@@ -23460,27 +23503,27 @@ msgstr ""
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23581,7 +23624,7 @@ msgid "expected boolean type"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 msgid "expected integer"
 msgstr "Μη ορισμένο όνομα %s"
@@ -23653,7 +23696,7 @@ msgstr "χωρίς ορίσματα"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 msgid "too many arguments"
 msgstr "πάρα πολλά ορίσματα"
@@ -24095,7 +24138,7 @@ msgstr ""
 msgid "target OS does not support unaligned accesses"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
@@ -24339,13 +24382,13 @@ msgstr "Στη συνάρτηση %qs:"
 msgid "Global declarative %s for %s"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24512,12 +24555,12 @@ msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
 # src/main.c:663
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "Άγνωστη συμβολοσειρά `%s'"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr ""
@@ -24949,8 +24992,8 @@ msgstr ""
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -24967,7 +25010,7 @@ msgstr "το `%s' είναι πρόγονος του `%s'"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "λάθος αριθμός ορισμάτων"
@@ -24977,7 +25020,7 @@ msgstr "λάθος αριθμός ορισμάτων"
 msgid "expected %i or more, found %i"
 msgstr ""
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "Μη ορισμένο όνομα %s"
@@ -25060,12 +25103,12 @@ msgstr ""
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25183,134 +25226,134 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "location is after end of function"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 #| msgid "';' expected"
 msgid "Not expected TAG."
 msgstr "αναμενόταν ';'"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "αδυναμία ανοίγματος αρχείου εισόδου `%s'"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr ""
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "δεν είναι δυνατό να μετανομαστεί το `.' ή το `..'"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "δε βρέθηκε ο προεπεξεργαστής C: %s \n"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "δε βρέθηκε ο προεπεξεργαστής C: %s \n"
@@ -25320,7 +25363,7 @@ msgstr "δε βρέθηκε ο προεπεξεργαστής C: %s \n"
 msgid "offset %qwi outside bounds of constant string"
 msgstr ""
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 msgid "%qE declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -25423,7 +25466,7 @@ msgstr "Ο αριθμός σύνδεσμου είναι έξω από το όρ
 msgid "illegal argument 0 to %qs"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr "Λείπει παράμετρος για `%s'"
@@ -25497,12 +25540,12 @@ msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 msgid "cannot tail-call: %s"
 msgstr "αδυναμία εκτέλεσης ioctl στο `%s'"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr ""
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "Λείπει παράμετρος για `%s'"
@@ -26146,344 +26189,344 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr ""
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr ""
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr ""
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "δεν δώθηκε συμβολικό όνομα"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr ""
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr ""
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr ""
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr ""
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "ορισμός δικαιωμάτων στο %s"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr ""
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "ορισμός δικαιωμάτων στο %s"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "ορισμός δικαιωμάτων στο %s"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "ορισμός δικαιωμάτων στο %s"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, fuzzy, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr ""
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "έχουν παραληφθεί ορίσματα"
@@ -27255,17 +27298,17 @@ msgstr ""
 msgid "impossible constraint in %<asm%>"
 msgstr ""
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr ""
@@ -27944,7 +27987,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -27984,7 +28027,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 msgid "%qD defined here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -28004,24 +28047,24 @@ msgstr "Μη έγκυρη πισω-παραπομπή"
 msgid "function may return address of local variable"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr ""
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -28911,7 +28954,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr ""
@@ -28983,206 +29026,206 @@ msgstr ""
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "μη έγκυρος αριθμός πεδίου: `%s'"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 msgid "valid models are %e"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "μη έγκυρος αριθμός πεδίου: `%s'"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "Στη συνάρτηση μέλος `%s':"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "in a call to function %qD"
 msgstr "κλήση σε μη-συνάρτηση %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 msgid "assigned here"
 msgstr "προσπέρασμα ορίσματος"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr "μόνο ένα όρισμα μπορεί να δηλωθεί"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "άγνωστος χαρακτήρας `%s'"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 msgid "call to %qD here"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "ΣΦΑΛΜΑ: Αδυναμία δημιουργίας προσωρινού αρχείου για αλλαγή"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "call to %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr ""
@@ -29988,346 +30031,346 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, fuzzy, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr ""
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "Κακοσυνταίριασμα τύπων καταχώρησης/πίνακα"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, fuzzy, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "Κακοσυνταίριασμα τύπων καταχώρησης/πίνακα"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 msgid "mismatching definition"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
@@ -30347,7 +30390,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "μη έγκυρη μέτρηση επανάληψης `%s' στη κατασκευή [c*n]"
@@ -30577,12 +30620,12 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr "αδυναμία εύρεσης βρόχου"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr ""
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -30952,7 +30995,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -32342,22 +32385,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr ""
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -33294,167 +33337,167 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr ""
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr ""
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "μη έγκυρος χρήστης"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "μη έγκυρη επιλογή %s"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr ""
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr ""
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "μη έγκυρος αρχικός αριθμός γραμμής: `%s'"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "μη έγκυρη διαμόρφωση συντόμευσης"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "μη έγκυρος αρχικός αριθμός γραμμής: `%s'"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -33465,597 +33508,597 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr ""
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "μη έγκυρη μέτρηση επανάληψης `%s' στη κατασκευή [c*n]"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "RPC: Μη συμβατές εκδόσεις του RPC"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "μη έγκυρη μέτρηση επανάληψης `%s' στη κατασκευή [c*n]"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, fuzzy, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, fuzzy, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, fuzzy, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "μη έγκυρη διαμόρφωση συντόμευσης"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "παράληψη ορίσματος αρχείου"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "μη έγκυρη μέτρηση επανάληψης `%s' στη κατασκευή [c*n]"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "μη έγκυρη επιλογή %s"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "Εμφάνιση έκδοσης προγράμματος"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "Ο αριθμός σύνδεσμου είναι έξω από το όριο"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr ""
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "Έχει παραληφθεί εντολή"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "Έχει παραληφθεί εντολή"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr ""
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "μη έγκυρη μέτρηση επανάληψης `%s' στη κατασκευή [c*n]"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr ""
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "Χρήση ξεχωριστής λανθάνουσας μνήμης για κάθε χρήστη"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "Χρήση ξεχωριστής λανθάνουσας μνήμης για κάθε χρήστη"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "μη έγκυρο δικαίωμα"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr ""
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr ""
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr ""
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "το αρχείο δεδομένων προφίλ `%s' δεν ταιριάζει με το διαμοιραζόμενο αντικείμενο `%s'"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "διπλός ορισμός συνόλου"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, fuzzy, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "ο έλεγχος φθάνει στο τέλος μη-κενής συνάρτησης"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr ""
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr ""
@@ -34235,12 +34278,12 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
@@ -34750,7 +34793,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -35170,29 +35213,29 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "σφάλμα ταιριάσματος τύπου με προηγούμενη αυτονόητη διακύρηξη"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 msgid "%qD conflicts for version %qB"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "αυτός είναι ο πρώτος ορισμός"
@@ -35267,7 +35310,7 @@ msgstr "Δεν ήταν δυνατή η εύρεση ετικέττας για 
 msgid "no initializers are allowed in section %qs"
 msgstr "Δεν ήταν δυνατή η εύρεση ετικέττας για μεταγωγή στο `%s'"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, fuzzy, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
@@ -35412,7 +35455,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr ""
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "Η οικογένεια διευθύνσεων δεν υποστηρίζεται από την οικογένεια πρωτοκόλλου"
@@ -35457,53 +35500,53 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr ""
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr ""
@@ -35518,12 +35561,12 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr ""
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr ""
@@ -35730,12 +35773,12 @@ msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του
 msgid "mode %qs applied to inappropriate type"
 msgstr ""
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, fuzzy, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
@@ -35745,18 +35788,18 @@ msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζοντ
 msgid "section attribute argument not a string constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
@@ -35841,7 +35884,7 @@ msgstr "διπλός προσδιοριστής μηνύματος"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "Στη συνάρτηση μέλος `%s':"
@@ -35887,12 +35930,12 @@ msgstr ""
 msgid "%qE attribute is only applicable on functions"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr ""
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
@@ -35902,12 +35945,12 @@ msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζετ
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
@@ -35998,23 +36041,23 @@ msgstr "το `%s' είναι πρόγονος του `%s'"
 msgid "visibility argument not a string"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -36031,7 +36074,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
@@ -36102,7 +36145,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
@@ -36177,7 +36220,7 @@ msgstr "δεν είστε μέλος της ομάδας `%s'"
 msgid "%qE argument is not a function"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
@@ -36243,7 +36286,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
@@ -36404,15 +36447,15 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
@@ -36680,7 +36723,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr ""
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "μη έγκυρος αριθμός από γραμμές"
@@ -36851,8 +36894,8 @@ msgstr "πολύ λίγα ορίσματα"
 msgid "missing sentinel in function call"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το αρχείο fifo `%s'"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -37862,7 +37905,7 @@ msgstr "μη τερματιζμένο αλφαριθμητικό σταθερά
 msgid "traditional C rejects string constant concatenation"
 msgstr ""
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -37917,7 +37960,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, fuzzy, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
@@ -37932,17 +37975,17 @@ msgstr ""
 msgid "%qE is not initialized"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, fuzzy, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "Η λειτουργία δεν επιτρέπεται"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "μη έγκυρο όνομα μήνα"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 msgid "missing increment expression"
 msgstr "παράληψη ορίσματος αρχείου"
@@ -37952,7 +37995,7 @@ msgstr "παράληψη ορίσματος αρχείου"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
@@ -38047,18 +38090,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -38068,8 +38111,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr ""
@@ -38586,7 +38629,7 @@ msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, fuzzy, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "μη τερματιζόμενo αλφαριθμητικό"
@@ -38661,8 +38704,8 @@ msgstr ""
 msgid "wrong type argument to %s"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -39156,17 +39199,17 @@ msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο ε
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, fuzzy, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, fuzzy, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "Μη αναγνωρίσιμη μεταβλητή `%s'"
@@ -39432,7 +39475,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] ""
 msgstr[1] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -40370,7 +40413,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -40999,7 +41042,7 @@ msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς με
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "διπλός ορισμός συνόλου"
@@ -41045,7 +41088,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -41096,7 +41139,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -41189,19 +41232,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41247,210 +41290,210 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "μη έγκυρος αριθμός από γραμμές"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "μη έγκυρος χρήστης"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "άγνωστο σετ `%s'"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr "Αποτυχία δέσμευσης πόρων συστήματος"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
 # src/dfa.c:569 src/dfa.c:583 src/dfa.c:587
 # src/dfa.c:577 src/dfa.c:591 src/dfa.c:595
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "κακοσχηματισμένος μετρητής επανάληψης"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41458,194 +41501,194 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "ειδικά αρχεία μπλοκ δεν υποστηρίζονται"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, fuzzy, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "%s: αριθμός γραμμής έξω από τα όρια"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "Εμφάνιση έκδοσης προγράμματος"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "το πέρασμα του ορίσματος %d του δείκτη στη συνάρτηση"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -41835,12 +41878,12 @@ msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένα
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41973,22 +42016,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr ""
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
@@ -42525,12 +42568,12 @@ msgstr "το -pipe δεν υποστηρίζεται"
 msgid "%<-fPIE%> is not supported"
 msgstr "Το ai_family δεν υποστηρίζεται"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "οι επιλογές --string και --check είναι αμοιβαίως αποκλειόμενες"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
@@ -42540,7 +42583,7 @@ msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
@@ -42870,7 +42913,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
@@ -43188,7 +43231,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -43354,168 +43397,168 @@ msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένα
 msgid "parameter to builtin not valid: %s"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "λάθος συνθηματικό"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "λάθος συνθηματικό"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 msgid "invalid third argument"
 msgstr "Μη έγκυρη παράμετρος"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
@@ -43910,8 +43953,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
@@ -44153,7 +44196,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -44178,12 +44221,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -44193,128 +44236,128 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr ""
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr ""
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr ""
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr ""
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "Εμφάνιση έκδοσης προγράμματος"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr ""
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "ειδικά αρχεία μπλοκ δεν υποστηρίζονται"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -44367,7 +44410,7 @@ msgstr ""
 msgid "argument %qd is not a constant"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr ""
@@ -44377,7 +44420,7 @@ msgstr ""
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr ""
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr ""
@@ -44530,48 +44573,48 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
@@ -45326,7 +45369,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 msgid "bad builtin code"
 msgstr "μη έγκυρο μήκος γραμμής: %s"
@@ -45551,82 +45594,82 @@ msgstr "αδυναμία ανοίγματος αρχείου εξόδου"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "Η οικογένεια διευθύνσεων δεν υποστηρίζεται από την οικογένεια πρωτοκόλλου"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "Η οικογένεια διευθύνσεων δεν υποστηρίζεται από την οικογένεια πρωτοκόλλου"
@@ -45855,322 +45898,322 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "αδυναμία ανάγνωσης καταλόγου locale `%s'"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "αδυναμία ανάγνωσης καταλόγου locale `%s'"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "μη αναγνωρίσημη επιλογή `-%c'"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to %<%T::%s(%A)%#V%>"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "δεν ταιριάζει συνάρτηση για την κλήση στο %<%T::%s(%A)%#V%>"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "πάρα πολλές δηλώσεις μετατροπής στην κατάληξη"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr ""
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr ""
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr ""
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -47169,22 +47212,22 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr ""
@@ -47407,32 +47450,32 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "Η οικογένεια διευθύνσεων δεν υποστηρίζεται από την οικογένεια πρωτοκόλλου"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47519,7 +47562,7 @@ msgid "%qs attribute only applies to variadic functions"
 msgstr ""
 
 # src/request.c:37
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47600,8 +47643,8 @@ msgstr ""
 msgid "could not get size of source file"
 msgstr "Δεν μπόρεσα να ανοίξω το αρχείο %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr ""
@@ -48081,7 +48124,7 @@ msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 msgid "%qE defined as wrong kind of tag"
 msgstr ""
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr ""
@@ -48230,7 +48273,7 @@ msgstr ""
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr ""
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr ""
@@ -48240,7 +48283,7 @@ msgstr ""
 msgid "%q+D is usually a function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
@@ -48317,7 +48360,7 @@ msgstr ""
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "μη αρχικοποιημένη σταθερά const %qD"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -48518,7 +48561,7 @@ msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεω
 msgid "storage class specified for unnamed parameter"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr ""
@@ -48691,7 +48734,7 @@ msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 msgid "function definition has qualified void return type"
 msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση πεδίου: `%s'"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr ""
@@ -48818,7 +48861,7 @@ msgstr ""
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr ""
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, fuzzy, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
@@ -49030,7 +49073,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr ""
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr ""
@@ -49096,7 +49139,7 @@ msgstr "επώνυμα μέλη"
 msgid "struct has no members"
 msgstr "%s σε %s"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "μη έγκυρη ώρα της μέρας"
@@ -49162,7 +49205,7 @@ msgstr "δημιουργία αρχείου `%s'\n"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr ""
@@ -49217,7 +49260,7 @@ msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
@@ -49367,12 +49410,12 @@ msgstr "λάθος αριθμός ορισμάτων"
 msgid "argument %qD doesn%'t match prototype"
 msgstr ""
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, fuzzy, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "έχουν παραληφθεί ορίσματα"
@@ -49454,7 +49497,7 @@ msgstr ""
 msgid "two or more data types in declaration specifiers"
 msgstr ""
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr ""
@@ -49558,7 +49601,7 @@ msgstr "αρχεία fifo δεν υποστηρίζονται"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
@@ -49715,12 +49758,12 @@ msgstr ""
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -49780,37 +49823,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr ""
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr ""
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr ""
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr ""
@@ -49830,7 +49873,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 msgid "expected end of line"
 msgstr "Μη ορισμένο όνομα %s"
@@ -49840,7 +49883,7 @@ msgstr "Μη ορισμένο όνομα %s"
 msgid "ISO C forbids an empty translation unit"
 msgstr ""
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49887,8 +49930,8 @@ msgid "unknown type name %qE"
 msgstr "άγνωστος χαρακτήρας `%s'"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, fuzzy, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "δημιουργία αρχείου `%s'\n"
@@ -49923,7 +49966,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "το `%s' είναι πρόγονος του `%s'"
@@ -49938,12 +49981,12 @@ msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζοντ
 msgid "unexpected attribute"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
@@ -49986,7 +50029,7 @@ msgstr "το `%s' δεν είναι κανονικό αρχείο"
 msgid "%qs may only be used with a single declarator"
 msgstr ""
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr ""
@@ -50020,7 +50063,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, fuzzy, gcc-internal-format
 msgid "expected string literal"
 msgstr "μη τερματιζόμενo αλφαριθμητικό"
@@ -50050,7 +50093,7 @@ msgstr "μη τερματιζμένο αλφαριθμητικό σταθερά
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr ""
@@ -50104,8 +50147,8 @@ msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, fuzzy, gcc-internal-format
 msgid "expected identifier"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
@@ -50135,12 +50178,12 @@ msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, fuzzy, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "σκουπίδια στο τέλος του αριθμού"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50221,22 +50264,22 @@ msgstr "διπλό όνομα χαρακτήρα `%s'"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
@@ -50246,7 +50289,7 @@ msgstr "μη τερματιζμένο αλφαριθμητικό σταθερά
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr ""
@@ -50276,17 +50319,17 @@ msgstr ""
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr ""
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -50296,44 +50339,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
@@ -50364,7 +50407,7 @@ msgstr ""
 msgid "expected %<}%> before %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -50379,7 +50422,7 @@ msgstr ""
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, fuzzy, gcc-internal-format
 msgid "expected statement"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
@@ -50414,27 +50457,27 @@ msgstr "μη έγκυρη ώρα της μέρας"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr ""
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 msgid "expected declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -50454,12 +50497,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -50474,8 +50517,8 @@ msgstr "δεν είναι δυνατό να δημιουργηθεί το αρχ
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "διπλός αριθμός μηνύματος"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -50497,12 +50540,12 @@ msgstr ""
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr ""
@@ -50674,7 +50717,7 @@ msgstr "αρχεία fifo δεν υποστηρίζονται"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, fuzzy, gcc-internal-format
 msgid "expected expression"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
@@ -50689,12 +50732,12 @@ msgstr ""
 msgid "ISO C forbids braced-groups within expressions"
 msgstr ""
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr ""
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -50840,7 +50883,7 @@ msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζοντ
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "λάθος αριθμός ορισμάτων"
@@ -50880,7 +50923,7 @@ msgstr ""
 msgid "rotate count is negative"
 msgstr ""
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -50990,7 +51033,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -51030,12 +51073,12 @@ msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χ
 msgid "no type or storage class may be specified here,"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 msgid "missing property attribute"
 msgstr "Ελλιπής ή κακοσχηματισμένη ιδιότητα"
@@ -51045,57 +51088,57 @@ msgstr "Ελλιπής ή κακοσχηματισμένη ιδιότητα"
 msgid "unknown property attribute %<%s%s%>"
 msgstr ""
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr ""
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -51105,12 +51148,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr ""
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
@@ -51120,11 +51163,11 @@ msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "πάρα πολλά ορίσματα"
@@ -51139,58 +51182,58 @@ msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 msgid "%qD is not a variable"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr ""
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr ""
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -51213,22 +51256,22 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr ""
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr ""
@@ -51238,99 +51281,99 @@ msgstr ""
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr ""
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr ""
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "διπλό κλειδί"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr ""
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, fuzzy, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "μη έγκυρος δηλωτής πεδίου: `%s'"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "μη έγκυρο δικαίωμα"
@@ -51340,38 +51383,38 @@ msgstr "μη έγκυρο δικαίωμα"
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr ""
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr "διπλό κλειδί"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -51386,22 +51429,22 @@ msgstr ""
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr ""
@@ -51411,7 +51454,7 @@ msgstr ""
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51426,315 +51469,315 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr ""
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "μη έγκυρος χρήστης"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "μη έγκυρο όνομα μήνα"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "υπερβολικά πολλά αρχεία εισόδου"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "υπερβολικά πολλά αρχεία εισόδου"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "υπερβολικά πολλά αρχεία εισόδου"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 msgid "invalid map kind"
 msgstr "μη έγκυρος χρήστης"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr ""
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "Μη έγκυρη ημερομηνία `%s'."
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "Μη έγκυρη ημερομηνία `%s'."
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr ""
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "άγνωστος χαρακτήρας `%s'"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "multi-line string literals are deprecated"
 msgid "non-empty string literal expected"
 msgstr "δε συνίσταται πια η χρήση αλφαριθμητικών σταθερών πολλαπλών γραμμών"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "διπλό κλειδί"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "διπλό κλειδί"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "διπλό κλειδί"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr ""
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr ""
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -51749,7 +51792,7 @@ msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 msgid "expected function name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "Το `%s' δεν είναι κατάλογος."
@@ -51759,22 +51802,22 @@ msgstr "Το `%s' δεν είναι κατάλογος."
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr ""
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -51800,7 +51843,7 @@ msgstr ""
 msgid "modified here"
 msgstr ""
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -51835,110 +51878,110 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr ""
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr ""
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, fuzzy, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
@@ -51948,27 +51991,27 @@ msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr ""
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr ""
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -51978,32 +52021,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr ""
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 msgid "for statement expected"
 msgstr "αναμενόταν ')'\n"
@@ -52011,68 +52054,68 @@ msgstr "αναμενόταν ')'\n"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 msgid "loop nest expected"
 msgstr "αναμενόταν ')'\n"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, fuzzy, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "εμφάνιση πληροφοριών προόδου"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr ""
@@ -52082,7 +52125,7 @@ msgstr ""
 msgid "expected a function name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, gcc-internal-format
 msgid "expected target-function call"
 msgstr ""
@@ -52092,47 +52135,47 @@ msgstr ""
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -52147,57 +52190,57 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr ""
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "μη τερματιζόμενo αλφαριθμητικό"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "ειδικά αρχεία μπλοκ δεν υποστηρίζονται"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr ""
@@ -52207,27 +52250,27 @@ msgstr ""
 msgid "variant %qD is not a function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -52237,7 +52280,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr ""
@@ -52247,17 +52290,17 @@ msgstr ""
 msgid "%<need_device_addr%> is not valid for C"
 msgstr ""
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
@@ -52277,12 +52320,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr ""
@@ -52292,7 +52335,7 @@ msgstr ""
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "μη πλήρης εγγραφή"
@@ -52302,7 +52345,7 @@ msgstr "μη πλήρης εγγραφή"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -52317,84 +52360,84 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr ""
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr ""
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr ""
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr ""
@@ -52419,12 +52462,12 @@ msgstr ""
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 msgid "unexpected clause"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "Ελλιπής ή κακοσχηματισμένη ιδιότητα"
@@ -52484,32 +52527,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr ""
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -52524,160 +52567,160 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 msgid "expected directive name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "άγνωστο σετ `%s'"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 msgid "unknown directive name"
 msgstr "άγνωστος χαρακτήρας `%s'"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr ""
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -52687,7 +52730,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -52702,7 +52745,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, fuzzy, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
@@ -52733,171 +52776,171 @@ msgstr "μη έγκυρος δεύτερος τελεστής σε κατάστ
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr ""
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr ""
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr ""
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "μη έγκυρη ώρα της μέρας"
 
 # src/main.c:697 src/main.c:751
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "Άγνωστη γλώσσα `%s'"
 
 # src/main.c:697 src/main.c:751
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, fuzzy, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "Άγνωστη γλώσσα `%s'"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, fuzzy, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "Δεν μπορεί να καθοριστεί το όνομα του συστήματος"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "το πέρασμα του ορίσματος %d του δείκτη στη συνάρτηση"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "το πέρασμα του ορίσματος %d του δείκτη στη συνάρτηση"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 msgid "array subscript is negative"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr ""
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr ""
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
@@ -52905,1866 +52948,1866 @@ msgstr "Το επώνυμο αντικείμενο δεν είναι αναζη
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr ""
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση πεδίου: `%s'"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr ""
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "το πέρασμα του ορίσματος %d του δείκτη στη συνάρτηση"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "το πέρασμα του ορίσματος %d του δείκτη στη συνάρτηση"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to procedure `%s'"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "πάρα πολλά ορίσματα στη ρουτίνα `%s'"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "πάρα πολλά ορίσματα"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "πολύ λίγα ορίσματα"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "πολύ λίγα ορίσματα"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "πολύ λίγα ορίσματα"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, fuzzy, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "Δεν μπορεί να καθοριστεί το όνομα του συστήματος"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr ""
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr ""
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr ""
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "Μη αναγνωρίσιμη μεταβλητή `%s'"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "Εξαίρεση κινητής υποδιαστολής"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr ""
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr ""
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "αδυναμία ανάγνωσης καταλόγου locale `%s'"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το αρχείο fifo `%s'"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr ""
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr ""
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, fuzzy, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "Σφάλμα στο ταίριασμα στην κανονική έκφραση `%s'"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr ""
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr ""
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr ""
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr ""
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr ""
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr ""
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr ""
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr ""
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr ""
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
 # src/request.c:263
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, fuzzy, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "Το βήμα αρχικοποίησης απέτυχε"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, fuzzy, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 msgid "expected %e but argument is of type %e"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 msgid "%e declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr ""
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, fuzzy, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, fuzzy, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του επεξεργαστή."
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του επεξεργαστή."
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, fuzzy, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr ""
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr ""
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, fuzzy, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer"
 msgstr "μη έγκυρο μέγεθος οριζόντιου στηλοθέτη: %s"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, fuzzy, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr ""
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr ""
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, fuzzy, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, fuzzy, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr ""
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr ""
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr ""
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr ""
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του επεξεργαστή."
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr ""
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, fuzzy, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, fuzzy, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr ""
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, gcc-internal-format
 msgid "function returns address of nested function referencing local context"
 msgstr ""
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr ""
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr ""
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr ""
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr ""
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr ""
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr ""
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr ""
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr ""
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr ""
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr ""
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr ""
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "εσωτερικό σφάλμα στο %s, γραμμή %u"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr ""
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "Οι ορισμοί πηγή βρίσκονται στο ΑΡΧΕΙΟ"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr ""
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "Εμφάνιση έκδοσης προγράμματος"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr ""
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, fuzzy, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -55032,253 +55075,248 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr ""
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s: μη έγκυρο είδος αρχείου"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr ""
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr ""
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55287,72 +55325,82 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr ""
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "άγνωστο σετ `%s'"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr ""
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55362,13 +55410,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "υπερβολικά πολλά αρχεία εισόδου"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr ""
@@ -55383,63 +55431,63 @@ msgstr "μη τερματιζόμενo αλφαριθμητικό"
 msgid "%s exited with status %d"
 msgstr "%s: Ο προεπεξεργαστής C απέτυχε με σήμα %d\n"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
 # src/request.c:37
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr "%s σε %s"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr ""
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr "%s: η έξοδος θα επικαλύψει το %s\n"
 
 # src/request.c:37
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: "
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr "%s: Σφάλμα κατά την εγγραφή του %s\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr "συντακτικό σφάλμα στον ορισμού locale μηνύματος"
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "%s: Σφάλμα κατά την εγγραφή του %s\n"
@@ -55889,7 +55937,7 @@ msgstr ""
 msgid "%q#D is private within this context"
 msgstr ""
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 msgid "declared private here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -55899,7 +55947,7 @@ msgstr "Δεν υπάρχει προηγούμενη κανονική έκφρα
 msgid "%q#D is protected within this context"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 msgid "declared protected here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -56230,7 +56278,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr ""
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 msgid "cannot convert %qH to %qI"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
@@ -56252,7 +56300,7 @@ msgstr "δεν ταιριάζει συνάρτηση για την κλήση σ
 msgid "call to non-function %qD"
 msgstr "κλήση σε μη-συνάρτηση %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -56853,7 +56901,7 @@ msgstr ""
 msgid "next member %q#D declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, fuzzy, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "κανένας ορισμός του `UNDEFINED'"
@@ -56863,7 +56911,7 @@ msgstr "κανένας ορισμός του `UNDEFINED'"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -56994,7 +57042,7 @@ msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -57045,7 +57093,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -57080,841 +57128,841 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση πεδίου: `%s'"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr ""
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr ""
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr ""
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "κλήση σε μη-συνάρτηση %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "Δεν μπορεί να καθοριστεί το όνομα του συστήματος"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to internal function %qE"
 msgstr "κλήση σε μη-συνάρτηση %qD"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr ""
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr ""
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr ""
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr ""
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr ""
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "αυτή είναι η θέση του πρώτου ορισμού"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "αυτή είναι η θέση του πρώτου ορισμού"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "Δεν μπορεί να καθοριστεί το όνομα του συστήματος"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 msgid "%qT object created here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 msgid "allocated here"
 msgstr "διπλό κλειδί"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "μη έγκυρο μέγεθος οριζόντιου στηλοθέτη: %s"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "το `%s' είναι μη-προσπελάσιμο"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 msgid "use of %qD"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr ""
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr ""
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr ""
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr ""
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr ""
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "Μη ορισμένο όνομα %s"
@@ -58048,352 +58096,352 @@ msgstr "μη έγκυρη μέτρηση επανάληψης `%s' στη κατ
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr ""
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr ""
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an aggregate"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an array"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
+msgid "%qT is not a structural type"
+msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 msgid "invalid constraints"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr ""
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -58423,47 +58471,47 @@ msgstr ""
 msgid "previous declaration with fewer contracts here"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "parameter declared here"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 msgid "first declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr ""
@@ -58534,7 +58582,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
@@ -58607,84 +58655,84 @@ msgstr ""
 msgid "awaitable type %qT is not a structure"
 msgstr "Έγκυρα ορίσματα είναι:"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr ""
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "Λείπει παράμετρος για `%s'"
 
 # src/outer.c:102
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "Ο αντιτοποθετητής επιφάνειας έχει τεθεί περισσότερο από μια φορά για το `%s'"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -58709,68 +58757,73 @@ msgstr "Το `%s' δεν είναι κατάλογος."
 msgid "%qs used outside of constant expressions"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "διπλό όνομα χαρακτήρα `%s'"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "μη έγκυρος αριθμός από στήλες: `%s'"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -58815,7 +58868,7 @@ msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαρ
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, fuzzy, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "Δεν μπορεί να καθοριστεί το όνομα του συστήματος"
@@ -59207,7 +59260,7 @@ msgstr "αυτός είναι ο πρώτος ορισμός"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "αυτός είναι ο πρώτος ορισμός"
@@ -59428,12 +59481,12 @@ msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 msgid "previous specification in %q#D here"
 msgstr "%s: Μη έγκυρη ρύθμιση `%s'.\n"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -59640,7 +59693,7 @@ msgstr "Το βήμα αρχικοποίησης απέτυχε"
 msgid "  enters %<template for%> statement"
 msgstr ""
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
@@ -59685,2425 +59738,2435 @@ msgstr "το `%s' δεν είναι κανονικό αρχείο"
 msgid "template parameters do not match template %qD"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr ""
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr ""
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr ""
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr ""
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr ""
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr ""
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "μόνο ένα όρισμα μπορεί να δηλωθεί"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr ""
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr ""
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr ""
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "Δεν ήταν δυνατή η εύρεση ετικέττας για μεταγωγή στο `%s'"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr ""
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr ""
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr ""
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr ""
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
 # src/request.c:263
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, fuzzy, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "Το βήμα αρχικοποίησης απέτυχε"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, fuzzy, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr ""
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr ""
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, fuzzy, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr ""
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "σφάλμα κατά το κλείσιμο της εισόδου `%s'"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr ""
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "Το όνομα `%s' είναι άγνωστο\n"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "Το όνομα `%s' είναι άγνωστο\n"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "μη αρχικοποιημένη σταθερά const %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr ""
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr ""
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, fuzzy, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr ""
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "μη έγκυρο μέγεθος οριζόντιου στηλοθέτη: %s"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, fuzzy, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "υπερβολικά πολλά αρχεία εισόδου"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, fuzzy, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, fuzzy, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr ""
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr ""
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, fuzzy, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr ""
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr ""
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr ""
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "η επιστρεφόμενη τιμή της `%s' δεν είναι `int'"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, fuzzy, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr ""
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr ""
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "Δεν είναι δυνατή η εκχώρηση της ζητηθήσας διεύθυνσης"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 msgid "lambda declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr ""
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr ""
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr ""
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "σφάλμα κατά το κλείσιμο της εισόδου `%s'"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr ""
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "συνεχίζεται στο τμήμα"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr ""
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr ""
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr ""
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 msgid "  declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr ""
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> πρέπει να επιστρέψει %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr ""
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "κανένας ορισμός του `UNDEFINED'"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr ""
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr ""
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "μη έγκυρος δεύτερος τελεστής σε κατάσταση συμβατότητας `%s'"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr ""
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr ""
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr ""
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr ""
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr ""
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr ""
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr ""
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr ""
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "creating array of void"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 msgid "creating array of functions"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "creating array of references"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 msgid "creating array of function members"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr ""
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 msgid "%e and %e specified together"
 msgstr "μόνο ένα όρισμα μπορεί να δηλωθεί"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr ""
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%s'"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, fuzzy, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr "Δεν υπάρχουν αρχεία εισόδου"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, fuzzy, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr ""
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "μη ορισμένο"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr ""
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "μη ορισμένο"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr ""
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, fuzzy, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "Μη έγκυρη προτεραιότητα `%s'"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, fuzzy, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, fuzzy, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων λέξεων-κλειδιών"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr ""
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr ""
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr ""
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "μη έγκυρος αριθμός από γραμμές"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "μη έγκυρος αριθμός από γραμμές"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "άγνωστος χαρακτήρας στο πεδίο `%s' της κατηγορίας `%s'"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, fuzzy, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr ""
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, fuzzy, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr ""
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "δεν είναι δυνατόν να γίνει `stat' το locale αρχείο `%s'"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "άγνωστος χαρακτήρας στο πεδίο `%s' της κατηγορίας `%s'"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr ""
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr ""
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr ""
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr ""
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, fuzzy, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr ""
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "Υπάρχει αντικείμενο με το ίδιο όνομα"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr ""
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, fuzzy, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, fuzzy, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr ""
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr ""
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr ""
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
 # src/grep.c:785 src/grep.c:792
 # src/grep.c:1060 src/grep.c:1067 src/grep.c:1076
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "μη έγκυρο όρισμα μήκους περιεχομένου"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "μη έγκυρη ώρα της μέρας"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%#D'"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "αδυναμία ανοίγματος του `%s'"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr ""
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, fuzzy, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr ""
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
 # src/shred.c:1134
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "%s: το αρχείο είναι πολύ μεγάλο"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr ""
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, fuzzy, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, fuzzy, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "μη έγκυρη τάξη χαρακτήρων `%s'"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr ""
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr ""
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr ""
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr ""
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr ""
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr ""
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, fuzzy, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr ""
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, fuzzy, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr ""
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr ""
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr ""
@@ -62115,102 +62178,102 @@ msgstr ""
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, fuzzy, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "έχουν παραληφθεί ορίσματα"
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, fuzzy, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr ""
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, fuzzy, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 msgid "previous definition here"
 msgstr "κανένας ορισμός του `UNDEFINED'"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr ""
@@ -62219,87 +62282,92 @@ msgstr ""
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr ""
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr ""
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr ""
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, fuzzy, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, fuzzy, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "η επιστρεφόμενη τιμή της `%s' δεν είναι `int'"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr ""
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr ""
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, fuzzy, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 msgid "using %qs"
 msgstr "σφάλμα ανάγνωσης %s"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "αυτός είναι ο πρώτος ορισμός"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -62732,342 +62800,342 @@ msgstr ""
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr ""
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr ""
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "Στη συνάρτηση μέλος `%s':"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr ""
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 #| msgid "In function"
 msgid "In lambda function"
 msgstr "Στη συνάρτηση"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "Στη συνάρτηση μέλος `%s':"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 msgid "In member function %qD"
 msgstr "Στη συνάρτηση μέλος `%s':"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs:"
 msgid "In function %qD"
 msgstr "Στη συνάρτηση %qs:"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "υπερβολικά πολλά δευτερόλεπτα αναπήδησης"
 
 # lib/argmatch.c:188
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "Έγκυρα ορίσματα είναι:"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr ""
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "κακό όρισμα"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr ""
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s: Μη έγκυρη ρύθμιση `%s'.\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr ""
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr ""
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr ""
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr ""
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr ""
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "χωρίς ορίσματα"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "χωρίς ορίσματα"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, fuzzy, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
@@ -63288,7 +63356,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -63406,7 +63474,7 @@ msgstr "Το `%s' δεν είναι κατάλογος."
 msgid "type %qT is not a direct base of %qT"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class type"
@@ -63597,42 +63665,42 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr ""
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 msgid "operator %<delete%> used on incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
@@ -63667,82 +63735,90 @@ msgstr "μη πλήρης εγγραφή"
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr ""
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, fuzzy, gcc-internal-format
 msgid "%qD not defined"
 msgstr "αόριστο"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -63752,64 +63828,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -64194,7 +64263,7 @@ msgstr "δημιουργία αρχείου `%s'\n"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "Μη έγκυρη ανταλλαγή"
@@ -64209,422 +64278,422 @@ msgstr "αυτός είναι ο πρώτος ορισμός"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 msgid "existing default declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr ""
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση πεδίου: `%s'"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "κανένας ορισμός του `UNDEFINED'"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "Μεταγλωττισμός προδιαγραφών τοπικών ρυθμίσεων"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "αδυναμία ανοίγματος αρχείου εξόδου `%s'"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr ""
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr ""
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 msgid "module %qs found"
 msgstr "το αρχείο χάρτη χαρακτήρων `%s' δεν βρέθηκε"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "Κακοσυνταίριασμα τύπων καταχώρησης/πίνακα"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "ειδικά αρχεία μπλοκ δεν υποστηρίζονται"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%#D'"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "αυτονόητη διακύρηξη της συνάρτησης `%#D'"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 msgid "module declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
@@ -64636,107 +64705,107 @@ msgstr "Δεν υπάρχει προηγούμενη κανονική έκφρα
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr ""
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr ""
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr ""
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "άγνωστο σετ `%s'"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr ""
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "σφάλμα εγγραφής %s"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "άγνωστο σετ `%s'"
@@ -64751,7 +64820,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
@@ -64796,264 +64865,274 @@ msgstr "δημιουργία αρχείου `%s'\n"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr ""
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
 # src/request.c:37
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s: %s: "
 
 # src/request.c:37
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s: %s: "
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, fuzzy, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 msgid "it was later defined here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr ""
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "%%%c: κατευθυντήριος γραμμή μη έγκυρη."
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "δεν είναι δυνατό να μετανομαστεί το `.' ή το `..'"
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "κανένας ορισμός του `UNDEFINED'"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -65083,7 +65162,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -65128,7 +65207,7 @@ msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 msgid "request for member %qE in non-class type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
@@ -65198,7 +65277,7 @@ msgstr ""
 msgid "%qE is not a class template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
@@ -65509,1694 +65588,1704 @@ msgstr ""
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "Το `%s' δεν είναι κατάλογος."
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr ""
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr ""
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, fuzzy, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr ""
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr ""
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr ""
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr ""
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr ""
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr ""
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr ""
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr ""
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr ""
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr ""
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr ""
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr ""
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr ""
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "παλαιού είδους θέση"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr ""
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr ""
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr ""
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr ""
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "Μη αναγνωρίσιμη μεταβλητή `%s'"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr ""
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr ""
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 msgid "condition declares an array"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 msgid "condition declares a function"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr ""
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 msgid "expected initializer"
 msgstr "μη έγκυρο μέγεθος οριζόντιου στηλοθέτη: %s"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr ""
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr ""
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 msgid "expected module-partition"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 msgid "expected module-name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr ""
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr ""
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr ""
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr ""
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "προειδοποίηση: το --pid=PID δεν υποστηρίζεται σε αυτό το σύστημα"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr ""
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, fuzzy, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση πεδίου: `%s'"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr ""
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, fuzzy, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "πολλαπλός αριθμός επιλογών την εντολή `s'"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "Η αλυσίδα μορφής δεν είναι έγκυρη: `%s'"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr ""
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr ""
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr ""
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr ""
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr ""
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "Μη έγκυρη ρύθμιση θύρας (port)"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr ""
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr ""
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "μη έγκυρος αριθμός πεδίου: `%s'"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr ""
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 msgid "expected operator"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr ""
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "Μη έγκυρος χαρακτήρας παραβολής"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "Μη έγκυρος χαρακτήρας παραβολής"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 msgid "expected template-id"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, fuzzy, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, fuzzy, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 msgid "expected template-name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr ""
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 msgid "expected template-argument"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr ""
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
 # src/dfa.c:962
 # src/dfa.c:970
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 msgid "expected type specifier"
 msgstr "Δεν ορίστηκε συντακτικό"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 msgid "expected type-name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr ""
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr ""
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr ""
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr ""
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, fuzzy, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr ""
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr ""
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr ""
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "άγνωστο σετ `%s'"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr ""
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr ""
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "μη έγκυρος δεύτερος τελεστής σε κατάσταση συμβατότητας `%s'"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "διπλός αριθμός μηνύματος"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr ""
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "διπλός προσδιοριστής μηνύματος"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr ""
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr ""
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr ""
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr ""
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση πεδίου: `%s'"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "Δεν ήταν δυνατή η εύρεση ετικέττας για μεταγωγή στο `%s'"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr ""
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, fuzzy, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
@@ -67205,275 +67294,275 @@ msgstr "το `%s' δεν είναι κανονικό αρχείο"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 msgid "invalid declarator"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "μη έγκυρος αριθμός από γραμμές"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 msgid "expected declarator"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, fuzzy, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, fuzzy, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "διπλός αριθμός μηνύματος"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "διπλός αριθμός μηνύματος"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "διπλός αριθμός μηνύματος"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "Ελλιπής ή κακοσχηματισμένη ιδιότητα"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "μη έγκυρος χρήστης"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr ""
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr ""
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr ""
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr ""
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, fuzzy, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr "%s: Αναμενόταν δυαδικός χειριστής.\n"
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr ""
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 msgid "expected class-name"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "διπλό κλειδί"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr ""
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, fuzzy, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr ""
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr ""
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "κανένας ορισμός του `UNDEFINED'"
@@ -67481,268 +67570,268 @@ msgstr "κανένας ορισμός του `UNDEFINED'"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 msgid "expected class-key"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, fuzzy, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "μη έγκυρος αριθμός πεδίου: `%s'"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr ""
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr "κενό αλφαριθμητικό"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr ""
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "Κακή αίτηση παραμέτρων"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on %qs"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr "Μη αναγνωρίσιμη μεταβλητή `%s'"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr ""
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, fuzzy, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
@@ -67751,434 +67840,434 @@ msgstr "διπλό όνομα χαρακτήρα `%s'"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr ""
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, fuzzy, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr ""
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "Μη έγκυρη ρύθμιση θύρας (port)"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr ""
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "Μη έγκυρη ρύθμιση θύρας (port)"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr ""
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "αρχεία fifo δεν υποστηρίζονται"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "μη έγκυρος δηλωτής πεδίου: `%s'"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "διπλό κλειδί"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "διπλό κλειδί"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, fuzzy, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, fuzzy, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, fuzzy, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, fuzzy, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr ""
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, fuzzy, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr ""
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, fuzzy, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, fuzzy, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr ""
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr ""
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr ""
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr ""
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr ""
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr ""
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr ""
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, fuzzy, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "άγνωστο σετ `%s'"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "μη τερματιζόμενο όνομα βάρους"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr ""
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
 # src/grep.c:785 src/grep.c:792
 # src/grep.c:1060 src/grep.c:1067 src/grep.c:1076
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, fuzzy, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "μη έγκυρο όρισμα μήκους περιεχομένου"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr ""
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "Ακατάλληλη τιμή στο ai_flags"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, fuzzy, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "Προσδιοριστής αφαιρέθηκε"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 msgid "invalid type for property"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr ""
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr ""
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr ""
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "μη έγκυρο μέγεθος οριζόντιου στηλοθέτη: %s"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "Το `%s' δεν είναι κατάλογος."
@@ -68187,173 +68276,173 @@ msgstr "Το `%s' δεν είναι κατάλογος."
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr ""
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr ""
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr ""
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "μη έγκυρο μέγεθος οριζόντιου στηλοθέτη: %s"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr ""
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr ""
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr ""
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr ""
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "κακοδιαμορφωμένη γραμμή αγνοήθηκε"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr ""
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr ""
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -68827,495 +68916,500 @@ msgstr ""
 msgid "redeclaration of %qD with different constraints"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "διπλό όνομα χαρακτήρα `%s'"
+
+#: cp/pt.cc:6461
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, fuzzy, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "διπλό όνομα χαρακτήρα `%s'"
 msgstr[1] "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 msgstr[1] "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, fuzzy, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr ""
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 msgid "redeclared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr ""
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "μη έγκυρος αριθμός από γραμμές"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, fuzzy, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, fuzzy, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, fuzzy, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, fuzzy, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, fuzzy, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr ""
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr ""
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, fuzzy, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "Μη έγκυρη προτεραιότητα `%s'"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr ""
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "%s: Μη έγκυρη ρύθμιση `%s'.\n"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr ""
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr ""
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr "αδυναμία ανοίγματος του `%s'"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr ""
@@ -69333,122 +69427,122 @@ msgstr ""
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "Μη έγκυρη προτεραιότητα `%s'"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, fuzzy, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr ""
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr ""
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr ""
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, fuzzy, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr ""
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr ""
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr ""
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr ""
@@ -69456,208 +69550,208 @@ msgstr ""
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr ""
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr ""
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, fuzzy, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "έχει παραληφθεί η λίστα με τα πεδία"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, fuzzy, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr ""
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, fuzzy, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, fuzzy, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "διπλός ορισμός συνόλου"
 
 # src/request.c:37
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 msgid "%s %#qS"
 msgstr "%s: %s"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, fuzzy, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "Ο έλεγχος μονοπατιού για το `%s' βρήκε `%s'"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr ""
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "αδυναμία ανοίγματος αρχείου ορισμού locale `%s'"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr ""
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "προηγούμενη αυτονόητη διακύρηξη του `%s'"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
@@ -69669,512 +69763,567 @@ msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χ
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr ""
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "Μη έγκυρος χαρακτήρας παραβολής"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr ""
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr ""
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "Δεν μπόρεσα να ανοίξω το αρχείο %s"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr ""
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr ""
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr ""
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr ""
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr "Μη ορισμένο όνομα %s"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 msgid "couldn%'t look up %qs"
 msgstr "αδυναμία εκτέλεσης ioctl στο `%s'"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr ""
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "άγνωστος χαρακτήρας στο πεδίο `%s' της κατηγορίας `%s'"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr ""
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "Μη έγκυρη παράμετρος"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr ""
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "άγνωστο σετ `%s'"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr ""
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "αδυναμία εισαγωγής στοιχείο παραβολής `%.*s'"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "διπλό κλειδί"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr ""
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr ""
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "Το `%s' δεν είναι κατάλογος."
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -70506,587 +70655,587 @@ msgstr "μη έγκυρος αριθμός αρχείου στη δήλωση π
 msgid "invalid base-class specification"
 msgstr "Μη έγκυρη ρύθμιση θύρας (port)"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr ""
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr ""
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments"
 msgstr "Ελλιπής ή κακοσχηματισμένη ιδιότητα"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, fuzzy, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr ""
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr ""
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr ""
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr ""
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "μη έγκυρος αριθμός από στήλες: `%s'"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "μη έγκυρος αριθμός από στήλες: `%s'"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr ""
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
 # src/request.c:37
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s: %s"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr ""
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr ""
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr ""
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr ""
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "αποτυχία κατά την εγγραφή δεδομένων για την κατηγορία `%s'"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr ""
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr ""
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr ""
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr ""
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr ""
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr ""
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr ""
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr ""
@@ -71094,342 +71243,342 @@ msgstr ""
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr ""
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, fuzzy, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 msgid " declared here"
 msgstr "Δεν υπάρχει προηγούμενη κανονική έκφραση"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr ""
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 msgid "%qD is not public"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "το `%s' είναι μη-προσπελάσιμο"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr ""
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr ""
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr ""
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "Μη έγκυρη ανταλλαγή"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr ""
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr ""
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr ""
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr ""
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr ""
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "δημιουργία αρχείου `%s'\n"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "μη τερματιζμένο αλφαριθμητικό σταθεράς"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "διπλός ορισμός συνόλου"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr ""
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr ""
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "αδυναμία ανάγνωσης κεφαλίδας από το `%s'"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr ""
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, gcc-internal-format
 msgid "annotation applied to a label"
 msgstr ""
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 msgid "annotation on void parameter"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr ""
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, gcc-internal-format
 msgid "annotation does not have copy constructible type"
 msgstr ""
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr ""
@@ -71631,801 +71780,806 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "δεν είστε μέλος της ομάδας `%s'"
+
+#: cp/typeck.cc:3781
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr ""
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr ""
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr ""
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 msgid "no default version in scope"
 msgstr "Δεν είναι δυνατόν να βρεθεί η προτεραιότητα."
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr ""
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "πάρα πολλά ορίσματα"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "πολύ λίγα ορίσματα"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "πάρα πολλά ορίσματα"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "πάρα πολλά ορίσματα"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "πάρα πολλά ορίσματα"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "πολύ λίγα ορίσματα"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "πάρα πολλά ορίσματα"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "πολύ λίγα ορίσματα"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, fuzzy, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, fuzzy, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr ""
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr ""
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr ""
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr ""
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, fuzzy, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το αρχείο fifo `%s'"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "μη έγκυρη ώρα της μέρας"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr ""
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr ""
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, fuzzy, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "δεν είναι δυνατόν να γίνει `stat' το locale αρχείο `%s'"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το αρχείο fifo `%s'"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "μη πλήρης εγγραφή"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr ""
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "Λάθος έκφραση στην αποτίμηση: %s"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "η επιστρεφόμενη τιμή της `%s' δεν είναι `int'"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 msgid "converting from %qH to %qI"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr ""
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr ""
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr ""
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, fuzzy, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, fuzzy, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr ""
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr ""
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 msgid "array used as initializer"
 msgstr "έχουν παραληφθεί ορίσματα"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr ""
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 msgid "cannot convert %qH to %qI in return"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, fuzzy, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "xdr_reference: η μνήμη εξαντλήθηκε\n"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "xdr_reference: η μνήμη εξαντλήθηκε\n"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "Έχει παραληφθεί εντολή"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr ""
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr ""
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, fuzzy, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 msgid "returning initializer list"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "`return' χωρίς τιμή, σε συνάρτηση που επιστρέφει μη-κενό"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "μη έγκυρος χρήστης"
@@ -72831,17 +72985,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "άγνωστο σετ `%s'"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%s: διπλός ορισμός έκδοσης κατηγορίας"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -72866,43 +73020,43 @@ msgstr "μη έγκυρο byte ή λίστα πεδίων"
 msgid "the address of %qD will never be %<null%>"
 msgstr ""
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 msgid "nested function missing body"
 msgstr "αδύνατη η φόρτωση δεδομένων προφίλ"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr ""
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr ""
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "δε βρέθηκε ο προεπεξεργαστής C: %s \n"
@@ -72980,32 +73134,32 @@ msgstr ""
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "πάρα πολλά ορίσματα"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "%s: Σφάλμα εγγραφής "
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "αδυναμία ανοίγματος αρχείου εξόδου `%s'"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "%s: Σφάλμα εγγραφής "
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "αδυναμία ανοίγματος αρχείου εξόδου `%s'"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -73105,7 +73259,7 @@ msgstr ""
 msgid "%qs is not an associative array"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -73120,22 +73274,22 @@ msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση
 msgid "%qs is not a field, but a %qs"
 msgstr "δεν είστε μέλος της ομάδας `%s'"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "αδυναμία αλλαγής στο κατάλογο %s"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr "Αδυναμία προσπέλασης του αρχείου της αλλαγής"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
@@ -73227,17 +73381,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "Δεν είναι δυνατό να χρησιμοποιηθεί η επιλογή -a χωρίς το -n"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -73560,8 +73714,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -73838,7 +73992,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "μη έγκυρος αριθμός από στήλες: `%s'"
@@ -73913,7 +74067,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr ""
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
@@ -74053,7 +74207,7 @@ msgstr ""
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr ""
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "είδος μορφής"
@@ -74068,7 +74222,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr ""
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr ""
@@ -74209,8 +74363,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74309,9 +74463,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr ""
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -74326,12 +74480,12 @@ msgstr ""
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr ""
@@ -74426,618 +74580,618 @@ msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένα
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Λείπει παράμετρος για `%s'"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "κενό αλφαριθμητικό"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr ""
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr ""
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr ""
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr ""
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr ""
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr ""
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr ""
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr ""
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr ""
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr ""
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr ""
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr ""
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr ""
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr ""
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr ""
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr ""
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr ""
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr ""
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr ""
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr ""
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr ""
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr ""
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "%s: οι τιμές του πεδίου `%s' δεν πρέπει να είναι μεγαλύτερες από %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr ""
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr ""
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr ""
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr ""
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr ""
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "πάρα πολλά ορίσματα"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "λάθος αριθμός ορισμάτων"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr ""
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr ""
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr ""
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -75102,12 +75256,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -75158,2066 +75312,2066 @@ msgstr ""
 msgid "Simplification error"
 msgstr ""
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "ακολουθούν σκουπίδια στο τέλος της γραμμής"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "υπερβολικά πολλά αρχεία εισόδου"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "κενό αλφαριθμητικό"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr ""
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr ""
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr ""
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr ""
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr ""
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr ""
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr ""
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
 # src/request.c:263
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Το βήμα αρχικοποίησης απέτυχε"
 
 # src/request.c:263
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "Το βήμα αρχικοποίησης απέτυχε"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr ""
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr ""
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του επεξεργαστή."
 
 # src/request.c:263
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Το βήμα αρχικοποίησης απέτυχε"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "%s μετατρέπει ακέραιο σε δείκτη χωρίς μετατροπέα"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr ""
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Η λειτουργία δεν υποστηρίζεται"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Μη έγκυρη επιλογή `%s'"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "ορισμός δικαιωμάτων στο %s"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Το servname δεν υποστηρίζεται από το ai_socktype"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Το servname δεν υποστηρίζεται από το ai_socktype"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "συντακτικό σφάλμα στο ορισμό του %s: %s"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "έχει παραληφθεί το αρχείο προορισμού"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "αυτός είναι ο πρώτος ορισμός"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr ""
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr ""
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Έχει παραληφθεί εντολή"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr ""
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr ""
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "έχει παραληφθεί το όνομα της παραμέτρου"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr ""
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Ελλιπής ή κακοσχηματισμένη ιδιότητα"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "μη έγκυρος αριθμός από κενές γραμμές: `%s'"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "συμβολικοί σύνδεσμοι δεν υποστηρίζονται στο σύστημα αυτό"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr ""
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr ""
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr ""
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Αγνωστος δυαδικός χειριστής."
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr ""
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "%s: αναμενόταν αριθμητική τιμή."
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "Δεν είναι δυνατόν να βρεθεί ο τύπος του επεξεργαστή."
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "συντακτικό σφάλμα στον καθορισμό σειράς"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "συντακτικό σφάλμα στον ορισμό κλάσης χαρακτήρων"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr ""
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr ""
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr ""
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "Εγγραφή ονομάτων των επιλεγμένων κατηγοριών"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "συντακτικό σφάλμα στο ορισμό του %s: %s"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 #| msgid "')' expected"
 msgid "%<)%> expected at %C"
 msgstr "αναμενόταν '('"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr ""
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "άγνωστος χαρακτήρας στο πεδίο `%s' της κατηγορίας `%s'"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr ""
@@ -77360,408 +77514,408 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr ""
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr ""
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr ""
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr ""
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr ""
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "ο διαχωριστής δε μπορεί να είναι κενός"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr ""
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "μη έγκυρο είδος αλφαριθμητικού `%s'"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "%s: Μη έγκυρη ρύθμιση `%s'.\n"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Η παράμετρος κινητής υποδιαστολής δεν είναι έγκυρη: %s"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr ""
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr ""
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "διπλό όνομα χαρακτήρα `%s'"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr ""
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -77769,197 +77923,197 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr ""
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -77980,7 +78134,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -78041,42 +78195,42 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr ""
@@ -78201,12 +78355,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -78632,307 +78786,312 @@ msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένα
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr ""
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr ""
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr ""
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr ""
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "Δεν μπόρεσα να ανοίξω το αρχείο %s"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, fuzzy, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "εσωτερικό σφάλμα στο %s, γραμμή %u"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr ""
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr ""
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr ""
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr ""
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr ""
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to procedure `%s'"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -79124,7 +79283,7 @@ msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζε
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "δεν είναι δυνατό να δημιουργηθεί το %s `%s' στο `%s'"
@@ -79670,7 +79829,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -79841,12 +80000,12 @@ msgstr ""
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -80350,7 +80509,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr ""
@@ -80863,92 +81022,92 @@ msgstr ""
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "συντακτικό σφάλμα στο ορισμό του %s: %s"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "συντακτικό σφάλμα στο ορισμό του %s: %s"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "συντακτικό σφάλμα στο ορισμό του %s: %s"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "συντακτικό σφάλμα στο ορισμό του %s: %s"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "το αρχείο δεδομένων προφίλ `%s' δεν ταιριάζει με το διαμοιραζόμενο αντικείμενο `%s'"
@@ -81931,7 +82090,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -81966,12 +82125,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -82445,7 +82604,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr ""
@@ -82465,7 +82624,7 @@ msgstr ""
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -82495,17 +82654,17 @@ msgstr "εσωτερικό σφάλμα στο %s, γραμμή %u"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -82625,8 +82784,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -82706,7 +82865,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "το `%s' είναι πρόγονος του `%s'"
@@ -82729,7 +82888,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -82769,7 +82928,7 @@ msgstr ""
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr ""
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -83081,598 +83240,608 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr ""
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Μη έγκυρη προπορευόμενη κανονική έκφραση"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -84337,62 +84506,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "η μετατροπή από `%s' σε `%s' δεν υποστηρίζετε"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr ""
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -84400,7 +84569,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -84857,1085 +85026,1085 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr ""
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "η `%s' είναι συνήθως μη-στατική συνάρτηση"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to procedure"
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "πάρα πολλά ορίσματα στη ρουτίνα"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr ""
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Μεταγλωττισμός προδιαγραφών τοπικών ρυθμίσεων"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr ""
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr ""
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr ""
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr ""
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
 # src/getopt.c:628
 # src/getopt.c:628
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "%s: η επιλογή `%s' είναι ασαφής\n"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr ""
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr ""
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr ""
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "Το `%s' δεν είναι κατάλογος."
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr ""
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr ""
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "το `%s' είναι πρόγονος του `%s'"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr ""
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Λάθος έκφραση στην αποτίμηση (λάθος είσοδος): %s"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Μη έγκυρη ακέραια παράμετρος `%s'"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr ""
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "Κακή αίτηση παραμέτρων"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -85944,12 +86113,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -85958,414 +86127,414 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
 # src/shred.c:1134
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%s: το αρχείο είναι πολύ μεγάλο"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "Μη έγκυρη πισω-παραπομπή"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "η τιμή για το %s πρέπει να είναι ακέραιος"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr ""
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -86374,314 +86543,314 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr ""
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr ""
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "%s: αναμενόταν ακέραιος μετά το `%c'"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "Η παράμετρος στο <%s> πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -86689,212 +86858,212 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Μη αναγνωρίσιμη μεταβλητή `%s'"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr ""
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -86902,1058 +87071,1058 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "σχετική θέση αρχείου είναι εκτός ορίων"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr ""
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr ""
 
 # src/request.c:37
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "fstat %s"
 msgid "%s at %L"
 msgstr "fstat %s"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "η `%s' παίρνει είτε κανένα είτε δύο ορίσματα"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Δεν μπορεί να τεθεί η ημερομηνία."
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "Αδυναμία προσπέλασης του αρχείου της αλλαγής"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr ""
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr ""
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr ""
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr ""
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr ""
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -87973,97 +88142,97 @@ msgstr "διαγραφή μη-καταλόγου `%s'\n"
 msgid "%qs is not a directory"
 msgstr "Δεν είναι κατάλογος"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "κενό αλφαριθμητικό"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "μη έγκυρος χαρακτήρας `%c' στο τύπο αλφαριθμητικού `%s'"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "το `%s' δεν είναι κανονικό αρχείο"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr ""
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "αδυναμία ανοίγματος του `%s'"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "αδυναμία ανοίγματος αρχείου εισόδου `%s'"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "αδυναμία ανοίγματος αρχείου εισόδου `%s'"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "%s' δεν είναι ισχύων θετικός ακέραιος."
@@ -88228,218 +88397,218 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "το δεύτερο όρισμα της `%s' πρέπει να είναι `char **'"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "Η παράμετρος στο `%s' πρέπει να είναι ένας απλός χαρακτήρας"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Ο κατάλογος `%s' δεν είναι προσιτός."
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr ""
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr ""
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr ""
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -88779,74 +88948,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr ""
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -88876,29 +89045,34 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "%s: μη έγκυρη κανονική έκφραση: %s"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -89000,115 +89174,115 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "μη πλήρης εγγραφή"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
 # src/shred.c:1134
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "%s: το αρχείο είναι πολύ μεγάλο"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Η παράμετρος `%s' δεν είναι έγκυρη."
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
 # src/shred.c:1134
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "%s: το αρχείο είναι πολύ μεγάλο"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "ο χάρτης χαρακτήρων `%s' ορίστηκε ήδη"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -89139,12 +89313,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "άγνωστη μέθοδος καταλόγων"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -89160,12 +89334,12 @@ msgstr ""
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr ""
@@ -89190,182 +89364,182 @@ msgstr "το --no-dereference (-h) δεν υποστηρίζεται σε αυτ
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 msgid "optional class parameter"
 msgstr "Μη έγκυρος χαρακτήρας παραβολής"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 msgid "unhandled expression"
 msgstr "Μη έγκυρη κανονική έκφραση"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "αδυναμία εκτέλεσης ioctl στο `%s'"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "Το επώνυμο αντικείμενο δεν είναι αναζητήσιμο"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr ""
@@ -89705,7 +89879,7 @@ msgstr "close %s"
 msgid "two or more sections for %s"
 msgstr "Προειδοποίηση: Πολύ λίγα ορίσματα στο εσωδομημένο `%s'"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -90030,32 +90204,32 @@ msgstr "Η λειτουργία δεν έχει υλοποιηθεί"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "Κακή αίτηση παραμέτρων"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "μόνο ένα όρισμα μπορεί να δηλωθεί"
@@ -91799,10 +91973,6 @@ msgstr ""
 #~ msgid "gfc_todo: Not Implemented: "
 #~ msgstr "συγγνώμη, η λειτουργία δεν έχει υλοποιηθεί: "
 
-#, fuzzy
-#~ msgid "%J'%D' used prior to declaration"
-#~ msgstr "αυτός είναι ο πρώτος ορισμός"
-
 #, fuzzy, c-format
 #~ msgid "declaration of %qs shadows a parameter"
 #~ msgstr "Η λειτουργία δεν υποστηρίζεται"
@@ -92878,10 +93048,6 @@ msgstr ""
 #~ msgid "too few arguments to process"
 #~ msgstr "πολύ λίγα ορίσματα"
 
-#, fuzzy
-#~ msgid " and no destination process specified"
-#~ msgstr "Απαιτείται διεύθυνση προορισμού"
-
 #, fuzzy
 #~ msgid "slice length out-of-range"
 #~ msgstr "σχετική θέση αρχείου είναι εκτός ορίων"
--- a/src/gcc/po/es.po
+++ b/src/gcc/po/es.po
@@ -44,7 +44,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 15.2.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2026-02-05 22:30+0100\n"
 "Last-Translator: Antonio Ceballos Roa <aceballos@gmail.com>\n"
 "Language-Team: Spanish <es@tp.org.es>\n"
@@ -1305,12 +1305,12 @@ msgstr "Alias:"
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Versiones ISA PTX conocidas (para uso con la opción -mptx=):"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "Especifica la versión de ISA PTX que se usará."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr "Inicializa los registros ptx."
@@ -2131,13 +2131,13 @@ msgstr "Activa las conversiones predefinidas entre __float128 y long double."
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "USa la guarda de protección de la pila dada."
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2586,7 +2586,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Asume que la CPU destino está configurada como big endian."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Asume que el CPU destino está configurado como little endian."
@@ -2661,7 +2661,7 @@ msgstr "Usa código de prólogo y epílogo más pequeño pero más lento."
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr "Convierte las direcciones BASE + LARGE_OFFSET en NEW_BASE + SMALL_OFFSET para permitir que más accesos a memoria se generen como instrucciones comprimidas."
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2698,7 +2698,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr "Activa las comprobaciones de CSR para el CSR dependiente de ISA y el CSR de solo lectura. Los CR dependientes de ISA solo son válidos cuando el ISA específico está configurado."
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Omite el puntero del marco de referencia para las funciones hojas."
@@ -2808,7 +2808,7 @@ msgstr "-param=vsetvl-strategy=<cadena>\tEstablece el nivel de optimización del
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr "-param=riscv-two-source-permutes Activa las permutaciones con vectores de dos fuentes."
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2857,7 +2857,7 @@ msgstr "-mrvv-vector-bits=<cadena>\tEstablece la clase de bits para un registro
 msgid "The possible TLS dialects:"
 msgstr "Los dialectos de TLS posibles:"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5128,7 +5128,7 @@ msgstr "Admite funciones internas y generación de código RAOINT."
 msgid "Enable conservative small loop unrolling."
 msgstr "Habilita el desenrrollamiento conservador de bucles pequeños."
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr "Limita cuánto puede desenrrollar un bucle el autovectorizador."
@@ -5488,7 +5488,7 @@ msgstr "Cuando se enlaza para objetivos «big endian», genera una imagen en el
 msgid "Cost to assume for a branch insn."
 msgstr "Costo de asumir una ramificación de insn."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr "Utiliza las características de protección de bifurcación."
@@ -5795,213 +5795,218 @@ msgstr "Solución alternativa para la errata de ARM Cortex-A53 número 835769."
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr "Solución alternativa para la errata de ARM Cortex-A53 número 843419."
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "El registro utilizado para acceder al puntero de hilo:"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Especifica el registro de puntero de hilo."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "No asume que los accesos sin alinear los maneja el sistema."
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Especifica el tamaño de bit para los desplazamientos TLS inmediatos. Los valores válidos son 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "Usa las características de la arquitectura ARCH."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "Usa las características de y optimiza para CPU."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr "Optimiza para CPU."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Genera código que cumpla con la ABI especificada."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr "-moverride=<cadena>\t¡Solo usuarios avanzados! Anula los parámetros de optimización de la CPU."
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "ABIs AArch64 conocidas (para uso con la opción -mabi=):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr "Cargas literales relativas a PC."
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr "Selecciona el ámbito de la firma de la dirección de retorno."
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Ámbito de firma de la dirección de retorno de AArch64 disponible (para uso con la opción -msign-return-address=):"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Activa la aproximación de raíz cuadrada recíproca.  Activar esto reduce la precisión de los resultados de la raíz cuadrada recíproca a 16 bits aproximadamente para precisión sencilla y a 32 bits para doble precisión."
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr "Activa la aproximación de raíz cuadrada.  Activar esto reduce la precisión de los resultados de la raíz cuadrada a 16 bits aproximadamente para precisión sencilla y a 32 bits para doble precisión. Si se activa, implica -mlow-precision-recip-sqrt."
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Activa la aproximación de la división.  Activar esto reduce la precisión de los resultados de la divisón a 16 bits aproximadamente para precisión sencilla y a 32 bits para doble precisión. Si se activa, implica -mlow-precision-recip-sqrt."
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr "Especifica cuándo habilitar paso de reserva de registro temprano.  Posibilidades: todas las funciones, funciones con acceso a instrucciones multi-registro por pasos, ninguna función."
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "Las direcciones de vector SVE posibles:"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "-msve-vector-bits=<número>\tEstablece el número de bits en un registro vectorial SVE."
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, fuzzy, no-c-format
 #| msgid "--param=aarch64-autovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization."
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr "--param=aarch64-autovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Fuerza una estrategia de selección de ISA para auto vectorización."
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr "Activa volcado de modelo de coste expresivo en los ficheros de volcado para depuración."
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr "Genera código para rastrear cuándo la CPU podría estar especulando incorrectamente."
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr "Habilita la copia de paso de fusión de parejas load/store de AArch64 que corre antes de la reserva de registros."
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr "Habilita la copia de paso de fusión de parejas load/store de AArch64 que corre después de la reserva de registros."
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Utiliza el registro del sistema especificado en la línea de órdenes como registro de guarda de protección de la pila. Esta opción es para utilizar con fstack-protector-strong y no para utilizar en código del usuario."
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Utiliza un inmediato para desplazar desde el registro de guarda de protección de la pila, sp_el0. Esta opción es para utilizar con fstack-protector-strong y no para utilizar en código del usuario."
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Genera llamadas locales a operaciones atómicas de fuera de línea."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr "Cuando se vectoriza, considera el uso de diversas estrategias y utiliza el modelo de costes para elegir la más barata."
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr "El número de iteraciones de Newton para calcular el recíproco de un tipo float.  La precisión de la división es proporcional a este parámetro cuando la aproximación de la división está habilitada.  El valor predefinido es 1."
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr "El número de iteraciones de Newton para calcular el recíproco de un tipo double.  La precisión de la división es proporcional a este parámetro cuando la aproximación de la división está habilitada.  El valor predefinido es 2."
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr "Tamaño en bytes de memcpy constante por encima del cual empezar a utilizar una secuencia MOPS."
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr "Tamaño en bytes de memmove constante por encima del cual empezar a utilizar una secuencia MOPS."
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr "Tamaño en bytes de memset constante por encima del cual empezar a utilizar una secuencia MOPS."
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr "--param=aarch64-ldp-policy=[default|always|never|aligned] Política de grano fino para pares de load."
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr "--param=aarch64-stp-policy=[default|always|never|aligned] Política de grano fino para pares de store."
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr "Límite del número de comprobaciones de alias realizados cuando se intenta formar un ldp/stp."
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr "Parámetro para controlar qué oportunidades de retroescritura intentamos manejar en los pasos de fusión load/store.  Un valor de cero deshabilita el manejo de la retroescritura. Uno significa que intentamos formar pares implicando uno o más accesos de retroescritura individuales existentes cuando sea posible.  Un valor de dos significa que también intentamos oportunísticamente formar oportunidades de retroescritura incorporando actualizaciones destructivas residuales del registro base utilizado por un par."
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "This option is deprecated and has no effect."
 msgid "This option is deprecated."
@@ -11487,7 +11492,7 @@ msgstr "Activa la vectorización de bucles en árboles."
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18522,97 +18527,97 @@ msgstr "Conforma al estándar ISO 2014 C++."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Conforma al borrador del estándar ISO 202Y C (soporte experimental e incompleto)"
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a map"
 msgid "argument must be passed by copying"
 msgstr "el argumento 1 debe ser un mapa"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 #, fuzzy
 #| msgid "argument is a structure"
 msgid "callee returns a structure"
 msgstr "el argumento es una estructura"
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 #| msgid "call %d returns = %s\n"
 msgid "callee returns twice"
 msgstr "la llamada %d devuelve = %s\n"
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 #| msgid "call %d returns = %s\n"
 msgid "callee does not return"
 msgstr "la llamada %d devuelve = %s\n"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "la variable %qD tiene tipo de función"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "se esperaba función"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "different number of parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "número diferente de parámetros"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s no admite split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "value argument"
 msgid "variable size arguments"
 msgstr "argumento de valor"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "passing too large argument on stack"
 msgid "hidden string length argument passed on stack"
 msgstr "pasando argumento demasiado grande a la pila"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "static assertion failed: %E"
 msgid "tail call production failed"
@@ -18735,12 +18740,12 @@ msgstr "el operando '%%l' no es una etiqueta"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "constante de coma flotante mal usada"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -20078,13 +20083,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "este es la insn:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "invalid operand address"
 msgid "unable to reload address in "
 msgstr "dirección de operando no válida"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "no se pueden generar recargas para:"
 
@@ -20313,7 +20318,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC heurísticas: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anónimo>"
@@ -20705,20 +20710,20 @@ msgstr "no se admite el operando para el código '%c'"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "operando no válido para '%%%c'"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "constante de vector no válida"
@@ -20765,101 +20770,101 @@ msgstr "prefijo de operando no válido '%%%c'"
 msgid "invalid address mode"
 msgstr "modo de direccionamiento no válido"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "conversión no válida desde el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "conversión no válida al tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "negation operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "plus operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "minus operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "multiply operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "divide operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "shift operation not permitted on svbool_t"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 #| msgid "stack usage computation not supported for this target"
 msgid "subscript operation not supported on svbool_t"
 msgstr "no se admite el cálculo de uso de pila para este objetivo"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands in binary operation"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "operandos no válidos en la operación binaria"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20876,13 +20881,13 @@ msgid "invalid %%r value"
 msgstr "valor %%r no válido"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "valor %%R no válido"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "valor %%N no válido"
@@ -20897,7 +20902,7 @@ msgstr "valor %%P no válido"
 msgid "invalid %%h value"
 msgstr "valor %%h no válido"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "valor %%L no válido"
@@ -20912,7 +20917,7 @@ msgstr "valor %%m no válido"
 msgid "invalid %%M value"
 msgstr "valor %%M no válido"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "valor %%U no válido"
@@ -21257,7 +21262,7 @@ msgstr "operando inesperado"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21504,140 +21509,140 @@ msgstr "constante fp no válida"
 msgid "Expected register or constant integer."
 msgstr "se esperaba interfaz o puntero a interfaz"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "UNSPEC no válido como operando"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "uso no válido del registro '%s'"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "tipo no válido de la salida del indicador asm"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "tamaño de operando no válido para el código de operando 'O'"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "tamaño de operando no válido para el código de operando 'z'"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand type used with operand code 'Z'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "se usó un tipo de operando no válido con el código de operando 'Z'"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand size for operand code 'O'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "tamaño de operando no válido para el código de operando 'O'"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "el operando no es un código de condición, código de operando 'Y' no válido"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "el operando no es un código de condición, código de operando 'D' no válido"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "el operando no es un código de condición, código de operando '%c' no válido"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "el operando no es una referencia de memoria desplazable, código de operando 'H' no válido"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "el operando no es un entero, código de operando 'K' no válido"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "el operando no es un entero concreto, código de operando 'r' no válido"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "el operando no es un entero, código de operando 'R' no válido"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "el operando no es un entero concreto, código de operando 'R' no válido"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "el operando no es una referencia de memoria desplazable, código de operando 'H' no válido"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "código de operando '%c' no válido"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "restricciones no válidas para el operando"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "invalid vector constant"
 msgid "invalid vector immediate"
 msgstr "constante de vector no válida"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "modo insn desconocido"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "conversión no válida desde el tipo %<bfloat16_t%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "conversión no válida desde el tipo %<bfloat16_t%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "conversión no válida al tipo %<bfloat16_t%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "conversión no válida al tipo %<bfloat16_t%>"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr "operación no permitida con el tipo %<bfloat16_t%>"
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
@@ -21718,9 +21723,9 @@ msgstr "'%%%c' no es un prefijo de operando válido"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "uso no válido de '%%%c'"
@@ -21785,7 +21790,7 @@ msgid "insn contains an invalid address !"
 msgstr "¡ La insn contiene una dirección no válida !"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "dirección no válida"
 
@@ -21860,7 +21865,7 @@ msgstr "reubicación no válida"
 msgid "invalid %%H value"
 msgstr "valor %%H no válido"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "valor %%d no válido"
@@ -21918,35 +21923,35 @@ msgstr "no se admite la combinación: %s"
 msgid "unsupported memory expression:"
 msgstr "conversión de coma fija no admitida"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%r operand"
 msgid "invalid vector operand"
 msgstr "operando %%r no válido"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "operando no válido para el modificador 'b'"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "'V' modifier on non-integer register"
 msgid "modifier 'H' is for integer registers only"
 msgstr "modificador 'V' en registro no entero"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -22007,7 +22012,7 @@ msgstr "Movimiento de 128 bits erróneo"
 msgid "invalid %%A value"
 msgstr "valor %%J no válido"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "valor %%D no válido"
@@ -22047,7 +22052,7 @@ msgstr "código %%J no válido"
 msgid "invalid %%k value"
 msgstr "valor %%k no válido"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "valor %%K no válido"
@@ -22077,17 +22082,17 @@ msgstr "valor %%T no válido"
 msgid "invalid %%u value"
 msgstr "valor %%u no válido"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "valor %%v no válido"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "valor %%V no válido"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "valor %%x no válido"
@@ -22307,28 +22312,28 @@ msgstr "operando %%s no válido"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "la constante de coma flotante no es un operando inmediato válido"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "el operando 'B' no es una constante"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "el operando 'B' tiene establecidos múltiples bits"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "el operando 'o' no es una constante"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "`%%d' operand isn't a register"
 msgid "'h' operand is not SImode register"
 msgstr "el operando `%%d' no es un registro"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: código desconocido"
@@ -22386,24 +22391,24 @@ msgstr "dirección de operando ilegal (4)"
 msgid "Unable to load DLL."
 msgstr "Genera código para una DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "prueba errónea"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "máscara no válida"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "valor %%t%%b no válido"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "no hay registro en la dirección"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "el desplazamiento de dirección no es una constante"
 
@@ -22437,7 +22442,7 @@ msgstr "{anónimo}"
 msgid "aka"
 msgstr "también conocido como"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anónimo})"
 
@@ -22462,8 +22467,8 @@ msgstr "({anónimo})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "se esperaba %<;%>"
@@ -22491,7 +22496,7 @@ msgstr "se esperaba %<:%> o %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "se esperaba %<)%>"
@@ -22499,7 +22504,7 @@ msgstr "se esperaba %<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "se esperaba %<]%>"
@@ -22519,13 +22524,13 @@ msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "se esperaba %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "se esperaba %<[%>"
@@ -22534,7 +22539,7 @@ msgstr "se esperaba %<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22551,13 +22556,13 @@ msgstr "se esperaba %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "se esperaba %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "se esperaba %<while%>"
@@ -22567,7 +22572,7 @@ msgstr "se esperaba %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "se esperaba %<,%>"
@@ -22577,18 +22582,18 @@ msgid "expected %<.%>"
 msgstr "se esperaba %<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "se esperaba %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "se esperaba %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "se esperaba %<,%> o %<)%>"
@@ -22598,14 +22603,14 @@ msgstr "se esperaba %<,%> o %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "se esperaba %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<)%> or %<,%>"
@@ -22613,32 +22618,32 @@ msgstr "se esperaba %<,%> o %<)%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "se esperaba %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<else%>"
 msgstr "se esperaba %<delete%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "se esperaba %<#pragma omp section%> o %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anónimo)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "se esperaba %<<%>"
@@ -22668,7 +22673,7 @@ msgstr "el candidato es:"
 msgid "  after user-defined conversion:"
 msgstr "Activa las instrucciones definidas por el usuario."
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "el candidato es:"
@@ -22768,7 +22773,7 @@ msgstr "<error de parámetro de plantilla>"
 msgid "<statement>"
 msgstr "<sentencia>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<desconocido>"
@@ -22795,332 +22800,380 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<error de expresión>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<operador desconocido>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "En el ámbito global:"
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "el acumulador no es una constante entera"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "expected initializer"
 msgid "reflect_constant failed"
 msgstr "se esperaba un inicializador"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "el acumulador no es una constante entera"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "redeclaration of friend %q#D may not have default template arguments"
 msgid "reflection does not have template arguments"
 msgstr "la redeclaración de friend %q#D no puede tener argumentos de plantilla por defecto"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "called object is not a function or function pointer"
 msgid "reflection does not represent a function or function type"
 msgstr "el objeto llamado no es una función ni un puntero a función"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "format argument is not a pointer (arg %d)"
 msgid "operators argument is not a valid operator"
 msgstr "el argumento de formato no es un puntero (argumento %d)"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not name a type"
 msgid "reflection does not have a type"
 msgstr "%qE no nombra a un tipo"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "la declaración friend no nombra una clase o función"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 #| msgid "called object is not a function or function pointer"
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "el objeto llamado no es una función ni un puntero a función"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 #| msgid "non-constant condition for static assertion"
 msgid "non-constant offset for offset_of"
 msgstr "condición que no es constante para una aserción estática"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type %qT"
 msgid "reflection with incomplete type in size_of"
 msgstr "puntero deferenciado al tipo de dato incompleto %qT"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment."
 msgid "reflection not suitable for alignment_of"
 msgstr "No ajusta la alineación de los datos modificables."
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "invalid new of function type"
 msgid "alignment_of on function type"
 msgstr "new no válido de tipo de función"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 #| msgid "indirection will not access object of incomplete type %qT in statement"
 msgid "reflection with incomplete type in alignment_of"
 msgstr "la indirección no accederá a un objeto de tipo incompleto %qT en la declaración"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type %qT"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "puntero deferenciado al tipo de dato incompleto %qT"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete type or type alias"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "expected function name"
 msgid "reflect_function failed"
 msgstr "se esperaba nombre de función"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "argument to '-Xassembler' is missing"
 msgid "value member missing"
 msgstr "falta el argumento para '-Xassembler'"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "expected class name"
 msgid "unexpected value of value member"
 msgstr "se esperaba un nombre de clase"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "%qD does not have integral or enumeration type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 #| msgid "expected integer or boolean type"
 msgid "reflection represents non-integral or bool type"
 msgstr "se esperaba un tipo entero o booleano"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qE attribute"
 msgid "invalid argument to can_substitute"
 msgstr "argumento no válido del atributo %qE"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "target is not pointer or reference"
 msgid "type is not object or reference type"
 msgstr "el objetivo no es puntero o referencia"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 #, fuzzy
 #| msgid "conversion from %qT to %qT may change value"
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "la conversión de %qT a %qT puede cambiar el valor"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "\"%s\" is not a valid filename"
 msgid "name is not a valid identifier"
 msgstr "\"%s\" no es un nombre de fichero válido"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 #, fuzzy
 #| msgid "`bool' is now a keyword"
 msgid "name is a keyword"
 msgstr "`bool' ahora es una palabra clave"
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "no se especifica un nombre de registro para %q+D"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+#, fuzzy
+#| msgid " and no destination process specified"
+msgid "no name and non-empty annotations specified"
+msgstr " y no se especificó un proceso destino"
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "la alineación puede no estar especificada para %q+D"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "especificador de anchura de campo"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "shift count is negative"
 msgid "bit_width is negative"
 msgstr "la cuenta de desplazamiento es negativa"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+#| msgid "alignment specified for typedef %qE"
+msgid "name unspecified and type is const"
+msgstr "se especificó la alineación para la definición de tipo %qE"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+#| msgid "alignment specified for typedef %qE"
+msgid "name unspecified and type is volatile"
+msgstr "se especificó la alineación para la definición de tipo %qE"
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a positive power of 2"
 msgid "alignment is not power of two"
 msgstr "la alineación solicitada no es una potencia positiva de 2"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "shift count is negative"
 msgid "alignment is negative"
 msgstr "la cuenta de desplazamiento es negativa"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "la alineación de %qD es más grande que la declaración original"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "%qE does not have pointer or array type"
+msgid "reflection does not have non-array object type"
+msgstr "%qE no es de tipo puntero o matriz"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "%qD does not refer to a function"
+msgid "current scope does not represent a function"
+msgstr "%qD no hace referencia a una función"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "la declaración friend no nombra una clase o función"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qE"
 msgid "incomplete parent class"
 msgstr "implementación incompleta de la clase %qE"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qE is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qE no es una clase o un espacio de nombres"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "source is of incomplete class type"
 msgid "not a complete class type"
 msgstr "la fuente es de tipo de clase incompleto"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 #, fuzzy
 #| msgid "close %d"
 msgid "closure type"
 msgstr "close %d"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "a template cannot be defaulted"
 msgid "value cannot be extracted"
@@ -23166,52 +23219,52 @@ msgstr "la conversión descarta la constancia"
 msgid "source type is not polymorphic"
 msgstr "el tipo fuente no es polimórfico"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "los candidatos son:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "argumento de tipo erróneo para el decremento unario"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "argumento de tipo erróneo para el incremento unario"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "argumento de tipo erróneo para complemento de bits"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "argumento de tipo erróneo para abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "argumento de tipo erróneo para la conjugación"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "en el argumento para el ! unario"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "no hay operador de pre-incremento para el tipo"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "no hay operador de post-incremento para el tipo"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "no hay operador de pre-decremento para el tipo"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "no hay operador de post-decremento para el tipo"
 
@@ -23229,73 +23282,73 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "Se truncó la línea en %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "argumentos 'a%d' y 'a%d' para el intrínseco '%s'"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "argumentos '%s' y '%s' para el intrínseco %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "argumentos '%s' y '%s' para el intrínseco '%s'"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "%qD is not a pointer variable"
 msgid "NULL() is not interoperable"
 msgstr "%qD no es una variable puntero"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "constante no válida"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "End expression in DO loop"
 msgid "Expression is polymorphic"
 msgstr "Expresión de fin en el bucle DO"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "'%s' in EXTENDS expression at %C is not a derived type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "'%s' en la expresión EXTENDS en %C no es un tipo derivado"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected argument"
 msgid "Procedure unexpected as argument"
 msgstr "argumento inesperado"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 #| msgid "Obsolescent feature: Old-style character length at %C"
 msgid "Type shall have a character length of 1"
 msgstr "Característica obsoleta: Longitud de carácter de estilo antiguo en %C"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "los tipos no son totalmente compatibles"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 #| msgid "Assumed size array '%s' in namelist '%s' at %C is not allowed"
 msgid "Assumed-size arrays are not interoperable"
@@ -23377,7 +23430,7 @@ msgstr "Característica borrada:"
 msgid "Unsigned:"
 msgstr "<consigno-sinnombre:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "asignación de matriz"
 
@@ -23386,17 +23439,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "Desajuste de frontera de matriz en la dimensión 1 de la matriz (%ld/%ld)"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "Desajuste de frontera de matriz en la dimensión 2 de la matriz (%ld/%ld)"
@@ -23592,11 +23645,11 @@ msgstr "bloque IF"
 msgid "implied END DO"
 msgstr "END DO implícito"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "asignación"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "asignación de puntero"
 
@@ -23604,125 +23657,125 @@ msgstr "asignación de puntero"
 msgid "simple IF"
 msgstr "IF simple"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "procedimiento elemental"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "argumento asignable"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "argumento asíncrono"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "argumento opcional"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "argumento puntero"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "argumento destino"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "argumento de valor"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "argumento volátil"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "se asume argumento de aspecto"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "se asume argumento de rango"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "argumento de coarray"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "argumento de tipo derivado parametrizado"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "argumento polimórfico"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "atributo NO_ARG_CHECK"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "se asume argumento de tipo"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "resultado array"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "puntero o resultado asignable"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr "resultado con longitud de carácter no constante"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "procedimiento bind(c)"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Variable de ciclo"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "variable de iterador"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Expresión de inicio en el bucle DO"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "Expresión de fin en el bucle DO"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Expresión de paso en el bucle DO"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "objeto DEALLOCATE"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "objeto ALLOCATE"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "variable STAT"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "variable ERRMSG"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "elemento en READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "variable ACQUIRED_LOCK"
 
@@ -23731,31 +23784,31 @@ msgstr "variable ACQUIRED_LOCK"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Longitudes de CHARACTER diferentes (%ld/%ld) en el constructor de matriz"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "Desborde entero al calcular la cantidad de memoria a reservar"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr "El valor del parámetro PDT LEN '%s' no concuerda con el de la declaración «dummy»"
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "La longitud de la cadena actual no coincide con la declarada para el argumento dummy '%s' (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "La longitud de la cadena actual es más corta que la declarada para el argumento dummy '%s' (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "El objetivo del remapeo de rango es demasiado pequeño (%ld < %ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Asignación de escalar a un array sin espacio asignado"
 
@@ -23820,30 +23873,30 @@ msgstr "El argumento NCOPIES del intrínseco REPEAT es negativo (su valor es %ld
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "El argumento NCOPIES del intrínseco REPEAT es demasiado grande"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, fuzzy, c-format
 #| msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "argumentos 'a%d' y 'a%d' para el intrínseco '%s'"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, fuzzy, c-format
 #| msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "argumentos 'a%d' y 'a%d' para el intrínseco '%s'"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, fuzzy, c-format
 #| msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "argumentos 'a%d' y 'a%d' para el intrínseco '%s'"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23943,7 +23996,7 @@ msgid "expected boolean type"
 msgstr "se esperaba un tipo booleano"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "se esperaba un entero"
@@ -24008,7 +24061,7 @@ msgstr "faltan argumentos"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "demasiados argumentos"
@@ -24419,7 +24472,7 @@ msgstr "soporte de análisis de perfil para VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "el OS objetivo no admite accesos sin alinear"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "el análisis de perfil aún no se implementa en esta arquitectura"
@@ -24675,14 +24728,14 @@ msgstr "Se crea '%s'\n"
 msgid "Global declarative %s for %s"
 msgstr "una declaración global"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Invalid state file; %s"
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr "%s:%d: Fichero de estado no válido; %s"
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24856,13 +24909,13 @@ msgstr "%qs es obsoleto; utilice -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs es obsoleto; utilice -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown stack check parameter %qs"
 msgid "unknown autovec preference %qs"
 msgstr "parámetro de revisión de pila desconocido %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -25334,8 +25387,8 @@ msgstr "Se hace caso omiso del atributo %qE debido a un conflicto con el atribut
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "declaración previa aquí"
@@ -25352,7 +25405,7 @@ msgstr "se descarta la directiva de atributo %qE"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "se descarta la directiva de atributo de alcance %<%E::%E%>"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "se especificó el número equivocado de argumentos para el atributo %qE"
@@ -25363,7 +25416,7 @@ msgstr "se especificó el número equivocado de argumentos para el atributo %qE"
 msgid "expected %i or more, found %i"
 msgstr "se esperaba %<(%> o fin de línea"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %i, found %i"
@@ -25447,12 +25500,12 @@ msgstr "se descartan los atributos de tipo después de que el tipo ya se defini
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25574,139 +25627,139 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "el borde %s->%s no tiene un call_stmt correspondiente"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 #| msgid "creating run-time relocation"
 msgid "corresponding source location"
 msgstr "se crea una reubicación en tiempo de ejecución"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, fuzzy, gcc-internal-format
 #| msgid "This is the location of the previous declaration of label %qs"
 msgid "location of the second call"
 msgstr "Esta es la ubicación de la declaración previa de la etiqueta %qs"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of functions"
 msgid "location is after end of function"
 msgstr "se crea la matriz de funciones"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "No se esperaba TAG."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "no se puede abrir el fichero de perfil %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr "El número mágico de perfil AutoFDO no cuadra"
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "AutoFDO profile version %u does match %u"
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "La versión %u de perfil AutoFDO no cuadra con %u"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read string table from %s"
 msgid "cannot read summary information from %s"
 msgstr "no se puede leer la tabla de cadenas de %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "no se puede leer la tabla de cadenas de %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "no se puede leer el perfil de función de %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read function profile from %s"
 msgid "cannot read module profile from %s"
@@ -25717,7 +25770,7 @@ msgstr "no se puede leer el perfil de función de %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "el desplazamiento %qwi fuera de los límites de la constante de cadena"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "%qE declared here"
@@ -25829,7 +25882,7 @@ msgstr "el argumento constante está fuera de rango para %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "argumento %qs no válido para %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -25909,12 +25962,12 @@ msgstr "%Kel último argumento de %qD no es una constante entera entre 0 y 3"
 msgid "cannot tail-call: %s"
 msgstr "llamada al extremo imposible: %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "la llamada a la función tiene valor agregado"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "pasando argumento demasiado grande a la pila"
@@ -26572,352 +26625,352 @@ msgstr "los bloques básicos no están ubicados consecutivamente"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "el número de notas bb en la cadena insn (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "la cuenta de borde llamador no es válida"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing counts for called function %s"
 msgid "missing direct call for speculation %i"
 msgstr "Faltan las cuentas para la función invocada %s"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing barrier after block %i"
 msgid "missing ref for speculation %i"
 msgstr "falta una barrera después del bloque %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "campo aux establecido para el borde %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr "cuenta de cgraph no válida"
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "clon en línea en el mismo grupo comdat"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "inline clone is forced to output"
 msgid "inline clone count is not compatible"
 msgstr "se fuerza en la salida un clon incluido en línea"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "tp_first_run must be non-negative"
 msgstr "el valor de %<priority%> debe ser no negativo"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "los símbolos locales deben definirse"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "clon incluido en línea visible externamente"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "clon incluido en línea con dirección tomada"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "se fuerza en la salida un clon incluido en línea"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "inline clone is forced to output"
 msgid "inline clone is referenced by assembly"
 msgstr "se fuerza en la salida un clon incluido en línea"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 #| msgid "returns_nonnull attribute on a function not returning a pointer"
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "atributo returns_nonnull en una función que no devuelve puntero"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "target specific option mismatch"
 msgid "semantic interposition mismatch"
 msgstr "no coincide la opción específica del objetivo"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "se define el campo aux para el borde indirecto desde %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "edge count is not compatible with function count"
 msgstr "-mnop-mcount no es compatible con este objetivo"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "-mnop-mcount no es compatible con este objetivo"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "Un borde indirecto de %s no está marcado como indirecto o tiene indirect_info asociado, la declaración correspondiente es: "
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr "función comdat-local llamada por %s fuera de su comdat"
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "el puntero inlined_to está mal"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "múltiples llamantes inline"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "se estableció el puntero inlined_to para llamantes no-inline"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "la cuenta de borde llamador no coincide con la cuenta BB"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "la cuenta de llamadas indirectas no coincide con la cuenta BB"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "se estableció el puntero inlined_to, pero no se encontraron predecesores"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "el puntero inlined_to se refiere a sí mismo"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "el cgraph_node tiene un clone_of erróneo"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "el cgraph_node tiene una lista de clones errónea"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "el cgraph_node está en la lista de clones pero no es clon"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "el cgraph_node tiene un puntero prev_clone erróneo"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "lista de clones doblemente ligada corrrupta"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "Alias tiene bordes de llamada"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "Alias tiene una referencia que no es alias"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "Alias tiene más de una referencia alias"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "El alias analizado no tiene referencia"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "No hay un borde fuera de un nodo thunk"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "Más de un borde fuera de un nodo thunk"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "No se supone que thunk tenga cuerpo"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "call_stmt compartida:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "puntos de borde para una declaración errónea:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "un borde indirecto con un llamante desconocido que corresponde a call_stmt con una declaración conocida:"
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "falta el borde de callgraph para la llamada stmt:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "referencia a sentencia muerta"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "el borde %s->%s no tiene un call_stmt correspondiente"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "un borde indirecto desde %s no tiene un call_stmt correspondiente"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of register to a different size"
 msgid "origin points to a different parent"
 msgstr "conversión de registro a un tamaño diferente"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "falló verify_cgraph_node"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: section %s is missing"
 msgid "%s: section %s.%d is missing"
@@ -27747,17 +27800,17 @@ msgstr "el tamaño total de los objetos locales es demasiado grande"
 msgid "impossible constraint in %<asm%>"
 msgstr "restricción imposible en %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "la variable %q+D puede ser sobreescrita por %<longjmp%> o %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "el argumento %q+D puede ser sobreescrito por %<longjmp%> o %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "la función devuelve un agregado"
@@ -28482,7 +28535,7 @@ msgstr "el límite de %G%qD especificado %E es igual a la longitud del origen"
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "el miembro de matriz flexible no está al final del struct"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -28524,7 +28577,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%qD defined here"
@@ -28545,24 +28598,24 @@ msgstr "desreferencia a puntero nulo"
 msgid "function may return address of local variable"
 msgstr "la función puede devolver la dirección de una variable local"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "la función devuelve la dirección de una variable local"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -29589,7 +29642,7 @@ msgstr "%K%qD leyendo entre %E y %E bytes en una región de tamaño %E"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 #| msgid "required from %q#D\n"
 msgid "returned from %qD"
@@ -29670,235 +29723,235 @@ msgstr "en una llamada a la función de reserva %qD declarada aquí"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "modelo de memoria específico de la arquitectura desconocido"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model argument %d of %qE"
 msgid "invalid memory model %qs for %qD"
 msgstr "argumento de modelo de memoria %d no válido de %qE"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model argument %d of %qE"
 msgid "invalid memory model %wi for %qD"
 msgstr "argumento de modelo de memoria %d no válido de %qE"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "valid arguments are: %s"
 msgid "valid models are %e"
 msgstr "los argumentos válidos son: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model argument %d of %qE"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "argumento de modelo de memoria %d no válido de %qE"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, fuzzy, gcc-internal-format
 #| msgid "valid feature names are: %s; did you mean %qs?"
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "los nombres de característica válidos son: %s; ¿quiso decir %qs?"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, fuzzy, gcc-internal-format
 #| msgid "failure memory model cannot be stronger than success memory model for %<__atomic_compare_exchange%>"
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "la falla de modelo de memoria no puede ser más fuerte que el modelo de memoria exitoso para %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, fuzzy, gcc-internal-format
 #| msgid "failure memory model cannot be stronger than success memory model for %<__atomic_compare_exchange%>"
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "la falla de modelo de memoria no puede ser más fuerte que el modelo de memoria exitoso para %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE attribute not available to functions with variable number of arguments"
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "el atributo %qE no está disponible para funciones con un número variable de argumentos"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Kargument %i value %qE is negative"
 msgid "argument %i value %s is negative"
 msgstr "%Kargumento %i, valor %qE, negativo"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "referencing argument %u of type %qT"
 msgstr "se esperaba %qT pero el argumento es de tipo %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared here"
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "en una llamada a la función %qD declarada aquí"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "tipo de elemento no válido para el atributo %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to built-in function %qD"
 msgid "in a call to function %qD"
 msgstr "en una llamada a la función interna %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "in a call with type %qT"
 msgstr "tipo de elemento no válido para el atributo %qs"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD called on unallocated object %qD"
 msgstr "no se puede abrir %s"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "assigned here"
 msgstr "se definió union aquí"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD no es una función plantilla miembro"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to a member used in arithmetic"
 msgid "pointer %qE may be used after %qD"
 msgstr "se usó un puntero a un miembro en la aritmética"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "pointer %qE used after %qD"
 msgstr "El puntero Cray '%s' en la cláusula %s en %L"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to a member used in arithmetic"
 msgid "pointer may be used after %qD"
 msgstr "se usó un puntero a un miembro en la aritmética"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %qD"
 msgid "pointer used after %qD"
 msgstr "parámetro %qD sin uso"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "call to %qD here"
 msgstr "%qD se declara aquí"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "modo de puntero %qs no válido"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "asumiendo el puntero a miembro %qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "modo de puntero %qs no válido"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD se declara aquí"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "plugin cannot register an unnamed pass"
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "el plugin no puede registrar un paso sin nombre"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "unnamed temporary defined here"
 msgstr "se definió union aquí"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to built-in allocation function %qD"
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "en una llamada a la función de reserva interna %qD"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to built-in allocation function %qD"
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "en una llamada a la función de reserva interna %qD"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  en la llamada a %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -30788,358 +30841,358 @@ msgstr "el elemento %u tiene ubicación-y == %u"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "uso no válido del atribute  %<fallthrough%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "la tabla virtual de tipo %qD viola la regla de definición única"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "variable del mismo nombre de ensamblador que la tabla virtual está definida en otra unidad de traducción"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "la tabla virtual de tipo %qD contiene información RTTI"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "RTTI no funcionará en este tipo"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "el tipo conflictivo definido en otra unidad de traducción tiene una tabla virtual de tamaño diferente"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "el tipo conflictivo definido en otra unidad de traducción tiene una información RTTI diferente"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "el tipo conflictivo definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "contiene el método virtual adicional %qD"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "el tipo conflictivo definido en otra unidad de traducción tiene una una tabla virtual con más entradas"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "método virtual %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr "debería concordar con el método virtual %qD pero no concuerda"
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "el tipo conflictivo definido en otra unidad de traducción tiene una una tabla virtual con diferente contenido"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT itself violates the C++ One Definition Rule"
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "el propio tipo %qT viola la regla de una sola definición de C++"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "el tipo %qT viola la regla de definición única de C++"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "hay definido un tipo diferente en otra unidad de traducción"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr "la primera diferencia de las definiciones correspondientes es el campo %qD"
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr "la primera diferencia de las definiciones correspondientes es el método %qD"
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT defined in anonymous namespace can not match type %qT across the translation unit boundary"
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "el tipo %qT definido en el espacio de nombres anónimo no puede coincidir con el tipo %qT a través del contorno de la unidad de traducción"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT defined in anonymous namespace can not match across the translation unit boundary"
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "el tipo %qT definido en el espacio de nombres anónimo no puede coincidir a través del contorno de la unidad de traducción"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "el tipo incompatible definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "el nombre de tipo %qs debería concordar con el nombre de tipo %qs"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "el tipo incompatible está definido aquí"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "Los tipos de array tienen límites diferentes"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "no coincide el tipo del valor de retorno"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "no coincide el tipo del puntero this implícito"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "los tipos no coinciden en el parámetro %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "tipos con número de parámetros diferentes"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "el propio tipo %qT viola la regla de una sola definición de C++"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "el tipo %qT debería coincidir con el tipo %T"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "hay un tipo con distinta precisión definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 #| msgid "a type with different number of methods is defined in another translation unit"
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "hay un tipo con distinto número de métodos definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "hay un tipo con diferente tipo de signo definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "está definido como puntero en un espacio de direcciones diferente en otra unidad de traducción"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "está definido como puntero a un tipo diferente en otra unidad de traducción"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "hay un array de distinto tamaño definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "tiene distinto valor de retorno en otra unidad de translación"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "tiene parámetros distintos en otra unidad de translación"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "un tipo definido en otra unidad de traducción no es polimórfico"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "un tipo definido en otra unidad de traducción es polimórfico"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "hay un tipo con punteros de tabla virtual distinta definidos en otra unidad de traducción"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "hay un tipo con bases distintas definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "hay un campo con un nombre distinto definido en otra unidad de translación"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "hay un campo con el mismo nombre pero distinto tipo definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "los campos tienen distinta disposición en otra unidad de translación"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "hay un tipo con distinto número de campos definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "hay un tipo con distinto tamaño definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, fuzzy, gcc-internal-format
 #| msgid "  and each type can be converted to the other"
 msgid "one type needs to be constructed while the other does not"
 msgstr "  y cada tipo puede convertirse al otro"
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "Array bound mismatch"
 msgid "memory layout mismatch"
 msgstr "El límite de la matriz no coincide"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "la base extra se define aquí"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] "Declarar el tipo %qD final permitiría desvirtualizar %i llamada"
 msgstr[1] "Declarar el tipo %qD final permitiría desvirtualizar %i llamadas"
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Declarar el tipo %qD final permitiría desvirtualizar %i llamada ejecutada %lli veces"
 msgstr[1] "Declarar el tipo %qD final permitiría desvirtualizar %i llamadas ejecutadas %lli veces"
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] "Declarar el destructor virtual de %qD final permitiría desvirtualizar %i llamada"
 msgstr[1] "Declarar el destructor virtual de %qD final permitiría desvirtualizar %i llamadas"
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] "Declarar el método %qD final permitiría desvirtualizar %i llamada"
 msgstr[1] "Declarar el método %qD final permitiría desvirtualizar %i llamadas"
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Declarar el destructor virtual de %qD final permitiría desvirtualizar %i llamada ejecutada %lli veces"
 msgstr[1] "Declarar el destructor virtual de %qD final permitiría desvirtualizar %i llamadas ejecutadas %lli veces"
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Declarar el método %qD final permitiría desvirtualizar %i llamada ejecutada %lli veces"
 msgstr[1] "Declarar el método %qD final permitiría desvirtualizar %i llamadas ejecutadas %lli veces"
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT violates the C++ One Definition Rule"
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "el tipo %qT viola la regla de definición única de C++"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 #| msgid "an enum with different values is defined in another translation unit"
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "hay un enum con valores distintos definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "hay un enum con nombre de valor distinto definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "hay un enum con valores distintos definido en otra unidad de traducción"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 #| msgid "a field with different name is defined in another translation unit"
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "hay un campo con un nombre distinto definido en otra unidad de translación"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 #| msgid "a type defined in another translation unit is not polymorphic"
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "un tipo definido en otra unidad de traducción no es polimórfico"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 #| msgid "a type defined in another translation unit is polymorphic"
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "un tipo definido en otra unidad de traducción es polimórfico"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 #| msgid "it is defined as a pointer to different type in another translation unit"
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "está definido como puntero a un tipo diferente en otra unidad de traducción"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -31162,7 +31215,7 @@ msgstr "falta el resumen de inclusión en línea ipa en el fichero de entrada"
 msgid "IPA modref summary is missing in input file"
 msgstr "falta el resumen de inclusión en línea ipa en el fichero de entrada"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function in gimple call"
 msgid "invalid jump function in LTO stream"
@@ -31409,12 +31462,12 @@ msgstr "Se ha alcanzado el número máximo de pasos de asignación de LRA (%d)\n
 msgid "unable to find a register to spill"
 msgstr "no se puede encontrar un registro para vaciar"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "restricciones de operandos inconsistentes en un %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Max. number of generated reload insns per insn is achieved (%d)\n"
 msgid "maximum number of generated reload insns per insn achieved (%d)"
@@ -31809,7 +31862,7 @@ msgstr "cláusula %<depend(sink)%> esperando iteración léxica posterior"
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "%<depend(sink)%> se refiere a una iteración ajena al espacio de iteración"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -33328,25 +33381,25 @@ msgstr "los registros usados explícitamente deben ser agrupados en la parte sup
 msgid "output operand %d must use %<&%> constraint"
 msgstr "el operando de salida %d debe usar la restricción %<&%>"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data: [%u] next_regno erróneo para la cadena vacía (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data: Ciclo en la cadena regno (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data: [%u] oldest_regno erróneo (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -34347,189 +34400,189 @@ msgstr "transacción más externa en la función %<transaction_safe%>"
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "no se recomputa la constante cuando cambia ADDR_EXPR"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "no se recomputan los efectos laterales cuando cambia ADDR_EXPR"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "se tomó la dirección, pero el bit ADDRESSABLE no está activado"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 #| msgid "non-scalar type"
 msgid "non-scalar %qs"
 msgstr "tipo que no es escalar"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size operand to %qs"
 msgstr "posición o tamaño de operando no válido para BIT_FIELD_REF"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, fuzzy, gcc-internal-format
 #| msgid "integral result type precision does not match field size of BIT_FIELD_REF"
 msgid "integral result type precision does not match field size of %qs"
 msgstr "la precisión del tipo de resultado integral no coincide con el tamaño del campo de BIT_FIELD_REF"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, fuzzy, gcc-internal-format
 #| msgid "mode size of non-integral result does not match field size of BIT_FIELD_REF"
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "el modo de tamño del resultado que no es integral no coincide con el tamaño del campo de BIT_FIELD_REF"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 #| msgid "shift of non-integer operand"
 msgid "%qs of non-mode-precision operand"
 msgstr "desplazamiento de un operando que no es entero"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, fuzzy, gcc-internal-format
 #| msgid "position plus size exceeds size of referenced object in BIT_FIELD_REF"
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "posición más tamaño supera el tamaño del objeto referenciado en BIT_FIELD_REF"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in array reference"
 msgid "type mismatch in %qs reference"
 msgstr "los tipos de datos no coinciden en la referencia de matriz"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of an SSA_NAME on the left hand side"
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "conversión de un SSA_NAME del lado izquierdo"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of register to a different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "conversión de registro a un tamaño diferente"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, fuzzy, gcc-internal-format
 #| msgid "non-lvalue in %s"
 msgid "non-top-level %qs"
 msgstr "no es valor-l en %s"
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "operando no válido para %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in parameter %i"
 msgid "type mismatch in %qs"
 msgstr "los tipos no coinciden en el parámetro %i"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offset operand of MEM_REF"
 msgid "invalid %qs offset operator"
 msgstr "operando de desplazamiento de MEM_REF no válido"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid address operand in MEM_REF"
 msgid "invalid address operand in %qs"
 msgstr "operando de dirección no válido en MEM_REF"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offset operand in MEM_REF"
 msgid "invalid offset operand in %qs"
 msgstr "operando de desplazamiento no válido en MEM_REF"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "uso no válido de %qD"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "IF simple"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "se usa un valor de tipo struct cuando se requiere un escalar"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "expresión no válida para el l-valor min"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "la llamada gimple tiene dos objetivos"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "la llamada gimple no tiene objetivo"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "función no válida en la llamada gimple"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "no es función en la llamada gimple"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "estado const pure no válido para la función"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "LHS no válido en la llamada gimple"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "LHS in noreturn call"
 msgid "LHS in %<noreturn%> call"
 msgstr "LHS en la llamada noreturn"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "conversión no válida en la llamada gimple"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "cadena estática no válida en la llamada gimple"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "cadena static con una función que no usa una"
@@ -34540,651 +34593,651 @@ msgstr "cadena static con una función que no usa una"
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_unreachable or __builtin_trap call with arguments"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "llamada a __builtin_unreachable o __builtin_trap con argumentos"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "argumento no válido en la llamada gimple"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "operandos no válidos en la comparación gimple"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "comparación de tipos de operandos que no coinciden"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "operandos que no son vectores en la comparación de vectores"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "tipo resultante no válido de la comparación de vectores"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "tipo resultante no válido de la comparación"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "el LHS de una operación unaria no es un registro"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "operando no válido en la operación unaria"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid vector types in nop conversion"
 msgstr "tipos no válidos en la conversión nop"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "tipos no válidos en la conversión nop"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "tipos no válidos en la conversión nop"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "tipos no válidos en la conversión de coma fija"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in conversion to floating point"
 msgid "invalid types in conversion to floating-point"
 msgstr "tipos no válidos en la conversión a coma flotante"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "tipos no válidos en la conversión a entero"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in sad expression"
 msgid "type mismatch in %qs expression"
 msgstr "no coincide el tipo en expresión triste"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid prototype for '%s'"
 msgid "invalid types for %qs"
 msgstr "prototipo no válido para '%s'"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid prototype for '%s'"
 msgid "invalid type for %qs"
 msgstr "prototipo no válido para '%s'"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "conversión que no es trivial en la operación unaria"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "el LHS de una operación binaria no es un registro"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "operandos no válidos en la operación binaria"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid non-vector operands to vector valued plus"
 msgid "invalid non-vector operands to %qs"
 msgstr "operandos que no son vectores no válidos para un vector valuado con más"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "modo de puntero %qs no válido"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "vector types expected in sad expression"
 msgid "vector type expected in %qs"
 msgstr "se esperaban tipos vector en una expresión de permutación de vector"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "los tipos de datos no coinciden en la expresión binaria"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "el LHS de una operación terniaria no es un registro"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "operandos no válidos en la operación terniaria"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, fuzzy, gcc-internal-format
 #| msgid "the first argument of a VEC_COND_EXPR must be of a boolean vector type of the same number of elements as the result"
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr "el primer argumento de una VEC_COND_EXPR debe ser de tipo vector de booleanos del mismo número de elementos que el resultado"
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "vector types expected in sad expression"
 msgid "vector types expected in %qs"
 msgstr "se esperaban tipos vector en una expresión de permutación de vector"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 #| msgid "vectors with different element number found in vector permute expression"
 msgid "vectors with different element number found in %qs"
 msgstr "se encontraron vectores con número de elementos diferentes en la expresión de permutación"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offload table in %s"
 msgid "invalid mask type in %qs"
 msgstr "tabla de descarga no válida en %s"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "not allowed type combination in BIT_INSERT_EXPR"
 msgid "not allowed type combination in %qs"
 msgstr "no se permite combinar tipos en BIT_INSERT_EXPR"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size in BIT_INSERT_EXPR"
 msgid "invalid position or size in %qs"
 msgstr "posición o tamaño no válido en BIT_INSERT_EXPR"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 #| msgid "'h' applied to non-register operand"
 msgid "%qs into non-mode-precision operand"
 msgstr "`h' aplicado a un operando no registro"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "insertion out of range in BIT_INSERT_EXPR"
 msgid "insertion out of range in %qs"
 msgstr "inserción fuera de rango en BIT_INSERT_EXPR"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "vector insertion not at element boundary"
 msgid "%qs not at element boundary"
 msgstr "inserción de vector no en contorno de elemento"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion at assignment"
 msgid "non-trivial conversion in %qs"
 msgstr "conversión que no es trivial en la asignación"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cpu %qs for %s%qs%s"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "cpu %qs no válida para %s%qs%s"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "non-decl/MEM_REF LHS in clobber statement"
 msgid "%qs LHS in clobber statement"
 msgstr "non-decl/MEM_REF LHS en sentencia clobber"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, fuzzy, gcc-internal-format
 #| msgid "non-decl/MEM_REF LHS in clobber statement"
 msgid "%qs LHS in assignment statement"
 msgstr "non-decl/MEM_REF LHS en sentencia clobber"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "operando no válido para %%R"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of `->'"
 msgid "invalid %qs size argument in load"
 msgstr "argumento de tipo no válido de `->'"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rhs for gimple memory store"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "rhs no válido para el almacenamiento de memoria gimple"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "non-register as LHS of ternary operation"
 msgid "non-register as LHS with vector constructor"
 msgstr "el LHS de una operación terniaria no es un registro"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect type of vector CONSTRUCTOR elements"
 msgid "incorrect type of vector %qs elements"
 msgstr "tipo incorrecto de elementos de CONSTRUCTOR de vector"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect number of vector CONSTRUCTOR elements"
 msgid "incorrect number of vector %qs elements"
 msgstr "número incorrecto de elementos de CONSTRUCTOR de vector"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "tipo incorrecto de elementos de CONSTRUCTOR de vector"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, fuzzy, gcc-internal-format
 #| msgid "vector CONSTRUCTOR with non-NULL element index"
 msgid "vector %qs with non-NULL element index"
 msgstr "CONSTRUCTOR de vector con índice de elemento no NULL"
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 #| msgid "vector CONSTRUCTOR element is not a GIMPLE value"
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "el elemento CONSTRUCTOR de vector no es un valor GIMPLE"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 #| msgid "non-vector CONSTRUCTOR with elements"
 msgid "non-vector %qs with elements"
 msgstr "CONSTRUCTOR no vector con elementos"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "%qs que no es parámetro no puede ser un paquete de parámetro"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "operando no válido en la declaración return"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "conversión no válida en la declaración return"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "el destino de goto no es una etiqueta ni un puntero"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "operando no válido para la declaración switch"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "sentencia switch de tipo no entero"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "etiqueta case default no váilda en sentencia switch"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "invalid CASE_CHAIN"
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "CASE_CHAIN no válido"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "etiqueta case no váilda en sentencia switch"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "rango case no váildo en sentencia switch"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "discordancia en precisión de tipo en sentencia switch"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "discordancia de tipos para etiqueta case en sentencia switch"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "etiquetas case no ordenadas en sentencia switch"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "label's context is not the current function decl"
 msgid "label context is not the current function declaration"
 msgstr "el contexto de la etiqueta no es la declaración de función actual"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect entry in label_to_block_map"
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "entrada incorrecta en label_to_block_map"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "definición incorrecta del número de relleno de aterrizaje"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "código de comparación no válido en la condición gimple"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "etiquetas no válidas en la condición gimple"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI result"
 msgid "invalid %<PHI%> result"
 msgstr "resultado PHI no válido"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<PHI%> def"
 msgstr "falta la definición PHI"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI argument"
 msgid "invalid %<PHI%> argument"
 msgstr "argumento PHI no válido"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in PHI argument %u"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "tipos incompatibles en el argumento PHI %u"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_gimple failed"
 msgid "%<verify_gimple%> failed"
 msgstr "falló verify_gimple"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, fuzzy, gcc-internal-format
 #| msgid "dead STMT in EH table"
 msgid "dead statement in EH table"
 msgstr "STMT muerto en la tabla EH"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr "la ubicación referencia un bloque que no está en el árbol de bloques"
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "Local declaration from a different function"
 msgid "local declaration from a different function"
 msgstr "Declaración local desde una función diferente"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "se estableció gimple_bb (phi) a un bloque básico erróneo"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr "nodo PHI con ubicación"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "compartición incorrecta de nodos de árbol"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "PHI virtual con ubicaciones de argumento"
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "se estableció gimple_bb (stmt) a un bloque básico erróneo"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "se marcó la sentencia para throw, pero no lo hace"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "se marcó la sentencia para throw en medio del bloque"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "falló verify_gimple"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK tiene IL asociado con él"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK tiene IL asociado con él"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "caida para salir del bb %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "grupo extra de llaves al final del inicializador"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "grupo extra de llaves al final del inicializador"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "exit block count is not compatible with entry block count"
 msgstr "-mnop-mcount no es compatible con este objetivo"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE no está inicializado"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Uninitialized probability of edge %i->%i"
 msgid "probability of edge %d->%d not initialized"
 msgstr "Probabilidad del borde %i->%i no inicializada"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-mnop-mcount no es compatible con este objetivo"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, fuzzy, gcc-internal-format
 #| msgid "nonlocal label %s is not first in a sequence of labels in bb %d"
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr "la etiqueta %s que no es local no es la primera en una secuencia de etiquetas en el bb %d"
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, fuzzy, gcc-internal-format
 #| msgid "nonlocal label %s is not first in a sequence of labels in bb %d"
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr "la etiqueta %s que no es local no es la primera en una secuencia de etiquetas en el bb %d"
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 #| msgid "label %s to block does not match in bb %d"
 msgid "label %qD to block does not match in bb %d"
 msgstr "la etiqueta %s para el bloque no coincide con el bb %d"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 #| msgid "label %s has incorrect context in bb %d"
 msgid "label %qD has incorrect context in bb %d"
 msgstr "la etiqueta %s tiene un contexto incorrecto en el bb %d"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "control de flujo enmedio del bloque básico %d"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "label %s in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "etiqueta %s enmedio del bloque básico %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "borde de caída después de una sentencia de control en bb %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "borde verdadero/falso después de una expresión que no es GIMPLE_COND en bb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "banderas de borde de salida erróneas al final del bb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "goto explícito al final del bb %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "el borde de devolución no apunta a exit en el bb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "se encontró un case por defecto que no está al inicio del vector case"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "las etiquetas case no están ordenadas:"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "borde de salida extra %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "falta el borde %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "la función %<noreturn%> devuelve"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "el control alcanza el final de una función que no es void"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "se descarta el valor de devolución de %qD, se declaró con el atributo warn_unused_result"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of function declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -35373,13 +35426,13 @@ msgstr "el objetivo no admite actualización de perfil atómica; se selecciona e
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "el objetivo no admite actualización de perfil atómica; se selecciona el modo sencillo"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "tipo de elemento no válido para el atributo %qs"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid use of attribute %<fallthrough%>"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -35940,7 +35993,7 @@ msgstr "la condición vectorial se expandirá por piezas"
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "la operación de ordenamiento vectorial se expandirá por piezas"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr "no se ha producido vectorización para un bucle simd"
@@ -36418,31 +36471,31 @@ msgstr "TYPE_CACHED_VALUES_P está activado y no debería"
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "TYPE_METHOD_BASETYPE no es una variante de main"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "falta el atributo %<target%> para %qD multiversionado"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "declaración previa de %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D genera un conflicto con una declaración previa"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "conflicts with previous declaration here"
 msgid "%qD conflicts for version %qB"
 msgstr "genera un conflicto con la declaración previa aquí"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -36527,7 +36580,7 @@ msgstr "solo se permiten inicializadores a cero en la sección %qs"
 msgid "no initializers are allowed in section %qs"
 msgstr "solo se permiten inicializadores a cero en la sección %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "no se especifica un nombre de registro para %q+D"
@@ -36683,7 +36736,7 @@ msgstr "la referencia débil %q+D finalmente apunta a sí misma"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "la referencia débil %q+D debe tener enlace estático"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "no se admiten las definiciones de alias en esta configuración"
@@ -36729,62 +36782,62 @@ msgstr "Usa la disposición de pila empacada."
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "el argumento de plantilla %d es no válido"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "el argumento de plantilla %d es no válido"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute argument has type %qT"
 msgstr "se descarta el atributo %qE para %qE"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "se descarta el atributo %qE para %qE"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "el argumento del atributo %qE no es una constante entera"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "el argumento del atributo %qE no es una constante entera"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to base type of a function pointer"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "el atributo %qE se aplica solamente al tipo base de un puntero a función"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to base type of a function pointer"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "el atributo %qE se aplica solamente al tipo base de un puntero a función"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "los argumentos por defecto sólo se permiten para parámetros de función"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "%Kargument %i value %qE exceeds maximum object size %E"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -36802,13 +36855,13 @@ msgstr "el atributo %qE no está disponible para funciones con un número variab
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "el atributo %qE no está disponible para funciones con un número variable de argumentos"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "se descarta el atributo %qE para %qE"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
@@ -37038,12 +37091,12 @@ msgstr "no se puede usar el modo %qs para tipos de enumeración"
 msgid "mode %qs applied to inappropriate type"
 msgstr "se aplicó el modo %qs a un tipo inapropiado"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "no se admiten atributos de sección en este objetivo"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "no se permite un atributo de sección para %q+D"
@@ -37053,18 +37106,18 @@ msgstr "no se permite un atributo de sección para %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "el argumento del atributo sección no es una constante de cadena"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "no se puede especificar el atributo de sección para las variables locales"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "la sección de %q+D genera un conflicto con la declaración previa"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "no se puede sobreescribir la sección de %q+D"
@@ -37162,7 +37215,7 @@ msgstr "el argumento %qE no es un identificador"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "el atributo readonly de la propiedad %qD genera un conflicto con la declaración previa"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "la función inline %q+D se declaró weak"
@@ -37213,13 +37266,13 @@ msgstr "se descartan los atributos en el argumento de plantilla %qT"
 msgid "%qE attribute is only applicable on functions"
 msgstr "el atributo %qE se aplica solamente a funciones"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "el atributo %qs se aplica solamente a funciones"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is only applicable on functions"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -37231,12 +37284,12 @@ msgstr "el atributo %qE se aplica solamente a funciones"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "el argumento del atributo %qE no es una constante de cadena"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -37338,24 +37391,24 @@ msgstr "se descarta el atributo %qE porque %qT ya está definido"
 msgid "visibility argument not a string"
 msgstr "el argumento de visibilidad no es una cadena"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "se descarta el atributo %qE en tipos"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %qE argument not a string"
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "el argumento del atributo %qE no es una cadena"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD se redeclaró con visibilidad diferente"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD se declaró %qs lo cual implica visibilidad por defecto"
@@ -37373,7 +37426,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "el atributo %qE se aplica solamente a funciones"
@@ -37455,7 +37508,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "el argumento del atributo %qE no es una constante de cadena"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute on function returning %<void%>"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -37537,7 +37590,7 @@ msgstr "%qD no es compatible con %qD"
 msgid "%qE argument is not a function"
 msgstr "el argumento %qE no es una función"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "el mensaje obsoleto no es una cadena"
@@ -37609,7 +37662,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "se descarta el atributo %qE en tipos"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "el atributo %qE requiere una cadena como argumento"
@@ -37787,15 +37840,15 @@ msgid "requested position is less than zero"
 msgstr "la posición solicitada es menor a cero"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "cadena vacía en el atributo %<target%>"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "el argumento del atributo %qE no es una constante de cadena"
@@ -38098,7 +38151,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "se sugieren paréntesis alrededor de la asignación usada como valor verdadero"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "uso no válido de %<restrict%>"
@@ -38280,8 +38333,8 @@ msgstr "no hay suficientes argumentos variables para ajustar un centinela"
 msgid "missing sentinel in function call"
 msgstr "falta un centinela en la llamada a la función"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "opción %qs errónea para el atributo %<optimize%>"
@@ -39364,7 +39417,7 @@ msgstr "no se admite la concatenación no estándar de literales de cadena"
 msgid "traditional C rejects string constant concatenation"
 msgstr "C tradicional rechaza la concatenación de constantes de cadenas"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -39423,7 +39476,7 @@ msgstr "cláusula %<depend(source)%> especificada junto con cláusulas %<depend(
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "la cláusula %<ordered%> con parámetro no se puede especificar en la construcción %qs"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "tipo no válido para la variable de iteración %qE"
@@ -39438,17 +39491,17 @@ msgstr "variable de iteración %<_Atomic%> %qE"
 msgid "%qE is not initialized"
 msgstr "%qE no está inicializado"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "falta el predicado controlador"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "predicado controlador no válido"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "falta la expresión de incremento"
@@ -39458,7 +39511,7 @@ msgstr "falta la expresión de incremento"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "expresión de incremento no válida"
@@ -39559,19 +39612,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an function argument"
 msgid "%qD is not a function argument"
 msgstr "%qD no es un argumento de función"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "campo de bits %qE en cláusula %qs"
@@ -39582,8 +39635,8 @@ msgstr "campo de bits %qE en cláusula %qs"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%> %qE en cláusula %qs"
@@ -40151,7 +40204,7 @@ msgstr "ubicación no válida en %<pragma %s%>, se descarta"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "%<#pragma %s%> malformado, se descarta"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "basura al final de %<#pragma %s%>"
@@ -40224,8 +40277,8 @@ msgstr "%<#pragma%> no se permite aquí"
 msgid "wrong type argument to %s"
 msgstr "argumento de tipo erróneo para %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -40718,17 +40771,17 @@ msgstr "decremento de la función %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "se usó la función %qD como salida %<asm%>"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "asignación de la ubicación de sólo lectura %qE"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "incremento de la ubicación de sólo lectura %qE"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "decremento de la ubicación de sólo lectura %qE"
@@ -41004,7 +41057,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "el paso del argumento %d de %qE descarta el calificador %qv del tipo del destino del puntero"
 msgstr[1] "el paso del argumento %d de %qE descarta el calificador %qv del tipo del destino del puntero"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr "esta condición tiene bifurcaciones idénticas"
@@ -42035,7 +42088,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "la función interna %qs requiere la opción %qs"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -42748,7 +42801,7 @@ msgstr "se pasa el argumento %d de %qE desde un tipo Objective-C distinto"
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate definition of '%s'"
 msgid "duplicate definition of %qs"
@@ -42802,7 +42855,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "el tipo %qT no tiene un tamaño conocido"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored because %qT is already defined"
 msgid "variables of type %qT cannot have thread-local storage duration"
@@ -42862,7 +42915,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qE no es una variable en la cláusula %<saligned%>"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -42969,21 +43022,21 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "Se pasó un argumento Altivec a una función sin prototipo"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, fuzzy, gcc-internal-format
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr "el paso de parámetro para argumentos de tipo %qT ha cambiado en GCC 7.1"
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, fuzzy, gcc-internal-format
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr "el paso de parámetro para argumentos de tipo %qT ha cambiado en GCC 7.1"
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, fuzzy, gcc-internal-format
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
@@ -43033,230 +43086,230 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, fuzzy, gcc-internal-format
 #| msgid "unknown flag passed in -moverride=%s (%s)"
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr "indicador pasado en -moverride=%s (%s) desconocido"
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%s string ill-formed\n"
 msgid "%qs string ill-formed"
 msgstr "cadena %s mal formada\n"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid format of %s"
 msgid "invalid format for %<sve_width%>"
 msgstr "formato no válido de %s"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %h value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "valor %h no válido"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "falta la cadena de ajuste en la opción (%s)"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "opción de cadena de ajuste desconocida (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 #| msgid "Specify the register allocation order"
 msgid "specify a system register with a small string length"
 msgstr "Especifica el orden de asignación de registros"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs no es un desplazamiento válido en %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, fuzzy, gcc-internal-format
 #| msgid "-fsanitize=address not supported for this target"
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "no se admite -fsanitize=address para este objetivo"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, fuzzy, gcc-internal-format
 #| msgid "builtin function %qs requires the %qs option"
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "la función interna %qs requiere la opción %qs"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 #| msgid "Do not use the SPE ABI extensions."
 msgid "streaming functions require the ISA extension %qs"
 msgstr "No usa las extensiones de ABI SPE."
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, fuzzy, gcc-internal-format
 #| msgid "builtin function %qs requires the %qs option"
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "la función interna %qs requiere la opción %qs"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument %qs to %qs"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "argumento %qs no válido para %qs"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid arguments for %<-fpatchable_function_entry%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "argumento no válido para %<-fpatchable_function_entry%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march=%s switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "la opción -mcpu=%s genera un conflicto con la opción -march=%s"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "assembler does not support -mabi=ilp32"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "el ensamblador no tiene soporte para -mabi=ilp32"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "%<-mstring%> is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%<-mstring%> es obsoleto"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs with -f%s"
 msgid "code model %qs with %<-f%s%>"
 msgstr "modelo de código %qs con -f%s"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in x32 mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "el modelo de código %qs no se admite en modo x32"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, fuzzy, gcc-internal-format
 #| msgid "builtin function %qs requires the %qs option"
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "la función interna %qs requiere la opción %qs"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "falta el nombre en atributo %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 #| msgid "invalid name (\"%s\") in %<target(\"arch=\")%> pragma or attribute"
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "nombre no válido (\"%s\") en el pragma o atributo %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "valor no válido (\"%s\") en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "falta el nombre en el pragma o atributo %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 #| msgid "invalid name (\"%s\") in %<target(\"cpu=\")%> pragma or attribute"
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "nombre no válido (\"%s\") en el pragma o atributo %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "valor no válido (\"%s\") en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 #| msgid "invalid name (\"%s\") in %<target(\"tune=\")%> pragma or attribute"
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "nombre no válido (\"%s\") en el pragma o atributo %<target(\"tune=\")%>"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "falta el valor en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "pragma o atributo %<target()%> mal formado"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "el pragma o atributo %<target(\"%s\")%> no acepta un argumento"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "el pragma o atributo %<target(\"%s\")%> no acepta forma negada"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "el pragma o atributo %<target(\"%s=%s\")%> no es válido"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -43264,226 +43317,226 @@ msgstr "el pragma o atributo %<target(\"%s=%s\")%> no es válido"
 msgid "attribute %<target%> argument not a string"
 msgstr "el argumento del atributo %<target%> no es una cadena"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "el pragma o atributo %<target(\"%s\")%> no es válido"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "pragma o atributo %<target(\"%s\")%> mal formado"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %<target%> argument not a string"
 msgid "attribute %<target_version%> has multiple values"
 msgstr "el argumento del atributo %<target%> no es una cadena"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %<target%> argument not a string"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "el argumento del atributo %<target%> no es una cadena"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "missing value in %<target()%> pragma or attribute"
 msgid "missing value in %<target_version%> attribute"
 msgstr "falta el valor en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "valor no válido (\"%s\") en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, fuzzy, gcc-internal-format
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "valor no válido (\"%s\") en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "Virtual function multiversioning not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "No se admiten versiones múltiples de funciones virtuales"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "multiversioning needs ifunc which is not supported on this target"
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "el versionado múltiple necesita ifunc, que no se admite en este objetivo"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T was previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q#T se declaró previamente aquí"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 #, fuzzy
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr "el paso de parámetro para argumentos de tipo %qT ha cambiado en GCC 7.1"
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 #, fuzzy
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr "el paso de parámetro para argumentos de tipo %qT ha cambiado en GCC 7.1"
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 #, fuzzy
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr "el paso de parámetro para argumentos de tipo %qT ha cambiado en GCC 7.1"
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "vía %wd fuera de rango %wd - %wd"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported simdlen %d"
 msgid "unsupported simdlen %wd"
 msgstr "simdlen %d no admitido"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported return type %qT for simd"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "no se admite el tipo de retorno %qT para simd"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "no se admite el tipo de retorno %qT para simd"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument type %qT for simd"
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "no se admite el tipo de argumento %qT para simd"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "no se admite el tipo de argumento %qT para simd"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "la opción -shared no se admite actualmente en ELF de VAX"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "la opción -shared no se admite actualmente en ELF de VAX"
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot change attributes of symbol at %L after it has been used"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "No se pueden cambiar los atributos del símbolo en %L después de ser usado"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%q+D defined here"
 msgstr "la etiqueta %qD se define aquí"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer to a constant size type"
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "el argumento %d de %qE debe ser un puntero a un tipo de tamaño constante"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "se pasa el argumento %d de %qE con anchura diferente debido al prototipo"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be in the range %d...%d"
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "el argumento %d de %qE debe estar dentro del rango %d...%d"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "se pasa el argumento %d de %qE con anchura diferente debido al prototipo"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "se pasa el argumento %d de %qE con anchura diferente debido al prototipo"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "se pasa el argumento %d de %qE con anchura diferente debido al prototipo"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 #| msgid "an empty string cannot be in %<target_clones%> attribute"
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "no puede haber una cada vacía en el atributo %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "valor no válido (\"%s\") en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 #, fuzzy
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "valor no válido (\"%s\") en el pragma o atributo %<target()%>"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 #| msgid "invalid value (\"%s\") in %<target()%> pragma or attribute"
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
@@ -43690,12 +43743,12 @@ msgstr "el argumento del atributo %qE no es \"ilink\" o \"firq\""
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -43833,24 +43886,24 @@ msgid "argument of %qE attribute ignored"
 msgstr "falta el argumento del atributo %qE"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "el atributo %qE solamente se aplica a variables"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "alternatives not allowed in asm flag output"
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "no se permiten alternativas en la salida del indicador asm"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 #| msgid "unknown asm flag output %qs"
 msgid "unknown %<asm%> flag output %qs"
 msgstr "salida del indicador asm %qs desconocida"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for asm flag output"
 msgid "invalid type for %<asm%> flag output"
@@ -44439,12 +44492,12 @@ msgstr "no se admite -fpie"
 msgid "%<-fPIE%> is not supported"
 msgstr "no se admite -fPIE"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "los atributos de función %qs y %qs son mutuamente excluyentes"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "la función %qs no puede tener argumentos"
@@ -44454,7 +44507,7 @@ msgstr "la función %qs no puede tener argumentos"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "la función %qs no puede devolver un valor"
@@ -44812,7 +44865,7 @@ msgstr "la llamada requiere ifunc, que no se admite en este objetivo"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "argumento no válido para la función interna"
@@ -45160,7 +45213,7 @@ msgstr "se usa vector_length (%d); se hace caso omiso de %d"
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr "se usa vector_length (%d); se hace caso omiso de la configuración de tiempo de ejecución"
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "using num_workers (%d), ignoring %d"
 msgid "using %<num_workers (%d)%>, ignoring %d"
@@ -45354,178 +45407,178 @@ msgstr "El parámetro para la función interna debe ser una cadena constante o l
 msgid "parameter to builtin not valid: %s"
 msgstr "El parámetro para la función interna no es válido: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt service routine can't be called directly"
 msgid "interrupt service routine cannot be called directly"
 msgstr "no se puede llamar directamente a la rutina de servicio de interrupciones"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "el tercer argumento debe ser un inmediato de 2-bit"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "el quinto argumento debe ser un inmediato de 8-bit"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "el tercer argumento debe ser un inmediato de 8-bit"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "el último argumento debe ser un inmediato de 1-bit"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "el último argumento debe ser un inmediato de 3-bit"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "el último argumento debe ser un inmediato de 4-bit"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "el último argumento debe ser un inmediato de 1-bit"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE necesita la opción isa %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "el tercer argumento debe ser un inmediato de 5-bit"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "el penúltimo argumento debe ser un inmediato de 8-bit"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "el último argumento debe ser un inmediato de 8-bit"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "el tercer argumento debe ser una constante de comparación"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "modo de comparación incorrecto"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "operando de redondeo incorrecto"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "el argumento inmediato debe ser un inmediato de 4-bit"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "el argumento inmediato debe ser un inmediato de 5-bit"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "el argumento inmediato debe ser un inmediato de 8-bit"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 #| msgid "the forth argument must be scale 1, 2, 4, 8"
 msgid "the fourth argument must be one of enum %qs"
 msgstr "el argumento delantero debe ser un escalar 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "el selector debe ser una constante entera en el rango 0..%wi"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE necesita la opción isa desconocida"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE necesita la opción isa %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "the third argument must be comparison constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "el tercer argumento debe ser una constante de comparación"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "el segundo argumento para %<__builtin_prefetch%> es no válido; se usa cero"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid arguments"
 msgid "invalid third argument"
 msgstr "argumentos no válidos"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "el tercer argumento para %<__builtin_prefetch%> es no válido; se usa cero"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "el tercer argumento para %<__builtin_prefetch%> es no válido; se usa cero"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "second argument must be slice or string"
 msgid "second argument must be a const"
 msgstr "el segundo argumento debe ser una rebanada o una cadena"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "el último argumento debe ser un inmediato de 32-bit"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "el último argumento debe ser un inmediato"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "el último argumento debe ser un escalar 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "the next to last argument must be an 8-bit immediate"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -45957,8 +46010,8 @@ msgstr "%qs no es un registro base válido en -mstack-protector-guard-reg="
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -46217,7 +46270,7 @@ msgstr "la ABI para pasar una estructura con un miembro de coma flotante complej
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "la ABI para pasar una estructura con un miembro de coma flotante compleja cambió en GCC 4.4"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -46244,12 +46297,12 @@ msgstr "argumento de registro SSE con SSE desactivado"
 msgid "x87 register return with x87 disabled"
 msgstr "se devuelve el registro x87 con x87 desactivado"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "se llama a %qD con el convenio de llamadas SSE sin activar SSE/SSE2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr "esto es un error de GCC que se puede sortear añadiendo el atributo usado a la función llamada"
@@ -46260,42 +46313,42 @@ msgstr "esto es un error de GCC que se puede sortear añadiendo el atributo usad
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "La ABI para pasar parámetros con alineación de %d-bytes cambió en GCC 4.6"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "-mcall-ms2sysv-xlogues is not compatible with %s"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "-mcall-ms2sysv-xlogues no es compatible con %s"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 #| msgid "ms_hook_prologue attribute isn%'t compatible with -mfentry for 32-bit"
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "el atributo ms_hook_prologue no es compatible con -mfentry para 32-bit"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr "No se admite Puntero de Argumento de Realineamiento Dinámico (DRAP) en la rutina de servicio de interrupciones.  Esto puede sortearse evitando funciones con retorno agregado."
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "el atributo %qE no se admite en esta plataforma"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "no se admiten funciones anidadas en este objetivo"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support fastcall with nested function"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "-fsplit-stack no admite fastcall con funciones anidadas"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support 2 register parameters for a nested function"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -46303,104 +46356,104 @@ msgstr "-fsplit-stack no admite 2 parámetros de registro para una función anid
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support 3 register parameters"
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "-fsplit-stack no admite 3 parámetros de registro"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren't allowed in function with no_caller_saved_registers attribute"
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "Las instrucciones %s no están permitidas en funciones con el atributo no_caller_saved_registers"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren't allowed in %s service routine"
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "las instrucciones %s no se permiten en la rutina de servicio %s"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren't allowed in %s service routine"
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "las instrucciones %s no se permiten en la rutina de servicio %s"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "'V' modifier on non-integer register"
 msgid "%<V%> modifier on non-integer register"
 msgstr "modificador 'V' en registro no entero"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "no se admite el tamaño para registro de enteros"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "los registros extendidos no tiene mitades superiores"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "no se admite el tamaño de operando para el registro extendido"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 #| msgid "non-integer operand used with operand code 'z'"
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "se usó un operando que no es entero con el código de operando 'z'"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "la alineación de %qD es más grande que la declaración original"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 #, fuzzy
 #| msgid "the mangling of %<va_list%> has changed in GCC 4.4"
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "la decodificación de %<va_list%> cambió en GCC 4.4"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "no hay registros inferiores disponibles para extraer registros superiores"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 #| msgid "-mcmodel= is not supported on 32-bit systems"
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "-mcmodel= no se admite en sistemas de 32 bits"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "modelo de memoria específico de la arquitectura desconocido"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, fuzzy, gcc-internal-format
 #| msgid "HLE_ACQUIRE not used with ACQUIRE or stronger memory model"
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr "HLE_ACQUIRE no se usa con ACQUIRE o modelos de memoria más fuertes"
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, fuzzy, gcc-internal-format
 #| msgid "HLE_RELEASE not used with RELEASE or stronger memory model"
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr "HLE_RELEASE no se usa con RELEASE o modelos de memoria más fuertes"
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 #| msgid "-fdirectives-only is incompatible with -traditional"
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
@@ -46455,7 +46508,7 @@ msgstr "gp_offset (%ld) o end_offset (%ld) es menor a cero"
 msgid "argument %qd is not a constant"
 msgstr "el argumento %qd no es una constante"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -46467,7 +46520,7 @@ msgstr "PRINT_OPERAND_ADDRESS, puntero nulo"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: Puntuación desconocida '%c'"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -46633,52 +46686,52 @@ msgstr "el pragma o atributo %<target(\"%s\")%> no es válido"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "se desconoce attribute(target(\"%s\"))"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, fuzzy, gcc-internal-format
 #| msgid "mudflap cannot be used together with link-time optimization"
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "mudflap no se puede usar junto con optimización en tiempo de enlazado"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "clones for %<target_clones%> attribute cannot be created"
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "no se pueden crear los clones para el atributo %<target_clones%>"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 #| msgid "readonly property can not be set"
 msgid "in attribute %qs priority cannot be empty"
 msgstr "no se puede establecer la propiedad readonly"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "value %qs is not supported by attribute %<target%>"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "no se admite el valor %qs para el atributo %<target%>"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "ifunc is not supported on this target"
 msgid "%qs is not supported in target attribute"
@@ -47506,7 +47559,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr "las funciones internas de MSP430 solo funcionan dentro de manejadores de interrupciones"
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "código interno erróneo"
@@ -47749,89 +47802,89 @@ msgstr "no se puede abrir el fichero ptx intermedio"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "la función %s no se admite conjuntamente con -fopenacc"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, fuzzy, gcc-internal-format
 #| msgid "%<-march=%s%> is not compatible with the selected ABI"
 msgid "%<-march=%> must be specified"
 msgstr "%<-march=%s%> no es compatible con la ABI seleccionada"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "no se genera zona de parche; no se admite nops"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr "no se admite la inicialización estática de la variable %q+D en memoria %<.shared%>"
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr "no se pueden emitir punteros desalineados en ensamblador ptx"
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr "PTX no admite declaraciones débiles (solamente definiciones débiles)"
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "el atributo %qE requiere tipo de retorno void"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "no se permite el atributo %qE con una clase de auto almacenamiento"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be in the range 0..15"
 msgid "barrier value must be within [0,15]"
 msgstr "el argumento d de debe estar dentro del rango 0..15"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of %s must be a constant"
 msgid "complement argument must be constant"
 msgstr "el argumento 1 de %s debe ser una constante"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, fuzzy, gcc-internal-format
 #| msgid "using vector_length (%d), ignoring %d"
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr "se usa vector_length (%d); se hace caso omiso de %d"
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, fuzzy, gcc-internal-format
 #| msgid "using vector_length (%d), ignoring runtime setting"
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr "se usa vector_length (%d); se hace caso omiso de la configuración de tiempo de ejecución"
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, fuzzy, gcc-internal-format
 #| msgid "using vector_length (%d), ignoring %d"
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr "se usa vector_length (%d); se hace caso omiso de %d"
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "no se admiten las definiciones de alias en esta configuración"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -48090,366 +48143,366 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "desajuste en el número de argumentos para la interna %qF. Esperados: %d obtenidos %d"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "el tipo %qT no tiene un tamaño conocido"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "el tipo %qT no tiene un tamaño conocido"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "aritmética en puntero a un tipo de dato incompleto"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "fields cannot have RVV type %qT"
 msgstr "el campo %qD tiene tipo de dato incompleto"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "function parameters cannot have __fp16 type"
 msgid "array elements cannot have RVV type %qT"
 msgstr "los parámetros de la función no pueden tener el tipo __fp16"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "no se puede asignar un objeto de tipo abstracto %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "no se puede asignar un objeto de tipo abstracto %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "no se puede asignar un objeto de tipo abstracto %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete type %q#T"
 msgid "capture by copy of RVV type %qT"
 msgstr "uso no válido del tipo incompleto %q#T"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qE no es una variable en la cláusula %<saligned%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is disallowed in Java %<throw%> or %<catch%>"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "el tipo %qT no está permitido en %<throw%> o %<catch%> de Java"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %<firstprivate%>"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE no es una variable en la cláusula %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "La función interna %s requiere la opción -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mhtm option"
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "La función interna %s requiere la opción -mhtm"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mpaired option"
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "La función interna %s requiere la opción -mpaired"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "La función interna %s requiere la opción -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "La función interna %s requiere la opción -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized wide sub-instruction"
 msgid "unrecognized RVV builtin"
 msgstr "no se reconoce la sub-instrucción ancha"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "La función interna %s requiere la opción -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to %<%D(%A)%>"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "no hay una función coincidente para la llamada a %<%D(%A)%>"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "unknown cpu %qs for -mtune"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "cpu %qs desconocida para -mtune"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, fuzzy, gcc-internal-format
 #| msgid "Do not use the SPE ABI extensions."
 msgid "this operation requires the RVV ISA extension"
 msgstr "No usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, fuzzy, gcc-internal-format
 #| msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "la ABI para pasar una estructura con un miembro de coma flotante compleja cambió en GCC 4.4"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, fuzzy, gcc-internal-format
 #| msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "la ABI para pasar una estructura con un miembro de coma flotante compleja cambió en GCC 4.4"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "Se pasó un argumento Altivec a una función sin prototipo"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the V ISA extension"
 msgstr "Usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "Usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "Usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "Usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "Usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 #| msgid "builtin function %qs requires the %qs option"
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "la función interna %qs requiere la opción %qs"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "builtin function %qs requires the %qs option"
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "la función interna %qs requiere la opción %qs"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, fuzzy, gcc-internal-format
 #| msgid "builtin function %qs requires the %qs option"
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "la función interna %qs requiere la opción %qs"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument to %qE attribute is neither zero, nor one"
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "el argumento del atributo %qE no es cero ni uno"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "sizeof applied to a function type"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "sizeof aplicado a un tipo de función"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "el atributo %qE requiere un argumento constante entero"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, fuzzy, gcc-internal-format
 #| msgid "-mdiv requires -march to subsume the %<M%> extension"
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr "-mdiv requiere -march para subsumir la extensión %<M%>"
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, fuzzy, gcc-internal-format
 #| msgid "Do not use the SPE ABI extensions."
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "No usa las extensiones de ABI SPE."
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support ARM mode"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "el CPU objetivo no tiene soporte para el modo ARM"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs with -f%s"
 msgid "code model %qs with %qs"
 msgstr "modelo de código %qs con -f%s"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, fuzzy, gcc-internal-format
 #| msgid "requested ABI requires -march to subsume the %qc extension"
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr "la ABI solicitada requiere -march para subsumir la extensión %qc"
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support the `%%%c' %s format"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "%1$s no tiene soporte para el formato %3$s `%%%2$c'"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, fuzzy, gcc-internal-format
 #| msgid "ABI requires -march=rv%d"
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "ABI requiere -march=rv%d"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d must be between %d and %d"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d debe estar entre %d y %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs no es un registro base válido en %qs"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs no es un número válido en %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "%qs function cannot have different interrupt type"
 msgstr "la función %qs no puede tener argumentos"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -49539,23 +49592,23 @@ msgstr "los requerimientos de memoria para variables locales excede la capacidad
 msgid "%<function_profiler%> support"
 msgstr "soporte para function_profiler"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "no se puede usar va_start en una función de interrupción"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "la declaración switch de tamaño de %lu entradas es demasiado grande"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "el atributo %<__BELOW100__%> solamente se aplica a variables"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -49805,34 +49858,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "se define %qD pero no se usa"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "se requieren registros booleanos para la opción de coma flotante"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "no se admite -f%s con instrucciones CONST16"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "se requiere PIC pero no se admite con instrucciones CONST16"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "sólo las variables sin inicializar se pueden colocar en una sección .bss"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -49927,7 +49980,7 @@ msgstr "el atributo %qs requiere prototipos con argumentos nombrados"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "el atributo %qs se aplica solamente a funciones variadic"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -50020,8 +50073,8 @@ msgstr "%s: No es un directorio"
 msgid "could not get size of source file"
 msgstr "no se puede escribir en el fichero de respuesta %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "no se descarta el valor void como debería de ser"
@@ -50520,7 +50573,7 @@ msgstr "switch salta dentro de una expresión de declaración"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE definido como un tipo erróneo de etiqueta"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute applied to %qD with void return type"
@@ -50681,7 +50734,7 @@ msgstr "ISO C90 no admite %<static%> o calificadores de tipo en los declaradores
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 no admite declaradores de matriz %<[*]%>"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -50692,7 +50745,7 @@ msgstr "no se puede usar %<this%> en este contexto"
 msgid "%q+D is usually a function"
 msgstr "%q+D generalmente es una función"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "no hay declaración previa para %qD"
@@ -50773,7 +50826,7 @@ msgstr "no se puede poner un objeto con un campo volatile en register"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "const %qD sin inicializar es no válida en C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%q+D en directiva de objetivo de declaración no tiene tipo asociable"
@@ -50982,7 +51035,7 @@ msgstr "se especificó una clase de almacenamiento para el parámetro %qE"
 msgid "storage class specified for unnamed parameter"
 msgstr "se especificó una clase de almacenamiento para un parámetro sin nombre"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "se especificó una clase de almacenamiento para el nombre de tipo"
@@ -51156,7 +51209,7 @@ msgstr "el nombre de tipo que se declaró como función devuelve una matriz"
 msgid "function definition has qualified void return type"
 msgstr "la definición de la función tiene un tipo de devolución void calificado"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "se descartan los calificadores de tipo en el tipo de devolución de la función"
@@ -51283,7 +51336,7 @@ msgstr "ISO C prohíbe los tipos de función const o volatile"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "un miembro de una estructura o union no puede tener un tipo modificado variablemente"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "se declaró la variable o campo %qE como void"
@@ -51502,7 +51555,7 @@ msgstr "la definición de tipo en %qs es no válida en C++"
 msgid "%qT defined in underspecified object initializer"
 msgstr "se especificó el campo desconocido %qE en el inicializador"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "la declaración no declara nada"
@@ -51568,7 +51621,7 @@ msgstr "struct no tiene miembros nombrados"
 msgid "struct has no members"
 msgstr "struct no tiene miembros"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -51640,7 +51693,7 @@ msgstr "redeclaración de %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -51701,7 +51754,7 @@ msgstr "el valor de enumerador %E es demasiado grande para el tipo subyacente %<
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C restringe los valores de enumeración al rango de %<int%>"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %qD given attribute noinline"
 msgid "inline function %qD given attribute %qs"
@@ -51855,12 +51908,12 @@ msgstr "el argumento %qD no coincide con el prototipo interno"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "el argumento %qD no coincide con el prototipo"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "no hay una declaración de devolución en la función que no devuelve void"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "se definió el parámetro %qD pero no se usa"
@@ -51946,7 +51999,7 @@ msgstr "se usó %qE con %<register%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "dos o más tipos de datos en los especificadores de la declaración"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> es demasiado largo para GCC"
@@ -52057,7 +52110,7 @@ msgstr "ISO C90 no admite tipos booleanos"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C no admite el tipo %<_float%d%s%>"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "no se admite %<_float%d%s%> para este objetivo"
@@ -52225,12 +52278,12 @@ msgstr "La longitud de línea fija debe ser al menos de siete."
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ no admite %<__int128%> para %qs"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr "el combinador %<#pragma omp declare reduction%> hace referencia a la variable %qD, la cual no es %<omp_out%> ni %<omp_in%>"
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr "el nicializador %<#pragma omp declare reduction%> hace referencia a la variable %qD, la cual no es %<omp_priv%> ni %<omp_orig%>"
@@ -52298,37 +52351,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs se debe usar con %qs"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "desplazamiento a la izquierda o valor negativo"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "la cuenta de desplazamiento a la izquierda es negativa"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "la cuenta de desplazamiento a la derecha es negativa"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "cuenta de desplazamiento a la izquierda >= anchura del tipo"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "cuenta de desplazamiento a la derecha >= anchura del tipo"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "cuenta de desplazamiento a la izquierda >= anchura del elemento del vector"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "cuenta de desplazamiento a la derecha >= anchura del elemento del vector"
@@ -52349,7 +52402,7 @@ msgstr "marcador de conflicto en control de versiones en el fichero"
 msgid "to match this %qs"
 msgstr "%J  otro tipo aquí"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "se esperaba fin de línea"
@@ -52359,7 +52412,7 @@ msgstr "se esperaba fin de línea"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C prohíbe una unidad de traducción vacía"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -52408,8 +52461,8 @@ msgid "unknown type name %qE"
 msgstr "nombre de tipo %qE desconocido"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "se esperaban especificadores de declaración"
@@ -52448,7 +52501,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "se esperaba %<;>, identificador o %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "se descartan los atributos de prefijo para los métodos"
@@ -52463,12 +52516,12 @@ msgstr "se descartan los atributos de prefijo para las implementaciones"
 msgid "unexpected attribute"
 msgstr "atributo inesperado"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "el atributo %<fallthrough%> no está seguido de %<;%>"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -52515,7 +52568,7 @@ msgstr "%<__auto_type%> requiere una declaración de datos inicializados"
 msgid "%qs may only be used with a single declarator"
 msgstr "%<__auto_type%> sólo se puede utilizar con una declaración simple"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "se esperaba %<,%> o %<;%>"
@@ -52552,7 +52605,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "la función %<__RTL%> no se puede compilar con %<-flto%>"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "se esperaba una cadena literal"
@@ -52583,7 +52636,7 @@ msgstr "la expresión en la aserción static no es una constante"
 msgid "static assertion failed: %E"
 msgstr "falló la aserción estática: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %E"
 msgid "static assertion failed"
@@ -52640,8 +52693,8 @@ msgstr "no se puede usar el modo %qs para tipos de enumeración"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "se esperaba un identificador"
@@ -52675,12 +52728,12 @@ msgstr "uso no válido del tipo indefinido %qT"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "no coinciden los tipos con la declaración implícita previa"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "coma al final de la lista de enumeradores"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -52765,25 +52818,25 @@ msgstr "se esperaban especificadores de declaración o %<...%>"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "los paquetes de parámetros deben estar al final de la lista de parámetros"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected OpenMP directive name"
 msgstr "se esperaba nombre de función"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "se esperaba %<none%> o %<present%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "el atributo %qD requiere un solo argumento NTBS"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "%qE attribute does not take any arguments"
@@ -52795,7 +52848,7 @@ msgstr "el atributo %qD requiere un solo argumento NTBS"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 no admite declaradores de matriz %<[*]%>"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -52827,19 +52880,19 @@ msgstr "ISO C90 prohíbe la especificación de subobjetos a inicializar"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "uso obsoleto del inicializador designado sin %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, fuzzy, gcc-internal-format
 #| msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "no hay cláusulas válidas especificadas en %<#pragma acc declare%>"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 #| msgid "%<ordered%> region must be closely nested inside a loop region with an %<ordered%> clause"
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "la región %<ordered%> debe estar bien anidada dentro de una región de bucle con una cláusula %<ordered%>"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
@@ -52850,44 +52903,44 @@ msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "%qs attribute does not take any arguments"
@@ -52919,7 +52972,7 @@ msgstr "ISO C90 prohíbe mezclar declaraciones y código"
 msgid "expected %<}%> before %<else%>"
 msgstr "se esperaba %<}%> antes de %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> sin un %<if%> previo"
@@ -52934,7 +52987,7 @@ msgstr "etiqueta al final de una declaración compuesta"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "se esperaba una declaración"
@@ -52972,27 +53025,27 @@ msgstr "ISO C no admite coma flotante decimal"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "se trata la lista de expresiones como una expresión compuesta en en inicializador"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "se esperaba una declaración"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "se sugieren llaves alrededor del cuerpo vacío en una declaración %<if%>"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "se sugieren llaves alrededor del cuerpo vacío en una declaración %<else%>"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "se sugieren llaves explícitas para evitar un %<else%> ambiguo"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -53012,12 +53065,12 @@ msgstr "múltiples variables de iteración en una enumeración rápida"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "variable de iteración no válida en la enumeración rápida"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr "falta la condición del bucle en bucle con pragma %<GCC ivdep%>"
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr "falta la condición del bucle en bucle con pragma %<GCC unroll%>"
@@ -53033,8 +53086,8 @@ msgstr "falta la colección en la enumeración rápida"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "calificador-cv duplicado"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "first seen here"
@@ -53059,12 +53112,12 @@ msgstr "ISO C prohíbe la omisión del término medio de una expresión ?:"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr "la división %<sizeof (%T) / sizeof (%T)%> no computa el número de elementos del array"
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "el primer operando %<sizeof%> se declaró aquí"
@@ -53251,7 +53304,7 @@ msgstr "ISO C90 no admite el identificador predefinido %<__func__%>"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "se esperaba una expresión"
@@ -53266,13 +53319,13 @@ msgstr "un grupo de llaves dentro de una expresión sólo se permite dentro de u
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C prohíbe grupos de llaves dentro de expresiones"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "el segundo parámetro de %<va_start%> no es el último argumento nombrado"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -53420,7 +53473,7 @@ msgstr "el tercer argumento de %<__builtin_prefetch%> debe ser una constante"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "el tercer argumento de %<__builtin_prefetch%> debe ser una constante"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "número erróneo de argumentos para %<__builtin_shuffle%>"
@@ -53467,7 +53520,7 @@ msgstr "el argumento 3 en la llamada a la función %qE tiene un tipo boolean"
 msgid "rotate count is negative"
 msgstr "la cuenta de rotación izquierda es negativa"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
@@ -53584,7 +53637,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -53624,13 +53677,13 @@ msgstr "se esperaba una declaración método objective-c"
 msgid "no type or storage class may be specified here,"
 msgstr "ninguna clase de almacenamiento o tipo se puede especificar aquí,"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "empty property attribute list"
 msgstr "atributo de propiedad desconocido"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -53642,61 +53695,61 @@ msgstr "falta el atributo Code"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "atributo de propiedad desconocido"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "atributo de propiedad desconocido"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 #| msgid "repeated %<@%> before Objective-C string"
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "%<@%> repetida antes de la cadena Objective-C"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected %qE selector name"
 msgstr "se esperaba una declaración de selección"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, fuzzy, gcc-internal-format
 #| msgid "setter name must terminate with %<:%>"
 msgid "setter method names must terminate with %<:%>"
 msgstr "el nombre del setter debe terminar con %<:%>"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr "%<#pragma GCC unroll%> requiere una expresión de asignación que evaluada dé una constante entera no negativa menor que %u"
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma %s%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> debe estar en el alcance del fichero"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp section%> sólo se puede usar en construcciones %<#pragma omp sections%>"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> sólo se puede usar en construcciones %<#pragma omp sections%>"
@@ -53707,12 +53760,12 @@ msgstr "%<#pragma omp section%> sólo se puede usar en construcciones %<#pragma
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma %s%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "se esperaba una declaración for, while o do"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> debe ser primero"
@@ -53722,11 +53775,11 @@ msgstr "%<#pragma GCC pch_preprocess%> debe ser primero"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "demasiadas cláusulas %qs"
@@ -53741,60 +53794,60 @@ msgstr "la expresión debe ser integral"
 msgid "%qD is not a variable"
 msgstr "%qD no es una variable"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD no es una variable puntero"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "se esperaba %<none%> o %<present%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<simd%> or %<reduction%> or %<target%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "se esperaba %<simd%>, %<reduction%> o %<target%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant logical expression"
 msgstr "se esperaba una expresión entera"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "se esperaba %<data%>, %<update%>, %<enter%> o %<exit%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "se esperaba %<data%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "demasiadas cláusulas %<if%>"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "demasiadas cláusulas %<if%> sin modificador"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr "si alguna cláusula %<if%> tiene modificador, entonces todas las cláusulas %<if%> tienen que usar modificador"
@@ -53817,23 +53870,23 @@ msgstr "el valor de %<num_threads%> debe ser positivo"
 msgid "%<num_tasks%> value must be positive"
 msgstr "el valor de %<num_tasks%> debe ser positivo"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "el valor de %<grainsize%> debe ser positivo"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "el valor de %<priority%> debe ser no negativo"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "se esperaba una expresión entera"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>"
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
@@ -53845,107 +53898,107 @@ msgstr "se esperaba %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "la expresión %qs debe ser integral"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "el valor de %qs debe ser positivo"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "demasiados argumentos %<static%>"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "argumento inesperado"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "el argumento de %<tile%> necesita una constante entera positiva"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<self%> clauses"
 msgstr "demasiadas cláusulas %<if%>"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "se esperaba %<none%> o %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<new%>"
 msgid "expected %<concurrent%>"
 msgstr "se esperaba %<new%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "ordered argument needs positive constant integer expression"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "se esperaba %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> o identificador"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "se usaron al mismo tiempo los modificadores %<monotonic%> y %<nonmonotonic%>"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "el planificador %<runtime%> no toma un parámetro %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "el planificador %<auto%> no toma un parámetro %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "chunk size value must be positive"
 msgstr "el valor de %<num_threads%> debe ser positivo"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "género de planificador no válido"
@@ -53955,41 +54008,41 @@ msgstr "género de planificador no válido"
 msgid "%<num_teams%> value must be positive"
 msgstr "el valor de %<num_teams%> debe ser positivo"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "el valor de %<thread_limit%> debe ser positivo"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "%Hel argumento de collapse necesita ser una expresión entera constante positiva"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "se esperaba %<,%> o %<)%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "%qs duplicado"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
@@ -54006,23 +54059,23 @@ msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple linear modifiers"
 msgstr "especificadores `virtual' múltiples"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple %<step%> modifiers"
@@ -54034,7 +54087,7 @@ msgstr "especificadores `virtual' múltiples"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "la expresión schedule chunk size debe ser integral"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -54051,344 +54104,344 @@ msgstr "%Hel argumento de collapse necesita ser una expresión entera constante
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "%Hel argumento de collapse necesita ser una expresión entera constante positiva"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "%qs feature modifier is incompatible with %s %s"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "el modificador de característica %qs es incompatible con %s %s"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "tipo de dependencia no válida"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid map kind"
 msgid "invalid doacross kind"
 msgstr "tipo de mapa no válida"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<parallel%> or %<target%> %<if%> clause modifier"
 msgid "expected %<fallback%> modifier"
 msgstr "se esperaba el modificador de cláusula %<parallel%> o %<target%> %<if%>"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "el valor de %<priority%> debe ser no negativo"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "illegal comma"
 msgstr "operando ilegal"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<always%> modifiers"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<close%> modifiers"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<iterator%> modifiers"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<mapper%> modifiers"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "se esperaba un identificador o %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<present%> modifiers"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "%<#pragma omp target%> con map-type distinto de %<to%>, %<from%>, %<tofrom%> y %<alloc%> en la cláusula %<map%>"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "tipo de mapa no válida"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "se esperaba %<none%> o %<present%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "la expresión schedule chunk size debe ser integral"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid dist_schedule kind"
 msgstr "género de planificador no válido"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid proc_bind kind"
 msgstr "género de planificador no válido"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "literal de cadena ancha en %<asm%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown pointer size model %qs"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "modelo de tamaño de punteros desconocido %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected string literal or constant integer expression"
 msgstr "se esperaba una expresión entera"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "se esperaba %<none%> o %<present%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicated %<fr%> preference selector"
 msgstr "condición %<if%> duplicada"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "multi-line string literals are deprecated"
 msgid "non-empty string literal expected"
 msgstr "las literales de cadena en múltiples líneas son obsoletas"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "calificador-cv duplicado"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<target%> modifier"
 msgstr "calificador-cv duplicado"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "condición %<if%> duplicada"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected an OpenACC clause"
 msgstr "se esperaba un puntero"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs no es válido para %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs debe ser la primera cláusula de %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected an OpenMP clause"
 msgstr "se esperaba un puntero"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "no hay cláusulas válidas especificadas en %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "sección de matriz en %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "%qD debe ser una variable global en %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "cláusula OpenACC no válida en el alcance del fichero"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "uso no válido de la variable %<extern%> %qD en %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "uso no válido de la variable %<global%> %qD en %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "%qD debe ser una variable global en %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "La variable %qD se usa más de una vez con %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "se esperaba %<data%> después de %<#pragma acc %s%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma acc %s data%> no tiene cláusula de movimiento de datos"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -54403,7 +54456,7 @@ msgstr "%qE no se ha declarado"
 msgid "expected function name"
 msgstr "se esperaba nombre de función"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD no hace referencia a una función"
@@ -54413,22 +54466,22 @@ msgstr "%qD no hace referencia a una función"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma acc routine%> no está inmediatamente seguido de una declaración o definición de función"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma acc routine%> no está inmediatamente seguido de una única declaración o definición de función"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> debe aplicarse antes de uso"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> debe aplicarse antes de definición"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> debe contener al menos una cláusula %<device%>, %<host%> o %<self%>"
@@ -54455,7 +54508,7 @@ msgstr ""
 msgid "modified here"
 msgstr "se definió union aquí"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
@@ -54491,125 +54544,125 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "se esperaba %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> o identificador"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many atomic clauses"
 msgstr "demasiadas cláusulas %qs"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many memory order clauses"
 msgstr "demasiadas cláusulas %qs"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%<#pragma omp target update%> debe contener al menos una cláusula %<from%> o %<to%>"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "%qs requires %qs"
 msgid "%qs clause requires %qs clause"
 msgstr "%qs requiere %qs"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp target update%> debe contener al menos una cláusula %<from%> o %<to%>"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp target update%> debe contener al menos una cláusula %<from%> o %<to%>"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp target update%> debe contener al menos una cláusula %<from%> o %<to%>"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp target update%> debe contener al menos una cláusula %<from%> o %<to%>"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after union definition"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "se esperaba %<;%> después de la definición de union"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "invalid form of %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "forma no válida de %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "se esperaba %<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "invalid form of %<#pragma omp atomic%>"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "forma no válida de %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "forma no válida de %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "operador no válido para %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> usa dos expresiones diferentes para la memoria"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "%<depobj%> expression is not lvalue expression"
@@ -54621,30 +54674,30 @@ msgstr "la expresión %qE no es una expresión constante"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "se esperaba %<data%>, %<update%>, %<enter%> o %<exit%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, fuzzy, gcc-internal-format
 #| msgid "%<linear%> clause may not be specified together with %<ordered%> clause with a parameter"
 msgid "%<flush%> list specified together with memory order clause"
@@ -54655,36 +54708,36 @@ msgstr "la cláusula %<linear%> no puede especificarse junto con la cláusula %<
 msgid "expected %<(%> or end of line"
 msgstr "se esperaba %<(%> o fin de línea"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp taskyield%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp taskyield%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "se esperaba %<none%> o %<present%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<#pragma omp scan%>"
 msgstr "se esperaba una cláusula %<#pragma omp%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp taskyield%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp taskyield%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "se esperaba una declaración for"
@@ -54692,71 +54745,71 @@ msgstr "se esperaba una declaración for"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "se esperaba una declaración for"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "se esperaba una declaración de iteración o una inicialización"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough perfectly nested loops"
 msgid "not enough nested loops"
 msgstr "no hay suficientes bucles perfectamente anidados"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "el parámetro de la cláusula %<ordered%> es menor que %<collapse%>"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "la variable de iteración %qD no debe ser firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "se esperaba %<fork%> después de %qs"
@@ -54767,7 +54820,7 @@ msgstr "se esperaba %<fork%> después de %qs"
 msgid "expected a function name"
 msgstr "se esperaba nombre de función"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected target-function call"
@@ -54779,50 +54832,50 @@ msgstr "se esperaba nombre de función"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma omp declare simd%> debe ir seguida de una declaración o definición de función"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "se esperaba %<point%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target data%> con map-type distinto de %<to%>, %<from%>, %<tofrom%> y %<alloc%> en la cláusula %<map%>"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target data%> must contain at least one %<map%> clause"
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp target data%> debe contener al menos una cláusula %<map%>"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp target update%> debe contener al menos una cláusula %<from%> o %<to%>"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target enter data%> with map-type other than %<to%> or %<alloc%> on %<map%> clause"
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target enter data%> con map-type distinto de %<to%> y %<alloc%> en la cláusula %<map%>"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target enter data%> debe contener al menos una cláusula %<map%>"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<release%> or %<delete%> on %<map%> clause"
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp target exit data%> con map-type distinto de %<from%>, %<release%> y %<delete%> en la cláusula %<map%>"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target exit data%> debe contener al menos una cláusula %<map%>"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target%> con map-type distinto de %<to%>, %<from%>, %<tofrom%> y %<alloc%> en la cláusula %<map%>"
@@ -54839,67 +54892,67 @@ msgstr "%<#pragma omp declare simd%> debe ir seguida de una declaración o defin
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma omp declare simd%> debe ir seguida de una declaración o definición de función"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected trait selector name"
 msgstr "se esperaba una declaración de selección"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 #| msgid "constructor not allowed for non-vector types"
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "no se permite un constructor para tipos que no sean vectores"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 #| msgid "%<no-custom-%s%> does not accept arguments"
 msgid "selector %qs does not accept any properties"
 msgstr "%<no-custom-%s%> no acepta argumentos"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> sólo se puede especificar dentro de una clase"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must be nonnegative"
 msgid "%<score%> argument must be non-negative"
 msgstr "'%s' en %L debe ser no negativo"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "se esperaba una cadena literal"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be integer expression"
 msgstr "se esperaba una expresión entera"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, fuzzy, gcc-internal-format
 #| msgid "property %qs already specified in %<@synthesize%>"
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "la propiedad %qs ya se especificó en %<@synthesize%>"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "aún no se admite el modelo de código %<large%>"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected context selector set name"
@@ -54911,30 +54964,30 @@ msgstr "se esperaba una declaración de selección"
 msgid "variant %qD is not a function"
 msgstr "'%s' en %L no es una función"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "variant %qD is the same as base function"
 msgstr "'%s' en %L no es una función"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<match%> clauses"
 msgstr "demasiadas cláusulas %<if%>"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 #| msgid "specified option %qs more than once"
 msgid "%qD is specified more than once"
@@ -54946,7 +54999,7 @@ msgstr "opción %qs especificada más de una vez"
 msgid "%qD is not of pointer type"
 msgstr "%qD no es una variable puntero"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -54958,18 +55011,18 @@ msgstr "se esperaba %<none%> o %<present%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs no es válido para %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<point%>"
 msgid "expected %<interop%>"
 msgstr "se esperaba %<point%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%> clause"
@@ -54992,13 +55045,13 @@ msgstr "aún no se admite el modelo de código %<large%>"
 msgid "base function %qD declared here"
 msgstr "la rutina %qD se declara aquí"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "el argumento %d de %qE debe ser un tipo puntero"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "%<long%> and %<short%> specified together for %qs"
 msgid "%<append_args%> specified here"
@@ -55010,7 +55063,7 @@ msgstr "%<long%> y %<short%>  se especificaron juntos para %qs"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "%qs y %qs son incompatibles"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "%qs and %qs are incompatible"
 msgid "variant %qD and base %qD have incompatible types"
@@ -55022,7 +55075,7 @@ msgstr "%qs y %qs son incompatibles"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma omp declare simd%> no inmediatamente seguida de una declaración o definición de función"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare simd%> not immediately followed by a single function declaration or definition"
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
@@ -55040,95 +55093,95 @@ msgstr "%<#pragma omp declare simd%> debe ir seguida de una declaración o defin
 msgid "no declaration of base function %qs"
 msgstr "declaración implícita de la función %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "la definición de la función no declara parámetros"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%>"
 msgstr "se esperaba %<catch%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "se esperaba %<none%> o %<present%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma omp end declare target%> sin su correspondiente %<#pragma omp declare target%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "El atributo %s genera un conflicto con el atributo %s en %L"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma omp end declare target%> sin su correspondiente %<#pragma omp declare target%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr "El atributo %s genera un conflicto con el atributo %s en %L"
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<declare%> or %<assumes%>"
@@ -55158,13 +55211,13 @@ msgstr "redeclaración de %qs %<#pragma omp declare reduction%> para el tipo %qT
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T se declaró previamente aquí"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "unexpected clause"
 msgstr "se esperaba una llave de clase"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<map%> clause"
@@ -55227,33 +55280,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "se esperaba %<simd%>, %<reduction%> o %<target%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target data%> must contain at least one %<map%> clause"
 msgid "%<pragma omp requires%> requires at least one clause"
@@ -55271,175 +55324,175 @@ msgstr "ISO C prohíbe los tipos de función calificados"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "se usó la matriz de longitud variable"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<while%>"
 msgid "expected %<sizes%>"
 msgstr "se esperaba %<while%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%<tile%> argument needs positive integral constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "el argumento de %<tile%> necesita una constante entera positiva"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %qs or %qs"
 msgstr "se esperaba %<,%> o %<)%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp barrier%> sólo se puede usar en declaraciones compuestas"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "expected at least one assumption clause"
 msgstr "El puntero Cray '%s' en la cláusula %s en %L"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected directive name"
 msgstr "se esperaba nombre de función"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown assumption clause %qs"
 msgstr "función de especificación %qs desconocida"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected assumption clause"
 msgstr "se esperaba un puntero"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "se esperaba %<;%>, %<,%> o %<)%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, fuzzy, gcc-internal-format
 #| msgid "property %qs already specified in %<@synthesize%>"
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "la propiedad %qs ya se especificó en %<@synthesize%>"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "nombre de registro desconocido: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, fuzzy, gcc-internal-format
 #| msgid "directives may not be used inside a macro argument"
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr "no se pueden usar las directivas dentro de un argumento de macro"
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE se declaró %<threadprivate%> después del primer uso"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "la variable automática %qE no puede ser %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE tiene tipo incompleto"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%> sin activar el soporte de memoria transaccional"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%> sin activar el soporte de memoria transaccional"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%> sin activar el soporte para memoria transaccional"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> dentro de un %<__transaction_relaxed%>"
@@ -55450,7 +55503,7 @@ msgstr "%<__transaction_cancel%> dentro de un %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "la llamada a la función %<transaction_may_cancel_outer%> no está en una transacción más externa o %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> no está dentro de %<__transaction_atomic%>"
@@ -55465,7 +55518,7 @@ msgstr "llave sin cerrar"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD tiene un tipo de dato incompleto %qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "uso no válido de la expresión void"
@@ -55496,179 +55549,179 @@ msgstr "uso no válido del typedef incompleto %qT"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT y %qT están en espacios de direcciones nombrados discontinuos"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "el atributo %qs se aplica solamente a funciones variadic"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "los tipos de función no son totalmente compatibles en ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and vector types"
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "no se pueden mezclar operandos de tipos de coma flotante decimal y vector"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and complex types"
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "no se pueden mezclar operandos de tipos de coma flotante decimal y complejos"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and other float types"
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "no se pueden mezclar operandos de tipos de coma flotante decimal otros tipos de coma flotante"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, fuzzy, gcc-internal-format
 #| msgid "pointers to arrays with different qualifiers are incompatible in ISO C"
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "los punteros a matrices con calificadores distintos son incompatibles en ISO C"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "los tipos no son totalmente compatibles"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "tipos de objetivo a incompatibles en C++"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "los tipos de devolución de función no son compatibles debido a %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, fuzzy, gcc-internal-format
 #| msgid "converting an array compound literal to a pointer is ill-formed in C++"
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "la conversión de una literal compuesta de matriz a un puntero está malformada en C++"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is used for non-class method"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "se usó el atributo %qE para método no de clase"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT no tiene un miembro llamado %qE; ¿quiso decir %qE?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT no tiene un miembro llamado %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "accediendo a un miembro %qE de una estructura atómica %qE"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "accediendo a un miembro %qE de una unión atómica %qE"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qE es un puntero; ¿pretendía utilizar %<->%>?"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qE es un puntero; ¿pretendía utilizar %<->%>?"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "petición del miembro %qE en algo que no es una estructura o unión"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "deferenciando el puntero %<void *%>"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "el valor del subíndice no es ni matriz ni puntero ni vector"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "el subíndice de la matriz no es un entero"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "el valor de subíndice es un puntero a función"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "el subíndice de la matriz no es un entero"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C prohíbe el subíndice de una matriz %<register%>"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 prohíbe el subíndice de una matriz no-lvaluada"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD declarado como referencia pero no se inicializa"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "la conversión de enum en la inicialización es no válida en C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "se definió la constante enum aquí"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr "%<sizeof%> sobre el parámetro matriz %qE de función devolverá el tamaño de %qT"
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "el objeto %qE llamado no es una función ni un puntero a función"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "el objeto %qD llamado no es una función ni un puntero a función"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "el objeto llamado no es una función ni un puntero a función"
@@ -55676,1980 +55729,1980 @@ msgstr "el objeto llamado no es una función ni un puntero a función"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "función llamada a través de un tipo de dato que no es compatible"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "se llamó a una función con tipo de devolución void calificado"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "el tipo de dato del parámetro formal %d está incompleto"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "se pasa el argumento %d de %qE como entero en lugar de coma flotante debido al prototipo"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "se pasa el argumento %d de %qE como entero en lugar de complejo debido al prototipo"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "se pasa el argumento %d de %qE como complejo en lugar de coma flotante debido al prototipo"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "se pasa el argumento %d de %qE como coma flotante en lugar de entero debido al prototipo"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "se pasa el argumento %d de %qE como complejo en lugar de entero debido al prototipo"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "se pasa el argumento %d de %qE como coma flotante en lugar de complejo debido al prototipo"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "se pasa el argumento %d de %qE como %<float%> en lugar de %<double%> debido al prototipo"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "se pasa el argumento %d de %qE como %qT en lugar de %qT debido al prototipo"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "se pasa el argumento %d de %qE con anchura diferente debido al prototipo"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "se pasa el argumento %d de %qE como unsigned debido al prototipo"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "se pasa el argumento %d de %qE como signed debido al prototipo"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to method %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "demasiados argumentos para el método %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "demasiados argumentos para la función %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "demasiados argumentos para la función %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared here"
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "en una llamada a la función %qD declarada aquí"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "conversión implícita de %qT a %qT al pasar el argumento a la función"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "faltan argumentos para la función %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "faltan argumentos para la función %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "faltan argumentos para la función %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "la comparación con una literal de cadena resulta en una conducta no especificada"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "comparación entre puntero y entero"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "¿pretendía desreferenciar el puntero?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "cero como constante de puntero nulo"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "comparación entre %qT y %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "se usó un puntero de tipo %<void *%> en la sustracción"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "se utilizó un puntero a una función en la sustracción"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "aritmética en puntero a un tipo de dato incompleto"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "aritmética en puntero a un agregado vacío"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> en una expresión booleana"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "¿pretendía utilizar la negación lógica?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C no admite %<~%> para conjugaciones complejas"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "argumento de tipo erróneo para abs"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "argumento de tipo erróneo para el signo de exclamación unario"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "el incremento de un valor de enumeración es no válido en C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "el decremento de un valor de enumeración es no válido en C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "incremento de una expresión booleana"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "decremento de una expresión booleana"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C no admite %<++%> y %<--%> en tipos complejos"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "argumento de tipo erróneo para el incremento"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "argumento de tipo erróneo para el decremento"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "incremento de puntero a un tipo incompleto %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "decremento de puntero a un tipo incompleto %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "se toma la dirección de la expresión de tipo %<id%>"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "no se puede tomar la dirección del campo de bits %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of an unaligned member"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "no se puede tomar la dirección de un miembro desalineado"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "se solicitó la dirección de la variable de registro %qD"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "se solicitó la dirección de la variable de registro %qD"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "se usó la variable de registro global %qD en la función anidada"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "se usó la variable de registro %qD en la función anidada"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "se solicitó la dirección de la variable de registro global %qD"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "se solicitó la dirección de la variable de registro %qD"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "matriz no-lvaluada en la expresión condicional"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "defining a type in a compound literal is invalid in C++"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "definir un tipo en una literal compuesta es no válido en C++"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "conversión implícita de %qT a %qT para coincidir con otro resultado del condicional"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "operand of ?: changes signedness from %qT to %qT due to unsignedness of other operand"
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr "un operando de ?: cambia de tipo de signo de %qT a %qT debido al tipo sin signo de otro operando"
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C prohíbe una expresión condicional con sólo un lado void"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "se usaron punteros a espacios de direcciones discontinuos en la expresión condicional"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "el puntero a matriz pierde el calificador en la expresión condicional"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to array loses qualifier in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "el puntero a matriz pierde el calificador en la expresión condicional"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C prohíbe expresiones condicionales entre %<void *%> y punteros de función"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "los tipos de datos punteros no coinciden en la expresión condicional"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "Se esperaba un tipo de expresión"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "Se esperaba un tipo de expresión"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "los tipos de datos punteros/enteros no coinciden en la expresión condicional"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "los tipos de datos no coinciden en la expresión condicional"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "se descarta el valor de devolución de %qD, se declaró con el atributo warn_unused_result"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "se descarta el valor de devolución de %qD, se declaró con el atributo warn_unused_result"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "se descarta el valor de devolución de %qD, se declaró con el atributo warn_unused_result"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "se descarta el valor de devolución de %qD, se declaró con el atributo warn_unused_result"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "in call to %qD, declared here"
 msgstr "%qD se declara aquí"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "el operador del lado izquierdo de la expresión coma no tiene efecto"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "el operador del lado derecho de la expresión coma no tiene efecto"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr "la conversión agrega el calificador %q#v al tipo de función"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "la conversión descarta el calificador %qv del tipo del destino del puntero"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "para estar seguro todos los punteros intermedios en la conversión de %qT a %qT se deben calificar como %<const%>"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "la conversión especifica el tipo matriz"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "la conversión especifica el tipo función"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C prohíbe la conversión de un no escalar al mismo tipo"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 #| msgid "%qT uses local type %qT"
 msgid "useless cast to type %qT"
 msgstr "%qT usa el tipo local %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C prohíbe la conversión al tipo union"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "conversión a tipo union desde un tipo no presente en union"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 #| msgid "cast to %s address space pointer from disjoint generic address space pointer"
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "conversión al puntero de espacio de direcciones %s desde un puntero de espacio de direcciones genérico discontinuo"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "cast to generic address space pointer from disjoint %s address space pointer"
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "conversión a un puntero de espacio de direcciones genérico desde un puntero de espacio de direcciones %s discontinuo"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 #| msgid "cast to %s address space pointer from disjoint %s address space pointer"
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "conversión a un puntero de espacio de direcciones %s desde un puntero de espacio de direcciones %s discontinuo"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "la conversión incrementa la alineación requerida del tipo del destino"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "conversión de puntero a entero de tamaño diferente"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "conversión desde una llamada a función de tipo %qT al tipo %qT que no coincide"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "conversión a puntero desde un entero de tamaño diferente"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C prohíbe la conversión de un apuntador a función a un tipo de objeto apuntador"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C prohíbe la conversión de objeto apuntador a un tipo de apuntador a función"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "conversión entre tipos de función incompatibles desde %qT a %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "definir un tipo en una conversión es no válido en C++"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "asignación a expresión con tipo matriz"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "conversión de enum en una asignación es no válido en C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(cerca de la inicialización de %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "matriz inicializada con una constante de cadena entre paréntesis"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "se esperaba %qT pero el argumento es de tipo %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "built-in %qD declared here"
 msgstr "la rutina %qD se declara aquí"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "declared here"
 msgid "%e declared here"
 msgstr "se declara aquí"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "la conversión de enum al pasar el argumento %d de %qE es no válido en C++"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "se esperaba %qT pero el argumento es de tipo %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "la conversión de enum desde %qT a %qT en una asignación no es válida en C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "la conversión de enum desde %qT a %qT en una inicialización no es válida en C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "la conversión de enum desde %qT a %qT en un return no es válida en C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %q#T to %q#T"
 msgid "implicit conversion from %qT to %qT"
 msgstr "conversión de %q#T a %q#T"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "el paso del argumento %d de %qE hace que la función calificada con %q#v apunte desde una no calificada"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "la asignación hace que la función calificada con %q#v apunte desde una no calificada"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "la inicialización hace que la función calificada con %q#v apunte desde una no calificada"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "la devolución hace que la función calificada con %q#v apunte desde una no calificada"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "el paso del argumento %d de %qE descarta el calificador %qv del tipo del destino del puntero"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "la asignación descarta el calificador %qv del tipo del destino del puntero"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "la inicialización descarta el calificador %qv del tipo del destino del puntero"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "la devolución descarta el calificador %qv del tipo del destino del puntero"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C prohíbe la conversión de argumentos a tipo union"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "no se permite la petición para la conversión implícita de %qT a %qT en C++"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "se pasa el argumento %d de %qE desde un puntero a espacio de direcciones no contenido"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "asignación desde puntero a espacio de direcciones no contenido"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "inicialización desde puntero a espacio de direcciones no contenido"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "devolución desde puntero a espacio de direcciones no contenido"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "se esperaba %qT pero el argumento es de tipo %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "el argumento %d de %qE puede ser un candidato para un atributo de formato"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "el lado izquierdo de la asignación puede ser un candidato para un atributo de formato"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "el lado izquierdo de la inicialización puede ser un candidato para un atributo de formato"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "el tipo de devolución puede ser un candidato para un atributo de formato"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "se pasa el argumento %d de %qE desde un tipo de puntero incompatible"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 #| msgid "assignment to %qT from incompatible pointer type %qT"
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "asignación a %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 #| msgid "initialization of %qT from incompatible pointer type %qT"
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "inicialización de %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "returning %qT from a function with incompatible return type %qT"
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "se devuelve %qT desde una función con tipo de devolución %qT incompatible"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C prohíbe el paso del argumento %d de %qE entre un puntero a función y %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C prohíbe la asignación entre un puntero a función y %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C prohíbe la inicialización entre un puntero a función y %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C prohíbe la devolución entre un puntero a función y %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "el puntero que apunta en el paso del argumento %d de %qE difiere en signo"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "el puntero que apunta en la asignación de %qT a %qT difiere en signo"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "el puntero que apunta en la inicialización de %qT a %qT difiere en signo"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "el puntero que apunta en el paso del argumento %d de %qE difiere en signo"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "se pasa el argumento %d de %qE desde un tipo de puntero incompatible"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "assignment to %qT from incompatible pointer type %qT"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "asignación a %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment to %qT from incompatible pointer type %qT"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "asignación a %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization of %qT from incompatible pointer type %qT"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "inicialización de %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization of %qT from incompatible pointer type %qT"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "inicialización de %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "returning %qT from a function with incompatible return type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "se devuelve %qT desde una función con tipo de devolución %qT incompatible"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "returning %qT from a function with incompatible return type %qT"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "se devuelve %qT desde una función con tipo de devolución %qT incompatible"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "el paso del argumento %d de %qE crea un puntero desde un entero sin una conversión"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "la asignación a %qT desde %qT crea un puntero desde un entero sin una conversión"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "la inicialización de %qT desde %qT crea un puntero desde un entero sin una conversión"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "el retorno de %qT desde una función con tipo de retorno %qT crea un puntero desde un entero sin una conversión"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "el paso del argumento %d de %qE crea un entero desde un puntero sin una conversión"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "la asignación a %qT desde %qT crea un entero desde un puntero sin una conversión"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "la inicialización de %qT desde %qT crea un entero desde un puntero sin una conversión"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "el retorno de %qT desde una función con tipo de retorno %qT crea un entero desde un puntero sin una conversión"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "tipo incompatible para el argumento %d de %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "tipos incompatible en la asignación al tipo %qT del tipo %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "tipos incompatibles en la inicialización del tipo %qT usando el tipo %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "tipos incompatible al devolver el tipo %qT pero se esperaba %qT"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "C tradicional rechaza la inicialización automática de agregados"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "el índice de matriz en el inicializador no es una expresión constante entera"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "el índice de matriz en el inicializador no es una expresión constante entera"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "inicialización de un miembro de matriz flexible"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, fuzzy, gcc-internal-format
 #| msgid "initialization of %qT from incompatible pointer type %qT"
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "inicialización de %qT desde un tipo de puntero %qT incompatible"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "la cadena del inicializador para la matriz de caracteres es demasiado larga"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "la cadena del inicializador para la matriz de caracteres es demasiado larga"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "matriz de tipo inapropiado inicializada con una constante de cadena"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "uso no válido de matriz no-lvaluada"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "inicializador no válido"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "el elemento inicializador no es una constante"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "matriz inicializada con una expresión matrizal que no es constante"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "el elemento inicializador no es una expresión constante"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT changes value from %qE to %qE"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "la conversión de %qT a %qT cambia el valor de %qE a %qE"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "el elemento inicializador no es calculable al momento de la carga"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "no se pueden inicializar los tipos de vector opacos"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "grupo extra de llaves al final del inicializador"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "llaves alrededor del inicializador escalar"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "inicialización de un miembro de matriz flexible en un contexto anidado"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "faltan llaves alrededor del inicializador"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "falta el inicializador para el campo %qD de %qT"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "elementos extras en el inicializador escalar"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "índice de matriz en el inicializador que no es matriz"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "el nombre del campo no está en el inicializador de record o union"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "el índice de matriz en el inicializador no es de tipo entero"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "el índice de matriz en el inicializador no es una expresión constante entera"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "el índice de matriz no es una constante en el inicializador"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "el índice de matriz en el inicializador excede los límites de la matriz"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "rango de índices vacío en el inicializador"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "el rango de índices de la matriz en el inicializador excede los límites de la matriz"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "campo inicializado sobreescrito"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "campo inicializado con efectos colaterales sobreescritos"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "la conversión de enum en la inicialización es no válida en C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "exceso de elementos en el inicializador de union"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "exceso de elementos en el inicializador de struct"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "inicialización posicional de un campo de %<struct%> declarado con el atributo %<designated_init%>"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "inicialización no estática de un miembro de matriz flexible"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "exceso de elementos en el inicializador de union"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "C tradicional rechaza la inicialización de unions"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "exceso de elementos en el inicializador de matriz"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "exceso de elementos en el inicializador de vector"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "exceso de elementos en el inicializador de escalar"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C no permite un %<;%> extra fuera de una función"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in output operand outside of a function"
 msgstr "tipo de tamaño variable declarado fuera de cualquier función"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "el operando de salida %d debe usar la restricción %<&%>"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Cilk_spawn%> may only be used inside a function"
 msgid "%<-%> modifier used inside of a function"
 msgstr "%<_Cilk_spawn%> sólo se puede usar dentro de una función"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute has no effect on automatic variables"
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr "el atributo %qE no tiene efecto en variables automáticas"
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in input operand outside of a function"
 msgstr "tipo de tamaño variable declarado fuera de cualquier función"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "taking the address of a function is non-standard"
 msgid "input operand outside of a function is not constant"
 msgstr "tomar la dirección de una función no es estándar"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C prohíbe %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "computed goto must be pointer type"
 msgstr "el argumento %d de %qE debe ser un tipo puntero"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "la función declarada %<noreturn%> tiene una declaración %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> sin valores, en una función que no devuelve void"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> con valor, en una función que devuelve void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C prohíbe %<return%> con expresión, en una función que devuelve void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "la función devuelve la dirección de una etiqueta"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "la función devuelve la dirección de una variable local"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "la cantidad de switch no es un entero"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "no se convierte la expresión de switch %<long%> a %<int%> en ISO C"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "la etiqueta de case no es una expresion constante entera"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "la etiqueta case no se encuentra dentro de una declaración switch"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "la etiqueta %<default%> no está dentro de una declaración switch"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "la declaración break no está dentro de un bucle o switch"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "salida no válida de un bloque estructurado OpenMP"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "se usó la declaración break en un bucle for de OpenMP"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "la declaración continue no está dentro de un bucle"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "declaración sin efecto"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "la declaración de la expresión tiene tipo de dato incompleto"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "la comparación siempre se evalúa como %<false%> para la dirección de %qD que nunca será NULL"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "la comparación siempre se evalúa como %<true%> para la dirección de %qD que nunca será NULL"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "la comparación siempre se evalúa como %<false%> para la dirección de %qD que nunca será NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "la comparación siempre se evalúa como %<true%> para la dirección de %qD que nunca será NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "se comparan vectores con tipos de elemento diferentes"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "se comparan vectores con números de elementos diferentes"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "comparación entre los tipos %qT y %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "no se puede encontrar un tipo entero del mismo tamaño que %qT"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "no es segura la comparacion de coma flotante con == o !="
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "la comparación de punteros a espacios de direcciones discontinuos"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C prohíbe la comparación de %<void *%> con un puntero de función"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "la comparación de diferentes tipos de puntero carece de una conversión"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "comparación entre puntero y entero"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "comparación de punteros completos e incompletos"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C prohíbe la comparación entre punteros a funciones"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "comparación ordenada de puntero con un puntero nulo"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "comparación ordenada de puntero con el entero cero"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "conversión implícita de %qT a %qT para coincidir con otro operando de la expresión binaria"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "se usa un valor de tipo matriz que no se puede cambiar a puntero cuando se requiere un escalar"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "se usa un valor de tipo struct cuando se requiere un escalar"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "se usa un valor de tipo union cuando se requiere un escalar"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "se usa un tipo vector cuando se requiere un escalar"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancel%> debe especificar una de las cláusulas %<parallel%>, %<for%>, %<sections%> o %<taskgroup%>"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<parallel%> or %<target%> %<if%> clause modifier"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "se esperaba el modificador de cláusula %<parallel%> o %<target%> %<if%>"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancellation point%> debe especificar una de las cláusulas %<parallel%>, %<for%>, %<sections%> o %<taskgroup%>"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 #| msgid "%Htoo many %qs clauses"
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%Hdemasiadas cláusulas %qs"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "low bound %qE of array section does not have integral type"
 msgstr "el tamaño de la matriz nueva debe tener un tipo integral"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "la longitud %qE de la sección de matriz no es de tipo integral"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "expected single pointer in %qs clause"
 msgstr "El puntero Cray '%s' en la cláusula %s en %L"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "sección de matriz de longitud cero en la cláusula %qs"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "límite inferior negativo en sección de matriz en cláusula %qs"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "longitud negativa en sección de matriz en cláusula %qs"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "límite inferior %qE por encima del tamaño de la sección de matriz en cláusula %qs"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "longitud %qE por encima del tamaño de la sección de matriz en cláusula %qs"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "límite superior %qE por encima del tamaño de la sección de matriz en cláusula %qs"
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 #| msgid "for increment expression has no effect"
 msgid "for array function parameter length expression must be specified"
 msgstr "la expresión de incremento for no tiene efecto"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, fuzzy, gcc-internal-format
 #| msgid "for increment expression has no effect"
 msgid "for pointer type length expression must be specified"
 msgstr "la expresión de incremento for no tiene efecto"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "la sección de matriz no es contigua en la cláusula %qs"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE no es de tipo puntero o matriz"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "arrojando NULL, que tiene un tipo integral, que no es puntero"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%>-qualified array type"
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "tipo matriz cualificado %<_Atomic%>"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD has incomplete type"
 msgid "iterator %qD has const qualified type"
 msgstr "el parámetro %qD tiene tipo incompleto"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "campo de bits %qD con tipo no integral"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 #| msgid "condition expression refers to iteration variable %qD"
 msgid "begin expression refers to outer iterator %qD"
 msgstr "la expresión de la condición hace referencia a la variable de iteración %qD"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "condition expression refers to iteration variable %qD"
 msgid "end expression refers to outer iterator %qD"
 msgstr "la expresión de la condición hace referencia a la variable de iteración %qD"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "initializer expression refers to iteration variable %qD"
 msgid "step expression refers to outer iterator %qD"
 msgstr "la expresión inicializadora hace referencia a la variable de iteración %qD"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected pointer in %qs clause"
 msgstr "se esperaba un puntero"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "aún no se admite el modelo de código %<large%>"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "aún no se admite el modelo de código %<large%>"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD en la cláusula %<reduction%> es una matriz de tamaño cero"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "ISO C prohíbe los tipos de función calificados"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qE in %qs clause"
 msgid "zero sized type %qT in %qs clause"
 msgstr "campo de bits %qE en cláusula %qs"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qE in %qs clause"
 msgid "variable sized type %qT in %qs clause"
 msgstr "campo de bits %qE en cláusula %qs"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE tiene tipo no válido para %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "No label definition found for %qs"
 msgid "user defined reduction not found for %qE"
 msgstr "No se encontró una definición de etiqueta para %qs"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "se usó la matriz de longitud variable"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE debe ser %<threadprivate%> para %<copin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr "cláusula lineal aplicada a variable no puntero no integral con tipo %qT"
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "cláusula %<linear%> paso %qE no es ni constante ni parámetro"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de reducción"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE no es una variable en la cláusula %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE no es una variable en la cláusula %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE no es una variable en la cláusula %<saligned%>"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "%qE en la cláusula %<aligned%> no es un puntero ni una matriz"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE no es una variable en la cláusula %<saligned%>"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr "el argumento %d de %qE debe ser un tipo puntero"
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "El nombre '%s' no se puede usar como un operador definido en %C"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "cannot initialize %qT from %qT"
 msgid "traits array must be initialized with constants"
 msgstr "no se pueden inicializar %qT desde %qT"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, fuzzy, gcc-internal-format
 #| msgid "Array section not permitted in '%s' call at %L"
 msgid "array section does not have mappable type in %qs clause"
 msgstr "No se permite una sección de matriz en la llamada '%s' en %L"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported fixed-point conversion"
 msgid "unsupported map expression %qE"
 msgstr "conversión de coma fija no admitida"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qs variable is not a pointer"
 msgstr "la fuente no es un puntero"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "la variable %qs no es un puntero ni una matriz"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %qs clauses on a task construct"
 msgstr "demasiadas cláusulas %qs"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "la cláusula %<inbranch%> es incompatible con %<notinbranch%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD debe tomar %<void%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not const"
 msgid "%qD shall not be const"
 msgstr "%q#D no es const"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE está predeterminado como %qs para %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr "el valor de la cláusula %<simdlen%> es mayor que el valor de la cláusula %<safelen%>"
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "demasiadas cláusulas %<if%> con el modificador %qs"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "no se puede utilizar %<va_arg%> con orden de almacenamiento inverso"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "el segundo argumento para %<va_arg%> es del tipo incompleto %qT"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "el segundo argumento para %<va_arg%> es del tipo incompleto %qT"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "el segundo argumento para %<va_arg%> es del tipo incompleto %qT"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "C++ requiere un tipo promovido, no un tipo enum, en %<va_arg%>"
@@ -57956,261 +58009,256 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%q#D is not const"
 msgid "%s should not be null"
 msgstr "%q#D no es const"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s:%d: Invalid state file; %s"
 msgid "%s: Invalid field type %s:"
 msgstr "%s:%d: Fichero de estado no válido; %s"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "invalid GIMPLE statement"
 msgid "Not valid for ACCEPT statement."
 msgstr "declaración GIMPLE no válida"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "invalid GIMPLE statement"
 msgid "Not valid for DISPLAY statement."
 msgstr "declaración GIMPLE no válida"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 #| msgid "unknown type name %qE"
 msgid "unknown %<setop_t%> code %d"
 msgstr "nombre de tipo %qE desconocido"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT resuelve a %qT, el cual no es un tipo de clase"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "El nombre '%s' en %C es el nombre del procedimiento"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -58219,75 +58267,86 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "declaración de tipo derivado"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown type name %qE"
 msgid "Unknown type %d"
 msgstr "nombre de tipo %qE desconocido"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "command line option file '%s' does not exist"
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr "no existe el fichero de opciones de línea de órdenes '%s'"
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "`%s' not supported by %s"
+msgid "%s:%d: Must not call here with %s"
+msgstr "`%s' no tiene soporte para %s"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -58297,13 +58356,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "demasiados ficheros de entrada"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "cannot read string table from %s"
 msgid "cannot get %<float%> value from %s"
@@ -58321,69 +58380,69 @@ msgstr "la señal %s terminó el programa %s"
 msgid "%s exited with status %d"
 msgstr "%s terminó con estado %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
 # Se refiere a la llamada de sistema wait(2). cfuga
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: wait: %s\n"
 msgid "%s: data item %s #"
 msgstr "%s: wait: %s\n"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs value must be positive"
 msgid "%s: key must be field"
 msgstr "el valor de %qs debe ser positivo"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s%qs%s is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s%qs%s no es válido"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: would convert file '%s'\n"
 msgid "%s:%d: could not add '%s'"
 msgstr "%s: se podría convertir el fichero '%s'\n"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling '%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s: compilando '%s'\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "syntax error - missing mode"
 msgid "logic error: missing inode for %s"
 msgstr "error sintáctico - modo faltante"
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -58874,7 +58933,7 @@ msgstr "no hay un %<operator %s%> adecuado para %qT"
 msgid "%q#D is private within this context"
 msgstr "desde este contexto"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "declared private here"
@@ -58886,7 +58945,7 @@ msgstr "se declara aquí"
 msgid "%q#D is protected within this context"
 msgstr "desde este contexto"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "declared protected here"
@@ -59255,7 +59314,7 @@ msgstr "el argumento 3 en la llamada a la función %qE tiene un puntero a un tip
 msgid "constructor delegates to itself"
 msgstr "la constante se refiere a sí misma"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 #| msgid "cannot convert %qT to %qT"
 msgid "cannot convert %qH to %qI"
@@ -59277,7 +59336,7 @@ msgstr "no se encontró una función coincidente para la llamada a %<%T::%s(%A)%
 msgid "call to non-function %qD"
 msgstr "llamada a %qD que no es función"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "no se puede llamar directamente al constructor %<%T::%D%>"
@@ -59947,7 +60006,7 @@ msgstr "el miembro de matriz flexible sería de otra manera un struct vacío"
 msgid "next member %q#D declared here"
 msgstr "  %q+#D se declaró aquí"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "redefinición de %q#T"
@@ -59957,7 +60016,7 @@ msgstr "redefinición de %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -60095,7 +60154,7 @@ msgstr "tipo no válido del parámetro %d en la función %<constexpr%> %q+#D"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
@@ -60154,7 +60213,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%q+D no se puede usar como una función constexpr porque:"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -60193,954 +60252,954 @@ msgstr "Se crea '%s'\n"
 msgid "uncaught exception of type %qT"
 msgstr "no se puede declarar el puntero para el tipo de función calificado %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute not available to functions with variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "el atributo %qE no está disponible para funciones con un número variable de argumentos"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D se declaró con una especificación de excepción"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "storage size not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "el tamaño de almacenamiento no es constante"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D se declaró con una especificación de excepción"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%qs does not support feature %qs"
 msgid "%qD called without supportable %qs"
 msgstr "%qs no admite la característica %qs"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "%qD called with unexpected %qs argument"
 msgstr "argumento inesperado"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to %s"
 msgid "wrong number of arguments to %qs call"
 msgstr "argumento de tipo erróneo para %s"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma message: %s"
 msgid "constexpr message: %.*s"
 msgstr "#pragma message: %s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 #| msgid "Warn on calls to these functions"
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "Avisa en las llamadas a estas funciones"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E no es una expresión constante"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-constexpr function %qD"
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "llamada a la función %qD que no es constexpr"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer"
 msgstr "deferenciando el puntero %<void *%>"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %qE"
 msgid "the comparison reduces to %qE"
 msgstr "demasiados argumentos para %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, fuzzy, gcc-internal-format
 #| msgid "self-comparison always evaluates to false"
 msgid "%qE evaluates to false"
 msgstr "autocomparación siempre falsa"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "internal function"
 msgid "call to internal function %qE"
 msgstr "función interna"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 #| msgid "originally defined here"
 msgid "originally declared %<const%> here"
 msgstr "se definió originalmente aquí"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "el tipo %qT no es un tipo base para el tipo %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 #| msgid "variable %D of type %<io%> must be uninitialized"
 msgid "virtual table pointer is used uninitialized"
 msgstr "la variable %D de tipo %<io%> no debe ser inicializada"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is an ambiguous base class of %qT"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "  %qT es una clase base ambigua de %qT"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "no se puede llamar a la función miembro %qD sin un objeto"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "no se puede ejecutar '%s': %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE does not designate a constexpr function"
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "la expresión %qE no designa una función constexpr"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "storage size not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "el tamaño de almacenamiento no es constante"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, fuzzy, gcc-internal-format
 #| msgid "-client_name not allowed with -dynamiclib"
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "no se permite -client_name con -dynamiclib"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "allocation performed here"
 msgstr "se declara aquí"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "-client_name not allowed with -dynamiclib"
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "no se permite -client_name con -dynamiclib"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, fuzzy, gcc-internal-format
 #| msgid "Attempting to allocate already allocated variable"
 msgid "deallocation of already deallocated storage"
 msgstr "Se intentó alojar una variable ya alojada"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "la declaración de %qD oscurece a una declaración local previa"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 #| msgid "%qD called in a constant expression"
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "se llamó %qD en una expresión constante"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "se llamó %qD en una expresión constante"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "se usó %qD antes de su definición"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "la llamada tiene una dependencia circular"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 #| msgid "constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to increase the maximum)"
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "la profundidad de evaluación de constexpr excede el máximo de %d (use -fconstexpr-depth= para incrementar el máximo)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "reference to %qD is not a constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is negative"
 msgstr "la cuenta de desplazamiento a la derecha es negativa"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "la cuenta de desplazamiento a la derecha es negativa"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "el operador del lado izquierdo de la expresión coma no tiene efecto"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "shift expression %q+E overflows"
 msgstr "la expresión integral %qE no es una constante"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is outside array bounds"
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "el subíndice de la matriz está fuera de los límites de la matriz"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is outside array bounds"
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "el subíndice de la matriz está fuera de los límites de la matriz"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is outside array bounds"
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "el subíndice de la matriz está fuera de los límites de la matriz"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is outside array bounds"
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "el subíndice de la matriz está fuera de los límites de la matriz"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized array element"
 msgstr "falta el inicializador para el miembro %qD"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "deferenciando el puntero %<void *%>"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%qD mutable no se puede usar en una expresión constante"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized member %qD"
 msgstr "falta el inicializador para el miembro %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 #| msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "se accede al miembro %qD  en lugar del miembro inicializado %qD en la expresión constante"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "se accede al miembro %qD  en lugar del miembro inicializado %qD en la expresión constante"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "ifunc is not supported on this target"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "no se admiten ifunc en este objetivo"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "falta el inicializador para el miembro %qD"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 #| msgid "accessing value of %qE through a %qT glvalue in a constant expression"
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "se accede al valor de %qE a través de glvalue %qT en una expresión constante"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared here"
 msgid "%qT object created here"
 msgstr "%qT se declara aquí"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D declared here"
 msgid "%q#D declared here"
 msgstr "%q+#D se declaró aquí"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "use of the value of the object being constructed in a constant expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "uso del valor del objeto en construcción en una expresión constante"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "allocated here"
 msgstr "se declara aquí"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "the value of %qD is not usable in a constant expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "el valor de %qD no se puede usar en una expresión constante"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "el valor de %qD no se puede usar en una expresión constante"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "se usó %qD en su propio inicializador"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D no es const"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q+#D es volatile"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD no se inicializó con una expresion constante"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD no se declaró %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 #| msgid "use of the value of the object being constructed in a constant expression"
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "uso del valor del objeto en construcción en una expresión constante"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 #| msgid "difference of two pointer expressions is not a constant expression"
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "la diferencia de dos expresiones puntero no es una expresión constante"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 #| msgid "Change of value in conversion from  %s to %s at %L"
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "Cambio de valor en la conversión de %s a %s en %L"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 #| msgid "Change of value in conversion from  %s to %s at %L"
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "Cambio de valor en la conversión de %s a %s en %L"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, fuzzy, gcc-internal-format
 #| msgid "constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to increase the maximum)"
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "la profundidad de evaluación de constexpr excede el máximo de %d (use -fconstexpr-depth= para incrementar el máximo)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "inline assembly is not a constant expression"
 msgstr "el elemento inicializador no es una expresión constante"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "uso no válido de %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D se declaró con una especificación de excepción"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, fuzzy, gcc-internal-format
 #| msgid "constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to increase the maximum)"
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "la profundidad de evaluación de constexpr excede el máximo de %d (use -fconstexpr-depth= para incrementar el máximo)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, fuzzy, gcc-internal-format
 #| msgid "capture of variable %qD with non-automatic storage duration"
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "captura de la variable %qD con duración de almacenamiento que no es automática"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "temporal del tipo %qT que no es literal en una expresión constante"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 #| msgid "invalid return type %qT of constexpr function %q+D"
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "tipo de devolución %qT no válido para la función constexpr %q+D"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from pointer type %qT to arithmetic type %qT in a constant-expression"
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "conversión del tipo puntero %qT al tipo aritmético %qT en una expresión constante"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "pointed-to object declared here"
 msgstr "  %q+#D se declaró aquí"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "expression %qE is not a constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%<goto%> is not a constant expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "el tamaño de la matriz %qD no es una expresion constante integral"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "statement is not a constant expression"
 msgstr "el elemento inicializador no es una expresión constante"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "expresión %qE inesperada de género %s"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "el operando 'B' no es una constante"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "contract predicate is false in constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "%<break%> must be in loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "%<break%> debe estar dentro de un bucle o switch"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcontinue statement not within a loop"
 msgid "%<continue%> outside of a loop"
 msgstr "%Hla declaración continue no está dentro de un bucle"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "%Jjump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "%Jsalto a una expresión de declaración"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "se toma la dirección del destructor %qE"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 #| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qT no puede ser el tipo de una expresión constante completa porque tiene sub-objetos mutables"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "conversión no válida de una expresión r-valuada de tipo %qT al tipo %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid reinterpret_cast from type `%T' to type `%T'"
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "reinterpret_cast no válido del tipo `%T' al tipo `%T'"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "la dirección de un objeto %qE con hilo local o almacenamiento automático no es una expresión constante"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "las funciones virtual no pueden ser friend"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "la expresión id de tipo no es una expresión constante porque %qE es de tipo polimórfico"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 #| msgid "temporary of non-literal type %qT in a constant expression"
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "temporal del tipo %qT que no es literal en una expresión constante"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 #| msgid "%qE undeclared here (not in a function)"
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qE no se declaró aquí (no en una función)"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 #| msgid "%q+F declared %<static%> but never defined"
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%q+F se declaró %<static%> pero nunca se define"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "division by zero is not a constant expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "inicialización de una matriz que no es constante"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "AST inesperado de género %s"
@@ -61288,417 +61347,417 @@ msgstr "operando no válido en la instrucción"
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD no es una variable puntero"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not nothrow default constructible"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not nothrow copy constructible"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid class name"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qs no es un nombre de clase válido"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not trivially default constructible"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially copy constructible"
 msgstr "  %q+T tiene un destructor que no es trivial"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially destructible"
 msgstr "  %q+T tiene un destructor que no es trivial"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE does not designate a constexpr function"
 msgid "%qT does not have unique object representations, because"
 msgstr "la expresión %qE no designa una función constexpr"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE does not designate a constexpr function"
 msgid "%qT does not have a virtual destructor"
 msgstr "la expresión %qE no designa una función constexpr"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an abstract class"
 msgstr "%q#T no es una clase"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an aggregate"
 msgstr "%qT no es un tipo agregado"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an array"
 msgstr "%qT no es un tipo agregado"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not assignable from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT no es una base de %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not a bounded array"
 msgstr "%qD no es una variable puntero"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T no es una clase"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a const type"
 msgstr "%qT no es un tipo de clase"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "type %qE has no default constructor to call"
 msgid "%qT is not default constructible, because"
 msgstr "el tipo %qE no tiene un constructor para llamar por defecto"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not constructible from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not destructible, because"
 msgstr "%q+T no es literal porque:"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an empty class"
 msgstr "%q#T no es una clase"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT no es una plantilla"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a final class"
 msgstr "%q#T no es una clase"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "%qT is not a function"
 msgstr "'%s' en %L no es una función"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT no es un tipo plantilla"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not invocable, because"
 msgstr "%qD no es una variable"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "  %qE is not equivalent to %qE"
 msgid "%qT is not invocable by %qT, because"
 msgstr "  %qE no es equivalente a %qE"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not compatible with %qD"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qD no es compatible con %qD"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a literal type"
 msgstr "%qT no es un tipo de clase"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD no es una función plantilla miembro"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT no es un miembro de %qT"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT no es un miembro de %qT"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qD no es una variable puntero"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "  %qE is not equivalent to %qE"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "  %qE no es equivalente a %qE"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT no es de tipo puntero-a-objeto"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT no es una base inaccesible de %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a POD type"
 msgstr "%qD no es un tipo"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "la fuente no es un puntero"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qT no es un tipo de clase"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT no es un espacio de nombres"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT no es una base de %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "%qT no es un espacio de nombres"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT no es un tipo agregado"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a trivial type"
 msgstr "%qT no es un tipo de clase"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not trivially default constructible, because"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially copyable"
 msgstr "%q+T no es literal porque:"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially destructible, because"
 msgstr "  %q+T tiene un destructor que no es trivial"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%qT is not an unbounded array"
 msgstr "%qT no es un tipo de enumeración"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is a member of a union"
 msgid "%qT is not a union"
 msgstr "%qE no es un miembro de una unión"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "el tipo %qT no es una base directa de %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT no es un tipo plantilla"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "%q#D is not const"
-msgid "%qT is not consteval-only"
-msgstr "%q#D no es const"
+#| msgid "%qT is not a class type"
+msgid "%qT is not a structural type"
+msgstr "%qT no es un tipo de clase"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs and %qs are incompatible"
 msgid "%qT and %qT cannot be ordered"
 msgstr "%qs y %qs son incompatibles"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "type %qE has no default constructor to call"
 msgid "%qT is not destructurable"
 msgstr "el tipo %qE no tiene un constructor para llamar por defecto"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "constante no válida"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "bitwise comparison always evaluates to false"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "comparación de bits siempre falsa"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "-mhard-float not supported"
 msgid "constraints not satisfied"
 msgstr "no se admite -mhard-float"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -61733,52 +61792,52 @@ msgstr "se descarta la declaración asm debido a un conflicto con el renombrado
 msgid "previous declaration with fewer contracts here"
 msgstr "la definición original apareció aquí"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "parameter declared here"
 msgstr "se declara aquí"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "global declaration %q+#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "la declaración global %q+#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "first declared here"
 msgstr "se declara aquí"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -61857,7 +61916,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%qD se declaró aquí"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "no member named %qE in %qT"
@@ -61941,92 +62000,92 @@ msgstr "el tipo calificado %qT no coincide con el nombre del destructor ~%qT"
 msgid "awaitable type %qT is not a structure"
 msgstr "el tipo calificado %qT no coincide con el nombre del destructor ~%qT"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "la función declarada %<noreturn%> tiene una declaración %<return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "el tercer argumento de %<__builtin_prefetch%> debe ser una constante"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "el tercer argumento de %<__builtin_prefetch%> debe ser una constante"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %qD"
 msgid "no suspend point info for %qD"
 msgstr "no hay un prototipo previo para %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "%qE duplicado"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "no se permite usar punteros como valores case"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, fuzzy, gcc-internal-format
 #| msgid "variable-length array bound is unknown"
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "el límite del array de longitud variable es desconocido"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "ms_hook_prologue is not compatible with nested function"
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "ms_hook_prologue no es compatible con la función anidada"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -62053,78 +62112,84 @@ msgstr "%qD no es una función plantilla"
 msgid "%qs used outside of constant expressions"
 msgstr "%qE no es una expresión constante"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "se esperaba una declaración"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "taking address of an immediate function %qD"
 msgstr "se toma la dirección del destructor %qE"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "la dirección de %qD siempre se evaluará como %<true%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "un destructor no puede ser %<constexpr%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes on template argument %qT"
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "se descartan los atributos en el argumento de plantilla %qT"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qE attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "argumento no válido del atributo %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in unevaluated context"
 msgid "use fold expression in the attribute argument instead"
 msgstr "expresión lambda en un contexto sin evaluar"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD no es un tipo"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qD is not a class type"
 msgstr "%qT no es un tipo de clase"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have pointer or array type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qE no es de tipo puntero o matriz"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qD does not have integral type"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -62173,7 +62238,7 @@ msgstr "inicialización a un tipo de referencia que no es constante %q#T desde u
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "la conversión de %qT a %qT descarta los calificadores"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "la conversión de %qT a %qT no dereferencía a los punteros"
@@ -62581,7 +62646,7 @@ msgstr "de la declaración previa de %q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "la redeclaración de %qD difiere en %<constexpr%>"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D"
 msgid "previous declaration %qD"
@@ -62838,13 +62903,13 @@ msgstr "argumento por defecto dado para el parámetro %d de %q#D"
 msgid "previous specification in %q#D here"
 msgstr "después de la especificación previa en %q+#D"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "declaraciones de %q#D en conflicto"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared here without exporting"
@@ -63067,7 +63132,7 @@ msgstr "  salta la inicialización de %q+#D"
 msgid "  enters %<template for%> statement"
 msgstr "se esperaba una declaración"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -63116,584 +63181,584 @@ msgstr "%<typename %T::%D%> nombra a %q#T, el cual no es un tipo"
 msgid "template parameters do not match template %qD"
 msgstr "los parámetros de la plantilla no coinciden con la plantilla"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "-falign-labels=%d is not supported"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "no se admite -falign-labels=%d"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q#D no válido; una union anónima solo puede tener miembros con datos no estáticos públicos"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr "esta flexibilidad es obsoleta y será eliminada"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "struct anónimo no está dentro de un tipo nombrado"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "no se permite el miembro %q+#D con constructor en un agregado anónimo"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "no se permite el miembro %q+#D con destructor en un agregado anónimo"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "no se permite el miembro %q+#D con operador de asignación de copia en un agregado anónimo"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "se descarta el atributo en la declaración de %q#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "el atributo para %q#T debe estar a continuación de la palabra clave %qs"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "tipos múltiples en una declaración"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "redeclaración del tipo interno de C++ %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> sólo se puede especificar para variables o declaraciones de función"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "falta el nombre del tipo en la declaración typedef"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ prohíbe structs anónimos"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "%qs sólo se puede especificar para funciones"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%qs sólo se puede especificar para funciones"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> sólo se puede especificar dentro de una clase"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> sólo se puede especificar para constructores"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "una clase de almacenamiento sólo se puede especificar para objetos y funciones"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "los calificadores sólo se pueden especificar para objetos y funciones"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "los calificadores sólo se pueden especificar para objetos y funciones"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "los calificadores sólo se pueden especificar para objetos y funciones"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "a storage class can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "una clase de almacenamiento sólo se puede especificar para objetos y funciones"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "se descartó %<typedef%> en esta declaración"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot be used for type declarations"
 msgid "%qs cannot be used for type declarations"
 msgstr "%<constexpr%> no se puede usar en declaraciones de tipo"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "se descartan los atributos en la instanciación de una plantilla"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "el atributo %qE sólo se puede aplicar a definiciones de clase"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "se descarta el atributo"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "un atributo que atañe a un especificador de tipo se descarta"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "se descartan los atributos aplicados al tipo de clase %qT fuera de la definición"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "se descartan los atributos aplicados al tipo dependiente %qT sin una declaración asociada"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %qD is initialized (use decltype instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD está inicializado (utilice decltype en su lugar)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "la declaración de %q#D tiene %<extern%> y está inicializada"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "la definición de %q#D se marca como %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q#D no es un dato miembro no static de %qT"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member-template declaration of %qD"
 msgstr "declaración plantilla de %q#D"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member template declaration %qD"
 msgid "does not match member template declaration here"
 msgstr "declaración de la plantilla miembro %qD no válida"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ no permite que %<%T::%D%> se defina como %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "inicialización duplicada de %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "la declaración de %q#D fuera de la clase no es una definición"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "la variable %q#D tiene inicializador pero de tipo de dato incompleto"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "elementos de la matriz %q#D con tipo de dato incompleto"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "el agregado %q#D tiene un tipo incompleto y no se puede definir"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD declarado como referencia pero no se inicializa"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "se usó un nombre en un inicializador designado de estilo GNU para una matriz"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "el nombre %qD se utiliza en un inicializador designado en estilo GNU para una matriz"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "no se admiten los inicializadores designados como no triviales"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "el tamaño de la matriz %qD no es una expresion constante integral"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "el inicializador no puede determinar el tamaño de %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "falta el tamaño de la matriz en %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "matriz %qD de tamaño cero"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "no se conoce el tamaño de almacenamiento de %qD"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "el tamaño de almacenamiento de %qD no es constante"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you%'ll wind up with multiple copies)"
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "perdón: la semántica de los datos static de la función inline %q+#D es errónea (terminará con múltiples copias)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you%'ll wind up with multiple copies)"
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "perdón: la semántica de los datos static de la función inline %q+#D es errónea (terminará con múltiples copias)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 #| msgid "  you can work around this by removing the initializer"
 msgid "you can work around this by removing the initializer"
 msgstr "  puede evitar esto eliminando el inicializador"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "const %qD sin inicializar"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized member %qD in %<constexpr%> constructor"
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "miembro %qD sin inicializar en el constructor %<constexpr%>"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized member %qD in %<constexpr%> constructor"
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "miembro %qD sin inicializar en el constructor %<constexpr%>"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T no tiene constructor por defecto proporcionado por el usuario"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "el constructor no es proporcionado por el usuario porque está marcado explícitamente por defecto en el cuerpo de la clase"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, fuzzy, gcc-internal-format
 #| msgid "and the implicitly-defined constructor does not initialize %q+#D"
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "y el constructor implícitamente definido no inicializa %q+#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "tipo %qT no válido como inicializador para un vector de tipo %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "el inicializador para %qT debe estar encerrado entre llaves"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "se usa %<[%E] =%> en un inicializador designado en estilo GNU para la clase %qT"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "la petición para el miembro %qD es ambigua"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT no tiene un dato miembro que no es static llamado %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD no es un miembro de %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for array member %q#D"
 msgid "invalid initializer for %q#D"
 msgstr "inicializador no válido para la matriz miembro %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "asignador C99 %qE fuera del inicializador agregado"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "demasiados inicializadores para %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "llaves alrededor del inicializador escalar para el tipo %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "llaves alrededor del inicializador escalar para el tipo %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "faltan llaves alrededor del inicializador para %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding has incomplete type %qT"
 msgstr "puntero deferenciado a tipo de dato incompleto"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "elementos de la matriz %q#T tienen tipo de dato incompleto"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "literal compuesta de tamaño variable"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D tiene un tipo incompleto"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "el objeto escalar %qD requiere un elemento en el inicializador"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "en C++98 %qD debe ser inicializado por un constructor, no por %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "matriz %qD inicializada con una constante de cadena entre paréntesis %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "inicializador no válido para el miembro static con constructor"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "inicialización en clase que no es constante no válida para el miembro static %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 #| msgid "non-constant in-class initialization invalid for static member %qD"
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "inicialización en clase que no es constante no válida para el miembro static %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(se requiere una inicialización fuera de la clase)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "se solicitó la dirección de la variable register explícita %qD"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is initialized with itself"
 msgid "reference %qD is initialized with itself"
 msgstr "%qD se inicializa con sí mismo"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "el argumento %d de %qE debe ser un tipo puntero"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "could not find variant declaration"
 msgstr "%<[*]%> fuera de una declaración"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "%s: recursive invocation of constructor %qs"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%s: invocación recursiva del constructor %qs"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration cannot name destructor"
 msgid "%<declare variant%> on destructor %qD"
 msgstr "uan declaración de uso no puede nombrar al destructor"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "asignación (no inicialización) en la declaración"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ no permite inicializadores designados"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %qs"
 msgid "%<register%> storage class specifier used"
 msgstr "se especificó una clase de almacenamiento para %qs"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "la declaración de %q#D no tiene inicializadores"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of member function (did you forget the %<()%> ?)"
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "uso no válido de la función miembro (¿Olvidó el %<&%>?)"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -63701,134 +63766,134 @@ msgstr "el tipo de devolución %q#T es un tipo de dato incompleto"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be defaulted"
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD no se puede definir por defecto"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "se oscurece la declaración de tipo previa de %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables in static storage"
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "el atributo %qE se aplica solamente a variables en almacenamiento estático"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "la función %q#D se inicializa como una variable"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to qualified function type %qT"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "no se puede declarar el puntero para el tipo de función calificado %qT"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "lambda declared here"
 msgstr "se declara aquí"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at %q+D because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "  no se puede usar la asignación obsoleta en %q+D porque tiene un destructor"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "cannot form pointer to member of non-class %q#T"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "no se puede formar un puntero al miembro de %q#T que no es clase"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT no es una base anidada de %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding refers to incomplete type %qT"
 msgstr "puntero deferenciado a tipo de dato incompleto"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 #| msgid "cannot value-initialize array of unknown bound %qT"
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "no se puede inicializar por valor la matriz %qT de límite desconocido"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable length array %qE"
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 prohíbe la matriz de longitud variable %qE"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable length array %qE"
 msgid "cannot decompose variable length vector %qT"
 msgstr "ISO C90 prohíbe la matriz de longitud variable %qE"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "el tamaño de la matriz no es una expresion constante integral"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to qualified function type %qT"
 msgid "cannot decompose union type %qT"
 msgstr "no se puede declarar el puntero para el tipo de función calificado %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "se crea un puntero al miembro del tipo %qT que no es clase"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "puntero deferenciado a tipo de dato incompleto"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "array initializer for structured binding declaration in condition"
 msgstr "inicializador no válido para la cadena de bits"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs specified for structure field"
 msgid "%u name provided for structured binding"
@@ -63836,7 +63901,7 @@ msgid_plural "%u names provided for structured binding"
 msgstr[0] "se especificó %qs para el campo de estructura"
 msgstr[1] "se especificó %qs para el campo de estructura"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "only %u name provided for structured binding"
@@ -63844,1901 +63909,1913 @@ msgid_plural "only %u names provided for structured binding"
 msgstr[0] "inicializador no válido para la cadena de bits"
 msgstr[1] "inicializador no válido para la cadena de bits"
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "in initialization of structured binding pack %qD"
 msgstr "tipo no válido para la variable de iteración %qE"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "in initialization of structured binding variable %qD"
 msgstr "tipo no válido para la variable de iteración %qE"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to static data member %qD"
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "no se puede aplicar %<offsetof%> al dato miembro static %qD"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "  %q+T tiene un destructor que no es trivial"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "el inicializador no puede determinar el tamaño de %qT"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "falta el tamaño de la matriz en %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "matriz %qT de tamaño cero"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "el destructor para la clase extranjera %qT no puede ser un miembro"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "el constructor para la clase extranjera %qT no puede ser un miembro"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD se declaró como una variable %<virtual%>"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "los especificadores de función %<const%> y %<volatile%> en %qD son no válidos en la declaración de variable"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD se declaró como un parámetro %<virtual%>"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD se declaró como un parámetro %<inline%>"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "los especificadores de función %<const%> y %<volatile%> en %qD son no válidos en la declaración de parámetro"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD se declaró como un tipo %<virtual%>"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD se declaró como un tipo %<inline%>"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "los especificadores de función %<const%> y %<volatile%> en %qD son no válidos en la declaración de tipo"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD se declaró como un campo %<virtual%>"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD se declaró como un campo %<inline%>"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "los especificadores de función %<const%> y %<volatile%> en %qD son no válidos en la declaración de campo"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D se declaró como friend"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D se declaró con una especificación de excepción"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "la definición de %qD no está en un espacio de nombres que contenga a %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "la función miembro static %q#D se declara con calificadores de tipo"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "ya no se admiten los valores de devolución nombrados"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD no es una función plantilla"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "la declaración friend no está en una definición de clase"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "definiendo la especialización explícita %qD en la declaración friend"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "uso no válido del id de plantilla %qD en la declaración de la plantilla primaria"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "no se permiten los argumentos por defecto en la declaración de la especialización friend de la plantilla %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "no se permite %<inline%> en la declaración de la especialización friend de la plantilla %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "la declaración de %q#D fuera de la clase no es una definición"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "no se puede declarar %<::main%> como plantilla"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "no se puede declarar %<::main%> como inline"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "no se puede declarar %<::main%> como static"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "no se puede declarar %<::main%> como static"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "no se puede declarar %<::main%> como static"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "no se puede declarar %<::main%> como plantilla"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "la función que no es miembro %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "la función miembro static %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "la función miembro static %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 #| msgid "non-member function %qD cannot have cv-qualifier"
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "la función que no es miembro %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "la función miembro static %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "la función miembro static %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "explicit object parameter declared here"
 msgstr "el tipo de parámetro de plantilla %qT se declaró %<friend%>"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "la especialización de %qD debe aparecer en un ámbito de espacio de nombres"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "  declared here"
 msgstr "se declara aquí"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "la especialización de %qD debe aparecer en un ámbito de espacio de nombres"
 
 #  FIXME traducción
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "la declaración de %qD como algo que no es función"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "operador literal con enlace C"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD tien una lista de argumentos no válida"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, fuzzy, gcc-internal-format
 #| msgid "integer suffix %<%s%> shadowed by implementation"
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "se oscurece el sufijo entero %<%s%> por la implementación"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, fuzzy, gcc-internal-format
 #| msgid "floating point suffix %<%s%> shadowed by implementation"
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "se oscurece el sufijo de coma flotante %<%s%> por la implementación"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "los sufijos de operador literal que no están precedidos por %<_%> están reservados para estandarización futura"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD debe ser una función que no sea miembro"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> debe devolver %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "la definición de %qD declarado implícitamente"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "la definición de %qD explícitamente por defecto"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D explicitly defaulted here"
 msgid "%q#D explicitly defaulted here"
 msgstr "%q+#D explícitamente por defecto aquí"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "no hay una función miembro %q#D declarada en la clase %qT"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "no se puede declarar %<::main%> como plantilla"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 #| msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "la variable automática %qE no puede ser %<threadprivate%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "concept must be defined at namespace scope"
 msgstr "la especialización de %qD debe aparecer en un ámbito de espacio de nombres"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "ya no se admiten los valores de devolución nombrados"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "inicialización en la clase del miembro de datos static %q#D de tipo incompleto"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "se necesita %<constexpr%> para la inicialización en la clase no válida del miembro de datos static %q#D de tipo que no es integral"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "inicialización en la clase del miembro de datos static %q#D de tipo que no es literal"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "inicialización en la clase no válida para el miembro de datos static de tipo %qT que no es integral"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ prohíbe la inicialización en la clase del miembro static %qD que no es constante"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ prohíbe la inicialización de la constante miembro %qD del tipo %qT que no es entero"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "el tamaño de la matriz %qD tiene un tipo %qT que no es integral"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "el tamaño de la matriz tiene un tipo %qT que no es integral"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "el tamaño de la matriz %qD no es una expresion constante integral"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "el tamaño de la matriz no es una expresion constante integral"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ prohíbe la matriz %qD de tamaño cero"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ prohíbe matrices de tamaño cero"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ prohíbe la matriz %qD de longitud variable"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ prohíbe las matrices de longitud variable"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "se usa la matriz de longitud variable %qD"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "se usó la matriz de longitud variable"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "desbordamiento en la dimensión de la matriz"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%q+D se declaró como friend"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "se crea un puntero al miembro de referencia de tipo %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "la declaración de %qD como una matriz de voids"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "se crea la matriz de voids"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "la declaración de %qD como una matriz de funciones"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "se crea la matriz de funciones"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "la declaración de %qD como una matriz de referencias"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "se crea la matriz de referencias"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "la declaración de %qD como una matriz de miembros de función"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "se crea la matriz de miembros de función"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "la declaración de %qD como una matriz multidimensional debe tener límites para todas las dimensiones excepto la primera"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "una matriz multidimensional debe tener límites para todas las dimensiones excepto para la primera"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "se usó la matriz de longitud variable"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "la especificación del tipo de devolución para el constructor es no válida"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "la especificación del tipo de devolución para el destructor es no válida"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "se especificó un tipo de devolución para %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "la especificación del tipo de devolución para el destructor es no válida"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "especificadores en conflicto en la declaración de %qs"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "especificadores en conflicto en la declaración de %qs"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "se declaró la variable o campo sin nombre como void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "se declaró la variable o campo como void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "el especificador %<inline%> es no válido para la función %qs declarada fuera del ámbito global"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it has a base class"
 msgstr "el tipo no es compatible con su variante"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "el tipo no es compatible con su variante"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "los destructores no pueden ser cv-calificados"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together for %qs"
 msgid "%e and %e specified together"
 msgstr "%<signed%> y %<unsigned%> se especificaron juntos para %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "uso no válido del nombre calificado %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "uso no válido del nombre calificado %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "uso no válido del nombre calificado %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT no es una clase o un espacio de nombres"
 
 #  FIXME traducción
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "la declaración de %qD como algo que no es función"
 
 #  FIXME traducción
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "declaración de %qD como algo que no es miembro"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "falta el id del declarador; se utiliza la palabra reservada %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "la definición de la función no declara parámetros"
 
 #  FIXME traducción
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "la declaración de %qD como algo que no es función"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "declaración de %qD como %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "la declaración de %qD como parámetro"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, fuzzy, gcc-internal-format
 #| msgid "no classes specified"
 msgid "both %qs and %qs specified"
 msgstr "no se especificó ninguna clase"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot appear in a typedef declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%<constexpr%> no puede aparecer en una declaración typedef"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "dos o más tipos de datos en la declaración de %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain %<complex%> meaning %<double complex%>"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C no admite %<complex%> simples que significan %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ prohíbe la declaración de %qs sin tipo"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 #| msgid "%<__int128%> is not supported by this target"
 msgid "%<__int%d%> is not supported by this target"
 msgstr "no se admite %<__int128%> en este objetivo"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support %<__int128%> for %qs"
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ no admite %<__int128%> para %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "%qs used with %qE"
 msgid "%qs specified with %qT"
 msgstr "se usó %qs con %qE"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qs specified with typedef-name %qD"
 msgstr "se usó %qE con %<typedef%>"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qs specified with %<decltype%>"
 msgstr "se usó %qE con %<typedef%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qs specified with %<typeof%>"
 msgstr "se usó %qE con %<typedef%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "complex no válido para %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "el miembro %qD no se puede declarar como virtual y static al mismo tiempo"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "el miembro %qD no se puede declarar como virtual y static al mismo tiempo"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "declaración typedef no válida en la declaración de parámetros"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "se especificó una clase de almacenamiento para el parámetro de plantilla %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "se especificó una clase de almacenamiento para el parámetro %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "a parameter cannot be declared %qs"
 msgstr "un parámetro no se puede declarar %<constexpr%>"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "declaración de clase fuera de %<virtual%>"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q#T"
 msgid "structured binding declaration cannot be %qs"
 msgstr "se descarta el atributo en la declaración de %q#T"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "inicializador no válido para la cadena de bits"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, fuzzy, gcc-internal-format
 #| msgid "function %qs cannot be declared %<mutable%>"
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "la función %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 #| msgid "indirect function %q+D cannot be declared weak"
 msgid "structured binding declaration cannot have type %qT"
 msgstr "la función indirecta %q+D no se puede declarar weak"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, fuzzy, gcc-internal-format
 #| msgid "indirect function %q+D cannot be declared weak"
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "la función indirecta %q+D no se puede declarar weak"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "múltiples clases de almacenamiento en la declaración de %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "se especificó una clase de almacenamiento para %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "la función anidada %qs se declaró %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "la declaración del nivel superior de %qs especifica %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "el ámbito de la función %qs es implícitamente auto y declarado %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "especificadores de clase de almacenamiento no válidos en las declaraciones de funciones friend"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "múltiples clases de almacenamiento en la declaración de %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "Se esperaba un paréntesis izquierdo"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot have an initializer"
 msgid "a function type cannot have an explicit object parameter"
 msgstr "La función '%s' en %L no puede tener un inicializador"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "la función %qs no puede tener argumentos"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "  member function type %qT is not a valid template argument"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "  el tipo de función miembro %qT no es un argumento de plantilla válido"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "no se pueden definir tipos en condiciones"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "valid explicit object parameter declared here"
 msgstr "el tipo de parámetro de plantilla %qT se declaró %<friend%>"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "la función %qs usa el especificador de tipo %<auto%> sin un tipo de devolución trailing"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 #| msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "el tipo de devolución trailing sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "las funciones virtual no pueden ser friend"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "la función %qs con tipo de devolución trailing tiene %qT como su tipo en lugar de un simple %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "la función %qs con tipo de devolución trailing tiene %qT como su tipo en lugar de un simple %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "uso no válido de %<auto%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "la función %qs con tipo de devolución trailing tiene %qT como su tipo en lugar de un simple %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "uso no válido del constructor como una plantilla"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "se descartan los calificadores de tipo en el tipo de devolución de la función"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "la función %qs no puede tener argumentos"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 #| msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "el tipo de devolución trailing sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "no se declaró la función %qs con tipo de devolución trailing con el especificador de tipo %<auto%>"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "a conversion function cannot have a trailing return type"
 msgstr "la función %qs no puede tener argumentos"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%>-qualified return type of %qD"
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "calificado %<_Atomic%> el tipo de retorno de %qD"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs que se declaró como función devuelve una función"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs que se declaró como función devuelve una matriz"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "%<noreturn%> function returns non-void value"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "la función %<noreturn%> devuelve un valor que no es void"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "el destructor no puede ser una función miembro de tipo static"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "el constructor no puede ser una función miembro de tipo static"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "los destructores no pueden ser cv-calificados"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "los constructores tal vez no sean cv-calificados"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "destructors may not be ref-qualified"
 msgstr "los destructores no pueden ser cv-calificados"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "constructors may not be ref-qualified"
 msgstr "los destructores no pueden ser cv-calificados"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "los constructores no se pueden declarar virtual"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "las funciones virtual no pueden ser friend"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "la declaración friend no está en una definición de clase"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t define friend function %qs in a local class definition"
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "no se puede definir la función friend %qs en una definición de clase local"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "non-member function %qD cannot have cv-qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "la función que no es miembro %qD no puede tener calificador-cv"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "templates may not be %<virtual%>"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "las plantillas no pueden ser %<virtual%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "los constructores no se pueden declarar virtual"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD debe ser una función miembro que no sea static"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "los destructores no pueden tener parámetros"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "no se puede declarar el puntero a %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "no se puede declarar la referencia a %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "no se puede declarar el puntero al miembro %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "no se puede declarar la referencia para el tipo de función calificado %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "no se puede declarar el puntero para el tipo de función calificado %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "no se puede declarar la referencia a %q#T, el cual no es una definición de tipo o un argumento de tipo de plantilla"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "el id de plantilla %qD se usa como un declarador"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "las funciones miembros son implícitamente friends de su clase"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "calificación extra %<%T::%> en el miembro %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot define member function %<%T::%s%> within %<%T%>"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "no se puede definir la función miembro %<%T::%s%> dentro de %<%T%>"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function %<%T::%s%> within %<%T%>"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "no se puede declarar la función miembro %<%T::%s%> dentro de %<%T%>"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "no se puede declarar el miembro %<%T::%s%> dentro de %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "%qs que no es parámetro no puede ser un paquete de parámetro"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "los datos miembro pueden no tener el tipo modificado variablemente %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "el parámetro puede no tener el tipo modificado variablemente %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 #| msgid "%<virtual%> outside class declaration"
 msgid "%<explicit%> outside class declaration"
 msgstr "declaración de clase fuera de %<virtual%>"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%> en una declaración vacía"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 #| msgid "only declarations of constructors can be %<explicit%>"
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "solamente las declaraciones de constructores pueden ser %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "el no-miembro %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "el miembro que no es objeto %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "la función %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "static %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "const %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "la referencia %qs no se puede declarar %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "typedef may not be a function definition"
 msgstr "no se pueden definir tipos en condiciones"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "typedef may not be a member function definition"
 msgstr "no se pueden definir tipos en condiciones"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%> fuera de una declaración"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "la definición de tipo se declaró %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "el nombre del typedef puede no ser un especificador-de-nombre-anidado"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ prohíbe el tipo anidado %qD con el mismo nombre que la clase que lo contiene"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "se especificó %<inline%> para la declaración de clase friend"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "los parámetros de la plantilla no pueden ser friends"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "la declaración friend requere una llave de clase, p.e. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "la declaración friend requiere una llave de clase, p.e. %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "se intenta hacer que la clase %qT sea un friend de ámbito global"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "calificadores no válidos en el tipo de función que no es miembro"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "el declarador abstracto %qT se usó como declaración"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 #| msgid "value-initialization of function type %qT"
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "inicialización por valor del tipo de función %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "no se puede usar %<::%>  en la declaración de parámetros"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter %q+D to be of abstract type %qT"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "no se puede declarar que el parámetro %q+D sea del tipo abstracto %qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "no se puede usar %<this%> en este contexto"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "el parámetro se declaró %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "uso no válido del nombre-de-plantilla %qE sin una lista de argumentos"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member declared %<auto%>"
 msgid "non-static data member declared with placeholder %qT"
 msgstr "se declaró el miembro dato que no es static como %<auto%>"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C90 no admite miembros de matriz flexibles"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 no admite miembros de matriz flexibles"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "uso no válido de %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "declaración de la función %qD en un contexto no válido"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "la función %qD se declaró virtual dentro de un union"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be declared virtual, since it is always static"
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD no se puede declarar virtual, ya que siempre es static"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "se esperaba un nombre calificado en la declaración friend para el destructor %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "declaración de %qD como miembro de %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "a destructor cannot be %qs"
 msgstr "un destructor no puede ser %<constexpr%>"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "se esperaba un nombre calificado en la declaración friend para el constructor %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "a constructor cannot be %<concept%>"
 msgstr "un destructor no puede ser %<constexpr%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be a member function"
 msgstr "el constructor no puede ser una función miembro de tipo static"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "no se puede abrir %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD redeclared as function"
 msgid "specialization of variable template %qD declared as function"
 msgstr "la variable %qD se redeclaró como función"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 #| msgid "original type declared here"
 msgid "variable template declared here"
 msgstr "el tipo original se definió aquí"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "field %qD has incomplete type %qT"
 msgstr "el campo %qD tiene tipo de dato incompleto"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "el nombre %qT tiene tipo de dato incompleto"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE no es ni función ni función miembro; no se puede declarar friend"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE no es ni función ni función miembro; no se puede declarar friend"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+#| msgid "%s attribute applied to %s %s at %L"
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "El atributo %s se aplica a %s %s en %L"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "definiendo la especialización explícita %qD en la declaración friend"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, fuzzy, gcc-internal-format
 #| msgid "an attribute that appertains to a type-specifier is ignored"
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "un atributo que atañe a un especificador de tipo se descarta"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member %qE declared %<constexpr%>"
 msgid "static data member %qE declared %qs"
 msgstr "se declaró el miembro dato que no es static %qE como %<constexpr%>"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 #| msgid "constexpr static data member %qD must have an initializer"
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "el miembro dato static constexpr %qD debe tener un inicializador"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member %qE declared %<constexpr%>"
 msgid "non-static data member %qE declared %qs"
 msgstr "se declaró el miembro dato que no es static %qE como %<constexpr%>"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "la clase de almacenamiento %<auto%> es no válida para la función %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "la clase de almacenamiento %<register%> es no válida para la función %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "la clase de almacenamiento %<__thread%> es no válida para la función %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %<__thread%> invalid for function %qs"
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "la clase de almacenamiento %<__thread%> es no válida para la función %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for function %qE"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "se especificó la alineación para la función %qE"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "no se permiten los especificadores-virt en %qs fuera de una definición de clase"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "%<static%> specified invalid for function %qs declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "el especificador %<static%> es no válido para la función %qs declarada fuera del ámbito global"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "el especificador %<inline%> es no válido para la función %qs declarada fuera del ámbito global"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "función virtual %qs que no es clase"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "se definió %qs en un ámbito que no es una clase"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "se declaró %qs en un ámbito que no es una clase"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "no se puede declarar que la función miembro %qD tenga enlace estático"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "no se puede declarar una función static dentro de otra función"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> puede no ser utilizado cuando se define (opuesto a la declaración) un dato miembro static"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "se declaró el miembro static %qD como %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "no se puede declarar explícitamente que el miembro %q#D tenga un enlace externo"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of constexpr variable %qD is not a definition"
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "la declaración de la variable constexpr %qD no es una definición"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "un parámetro no se puede declarar %<constexpr%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs inicializado y declarado como %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs tiene %<extern%> e inicializador al mismo tiempo"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "el argumento por defecto %qE usa %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "el argumento por defecto %qE usa la variable local %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "uso no válido de %<virtual%> en la declaración de plantilla de %q#D"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "uso no válido de %<virtual%> en la declaración de plantilla de %q#D"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%>-qualified parameter type %qT of %q+D"
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "tipo de parámetro cualificado %<_Atomic%> %qT de %q+D"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "el parámetro %qD se declaró no válidamente como tipo de método"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "el parámetro %qD incluye un puntero a matriz %qT de límite desconocido"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "el parámetro %qD incluye una referencia a matriz %qT de límite desconocido"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "constructor no válido; tal vez quiso decir %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD no se puede declarar dentro de un espacio de nombres"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD no se puede declarar como static"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD debe ser una función miembro que no sea static"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a non-member function"
 msgid "%qD must be a member function"
 msgstr "%qD debe ser una función que no sea miembro"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD debe ser una función miembro que no sea static o una función que no sea miembro"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD debe tener un argumento de tipo clase o enumerado"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ prohíbe la sobrecarga del operador ?:"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD no debe tener un número variable de argumentos"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD debe tomar cero o un argumentos"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD debe tomar uno o dos argumentos"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "el postfijo %qD debe tomar %<int%> como su argumento"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "el postfijo %qD debe tomar %<int%> como su segundo argumento"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD debe tomar dos argumentos exactamente"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD debe tomar un argumento exactamente"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD debe tomar dos argumentos exactamente"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD no puede tener argumentos por defecto"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to void will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "la conversión a void nunca usará un operador de conversión de tipo"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a reference to the same type will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "la conversión a una referencia al mismo tipo nunca usará un operador de conversión de tipo"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to the same type will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "la conversión al mismo tipo nunca usará un operador de conversión de tipo"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a reference to a base class will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "la conversión a una referencia a una clase base nunca usará un operador de conversión de tipo"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a base class will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "la conversión a una clase base nunca usará un operador de conversión de tipo"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "el %qD definido por el usuario siempre evalúa ambos argumentos"
 
 #  En esta traducción se emplea 'devolver' por 'return'. Si embargo, aquí
 #  se cambió por cacofonía: no es agradable escuchar 'debe devolver'. cfuga
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "el prefijo %qD debe regresar %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "el postfijo %qD debe regresar %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD debe devolver por valor"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "usando el parámetro de tipo plantilla %qT después de %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "se usa especialización de plantilla %qT alias después de %qs"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "se usó el nombre de definición de tipo %qD después de %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD tiene una declaración previa aquí"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "se refirió a %qT como %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%qT has a previous declaration here"
 msgstr "%q+T tiene una declaración previa aquí"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "se refirió a %qT como un enum"
@@ -65750,60 +65827,60 @@ msgstr "se refirió a %qT como un enum"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "se requiere un argumento de plantilla para %<%s %T%>"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "la referencia a %qD es ambigua"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "function template %qD redeclared as a class template"
 msgid "class template %qD redeclared as non-template"
 msgstr "la plantilla de función %qD se redeclaró commo una plantilla de clase"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD tiene el mismo nombre que la clase en la cual se declaró"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT no es una plantilla"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "uso del enum %q#D sin declaración previa"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "redeclaración de %qT como algo que no es plantilla"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "union derivada %qT no válida"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct or virtual base of %qT"
 msgid "%qT defined with direct virtual base"
@@ -65811,43 +65888,43 @@ msgstr "el tipo %qT no es una base directa o virtual de %qT"
 
 #  No me gusta mucho esta traducción. Creo que es mejor
 #  "el tipo base %qT no es de tipo struct o clase". cfuga
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "el tipo base %qT falla en ser un tipo struct o clase"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "tipo recursivo %qT sin definir"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "tipo base duplicado %qT no válido"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "no coinciden scoped/unscoped en el enum %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "la definición previa está aquí"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "no coincide el tipo subyacente en el enum %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "tipos subyacentes diferentes en el enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 #| msgid "underlying type %<%T%> of %<%T%> must be an integral type"
 msgid "underlying type %qT of %qT must be an integral type"
@@ -65857,94 +65934,100 @@ msgstr "el tipo subyacente %<%T%> de %<%T%> debe ser un tipo integral"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "ningún tipo integral puede representar todos los valores de enumerador de %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qD is not an integer constant"
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "el valor de enumerador para %qD no es una constante entera"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "el valor de enumerador para %qD no es una constante entera"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "el valor del enumerador incrementado es demasiado grande para %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 #| msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "el valor del enumerador incrementado es demasiado grande para %<unsigned long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "desbordamiento en valores de enumeración en %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value %E is too large for underlying type %<%T%>"
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "el valor de enumerador %E es demasiado grande para el tipo subyacente %<%T%>"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "definición múltiple de %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "el tipo de devolución %q#T es un tipo de dato incompleto"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> debe devolver una referencia a %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statements in function returning %qT"
 msgstr "no hay una declaración de devolución en la función que no devuelve void"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 #| msgid "function return types not compatible due to %<volatile%>"
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "los tipos de devolución de función no son compatibles debido a %<volatile%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "no hay una declaración de devolución en la función que no devuelve void"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD ya se definió en la clase %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "enclosing %qs"
 msgid "using %qs"
 msgstr "%qs contenedora"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "se usa %q+D antes de la declaración"
+
+#: cp/decl.cc:21341
 #, fuzzy, gcc-internal-format
 #| msgid "type of %qD defaults to %<int%>"
 msgid "use of %qD before deduction of %<auto%>"
@@ -66422,390 +66505,390 @@ msgstr "la redeclaración de %qD difiere en %<constexpr%>"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "se usa %<typename%> fuera de la plantilla"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    incluido en línea de %qs en %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d%R"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    incluido en línea de %qs en %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    incluido en línea de %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In static member function %qD"
 msgstr "En la función miembro static %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In copy constructor %qs"
 msgid "In copy constructor %qD"
 msgstr "En el constructor copia %qs"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In constructor %qs"
 msgid "In constructor %qD"
 msgstr "En el constructor %qs"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In destructor %qs"
 msgid "In destructor %qD"
 msgstr "En el destructor %qs"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "En la función lambda"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "En la función miembro static %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "En la función miembro %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "En la función %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "but %qE is a type"
 msgstr "%qE no es un tipo"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "but %qE is an expression"
 msgstr "%qE no es una expresión constante"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 #| msgid "<structured bindings>"
 msgid "but %qE is a structured binding"
 msgstr "<vínculos estructurados>"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD no es una variable"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "parámetro de función"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "but %qE is a function"
 msgstr "'%s' en %L no es una función"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "but %qE is a data member"
 msgstr "%q#D no es un dato miembro no static de %qT"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD no es una plantilla de función"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "but %qE is a class template"
 msgstr "%qE no es una plantilla"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable template"
 msgstr "%qD no es una variable"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD es un espacio de nombres"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an enumerator-name"
 msgid "but %qE is an enumerator"
 msgstr "%qD no es un nombre-de-enumerador"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s: En la instanciación de %q#D:\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 #| msgid "%s: In substitution of %qS:\n"
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s: En la sustitución de %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s: En la instanciación de %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from here\n"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "se requiere recursivamente desde aquí\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required from %<template for%> iteration %E\n"
 msgstr "se requiere para la sustitución de %qS\n"
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "se requiere recursivamente para la sustitución de %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "se requiere para la sustitución de %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "se requiere recursivamente desde %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "se requiere desde %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "se requiere recursivamente desde aquí\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "se requiere desde aquí\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%r%s:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "%r%s:%d:%R   [ se saltan %d contextos de instanciación; utilice -ftemplate-backtrace-limit=0 para desactivarlo ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 #| msgid "%r%s:%d:%R   in %<constexpr%> expansion of %qs"
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%r%s:%d:%R   en la expansión de la %<constexpr%> de %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required by the constraints of %q#D\n"
 msgstr "se requiere para la sustitución de %qS\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required for the satisfaction of %qE"
 msgstr "se requiere para la sustitución de %qS\n"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c required for gnat2scil"
 msgid "required for constraint satisfaction\n"
 msgstr "se requiere -c para gnat2scil"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "%qs requires %qs"
 msgid "in requirements "
 msgstr "%qs requiere %qs"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "sin argumentos"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 #| msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las listas de inicializador extendidas sólo está disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "explicit conversion operators only available with -std=c++11 or -std=gnu++11"
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los operadores de conversión explícita sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las expresiones lambda sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 #| msgid "scoped enums only available with -std=c++11 or -std=gnu++11"
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los enums con ámbito sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las funciones por defecto y borradas sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 #| msgid "override controls (override/final) only available with -std=c++11 or -std=gnu++11"
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los controles de anulación (override/final) sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los inicializadores de datos miembro que no son static sólo está disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined literals only available with -std=c++11 or -std=gnu++11"
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las literales definidas por el usuario sólo está disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 #| msgid "delegating constructors only available with -std=c++11 or -std=gnu++11"
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los constructores delegadores sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 #| msgid "delegating constructors only available with -std=c++11 or -std=gnu++11"
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "los constructores delegadores sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined literals only available with -std=c++11 or -std=gnu++11"
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las literales definidas por el usuario sólo está disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "se utilizó el tipo incompleto %qT en un especificador de nombre anidado"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "la referencia a %<%T::%D%> es ambigua"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE; did you mean %qE?"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qT no tiene un miembro llamado %qE; ¿quiso decir %qE?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD no es un miembro de %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE; did you mean %qE?"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qT no tiene un miembro llamado %qE; ¿quiso decir %qE?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD no es un miembro de %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> no se ha declarado"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> no se ha declarado"
@@ -67042,7 +67125,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "el miembro %qD es una referencia sin inicializar"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "la matriz se debe inicializar con un inicializador dentro de llaves"
@@ -67161,7 +67244,7 @@ msgstr "el tipo %qT no es una base directa o virtual de %qT"
 msgid "type %qT is not a direct base of %qT"
 msgstr "el tipo %qT no es una base directa de %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -67368,47 +67451,47 @@ msgstr "se detectó un posible problema en la invocación del operador delete:"
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "no se llamará ni al destructor ni al operador delete específico de la clase, aún si se declaran cuando se defina la clase"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "el inicializador termina prematuramente"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "tamaño de matriz desconocida en delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "el tipo de devolución es un tipo de dato incompleto"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "se detectó un posible problema en la invocación del operador delete:"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined"
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "no se llamará ni al destructor ni al operador delete específico de la clase, aún si se declaran cuando se defina la clase"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, fuzzy, gcc-internal-format
 #| msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behaviour"
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "si borra un objeto de tipo de clase abstracta %qT que tiene un destructor que no es virtual, puede causar conducta indefinida"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, fuzzy, gcc-internal-format
 #| msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behaviour"
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "si borra un objeto de tipo de clase polimórfica %qT que tiene un destructor que no es virtual, puede causar conducta indefinida"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "el tipo de vector delete no es del tipo puntero ni matriz"
@@ -67446,89 +67529,97 @@ msgstr "uso no válido del tipo incompleto %q#T"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "inicializador no válido para la cadena de bits"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "no se capturó %<this%> para esta función lambda"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "la alineación de %qD es más grande que la declaración original"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "la alineación de %qD es más grande que la declaración original"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "#pragma %s no válido"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable ya no se admite"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "implementación de #pragma para %qs aparece después de que se incluye el fichero"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD no está definido"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 #| msgid "%<@required%> is not available in Objective-C 1.0"
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<@required%> no está disponible en Objective-C 1.0"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD no se declaró en este ámbito"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD no se declaró en este ámbito"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "no hay argumentos para %qD que dependan de un parámetro de plantilla, por lo cual una declaración de %qD debe estar disponible"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(si utiliza %<-fpermissive%>, G++ aceptará su código, pero permitir el uso de un nombre sin declarar es obsoleto)"
@@ -67538,69 +67629,62 @@ msgstr "(si utiliza %<-fpermissive%>, G++ aceptará su código, pero permitir el
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, fuzzy, gcc-internal-format
 #| msgid "mangling typeof, use decltype instead"
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "se decodifica typeof, utilice decltype en su lugar"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "decodificando %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "se omitió el operando de enmedio de %<?%>: no se puede revolver el operando"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "el nombre revuelto de %qD cambiará en una versión futura de GCC"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "el nombre revuelto de %qD cambiará en una versión futura de GCC"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "el nombre revuelto de %qD cambiará en una versión futura de GCC"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "el nombre revuelto de %qD cambiará en una versión futura de GCC"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
@@ -68029,7 +68113,7 @@ msgstr "redeclaración de %q+D sin enlace"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "declaraciones de %q#D en conflicto"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting type for imported declaration %#qD"
@@ -68047,472 +68131,472 @@ msgstr "declaraciones de %q#D en conflicto"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "declaraciones de %q#D en conflicto"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "especificadores en conflicto en la declaración de %qs"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for %q+#D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "se especificaron tipos de devolución en conflicto para %q+#D"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "especificadores en conflicto en la declaración de %qs"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "declaraciones de %q#D en conflicto"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "en la declaración %q+D"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "no hay un argumento por defecto para %qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "type of mismatching field declared here"
 msgid "existing default declared here"
 msgstr "el tipo del campo que no coincide se declaró aquí"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument missing for parameter %P of %q+#D"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "falta el argumento por defecto para el parámetro %P de %q+#D"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of %q#D doesn%'t match"
 msgid "definition of %qD does not match"
 msgstr "la declaración extern de %q#D no coincide"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "falta la definición"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "enumerator %qD does not match ..."
 msgstr "el argumento de tipo %qT no coincide con %qT"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "redeclaración del enumerador %q+D"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qD no es un miembro de tipo %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "partial specialization of alias template %qD"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "especialización parcial de la plantilla alias %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%qD se redeclaró con acceso diferente"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD no se puede declarar dentro de un espacio de nombres"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qE no se ha declarado"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qE no se ha declarado"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD has TU-local template argument %qD"
 msgstr "se usa %qD sin parámetros de plantilla"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qE no es un argumento de plantilla válido para el tipo %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not refer to a function"
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD no hace referencia a una función"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 #| msgid "instantiation of %q+D as type %qT"
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "instanciación de %q+D como tipo %qT"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared %<constexpr%> outside its class"
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD se declaró %<constexpr%> fuera de su clase"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared %<constexpr%> outside its class"
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr "%qD se declaró %<constexpr%> fuera de su clase"
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "module %qs depends on itself"
 msgstr "la rutina %qD se declara aquí"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "module %qs declared here"
 msgstr "la rutina %qD se declara aquí"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+D was here"
 msgid "macro definitions of %qE corrupted"
 msgstr "la definición previa de %q+D estaba aquí"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgid "inconsistent imported macro definition %qE"
 msgstr "  deducción de paquete de parámetros inconsistente con %qT y %qT"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 #| msgid "Can't delete module file %qs: %s"
 msgid "compiled module file is %qs"
 msgstr "No se puede borrar el fichero de módulo %qs: %s"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Display the compiler's version."
 msgid "compiled module is %sversion %s"
 msgstr "Muestra la versión del compilador."
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 versión %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "no %qs getter found"
 msgid "module %qs found"
 msgstr "no se encuentra el getter %qs"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, fuzzy, gcc-internal-format
 #| msgid "exception handling disabled, use -fexceptions to enable"
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "manejo de excepciones desactivado, use -fexceptions para activar"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, fuzzy, gcc-internal-format
 #| msgid "Coarrays disabled at %C, use -fcoarray= to enable"
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "Comatrices desactivadas en %C, use -fcoarray= para activar"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 #| msgid "function attribute mismatch"
 msgid "fixed tree mismatch"
 msgstr "no coincide el atributo de función"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "target optimization options not supported yet"
 msgid "interface partition is not exported"
 msgstr "no se admiten aún las opciones de optimización del objetivo"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to rename %s to state file %s [%s]"
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "no se puede renombrar %s al fichero de estado %s [%s]"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to open %s"
 msgid "failed to read compiled module: %s"
 msgstr "no se puede abrir %s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration %q#D"
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "genera un conflicto con la declaración interna %q#D"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration %q#D"
 msgid "declaration %qD conflicts with builtin"
 msgstr "genera un conflicto con la declaración interna %q#D"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "la declaración del espacio de nombres %qD genera un conflicto con"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "redeclaración de la plantilla %q#D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of %q+#D with %qL linkage"
 msgid "conflicting declaration of %qD in global module"
 msgstr "declaración previa de %q+#D con el enlace %qL"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared in module %qs"
 msgstr "se declaró previamente aquí"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared in global module"
 msgstr "se declaró previamente aquí"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration cannot name destructor"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "uan declaración de uso no puede nombrar al destructor"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "redeclaración de %q+D sin enlace"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "reading"
 msgid "reading CMI %qs"
 msgstr "leyendo"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, fuzzy, gcc-internal-format
 #| msgid "unknown option for %<%s=%s%>"
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "opción desconocida para %<%s=%s%>"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "la definición de método no está en el contexto @implementation"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "module declared here"
@@ -68525,118 +68609,118 @@ msgstr "la rutina %qD se declara aquí"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs already declared"
 msgid "module already declared"
 msgstr "El símbolo %qs ya se había declarado"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 #| msgid "module procedure"
 msgid "module already imported"
 msgstr "procedimiento módulo"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 #| msgid "module procedure"
 msgid "module %qs imported here"
 msgstr "procedimiento módulo"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown operand letter: '%c'"
 msgid "unknown compiled module interface: %s"
 msgstr "letra de operando desconocida: '%c'"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, fuzzy, gcc-internal-format
 #| msgid "while writing precompiled header"
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "al escribir el encabezado precompilado"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing."
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Habilita el preprocesamiento tradicional."
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param name %qs"
 msgid "invalid header name %qs"
 msgstr "nombre de --param %qs no válido"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid macro name `%s'"
 msgid "invalid module name %qs"
 msgstr "nombre de macro `%s' no válido"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "error al escribir %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "first error in %qD appeared here"
 msgstr "la rutina %qD se declara aquí"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to write state trailer [%s]"
 msgid "failed to write compiled module: %s"
 msgstr "no se puede escribir el estado remanente [%s]"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown header kind %qs"
@@ -68653,7 +68737,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "%q+D se declaró aquí, después en la unidad de translación"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
@@ -68704,296 +68788,307 @@ msgstr "la declaración de %q#D oscurece un parámetro"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "declaración de %qD como miembro de %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %qD but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "existe la declaración para el parámetro %qD pero no hay tal parámetro"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %qD in local class without prior declaration"
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "una declaración friend %qD en una clase local sin declaración previa"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s(%E) %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "exporting %q#D that does not have external linkage"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D declared here"
 msgid "%q#D declared here with no linkage"
 msgstr "%q+#D se declaró aquí"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here, later in the translation unit"
 msgid "%q#D declared here with internal linkage"
 msgstr "%q+D se declaró aquí, después en la unidad de translación"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D declared here"
 msgid "%q#D declared here with module linkage"
 msgstr "%q+#D se declaró aquí"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> nombra al destructor"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "declaración de uso para un no miembro en el ámbito de la clase"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class, namespace, or enumeration"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qE no es una clase, un espacio de nombres o una enumeración"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "declaración plantilla de %q#D"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "declaración de uso para un no miembro en el ámbito de la clase"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "el tipo %qT no es una base directa de %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has not been declared in %qD"
 msgstr "%qE no se ha declarado"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration cannot name destructor"
 msgid "using-declaration may not name namespace %qD"
 msgstr "uan declaración de uso no puede nombrar al destructor"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> nombra al constructor en %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "la declaración de %qD no está en un espacio de nombres alrededor de %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "calificación explícita en la declaración de %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD se debería declarar dentro de %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has not been declared within %qD"
 msgstr "%qE no se ha declarado"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D se declaró como friend"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "el atributo %qD requiere un solo argumento NTBS"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "el atributo %qD no tiene signifcado porque los miembros del espacio de nombres anónimo tiene símbolos locales"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes on template argument %qT"
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "se descartan los atributos en el argumento de plantilla %qT"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes on template argument %qT"
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "se descartan los atributos en el argumento de plantilla %qT"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "se descarta la directiva de atributo %qD"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "límite máximo de %d espacios de nombres buscados para %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "alternativa sugerida:"
 msgstr[1] "alternativas sugeridas:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "%s is not available for %s architecture"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%s no está disponible para la arquitectura %s"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "weak %q+D cannot be defined %qE"
 msgid "the macro %qs had not yet been defined"
 msgstr "weak %q+D no se puede definir como %qE"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "it was later defined here"
 msgstr "se definió struct aquí"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, fuzzy, gcc-internal-format
 #| msgid "deducing from brace-enclosed initializer list requires #include <initializer_list>"
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "la deducción de una lista inicializadora encerrada entre llaves requiere #include <initializer_list>"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "switch %qs is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "la opción %qs ya no se admite"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, fuzzy, gcc-internal-format
 #| msgid "This switch is deprecated; use -fsanitize-recover= instead."
 msgid "you can use an inline namespace instead"
 msgstr "Esta opción es obsoleta; utilice en su lugar -fsanitize-recover=."
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "no se puede usar %<this%> en este contexto"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "annotation on using directive"
 msgstr "se descartan los atributos en el tipo sin instanciar"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "cannot nest more than %d namespaces"
 msgstr "%qD no se puede declarar dentro de un espacio de nombres"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "'%s' en %L es ambiguo"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "no se permite aquí el alias del espacio de nombres %qD, se asume que es %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "redeclaración de %q+D sin enlace"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD no se puede declarar dentro de un espacio de nombres"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "se esperaba %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 #| msgid "method attributes must be specified at the end only"
 msgid "inline namespace must be specified at initial definition"
 msgstr "los atributos de método sólo se deben especificar al final"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "%qD conflicts with used function"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%qD genera un conflicto con la función utilizada"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "previous definition here"
 msgid "reachable %s definition here"
 msgstr "la definición previa está aquí"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX entrando a pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -69026,7 +69121,7 @@ msgstr "el identificador %qE es una palabra clave en C++11"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare simd%> not immediately followed by a function declaration or definition"
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
@@ -69075,7 +69170,7 @@ msgstr "%<::%E%> no se ha declarado"
 msgid "request for member %qE in non-class type %qT"
 msgstr "solicitud por el miembro %qE en el tipo %qT que no es clase"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> no se ha declarado"
@@ -69147,7 +69242,7 @@ msgstr "(tal vez falta un punto y coma después de la definición de %qT)"
 msgid "%qE is not a class template"
 msgstr "%qE no es una plantilla"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE no es una plantilla"
@@ -69487,1869 +69582,1880 @@ msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=g
 msgid "pack index missing"
 msgstr "falta el nombre del parámetro"
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected a reflection of a type"
 msgstr "se esperaba nombre de función"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "Expected structure component name at %C"
-msgid "expected a reflection of a function template"
-msgstr "Se esperaba un nombre de componente de estructura en %C"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "se usó %qD que no es plantilla como plantilla"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class, namespace, or enumeration"
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qE no es una clase, un espacio de nombres o una enumeración"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "no se admiten tipos de coma fija en C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ prohíbe grupos de llaves dentro de expresiones"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "las expresiones-de-declaraciones no se permiten fuera de funciones ni en listas de argumentos-plantilla"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "las expresiones lambda sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "se esperaba una expresión primaria"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "no se puede usar %<this%> en este contexto"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "una declaración de plantilla no puede aparecer en el ámbito de bloque"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "local variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "la variable local %qD no puede aparecer en este contexto"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "la variable local %qD no puede aparecer en este contexto"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "se esperaba una expresión id"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "el ámbito %qT antes de %<~%> no es un nombre-de-clase"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "no se puede usar %<this%> en este contexto"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "template-id not allowed for destructor in C++20"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "declaración de %<~%T%> como miembro de %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "se usa el nombre-de-definición-de-tipo %qD como un declarador de destructor"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "se esperaba un id sin calificar"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD no es una plantilla"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "se encontró %<:%> en un especificador de nombre anidado, se esperaba %<::%>"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 #| msgid "decltype evaluates to %qT, which is not a class or enumeration type"
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "el tipo de declaración evalúa a %qT, el cual no es una clase o un tipo enumerado"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "se utilizó el tipo incompleto %qT en un especificador de nombre anidado"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "se utilizó el tipo incompleto %qT en un especificador de nombre anidado"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 #| msgid "expected nested-name-specifier"
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "se esperaban especificadores de nombre anidados"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "se esperaban especificadores de nombre anidados"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "los tipos no se pueden definir en conversiones"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "no se pueden definir tipos en una expresión %<typeid%>"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "número erróneo de argumentos para %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_complex%>"
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "número erróneo de argumentos para %<__builtin_complex%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "número erróneo de argumentos para %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "número erróneo de argumentos para %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, fuzzy, gcc-internal-format
 #| msgid "destructors must be member functions"
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "los destructores deben ser funciones miembro"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared here"
 msgid "selected function declared here"
 msgstr "en una llamada a la función %qD declarada aquí"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ prohíbe las literales compuestas"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "no se pueden definir tipos en condiciones"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "uso no válido de %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> no es un miembro clase"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "tipo que no es escalar"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "typedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "el nombre del typedef puede no ser un especificador-de-nombre-anidado"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new no se puede aplicar a un tipo de referencia"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "'h' applied to non-register operand"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "`h' aplicado a un operando no registro"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ no permite %<alignof%> con algo que no es tipo"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "no se pueden definir tipos en expresiones %<noexcept%>"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD no puede tener argumentos por defecto"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in a new-expression"
 msgid "types may not be defined in %qs expressions"
 msgstr "no se pueden definir tipos en una expresión new"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_thread_pointer is not supported on this target"
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "no se admite __builtin_thread_pointer en este objetivo"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "no se pueden definir tipos en una expresión new"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "se prohíbe el límite de matriz después del id-de-tipo entre paréntesis"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "intente borrar los paréntesis alrededor del id-de-tipo"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected expression-list or type-id"
 msgstr "Se esperaba un tipo de expresión"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "no se pueden definir tipos en un id-tipo-nuevo"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "se descartan los atributos en la instanciación de una plantilla"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "la expresión en el declarador-new debe tener un tipo integral o de enumeración"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "uso de conversión de estilo antiguo"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "el operador %<>>%> se tratará como dos en llaves en ángulo derechas en C++11"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "se sugieren paréntesis alrededor de la expresión %<>>%>"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow ?: with omitted middle operand"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ no permite ?: con el operando medio omitido"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, fuzzy, gcc-internal-format
 #| msgid "use of cast expressions as lvalues is deprecated"
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "el uso de expresiones de conversión como l-valores es obsoleto"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "no se pueden definir tipos en condiciones"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "se esperaba el fin de la lista-de-captura"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "ya se capturó %qD en la expresión lambda"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "cannot capture %qE by reference"
 msgid "%<this%> cannot be captured by reference"
 msgstr "no se puede capturar %qE por referencia"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "las expresiones lambda sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, fuzzy, gcc-internal-format
 #| msgid "non-empty initializer for array of empty elements"
 msgid "empty initializer for lambda init-capture"
 msgstr "inicializador no-vacío para una matriz de elementos vacíos"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 #| msgid "capture of non-variable %qD "
 msgid "capture of non-variable %qE"
 msgstr "captura de %qD que no es variable "
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "captura de la variable %qD con duración de almacenamiento que no es automática"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<...%> in lambda capture"
 msgstr "demasiadas cláusulas %<if%>"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "la captura por copia explícita de %qD es redundante con la captura por copia por defecto"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "la captura por referencia explícita de %qD es redundate con la captura por referencia por defecto"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "se especificó un argumento por defecto para el parámetro lambda"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute specified with a parameter"
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "el atributo %<fallthrough%> se especificó con un parámetro"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute specified with a parameter"
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "el atributo %<fallthrough%> se especificó con un parámetro"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 #| msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "el tipo de devolución trailing sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%qD declared here"
+msgid "%q#E declared here"
+msgstr "%qD se declara aquí"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 #| msgid "attributes after parenthesized initializer ignored"
 msgid "attributes at the beginning of statement are ignored"
 msgstr "se descartan los atributos después del inicializador entre paréntesis"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "se esperaba una declaración etiquetada"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "la etiqueta case %qE no está dentro de una declaración switch"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "se necesita %<typename%> antes de %qE porque %qT es un ámbito dependiente"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%E%> names the constructor, not the type"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%> nombra el constructor, no el tipo"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 #| msgid "compound-statement in constexpr function"
 msgid "compound-statement in %<constexpr%> function"
 msgstr "declaración compuesta en una función constexpr"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp taskyield%> may only be used in compound statements"
 msgid "%<if consteval%> requires compound statement"
 msgstr "%<#pragma omp taskyield%> sólo se puede usar en declaraciones compuestas"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "se esperaba una declaración de selección"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "la función devuelve una matriz"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qE declared as a function"
 msgid "condition declares a function"
 msgstr "el campo %qE se declaró como una función"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "no se pueden definir tipos en condiciones"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "se esperaba un inicializador"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "non-local variable %q#D uses local type %qT"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "la variable %q#D que no es local usa el tipo local %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "la expresión %<for%> basada en rango de tipo %qT es de tipo incompleto"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "tipos begin/end inconsistentes para la declaración %<for%> basada en rango: %qT y %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "se esperaba una declaración de iteración"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "C99 designator %qE outside aggregate initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "asignador C99 %qE fuera del inicializador agregado"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "un parámetro no se puede declarar %<constexpr%>"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ prohíbe los gotos calculados"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "se esperaba una declaración de salto"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration"
 msgid "expected module-partition"
 msgstr "se esperaba una declaración"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-name"
 msgid "expected module-name"
 msgstr "se esperaba un nombre de plantilla"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "la declaración de método no está en el contexto @interface"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "declaración de uso para un no miembro en el ámbito de la clase"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "scope opened here"
 msgstr "se definió union aquí"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 #| msgid "volatile argument"
 msgid "private module fragment"
 msgstr "argumento volátil"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "declaración de uso para un no miembro en el ámbito de la clase"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in exception-declarations"
 msgid "%qE may only occur once in an export declaration"
 msgstr "no se pueden definir tipos en declaraciones de excepción"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C no permite un %<;%> extra fuera de una función"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C no permite un %<;%> extra fuera de una función"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after class definition"
 msgid "extra %<;%> after in-class function definition"
 msgstr "se esperaba %<;%> después de la definición de clase"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "attributes are not permitted in this position"
 msgstr "no se puede usar %<this%> en este contexto"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "attributes may not be specified before"
 msgid "attributes may be inserted here"
 msgstr "los atributos no se pueden especificar antes"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "instanciación explícita de %qT que no es plantilla"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "instanciación explícita de %q#D que no es plantilla"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "original definition appeared here"
 msgid "export-declarations are not permitted here"
 msgstr "la definición original apareció aquí"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label%> no está al inicio de un bloque"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "deducción inconsistente para %qT: %qT y después %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "se prohíbe mezclar declaraciones y definiciones-de-función"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in exception-declarations"
 msgid "types may not be defined in a for-range-declaration"
 msgstr "no se pueden definir tipos en declaraciones de excepción"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in range-based for loops"
 msgid "initializer in range-based %<for%> loop"
 msgstr "no se pueden definir tipos en bucles for basados en rango"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, fuzzy, gcc-internal-format
 #| msgid "multiple declarations `%T' and `%T'"
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "declaraciones múltiples `%T' y `%T'"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding pack outside of template"
 msgstr "puntero deferenciado a tipo de dato incompleto"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "multiple packs in structured binding declaration"
 msgstr "inicializador no válido para la cadena de bits"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "annotation on structured binding"
 msgstr "tipo no válido para la variable de iteración %qE"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "las uniones sin restricción sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "empty structured binding declaration"
 msgstr "inicializador no válido para la cadena de bits"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for bit string"
 msgid "invalid initializer for structured binding declaration"
 msgstr "inicializador no válido para la cadena de bits"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q#T"
 msgid "for-range-declaration cannot be %qs"
 msgstr "se descarta el atributo en la declaración de %q#T"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "especificadores de clase de almacenamiento no válidos en las declaraciones de parámetros"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "se usó %<friend%> fuera de la clase"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "No se permite el atributo %L en una definición TYPE"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %qD"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "conflicto de tipo de sección con %qD"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> cambiará su significado en C++11; por favor bórrelo"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "%qD invalid in %qT"
 msgid "%qD invalid in condition"
 msgstr "%qD no válido en %qT"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "%qD invalid in %qT"
 msgid "%qD invalid in lambda"
 msgstr "%qD no válido en %qT"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "decl-specifier invalid in condition"
 msgid "type-specifier invalid in lambda"
 msgstr "especificador-decl no válido en la condición"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "la definición de clase no se puede declarar como friend"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "las plantillas no pueden ser %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in an exception-specification"
 msgid "types may not be defined in explicit-specifier"
 msgstr "no se pueden definir tipos en una especificación de excepción"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "especificación de enlace no válida"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "no se pueden definir tipos en expresiones %<decltype%>"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in a new-type-id"
 msgid "types may not be defined in a conversion-type-id"
 msgstr "no se pueden definir tipos en un id-tipo-nuevo"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "uso no válido de %<auto%> en el operador de conversión"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "uso no válido de %<auto%> en el operador de conversión"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "solamente los constructores toman inicializadores miembro"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "cannot expand initializer for member %<%D%>"
 msgid "cannot expand initializer for member %qD"
 msgstr "no se puede expandir el inicializador para el miembro %<%D%>"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "inicializador mem para %qD después de una delegación de constructor"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "delegación de constructor después de un inicializador mem para %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "inicializador de clase base de estilo antiguo anacrónico"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "no se permite la palabra clave %<typename%> en este contexto (un inicializador de miembro calificado es implícitamente un tipo)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, fuzzy, gcc-internal-format
 #| msgid "missing space between %<\"\"%> and suffix identifier"
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "falta un espacio entre %<\"\"%> y el identificador sufijo"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, fuzzy, gcc-internal-format
 #| msgid "missing space between %<\"\"%> and suffix identifier"
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "falta un espacio entre %<\"\"%> y el identificador sufijo"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "se esperaba un identificador sufijo"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "se esperaba una cadena vacía después de la palabra clave %<operator%>"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in ternary operation"
 msgid "invalid encoding prefix in literal operator"
 msgstr "operandos no válidos en la operación terniaria"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "operador inesperado"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "no se admite la palabra clave %<export%>, y se descartará"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "no se admite la palabra clave %<export%>, y se descartará"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 #| msgid "-mexr is used without -ms"
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "se usó -mexr sin -ms"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 #| msgid "invalid template non-type parameter"
 msgid "invalid constrained type parameter"
 msgstr "parámetro que no es tipo plantilla no válido"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "cv-qualified type parameter"
 msgstr "parámetro de captura no válido"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of '%E' as a non-type template-argument"
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "uso no válido de '%E' como un argumento de plantilla que no es tipo"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "el paquete de parámetros plantilla %qD no puede tener un argumento por defecto"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "los paquetes de parámetro de plantilla no pueden tener argumentos por defecto"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "se esperaba un id de plantilla"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> no puede iniciar una lista de argumentos de plantilla"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> es una forma alternativa para %<[%>. Inserte espacios en blanco entre %<<%> y %<::%>"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 #| msgid "(if you use %<-fpermissive%> G++ will accept your code)"
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(si utiliza %<-fpermissive%>, G++ aceptará su código)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 #| msgid "invalid non-type template argument"
 msgid "invalid template-argument-list"
 msgstr "argumento de plantilla que no es tipo no válido"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "expected %<(%> after template-argument-list"
 msgstr "se esperaba un argumento de plantilla"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "error de decodificación en la lista de argumentos de plantilla"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "se esperaba un nombre de plantilla"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "se usó %qD que no es plantilla como plantilla"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "utilice %<%T::template %D%> para indicar que es una plantilla"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "se esperaba el parámetro pack antes de %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "se esperaba un argumento de plantilla"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "argumento de plantilla que no es tipo no válido"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 #| msgid "address of non-extern `%E' cannot be used as template argument"
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "no se puede usar la dirección de `%E' que no es externo como un argumento de plantilla"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "la instanciación explícita no debe usar el especificador %<inline%>"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "la instanciación explícita no debe usar el especificador %<constexpr%>"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "la instanciación explícita no debe usar el especificador %<constexpr%>"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "especialización de plantilla con enlace C"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "se esperaba un specificador de tipo"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "las funciones por defecto y borradas sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "las funciones por defecto y borradas sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "las funciones por defecto y borradas sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of '%E' as a non-type template-argument"
 msgid "use of %<auto%> in template argument"
 msgstr "uso no válido de '%E' como un argumento de plantilla que no es tipo"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "se esperaba un id de plantilla para el tipo"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "se esperaba un nombre de tipo"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE no nombra a un tipo"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "concept defined here"
 msgstr "se definió union aquí"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "uso no válido de %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "se esperaba %<,%> o %<)%>"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, fuzzy, gcc-internal-format
 #| msgid "elaborated-type-specifier for a scoped enum must not use the %<%D%> keyword"
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "el especificador de tipo elaborado para un ámbito enumerado no debe usar la palabra clave %<%D%>"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "la declaración %qD no declara nada"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "se descartan los atributos en el tipo sin instanciar"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "se descartan los atributos en la instanciación de una plantilla"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "se descartan los atributos en un especificador de tipo elaborado que no es una declaración adelantada"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD es una plantilla de enumeración"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 #| msgid "%<namespace%> definition is not allowed here"
 msgid "unnamed scoped enum is not allowed"
 msgstr "la definición %<namespace%> no se permite aquí"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in enum-base"
 msgstr "los tipos no se pueden definir en conversiones"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "se esperaba %<;%> o %<{%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "no se puede agregar una lista de enumerador a una instanciación de plantilla"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "la declaración friend no nombra una clase o función"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "la declaración de %qD en el espacio de nombres %qD el cual no incluye a %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "la declaración de %qD en %qD la cual no incluye a %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "no se permite la calificación extra"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids incrementing an enum"
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ prohíbe incrementar un enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "especificador enumerador opaco sin nombre"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "el especificador enumerador opaco debe usar un identificador simple"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qE no nombra a un tipo"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD no es un nombre-de-espacio-de-nombres"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "se esperaba un nombre de espacio"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "los nombres de espacio incluidos en línea sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 #| msgid "expected namespace-name"
 msgid "nested namespace name required"
 msgstr "se esperaba un nombre de espacio"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, fuzzy, gcc-internal-format
 #| msgid "namespace %qT undeclared"
 msgid "namespace name required"
 msgstr "espacio de nombres %qT sin declarar"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 #| msgid "Enumerator cannot have attributes %C"
 msgid "a nested namespace definition cannot have attributes"
 msgstr "El enumerador no puede tener atributos %C"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "varargs function cannot be inline"
 msgid "a nested namespace definition cannot be inline"
 msgstr "la función varargs no puede ser inline"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "namespace %qT undeclared"
 msgid "namespace %qD entered"
 msgstr "espacio de nombres %qT sin declarar"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "la definición %<namespace%> no se permite aquí"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "las expresiones lambda sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "un id-de-plantilla no puede aparecer en una declaración-using"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "las expresiones lambda sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, fuzzy, gcc-internal-format
 #| msgid "access declarations are deprecated in favour of using-declarations; suggestion: add the %<using%> keyword"
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "las declaraciones access son obsoletas en favor de las declaraciones using: sugerencia: use la palabra clave %<using%>"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of dependent type %qT"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "uso no válido del tipo dependiente %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qT no es un tipo de enumeración"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete type %q#T"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "uso no válido del tipo incompleto %q#T"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration here"
 msgid "opaque-enum-declaration here"
 msgstr "declaración previa aquí"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "no se pueden definir tipos en declaraciones de plantilla alias"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 #| msgid "expected interface or pointer to interface"
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "se esperaba interfaz o puntero a interfaz"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "calificador-cv duplicado"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "se descartan los calificadores de tipo en el tipo de devolución de la función"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT no es un espacio de nombres"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "use of parameter %qD outside function body"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "se usó el parámetro %qD fuera del cuerpo de la función"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q#T"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "se descarta el atributo en la declaración de %q#T"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "nombres de parámetros (sin tipos) en la declaración de la función"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 #| msgid "parenthesized initializer in array new"
 msgid "remove parentheses to default-initialize a variable"
 msgstr "inicializador entre paréntesis en la matriz new"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "nombres de parámetros (sin tipos) en la declaración de la función"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD redeclared as variable"
 msgid "add parentheses to declare a variable"
 msgstr "la función %qD se redeclaró como variable"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "cannot handle qualified name for variant function"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "declare variant directives are not allowed on destructors"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "el argumento %qE no es un identificador"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of function %qD in invalid context"
 msgid "no declaration of base function %qs in this scope"
 msgstr "declaración de la función %qD en un contexto no válido"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "la referencia a %qD es ambigua"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "no se permiten atributos en una definición-de-función"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "no se permiten atributos en una definición-de-función"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "no se permiten atributos en una definición-de-función"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "no se permiten atributos en una definición-de-función"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "una definición de función no se permite aquí"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "no se permite una especificación-asm en una definición-de-función"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "no se permiten atributos en una definición-de-función"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "se esperaba un constructor, un destructor, o una conversión de tipo"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "se proporcionó un inicializador para la función"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "se descartan los atributos después del inicializador entre paréntesis"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared as inline"
 msgid "non-function %qD declared as implicit template"
 msgstr "se redeclara la función %q+D como inline"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "el límite de la matriz no es una constante entera"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "no se puede definir el miembro de la definición de tipo dependiente %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> no es un tipo"
@@ -71358,292 +71464,292 @@ msgstr "%<%T::%E%> no es un tipo"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "declarador no válido"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "uso no válido del constructor como una plantilla"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "use %<%T::%D%> en lugar de %<%T::%D%> para nombrar el constructor en un nombre calificado"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type in declaration"
 msgid "qualified-id in declaration"
 msgstr "tipo no válido en la declaración"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "se esperaba un declarador"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD es un espacio de nombres"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "no se puede formar un puntero al miembro de %q#T que no es clase"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "se esperaba un operador puntero"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "calificador-cv duplicado"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 #| msgid "multiple `virtual' specifiers"
 msgid "multiple ref-qualifiers"
 msgstr "especificadores `virtual' múltiples"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, fuzzy, gcc-internal-format
 #| msgid "--resource requires -o"
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "--resource requiere -o"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "especificador-virt duplicado"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 #| msgid "in template argument for type %qT "
 msgid "missing template arguments after %qE"
 msgstr "en el argumento de plantilla para el tipo %qT "
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "in template argument for type %qT "
 msgid "%qT not permitted in template argument"
 msgstr "en el argumento de plantilla para el tipo %qT "
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "uso no válido de %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "no se pueden definir tipos en argumentos de plantilla"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of '%E' as a non-type template-argument"
 msgid "invalid use of %<auto%> in template argument"
 msgstr "uso no válido de '%E' como un argumento de plantilla que no es tipo"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "se esperaba un especificador de tipo"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "se esperaba %<,%> o %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "no se pueden definir tipos en tipos de parámetro"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "especificadores de clase de almacenamiento no válidos en las declaraciones de parámetros"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "%qs que no es parámetro no puede ser un paquete de parámetro"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "los argumentos por defecto sólo se permiten para parámetros de función"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "el paquete de parámetros %qD no puede tener un argumento por defecto"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "el paquete de parámetros plantilla no puede tener un argumento por defecto"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "el paquete de parámetros no puede tener un argumento por defecto"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter pack cannot have a default argument"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "el paquete de parámetros plantilla no puede tener un argumento por defecto"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 #| msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las listas de inicializador extendidas sólo está disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ no permite inicializadores designados"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ no permite inicializadores designados de C99"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ no permite inicializadores designados"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "se esperaba un nombre de clase"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "se esperaba %<;%> después de la definición de clase"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "se esperaba %<;%> después de la definición de struct"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "se esperaba %<;%> después de la definición de union"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate virt-specifier"
 msgid "duplicate %qD specifier"
 msgstr "especificador-virt duplicado"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "se esperaba %<{%> o %<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "la calificación global del nombre de clase es no válida"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "el nombre calificado no nombra una clase"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "no se permite la palabra clave %<typename%> fuera de las plantillas"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "nombre de clase no válido en la declaración de %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "definiendo la especialización explícita %qD en la declaración friend"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "una especialización explícita se debe preceder con %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "la plantilla de función %qD se redeclaró commo una plantilla de clase"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "no se puede resolver el tipo typename"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+#T"
 msgid "previous definition of %q#T"
@@ -71652,300 +71758,300 @@ msgstr "definición previa de %q+#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "se esperaba una llave de clase"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<class%> or %<typename%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "en C++03 se debe usar una llave-clase cuando se declara un friend"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "la declaración friend no nombra una clase o función"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 #| msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las listas de inicializador extendidas sólo está disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "default member initializer for unnamed bit-field"
 msgstr "se especificó la alineación para el campo de bits sin nombre"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "campo de bits %qD con tipo no integral"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "especificador-pure en la definición-de-función"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> at end of member declaration"
 msgid "stray %<,%> at end of member declaration"
 msgstr "se esperaba %<;%> al final de la declaración miembro"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "se esperaba %<;%> al final de la declaración miembro"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "especificador pure no válido (sólo se permite %<= 0%>)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "un inicializador dentro de llaves no se permite aquí"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "attributes may not be specified before"
 msgid "attributes on base specifiers are ignored"
 msgstr "los atributos no se pueden especificar antes"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, fuzzy, gcc-internal-format
 #| msgid "%<virtual%> specified more than once in base-specified"
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "se especificó %<virtual%> más de una vez en la base especificada"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, fuzzy, gcc-internal-format
 #| msgid "more than one access specifier in base-specified"
 msgid "more than one access specifier in base-specifier"
 msgstr "más de un especificador de acceso en la base especificada"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "no se permite la palabra clave %<typename%> en este contexto (la clase base es implícitamente un tipo)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "no se pueden definir tipos en una especificación de excepción"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 #| msgid "due to different exception specifications"
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "debido a diferentes especificaciones de excepciones"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, fuzzy, gcc-internal-format
 #| msgid "dynamic exception specifications are deprecated in C++0x; use %<noexcept%> instead"
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "las especificaciones de excepción dinámicas son obsoletas en C++0x; utilice %<noexcept%> en su lugar"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "uso no válido de %<auto%> en el operador de conversión"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "no se pueden definir tipos en declaraciones de excepción"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> en una declaración vacía"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD no puede tener argumentos por defecto"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "se esperaba %qT pero el argumento es de tipo %qT"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "El atributo %qE genera un conflicto con el atributo %s"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected an identifier for the attribute name"
 msgstr "se esperaba un identificador o %<(%>"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute specified multiple times"
 msgid "attribute %qs specified multiple times"
 msgstr "atributo %<fallthrough%> especificado múltiples veces"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 #| msgid "expected parameter pack before %<...%>"
 msgid "expected attribute before %<...%>"
 msgstr "se esperaba el parámetro pack antes de %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "un atributo que no es nulo sin argumento es un atributo que no es prototipo"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected conditional-expression"
 msgstr "se esperaba una expresión"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %qs"
 msgid "%qs is only available with %qs"
 msgstr "%qs es incompatible con %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "se descarta el atributo %qE para %qE"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "se descartan los atributos en el tipo sin instanciar"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "contracts are only available with %qs"
 msgstr "%<constexpr%> de C++11 sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 #| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x automático sólo está disponible con -std=c++11 o -std=gnu++11"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "expression must be integral"
 msgid "expression must be enclosed in parentheses"
 msgstr "la expresión debe ser integral"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "asm template is not a string constant"
 msgid "result type is not a plain type-constraint"
 msgstr "la plantilla asm no es una cadena constante"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not an integer constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "la alineación solicitada no es una constante entera"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "el miembro especializado %<%T::%E%> requiere sintaxis %<template<>%>"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "declaración no válida de %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "faltan listas-de-parámetros-de-plantilla"
@@ -71954,456 +72060,456 @@ msgstr "faltan listas-de-parámetros-de-plantilla"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "demasiadas listas-de-parámetros-de-plantilla"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "template-id not allowed for constructor in C++20"
 msgstr "no se permiten calificadores en la declaración de %<operator %T%>"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "ya no se admiten los valores de devolución nombrados"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, fuzzy, gcc-internal-format
 #| msgid "literal operator template %qD has invalid parameter list.  Expected non-type template argument pack <char...>"
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "la plantilla de operador literal %qD tiene una lista de parámetros no válida.  Se esperaba un paquete de argumentos de plantilla que no sean de tipo <char...>"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, fuzzy, gcc-internal-format
 #| msgid "literal operator template %qD has invalid parameter list.  Expected non-type template argument pack <char...>"
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "la plantilla de operador literal %qD tiene una lista de parámetros no válida.  Se esperaba un paquete de argumentos de plantilla que no sean de tipo <char...>"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "declaración no válida de plantilla miembro en la clase local"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "plantilla con enlace C"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "especialización explícita no válida"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "declaración plantilla de %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "la declaración no declara nada"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "la especialización de plantilla explícita no puede tener una clase de almacenamiento"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%> debe ser %<> >%> dentro de una lista de argumentos de plantilla anidada"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "%<>>%> sobrante, use %<>%> para terminar una lista de argumentos de plantilla"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%<>>%> sobrante, use %<>%> para terminar una lista de argumentos de plantilla"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "uso no válido de %qD en la especificación de enlace"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %qD"
 msgid "%qD specifier conflicts with %qs"
 msgstr "conflicto de tipo de sección con %qD"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> antes de %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "se usó %qE con %<typedef%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 no admite %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 #| msgid "both %<_Sat%> and %<char%> in declaration specifiers"
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "se usaron al mismo tiempo %<_Sat%> y %<char%> en los especificadores de declaración"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate %qD"
 msgstr "%qE duplicado"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "%qs duplicado"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "se esperaba %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "se esperaba %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "se esperaba %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "se esperaba %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "se esperaba %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "se esperaba %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "se esperaba %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "se esperaba %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "se esperaba %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "se esperaba %<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "se esperaba %<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "se esperaba %<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "se esperaba %<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "se esperaba %<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "se esperaba %<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>"
 msgid "expected %<auto%>"
 msgstr "se esperaba %<data%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "se esperaba %<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "se esperaba %<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "se esperaba %<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "se esperaba %<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "se esperaba %<__transaction_atomic%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "se esperaba %<__transaction_relaxed%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<@end%>"
 msgid "expected %<co_yield%>"
 msgstr "se esperaba %<@end%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "se esperaba %<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "se esperaba %<...%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "se esperaba %<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "se esperaba %<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "se esperaba %<:%> o %<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "se esperaba %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "se usó la etiqueta %qs al nombrar a %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T se declaró previamente aquí"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "no se puede declarar la referencia a %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared with greater visibility than its base %qT"
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT se declaró con mayor visibilidad que su base %qT"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "replace the class-key with %qs"
 msgstr "se esperaba una llave de clase"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%qT defined as %qs here"
 msgstr "la etiqueta %qD se define aquí"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "  first declared as %q#D here"
 msgid "%qT first declared as %qs here"
 msgstr "  declarado inicialmente como %q#D aquí"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD se redeclaró con acceso diferente"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, fuzzy, gcc-internal-format
 #| msgid "%<template%> (as a disambiguator) is only allowed within templates"
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "%<template%> (como desambiguador) sólo se permite dentro de plantillas"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "el fichero termina en el argumento por defecto"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "construct Objective-C++ %<@%D%> mal ubicado"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, fuzzy, gcc-internal-format
 #| msgid "objective-c++ message argument(s) are expected"
 msgid "objective-c++ message receiver expected"
 msgstr "se esperaba(n) argumento(s) de mensaje de objective-c++"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "se esperaba(n) argumento(s) de mensaje de objective-c++"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> debe especificar un tipo como un argumento"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "nombre de selector Objective-C++ no válido"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "se esperaba una declaración de método de objective-c++"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "los atributos de método se deben especificar al final"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "%qs sobrante después de los métodos Objective-C++"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "tipo no válido para la variable de de instancia"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "se esperaba un identificador después de %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "los atributos no se pueden especificar antes de la palabra clave de Objective-C++ %<@%D%>"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "se descartan los atributos de prefijo antes de %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "tipo no válido para la propiedad"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "unknown property attribute %qE"
 msgstr "atributo de propiedad desconocido"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected integer expression list"
 msgstr "se esperaba una expresión entera"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<wait%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "se esperaba %<class%>, %<typename%> o %<template%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid reduction-identifier"
 msgstr "inicializador no válido"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in parameter types"
 msgid "types may not be defined in iterator type"
@@ -72413,193 +72519,193 @@ msgstr "no se pueden definir tipos en tipos de parámetro"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable ya no se admite"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "no se permite la inicialización entre paréntesis para el bucle %<for%> en OpenMP"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, fuzzy, gcc-internal-format
 #| msgid "%<ordered%> clause with parameter may not be specified on %qs construct"
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "la cláusula %<ordered%> con parámetro no se puede especificar en la construcción %qs"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "la variable de iteración %qD no debe ser reduction"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp end declare target%> sin su correspondiente %<#pragma omp declare target%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare simd%> must be followed by function declaration or definition"
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma omp declare simd%> debe ir seguida de una declaración o definición de función"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qD is not a C pointer"
 msgstr "%qD no es una variable puntero"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "se esperaba %<target%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "inicializador no válido"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 #| msgid "expected id-expression"
 msgid "expected id-expression (arguments)"
 msgstr "se esperaba una expresión id"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in declare reduction type list"
 msgstr "no se pueden definir tipos nuevos en un tipo de devolución"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "const, volatile or restrict qualified type in %<#pragma omp declare reduction%>"
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "tipo calificado const, volatile o restrict en %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in parameter types"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "no se pueden definir tipos en tipos de parámetro"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<simd%> or %<reduction%> or %<target%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "se esperaba %<simd%>, %<reduction%> o %<target%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD no es una función plantilla miembro"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "compound-statement in constexpr function"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "declaración compuesta en una función constexpr"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> más externo no está dentro del %<__transaction_atomic%> más externo"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  o una función %<transaction_may_cancel_outer%>"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "malformed #pragma GCC coprocessor"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "#pragma GCC coprocessor malformado"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%> sólo se puede usar en declaraciones compuestas"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp taskyield%> may only be used in compound statements"
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp taskyield%> sólo se puede usar en declaraciones compuestas"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC optimize is not allowed inside functions"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "no se permite #pragma GCC optimize dentro de funciones"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "no se han implementado las optimizaciones intermódulos para C++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "no se permiten las conversiones estándar en este contexto"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, fuzzy, gcc-internal-format
 #| msgid "templates may not be %<virtual%>"
 msgid "implicit templates may not be %<virtual%>"
 msgstr "las plantillas no pueden ser %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -73116,24 +73222,30 @@ msgstr "utilice template<> para una especialización explícita"
 msgid "redeclaration of %qD with different constraints"
 msgstr "la redeclaración de %qD difiere en %<constexpr%>"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "lambda-expression in unevaluated context"
+msgid "local class in lambda in template parameter list"
+msgstr "expresión lambda en un contexto sin evaluar"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT no es un tipo plantilla"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "no se especificaron los especificadores de plantilla en la declaración de %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "se redeclaró con %d parámetro de plantilla"
 msgstr[1] "se redeclaró con %d parámetros de plantilla"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D used %d template parameter"
 #| msgid_plural "previous declaration %q+D used %d template parameters"
@@ -73142,134 +73254,134 @@ msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "la declaración previa de %q+#D usó %d parámetro de plantilla"
 msgstr[1] "la declaración previa de %q+#D usó %d parámetros de plantilla"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "parámetro de plantilla %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "redeclarado aquí como %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "redeclared here"
 msgstr "se declara aquí"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration %qD differs in %<constexpr%>"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "la redeclaración de %qD difiere en %<constexpr%>"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 #| msgid "original definition appeared here"
 msgid "original declaration appeared here"
 msgstr "la definición original apareció aquí"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration %qD differs in %<constexpr%>"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "la redeclaración de %qD difiere en %<constexpr%>"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE no es un argumento de plantilla válido para el tipo %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "debe ser la dirección de una función con enlace externo"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, fuzzy, gcc-internal-format
 #| msgid "it must be the address of a function with external linkage"
 msgid "it must be the name of a function with external linkage"
 msgstr "debe ser la dirección de una función con enlace externo"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE no es un argumento válido de plantilla para el tipo %qT porque %qD no tiene enlace"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE no es un argumento válido de plantilla para el tipo %qT porque %qD no tiene enlace externo"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "debe ser un puntero-a-miembro de la forma %<&X::Y%>"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qD no es un miembro de %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "  couldn't deduce template parameter %qD"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  no se puede deducir el parámetro de plantilla %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  los tipos %qT y %qT tiene calificadores-cv incompatibles"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  no coinciden los tipos %qT y %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "  el parámetro de plantilla %qD no es un paquete de parámetro, pero el argumento %qD sí"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "  el argumento de plantilla %qE no coincide con la constante puntero-a-miembro %qE"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE no es equivalente a %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  deducción de paquete de parámetros inconsistente con %qT y %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  se deducen tipos en conflicto para el parámetro %qT (%qT y %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  se deducen valores en conflicto para el parámetro %qE que no es tipo (%qE y %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "  el tipo matriz de tamaño variable %qT no es un argumento de plantilla válido"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  el tipo de función miembro %qT no es un argumento de plantilla válido"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "  candidate expects %d argument, %d provided"
 #| msgid_plural "  candidate expects %d arguments, %d provided"
@@ -73278,377 +73390,377 @@ msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  el candidato espera %d argumento, se proporcionaron %d"
 msgstr[1] "  el candidato espera %d argumentos, se proporcionaron %d"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  el candidato espera %d argumento, se proporcionaron %d"
 msgstr[1] "  el candidato espera %d argumentos, se proporcionaron %d"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  no se puede convertir %qE (tipo %qT) al tipo %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT es una clase base ambigua de %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT no es derivado de %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  los parámetros de plantilla de un argumento de plantilla plantilla son inconsistentes con otros argumentos de plantilla deducidos"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "  can't deduce a template for %qT from non-template type %qT"
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  no se puede deducir una plantilla para %qT del tipo %qT que no es plantilla"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 #| msgid "  template argument %qE does not match %qD"
 msgid "  template argument %qE does not match %qE"
 msgstr "  el argumento de plantilla %qE no coincide con %qD"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE no es un argumento válido de plantilla de tipo %qT porque %qE no es una variable"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE no es un argumento válido de plantilla de tipo %qT porque %qD no tiene enlace externo"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE no es un argumento válido de plantilla de tipo %qT porque %qD no tiene enlace"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 #| msgid "  variable-sized array type %qT is not a valid template argument"
 msgid "the address of %qD is not a valid template argument"
 msgstr "  el tipo matriz de tamaño variable %qT no es un argumento de plantilla válido"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 #| msgid "  variable-sized array type %qT is not a valid template argument"
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "  el tipo matriz de tamaño variable %qT no es un argumento de plantilla válido"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qE no es un argumento válido de plantilla de tipo %qT porque %qD no tiene enlace externo"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD no es un argumento válido de plantilla porque %qD es una variable, no la dirección de una variable"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qD no es un argumento válido de plantilla porque %qD es una variable, no la dirección de una variable"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE no es un argumento válido de plantilla para el tipo %qT porque las literales de cadena nunca se pueden usar en este contexto"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 #| msgid "in template argument for type %qT "
 msgid "in template argument for type %qT"
 msgstr "en el argumento de plantilla para el tipo %qT "
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 #| msgid "in template argument for type %qT "
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "en el argumento de plantilla para el tipo %qT "
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE no es un argumento de plantilla válido para el tipo %qT debido a conflictos en la calificación cv"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE no es un argumento válido de plantilla para el tipo %qT porque no es un l-valor"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D no es un argumento válido de plantilla para el tipo %qT porque una referencia variable no tiene una dirección constante"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE no es un argumento de plantilla válido para el tipo %qT porque es un puntero"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "intente utilizar %qE en su lugar"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE no es un argumento de plantilla válido para el tipo %qT porque es de tipo %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "se descartan los atributos en el argumento de plantilla %qT"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes on template argument %qT"
 msgid "ignoring attributes in template argument %qE"
 msgstr "se descartan los atributos en el argumento de plantilla %qT"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "se usó el nombre-de-clase-inyectada %qD como un argumento de plantilla plantilla"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "uso no válido del destructor %qE como un tipo"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "para hacer referencia a un tipo miembro de un parámetro de plantilla, use %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "no coincide el tipo/valor en el argumento %d en la lista de parámetros de plantilla para %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  se esperaba una constante de tipo %qT, se obtuvo %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for template parameter for class enclosing %qD"
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "argumento por defecto para el parámetro de plantilla para la clase incluyente %qD"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  se esperaba una plantilla de clase, se obtuvo %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  se esperaba un tipo, se obtuvo %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  se esperaba un tipo, se obtuvo %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  se esperaba una plantilla de clase, se obtuvo %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  se esperaba una plantilla de tipo %qD, se obtuvo %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "no coincide el tipo/valor en el argumento %d en la lista de parámetros de plantilla para %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "  expected %qD but got %qD"
 msgstr "  se esperaba un tipo, se obtuvo %qE"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument %qE to %qT"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "no se puede convertir el argumento de plantilla %qE a %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "el argumento de plantilla %d es no válido"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "número erróneo de argumentos de plantilla (%d, debe ser %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "número erróneo de argumentos de plantilla (%d, debe ser %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "provisto por %q+D"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for template parameter for class enclosing %qD"
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "argumento por defecto para el parámetro de plantilla para la clase incluyente %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "argumento por defecto dado para el parámetro %d de %q#D"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D no es una plantilla de función"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "se usa el tipo %qT que no es plantilla como una plantilla"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "para la declaración de plantilla %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "internal consistency failure"
 msgid "template constraint failure for %qD"
 msgstr "falla interna de consistencia"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "use of %qs in template"
 msgid "use of invalid variable template %qE"
 msgstr "uso de %qs en la plantilla"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) substituting %qS"
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "la profundidad de instanciación de la plantilla excede el máximo de %d (use -ftemplate-depth= para incrementar el máximo) al sustituir %qS"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "score argument must be constant integer expression"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must be nonnegative"
 msgid "score argument must be non-negative"
 msgstr "'%s' en %L debe ser no negativo"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "property must be constant integer expression or string literal"
 msgstr "%Hel argumento de collapse necesita ser una expresión entera constante positiva"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be constant integer expression"
 msgstr "se esperaba una expresión entera"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "instantiating erroneous template"
 msgstr "  en la instanciación de la plantilla %qT"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "first error appeared here"
 msgstr "se definió struct aquí"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member %qD in union"
 msgstr "miembro de matriz flexible en union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a potential constant expression"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE no es una expresión constante potencial"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%T%>"
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "no coinciden las longitudes de los paquetes de argumentos al expandir %<%T%>"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%E%>"
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "no coinciden las longitudes de los paquetes de argumentos al expandir %<%E%>"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for %q#D"
 msgid "  when instantiating default argument for call to %qD"
 msgstr "redefinición del argumento por defecto para %q#D"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "se crea un puntero a función miembro del tipo %qT que no es clase"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%T%>"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -73667,130 +73779,130 @@ msgstr "no coinciden las longitudes de los paquetes de argumentos al expandir %<
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "la variable %qD tiene tipo de función"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "tipo de parámetro %qT no válido"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "en la declaración %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "la función devuelve una matriz"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "la función devuelve una función"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%<locus%> is not defined as a type"
 msgid "%qE is not usable in a splice type"
 msgstr "%<locus%> no se define como un tipo"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE no es una variable en la cláusula %qs"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "se forma la referencia a void"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "se forma un puntero para referenciar al tipo %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "se forma una referencia para referenciar al tipo %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to qualified function type %qT"
 msgid "forming pointer to qualified function type %qT"
 msgstr "no se puede declarar el puntero para el tipo de función calificado %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to qualified function type %qT"
 msgid "forming reference to qualified function type %qT"
 msgstr "no se puede declarar la referencia para el tipo de función calificado %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "se crea un puntero al miembro del tipo %qT que no es clase"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "se crea un puntero al miembro de referencia de tipo %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "se crea un puntero al miembro de tipo void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "se crea la matriz de %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "se asume que la matriz %q+D tiene un elemento"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT no es de tipo clase, struct o union"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT resuelve a %qT, el cual no es un tipo enumerado"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT resuelve a %qT, el cual no es un tipo de clase"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT resuelve a %qT, el cual no es un tipo enumerado"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected a reflection of a type template"
 msgstr "se esperaba nombre de función"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "uso de %qs en la plantilla"
@@ -73798,218 +73910,218 @@ msgstr "uso de %qs en la plantilla"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "especialización explícita de %qD después del primer uso"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "el tipo calificador %qT no coincide con el nombre del destructor ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "el nombre dependiente %qE se decodifica como un no tipo, pero la instanciación genera un tipo"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "escriba %<typename %E%> si quiere un tipo"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "el elemento inicializador no es una expresión constante"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "uso no válido de la expresión de expansión de paquete"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "use %<...%> para expandir el paquete de argumentos"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, fuzzy, gcc-internal-format
 #| msgid "non-empty initializer for array of empty elements"
 msgid "empty initializer in lambda init-capture"
 msgstr "inicializador no-vacío para una matriz de elementos vacíos"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD no se declaró en este ámbito, y no se encontraron declaraciones en la búsqueda dependiente de argumentos en el punto de la instanciación"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "no se encontraron declaraciones en la base dependiente %qT pur la búsqueda no calificada"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "use %<this->%D%> en su lugar"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "use %<%T::%D%> en su lugar"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here, later in the translation unit"
 msgid "%qD declared here, later in the translation unit"
 msgstr "%q+D se declaró aquí, después en la unidad de translación"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_choose_expr%>"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "número erróneo de argumentos para %<__builtin_choose_expr%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qE attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "se especificó el número equivocado de argumentos para el atributo %qE"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT no es una clase o un espacio de nombres"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD no es una clase o un espacio de nombres"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "se usa el campo no válido %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is/uses anonymous type"
 msgid "%qT is/uses unnamed type"
 msgstr "%qT es/usa un tipo anónimo"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "el argumento de plantilla para %qD usa el tipo local %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT es un tipo modificado variablemente"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "la expresión integral %qE no es una constante"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  se trata de instanciar %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#T"
 msgstr "instanciación de plantilla clase ambigua para %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#D"
 msgstr "instanciación de plantilla clase ambigua para %q#T"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %+#D"
 msgid "%s %#qS"
 msgstr "%s %+#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "instanciación explícita de %q#D que no es plantilla"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD no es un dato miembro static de una plantilla de clase"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "no se encontró una plantilla coincidente para %qD"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "el tipo %qT para la instanciación explícita %qD no coincide con el tipo declarado %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "instanciación explícita de %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "instanciación explícita duplicada de %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ 1998 prohíbe el uso de %<extern%> en instanciaciones explícitas"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "clase de almacenamiento %qD aplicada a la instanciación de una plantilla"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "instanciación explícita de la plantilla %qD que no es clase"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "instanciación explícita del tipo %qT que no es plantilla"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "instanciación explícita de %q#T antes de la definición de la plantilla"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ prohíbe el uso de %qE en las instanciaciones explícitas"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "instanciación explícita duplicada de %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "especialización explícita de %qD después del primer uso"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -74022,178 +74134,178 @@ msgstr "no se permiten los especificadores-virt en %qs fuera de una definición
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "instanciación explícita de %qD pero no hay una definición disponible"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "la profundidad de instanciación de la plantilla excede el máximo de %d al instanciar %q+D, posiblemente de la generación de tabla virtual (use -ftemplate-depth= para incrementar el máximo)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template non-type parameter"
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T no es un tipo válido para un parámetro que no es tipo plantilla"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "parámetro que no es tipo plantilla no válido"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T no es un tipo válido para un parámetro que no es tipo plantilla"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "no se permite la palabra clave %<typename%> fuera de las plantillas"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be constrained"
 msgstr "el constructor no puede ser una función miembro de tipo static"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT no es un espacio de nombres"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "la definición de %q#T dentro de la lista de parámetros de plantilla"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, fuzzy, gcc-internal-format
 #| msgid "deducing from brace-enclosed initializer list requires #include <initializer_list>"
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "la deducción de una lista inicializadora encerrada entre llaves requiere #include <initializer_list>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "se usó %qD que no es plantilla como plantilla"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "las plantillas variadic sólo están disponibles con -std=c++11 o -std=gnu++11"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "try using %qE instead"
 msgid "use %qD directly instead"
 msgstr "intente utilizar %qE en su lugar"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 #| msgid "in template argument for type %qT "
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "en el argumento de plantilla para el tipo %qT "
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 #| msgid "  template argument deduction/substitution failed:"
 msgid "class template argument deduction failed:"
 msgstr "  falló la deducción/sustitución del argumento de plantilla:"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "la función no se consideró para la inclusión en línea"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, fuzzy, gcc-internal-format
 #| msgid "  template argument deduction/substitution failed:"
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "  falló la deducción/sustitución del argumento de plantilla:"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared here"
 msgid "explicit deduction guide declared here"
 msgstr "en una llamada a la función %qD declarada aquí"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 #| msgid "  template argument deduction/substitution failed:"
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "  falló la deducción/sustitución del argumento de plantilla:"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 #| msgid "unable to deduce %qT from %qE"
 msgid "unable to deduce lambda return type from %qE"
 msgstr "no se puede deducir %qT de %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "no se puede deducir %qT de %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "la insn no satisface sus restricciones:"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "la insn no satisface sus restricciones:"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -74201,388 +74313,452 @@ msgstr "la insn no satisface sus restricciones:"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new no se puede aplicar a un tipo de referencia"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new no se puede aplicar a un tipo de función"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 #| msgid "type '%T' cannot be used as a value for a non-type template-parameter"
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "el tipo `%T' no se puede usar como un valor para un parámetro de plantilla que no es tipo"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "se descarta el atributo %qE en tipos que no son clases"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new no se puede aplicar a un tipo de función"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new no se puede aplicar a un tipo de función"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "passing argument %d of %qE from distinct Objective-C type"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "se pasa el argumento %d de %qE desde un tipo Objective-C distinto"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%E%> is not a class or namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<::%E> no es una clase o un espacio de nombres"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, fuzzy, gcc-internal-format
 #| msgid "decltype evaluates to %qT, which is not a class or enumeration type"
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "el tipo de declaración evalúa a %qT, el cual no es una clase o un tipo enumerado"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "no se puede ejecutar '%s': %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "se esperaba %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not find specs file %s\n"
 msgid "couldn%'t look up %qs"
 msgstr "no se puede encontrar el fichero de especificaciones %s\n"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  se esperaba un tipo, se obtuvo %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT no es de tipo puntero-a-objeto"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a non-member function"
 msgid "%qT must be a function type"
 msgstr "%qD debe ser una función que no sea miembro"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "se esperaba un argumento de plantilla"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, fuzzy, gcc-internal-format
 #| msgid "transaction_wrap argument is not a function"
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "el argumento transaction_wrap no es una función"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qs with %<warn_if_not_aligned%> type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "no se puede declarar el campo de bits %qs con un tipo %<warn_if_not_aligned%>"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "%<consteval%> block defined here"
 msgstr "se definió struct aquí"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI argument"
 msgid "invalid %<access_context%> argument"
 msgstr "argumento PHI no válido"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "se esperaba %<delete%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "argumento inesperado"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "passing argument %d of %qE from distinct Objective-C type"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "se pasa el argumento %d de %qE desde un tipo Objective-C distinto"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "vector types expected in sad expression"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "se esperaban tipos vector en una expresión de permutación de vector"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "vector types expected in sad expression"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "se esperaban tipos vector en una expresión de permutación de vector"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown metafunction %qD"
 msgstr "función de especificación %qs desconocida"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "splice argument must be an expression of type %qs"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot disable built-in function %qs"
+msgid "cannot splice a null reflection"
+msgstr "no se puede desactivar la función interna %qs"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "no se puede usar %<::%>  en la declaración de parámetros"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<register%>"
 msgid "add %<constexpr%>"
 msgstr "se usó %qE con %<register%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %qE must be directly called"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "la función interna %qE ha de ser llamada directamente"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "se esperaba una expresión booleana"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "no se permite la palabra clave %<typename%> fuera de las plantillas"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 #| msgid "expected constructor, destructor, or type conversion"
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "se esperaba un constructor, un destructor, o una conversión de tipo"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "uso del espacio de nombres %qD como expresión"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "no se puede declarar explícitamente que el miembro %q#D tenga un enlace externo"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "invalid cast to function type %qT"
+msgid "invalid class member access of type template %qE"
+msgstr "conversión no válida al tipo de función %qT"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can%'t use %qs as a call-used register"
+msgid "cannot use %qE to access a class member"
+msgstr "no se puede usar %qs como un registro usado de llamada"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "uso de la variable %<auto%> desde la función contenedora"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 #| msgid "division by zero is not a constant-expression"
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "la división entre cero no es una expresión constante"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about uses of a comma operator within a subscripting expression."
 msgid "cannot use a data member specification in a splice expression"
 msgstr "Avisa sobre usos de separador coma en una expresión ide subíndice."
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "Expected structure component name at %C"
+msgid "expected a reflection of a function template"
+msgstr "Se esperaba un nombre de componente de estructura en %C"
+
+#: cp/reflect.cc:9130
+#, fuzzy, gcc-internal-format
+#| msgid "Expected structure component name at %C"
+msgid "expected a reflection of a function or variable template"
+msgstr "Se esperaba un nombre de componente de estructura en %C"
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -74950,656 +75126,656 @@ msgstr "definición no válida del tipo calificado %qT"
 msgid "invalid base-class specification"
 msgstr "especificación de clase base no válida"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 #| msgid "protected member %q+#D in anonymous union"
 msgid "cannot capture member %qD of anonymous union"
 msgstr "miembro protegido %q+#D en union anónima"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD no se capturó"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of local variable with automatic storage from containing function"
 msgstr "uso de la variable %<auto%> desde la función contenedora"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "uso de parámetro desde la función contenedora"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "use of parameter %qD outside function body"
 msgid "use of parameter outside function body"
 msgstr "se usó el parámetro %qD fuera del cuerpo de la función"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "in template argument for type %qT "
 msgid "missing template arguments"
 msgstr "en el argumento de plantilla para el tipo %qT "
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "no se permite el parámetro de plantilla %qD de tipo %qT en una expresión integral constante porque no es de tipo integral o de enumeración"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "uso de la plantilla de clase %qT como expresión"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "la petición por el miembro %qD es ambigua en la red de herencia múltiple"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD no puede aparecer en una expresion constante"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "el tipo de %qE es desconocido"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT no es un tipo de enumeración"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "el tamaño de la matriz tiene un tipo %qT que no es integral"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "pack index is not an integral constant"
 msgstr "el límite de la matriz no es una constante entera"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "shift count is negative"
 msgid "pack index %qE is negative"
 msgstr "la cuenta de desplazamiento es negativa"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, fuzzy, gcc-internal-format
 #| msgid "intrinsic register index is out of range"
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr "el índice de registro intrínseco está fuera de rango"
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter pack __bases only valid in template declaration"
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "Los paquetes de parámetros __bases sólo son válidos en la declaración de plantilla"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "no se puede aplicar %<offsetof%> al destructor %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "no se puede aplicar %<offsetof%> a la función miembro %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "no se puede aplicar %<offsetof%> a la función miembro %qD"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "no se puede aplicar %<offsetof%> a la función miembro %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "cannot receive objects of non-trivially-copyable type %q#T through %<...%>; "
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "no se puede recibir objetos de tipo no-copiable-trivialmente q%#T a través de %<...%>"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "constructor priorities are not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "no se admiten las prioridades de constructor"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "user defined reduction lookup is ambiguous"
 msgstr "la referencia a %qD es ambigua"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %+#D"
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has invalid type for %<reduction%>"
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE tiene tipo no válido para %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, fuzzy, gcc-internal-format
 #| msgid "function or array type in %<#pragma omp declare reduction%>"
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "tipo función o matriz en %<#pragma omp declare reduction%>"
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "%qD debe ser una variable global en %<#pragma acc declare link%>"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "se esperaba una expresión entera"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "linear step expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD no es una variable en la cláusula %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD no es una variable en la cláusula %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<gang%> static expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<gang%> static value must be positive"
 msgstr "el valor de %<num_threads%> debe ser positivo"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<gang%> num expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<vector%> length expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<worker%> num expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<gang%> num value must be positive"
 msgstr "el valor de %<num_threads%> debe ser positivo"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<vector%> length value must be positive"
 msgstr "el valor de %<num_threads%> debe ser positivo"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<worker%> num value must be positive"
 msgstr "el valor de %<num_threads%> debe ser positivo"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "la expresión schedule chunk size debe ser integral"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%qs length expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "%Hel argumento de collapse necesita ser una expresión entera constante positiva"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<async%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<thread_limit%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 #| msgid "slice end must be integer"
 msgid "%<device%> id must be integral"
 msgstr "el final de la rebanada debe ser entero"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "la expresión schedule chunk size debe ser integral"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "la expresión schedule chunk size debe ser integral"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qE no es una variable en la cláusula %<saligned%>"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD aparece más de una vez en las cláusulas de datos"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "%qE no es una variable en la cláusula %<saligned%>"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "El nombre '%s' no se puede usar como un operador definido en %C"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable-length array bound is unknown"
 msgid "variable length traits arrays are not supported"
 msgstr "el límite del array de longitud variable es desconocido"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD no es una variable en la cláusula %qs"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "template %qE in clause %qs"
 msgstr "demasiadas cláusulas %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<grainsize%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<priority%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<hint%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%Hel argumento de collapse necesita ser una expresión entera constante positiva"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<filter%> expression must be integral"
 msgstr "la expresión num_threads debe ser integral"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "el tipo de vector delete no es del tipo puntero ni matriz"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "el tipo de vector delete no es del tipo puntero ni matriz"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<tile%> argument needs integral type"
 msgstr "el valor de %<num_threads%> debe ser positivo"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD no es un fichero, espacio de nombres o variable de ámbito de bloque"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "la directiva %<threadprivate%> %qE no está en la definición %qT"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "la diferencia entre %qE y %qD no tiene tipo entero"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp atomic update%> uses two different variables for memory"
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<#pragma omp atomic update%> usa dos variables diferentes para la memoria"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp atomic update%> uses two different variables for memory"
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic update%> usa dos variables diferentes para la memoria"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant-expression"
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "la expresión %qE no es una expresión constante"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qH to %qI in a converted constant expression"
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "conversión de %qH a %qI en una expresión constante convertida"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, fuzzy, gcc-internal-format
 #| msgid "converting UCN to source character set"
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr "convirtiendo un NUC al conjunto de caracteres fuente"
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %s"
 msgid "static assertion failed: %.*s"
 msgstr "falló la aserción estática: %s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "condición que no es constante para una aserción estática"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "el argumento para decltype debe ser una expresión"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "decltype cannot resolve address of overloaded function"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "el tipo de declaración no puede resolver la dirección de la función sobrecargada"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT no es un tipo de clase"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT no es un tipo agregado"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "se llamó a %<__builtin_next_arg%> sin un argumento"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "se llamó a %<__builtin_next_arg%> sin un argumento"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qs argument %qT is a reference"
 msgstr "%qT no es un espacio de nombres"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "%qD is not a class or alias template"
 msgstr "%qE no es una plantilla"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 #| msgid "third operand of conditional expression has no effect"
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "el tercer operando de la expresión condicional no tiene efecto"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "el argumento de plantilla %qE involucra a el(los) parámetro(s) de plantilla"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_call_with_static_chain%> must be a pointer type"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -75608,394 +75784,394 @@ msgstr "el segundo argumento de %<__builtin_call_with_static_chain%> debe ser un
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "new no se puede aplicar a un tipo de función"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "los calificadores %qV no se pueden aplicar a %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid " declared here"
 msgstr "se declara aquí"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "la alineación de %qD es más grande que la declaración original"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT is a floating-point type"
 msgstr "%qD no es una plantilla de función"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is a fixed-point type"
 msgstr "%qD no es una variable puntero"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT no es una base de %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE does not designate a constexpr function"
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr "la expresión %qE no designa una función constexpr"
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "SIGNAL `%s' has no data fields"
 msgid "%q#T has no data fields"
 msgstr "SIGNAL `%s' no tiene campos de datos"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE does not designate a constexpr function"
 msgid "base %qT does not have unique object representations"
 msgstr "la expresión %qE no designa una función constexpr"
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE does not designate a constexpr function"
 msgid "%qD with type %qT does not have unique object representations"
 msgstr "la expresión %qE no designa una función constexpr"
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "comparación entre %qT y %qT"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %qD"
 msgid "padding occurs after %qD"
 msgstr "parámetro %qD sin uso"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "SIGNAL `%s' has no data fields"
 msgid "%qT has padding and no data fields"
 msgstr "SIGNAL `%s' no tiene campos de datos"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class %qT has cv qualifiers"
 msgid "base class %qT is not public"
 msgstr "la clase base %qT tiene calificadores cv"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not captured"
 msgid "%qD is not public"
 msgstr "%qD no se capturó"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qD is mutable"
 msgstr "%qD no es una variable"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD has a non-structural type"
 msgstr "%qD no es un tipo"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "el atributo %qE sólo se puede aplicar a definiciones de clase"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "el argumento del atributo %qE no es una constante de cadena"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "el atributo %qE sólo se puede aplicar a definiciones de clase"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "el atributo %qE sólo se puede aplicar a definiciones de clase"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute cannot be applied to variables with specific sections"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "el atributo %qE no se puede aplicar a variables con secciones específicas"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "%qE attribute takes no arguments"
 msgstr "el atributo %qD requiere un solo argumento NTBS"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute does not apply to functions"
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "el atributo %qE no se aplica a funciones"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "declaración de función no válida"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT no es un tipo de enumeración"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "se aplicó %<__alignof%> a un campo de bits"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "%qE on unnamed bit-field"
 msgstr "se especificó la alineación para el campo de bits sin nombre"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %qD but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "existe la declaración para el parámetro %qD pero no hay tal parámetro"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "la init_priority solicitada no es una constante entera"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "solo se puede usar el atributo %qE en definiciones de rango de fichero de objetos de tipo class"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "la init_priority solicitada está fuera de rango"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "la init_priority solicitada está reservada para uso interno"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as member of %qT"
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "declaración de %qD como miembro de %qT"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "the %qE attribute requires arguments"
 msgstr "el atributo %qD requiere un solo argumento NTBS"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qE attribute is not a string constant"
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "el argumento del atributo %qE no es una cadena constante"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qE attribute is not a string constant"
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "el argumento del atributo %qE no es una cadena constante"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 #| msgid "%.*s is not a valid universal character"
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%.*s no es un carácter universal válido"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%T::%D%> no es un declarador válido"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "se descarta el atributo %qE en tipos que no son clases"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "se descartan los atributos aplicados al %qT después de la definición"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "se descartan los atributos aplicados al %qT después de la definición"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "se descartan los atributos aplicados al %qT después de la definición"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to functions, not %s"
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "el atributo %qE se aplica solamente a funciones, no a %s"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute applied to %s %s at %L"
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "El atributo %s se aplica a %s %s en %L"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not a string constant"
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "el argumento del atributo %qE no es una constante de cadena"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "`sizeof' applied to a bit-field"
 msgid "annotation applied to a label"
 msgstr "`sizeof' aplicado a un campo de bits"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "annotation on unnamed bit-field"
 msgstr "se especificó la alineación para el campo de bits sin nombre"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "parámetro de función"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "annotation does not have structural type"
 msgstr "%qD no tiene tipo integral o de enumeración"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "la función no devuelve valores de tipo cadena"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -76211,867 +76387,873 @@ msgstr "%qT no tiene un miembro llamado %qE"
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT no tiene un miembro llamado %qE"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> no es un miembro de %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD no es un miembro de %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD no es una función plantilla miembro"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT no es de tipo puntero-a-objeto"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "uso no válido del índice de matriz en puntero a miembro"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "uso no válido del unario %<*%> en puntero a miembro"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "uso no válido de la conversión implícita en puntero a miembro"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "falta el subíndice en la referencia de la matriz"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "se declaró el subíndice de la matriz como %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "el valor indicado por el subíndice no es ni matriz ni puntero"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "falta un objeto en el uso de %qE"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion at assignment"
 msgid "no default version in scope"
 msgstr "conversión que no es trivial en la asignación"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ prohíbe la llamada %<::main%> dentro del mismo programa"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "se debe usar %<.*%> o %<->*%> en la llamada a la función puntero-a-miembro en %<%E (...)%>, p.e. %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qD cannot be used as a function"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "expression cannot be used as a function"
 msgstr "no se puede usar %qE como una función"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "demasiados argumentos para el constructor %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "faltan argumentos para el constructor %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "demasiados argumentos para la función miembro %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "faltan argumentos para la función miembro %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "demasiados argumentos para la función %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "faltan argumentos para la función %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "demasiados argumentos para el método %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "faltan argumentos para el método %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "demasiados argumentos para la función"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "faltan argumentos para la función"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "el parámetro %P de %qD tiene el tipo incompleto %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "el parámetro %P tiene el tipo incompleto %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "la dirección de %qD nunca debe ser NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "la dirección de %qD nunca debe ser NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "la comparación siempre se evalúa como %<true%> para la dirección de %qD que nunca será NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "la comparación siempre se evalúa como %<true%> para la dirección de %qD que nunca será NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "los operandos de ?: tienen tipos diferentes %qT y %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "conversion between distinct pointer types %qT and %qT lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "la conversión entre diferentes tipos de punteros %qT y %qT carece de una conversión"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "same canonical type node for different types %T and %T"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "el mismo nodo de tipo canónico para los tipos diferentes %T y %T"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "la comparación entre diferentes tipos de punteros %qT y %qT carece de una conversión"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "complex arguments must have floating-point type"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "los argumentos complejos deben tener tipo de coma flotante"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "conversión desde una llamada a función de tipo %qT al tipo %qT que no coincide"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from pointer type %qT to arithmetic type %qT in a constant-expression"
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "conversión del tipo puntero %qT al tipo aritmético %qT en una expresión constante"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types when assigning to type %qT from type %qT"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "tipos incompatible en la asignación al tipo %qT del tipo %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "se asume la conversión al tipo %qT desde la función sobrecargada"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "se usó NULL en la aritmética"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ prohíbe la comparación entre puntero y entero"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "operand types are %qT and %qT"
 msgstr "no hay un tipo llamado %q#T en %q#T"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "comparación ordenada de puntero con el entero cero"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "comparación sin orden en el argumento de coma no flotante"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 #| msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "conversión implícita de %qT a %qT para coincidir con otro operando de la expresión binaria"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "operadores no válidos de tipos %qT y %qT para el binario %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ prohíbe el uso de un puntero de tipo %<void *%> en la sustracción"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ prohíbe el uso de un puntero a una función en la sustracción"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ prohíbe el uso de un puntero a un método en la sustracción"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "uso no válido de un puntero a un tipo incompleto en aritmética de punteros"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of constructor %qE"
 msgid "taking address of constructor %qD"
 msgstr "se toma la dirección del constructor %qE"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "taking address of destructor %qD"
 msgstr "se toma la dirección del destructor %qE"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "uso no válido de %qE para formar una función puntero a miembro"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  se requiere un id calificado"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "no se pueden usar paréntesis alrededor de %qE para formar una función-puntero-a-miembro"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ prohíbe tomar la dirección de una función miembro no estática sin calificar o entre paréntesis para formar un puntero a la función miembro.  Como %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 #| msgid "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%>"
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ prohíbe tomar la dirección de una función miembro no estática sin calificar o entre paréntesis para formar un puntero a la función miembro.  Como %<&%T::%D%>"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ prohíbe tomar la dirección de una función miembro limitada para formar un puntero a la función miembro.  Como %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ prohíbe tomar la dirección de una función miembro limitada para formar un puntero a la función miembro.  Como %<&%T::%D%>"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(un puntero a miembro solamente se puede formar con %<&%E%>)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "se toma la dirección del temporal"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ prohíbe tomar la dirección de la función %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "no se puede crear un puntero al miembro referencia %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field %qD"
 msgid "attempt to take address of bit-field"
 msgstr "no se puede tomar la dirección del campo de bits %qD"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of expression of type %<void%>"
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "se toma la dirección de la expresión de tipo %<id%>"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ prohíbe incrementar un enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ prohíbe decrementar un enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "no se puede incrementar un puntero a un tipo incompleto %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "no se puede decrementar un puntero a un tipo incompleto %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ prohíbe incrementar un puntero de tipo %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ prohíbe decrementar un puntero de tipo %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, fuzzy, gcc-internal-format
 #| msgid "use of cast expressions as lvalues is deprecated"
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr "el uso de expresiones de conversión como l-valores es obsoleto"
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "no se puede tomar la dirección de %<this%> que es una expresión r-valuada"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "se solicitó la dirección de %qD, la cual se declaró como %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "el inicializador de lista para el tipo que no es clase no debe estar entre paréntesis"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "se trata la lista de expresiones como una expresión compuesta en en inicializador"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "se trata la lista de expresiones como una expresión compuesta en el inicializador de memoria"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "se trata la lista de expresiones como una expresión compuesta en la conversión funcional"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "se trata la lista de expresiones como una expresión compuesta %s"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "no hay contexto para resolver el tipo de %qE"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "la conversión del tipo %qT al tipo %qT proscribe los calificadores"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 #| msgid "static_cast from type %qT to type %qT casts away qualifiers"
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "static_cast del tipo %qT al tipo %qT proscribe los calificadores"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from type %qT to type %qT casts away qualifiers"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "reinterpret_cast del tipo %qT al tipo %qT proscribe los calificadores"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 #| msgid "%qT uses local type %qT"
 msgid "useless cast to type %q#T"
 msgstr "%qT usa el tipo local %qT"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "se descartan los calificadores de tipo en el tipo de devolución de la función"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "static_cast no válido del tipo %qT al tipo %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "class type %qT is incomplete"
 msgstr "el tipo de devolución %q#T es un tipo de dato incompleto"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "se convierte de %qT a %qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "conversión no válida de una expresión r-valuada de tipo %qT al tipo %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "la conversión de %qT a %qT pierde precisión"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 #| msgid "comparison between distinct pointer-to-member types %qT and %qT lacks a cast"
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "la comparación entre diferentes tipos de punteros-a-miembro %qT y %qT carece de una conversión"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "la conversión de %qT a %qT incrementa la alineación requerida del tipo del destino"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ prohíbe la conversión entre puntero a función y puntero a objeto"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "conversión no válida del tipo %qT al tipo %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "uso no válido de const_cast con tipo %qT, que no es puntero, referencia, ni un tipo puntero-a-datos-miembro"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "uso no válido de const_cast con tipo %qT, el cual es un puntero o referencia a un tipo de función"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "const_cast no válido de un valor-r de tipo %qT al tipo %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "const_cast no válido del tipo %qT al tipo %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ prohíbe la conversión a un tipo de matriz %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "conversión no válida al tipo de función %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "no se puede convertir %qE desde el tipo %qT al tipo %qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  en la evaluación de %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "se asigna a una matriz desde una lista de inicializador"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "tipos incompatible en la asignación de %qT a %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "se usó una matriz como inicializador"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "asignación de matriz no válida"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   en la conversión del puntero a función miembro"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "puntero a la conversión miembro a través de la base virtual %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   en la conversión del puntero a miembro"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "conversión no válida del tipo %qT a partir del tipo %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in default argument"
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "no se puede convertir %qT a %qT en el argumento por defecto"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in argument passing"
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "no se puede convertir %qT a %qT en el paso de argumentos"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in initialization"
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "no se puede convertir %qT a %qT en la inicialización"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in return"
 msgid "cannot convert %qH to %qI in return"
 msgstr "no se puede convertir %qT a %qT en la devolución"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in assignment"
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "no se puede convertir %qT a %qT en la asignación"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "el parámetro %qP de %qD puede ser un candidato para un atributo de formato"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "el parámetro puede ser un candidato para un atributo de formato"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "el objetivo de conversión puede ser un candidato para un atributo de formato"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "el objetivo de inicialización puede ser un candidato para un atributo de formato"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "el lado izquierdo de la asignación puede ser un candidato para un atributo de formato"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of %q+D"
 msgid "in passing argument %P of %qD"
 msgstr "al pasar el argumento %P de %q+D"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "se devuelve la referencia al temporal"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "se devuelve la referencia al temporal"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable %q+D returned"
 msgid "reference to local variable %qD returned"
 msgstr "se devolvió una referencia a la variable local %q+D"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of label %qD returned"
 msgstr "se devolvió la dirección de la variable local %q+D"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of local variable %qD returned"
 msgstr "se devolvió la dirección de la variable local %q+D"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "not enough values in return statement"
 msgid "redundant move in return statement"
 msgstr "faltan valores en la declaración de devolución"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "not enough values in return statement"
 msgid "redundant move in initialization"
 msgstr "faltan valores en la declaración de devolución"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "se devuelve un valor de un destructor"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "no se puede regresar de un manejador de una función-intenta-bloque de un constructor"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "se devuelve un valor de un constructor"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "declaración return sin valores, en una función que devuelve %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 #| msgid "<brace-enclosed initializer list>"
 msgid "returning initializer list"
 msgstr "<lista inicializador dentro de llaves>"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "se deducen los tipos inconsistentes %qT y %qT para el tipo de devolución lambda"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "deducción inconsistente para %qT: %qT y después %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with no value, in function returning %qT"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "declaración return sin valores, en una función que devuelve %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> no debe regresar NULL a menos que se declare %<throw()%> (o -fcheck-new esté en efecto)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for %q+#D"
 msgid "not eliding copy on return from %qD"
 msgstr "tipo de devolución covariante no válido para %q+#D"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "using temporary as lvalue"
 msgid "using rvalue as lvalue"
@@ -77512,19 +77694,19 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "unknown attribute %qs"
 msgstr "atributo de propiedad desconocido"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%+qD declared weak after being used"
 msgid "%q+D declared weak after being used"
 msgstr "%+qD se declaró débil después de usarse"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, fuzzy, gcc-internal-format
 #| msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<__simd__%> attribute"
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
@@ -77554,47 +77736,47 @@ msgstr "falta el inicializador para el campo %qD de %qT"
 msgid "the address of %qD will never be %<null%>"
 msgstr "la dirección de %qD nunca debe ser NULL"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "no se puede declarar el puntero a %q#T"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code."
 msgid "nested function missing body"
 msgstr "Almacena nombres de función en el código objeto."
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "Nested %s %s is %s; cannot be accessed from here"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "El %s %s anidado es %s; no se puede acceder desde aquí"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qs used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "se usó la variable de registro %qs en la función anidada"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "forming reference to reference type %qT"
 msgid "forward reference to frame of %qs"
@@ -77686,36 +77868,36 @@ msgstr "argumento %qs no válido para %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "argumento %qs no válido para %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can't open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "no se puede abrir %s para escritura: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "abriendo el fichero de salida %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for reading: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "no se puede abrir %s para escritura: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "abriendo el fichero de dependencias %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -77824,7 +78006,7 @@ msgstr "modelo TLS %qs desconocido"
 msgid "%qs is not an associative array"
 msgstr "%qD no es una variable puntero"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -77841,25 +78023,25 @@ msgstr "%qD generalmente es una función que no es static"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs no es un desplazamiento válido en %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from %q#D\n"
 msgid "recursive reference %qs"
 msgstr "se requiere recursivamente desde %q#D\n"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "non-constant expression for BIN"
 msgid "non-constant expression %qs"
 msgstr "expresión no constante para BIN"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not an expression"
 msgstr "%qE no es una expresión constante"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "type %qs is not an expression"
@@ -77965,18 +78147,18 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "no se admiten las funciones incluídas en línea de C99; se usa GNU89"
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "%<dynamic_cast%> not permitted with -fno-rtti"
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "no se permite %<dynamic_cast%> sin -fno-rtti"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -78325,8 +78507,8 @@ msgstr "La referencia a matriz en %C no puede tener más de %d dimensiones"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, fuzzy, gcc-internal-format
 #| msgid "Coarrays disabled at %C, use -fcoarray= to enable"
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
@@ -78629,7 +78811,7 @@ msgstr "La lista de nombres %s no se puede renombrar por asociación de USE a %s
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "'I' en %L y 'J' en %L no pueden ser constantes literal BOZ al mismo tiempo"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid suffix on integer constant"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -78719,7 +78901,7 @@ msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser REAL o COMPLEX"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser INTEGER o PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -78887,7 +79069,7 @@ msgstr "La declaración ENTRY en %C no puede aparecer dentro de un procedimiento
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "Los argumentos '%s' y '%s' del intrínseco '%s' en %L deben tener el mismo tipo"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different type kinds at %L"
@@ -78905,7 +79087,7 @@ msgstr "No se permite un puntero NULL en %L como un argumento de la función int
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser un POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
@@ -79065,8 +79247,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "El argumento STAT= en %L debe ser una variable INTEGER escalar"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, fuzzy, gcc-internal-format
 #| msgid "Coarrays disabled at %C, use -fcoarray= to enable"
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
@@ -79173,9 +79355,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un subprograma contenido"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' intrinsic with KIND argument at %L"
 msgid "%qs intrinsic with KIND argument at %L"
@@ -79193,13 +79375,13 @@ msgstr "el argumento '%s' del intrínseco '%s' en %L tiene una forma no válida
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe tener el rango %d o ser un escalar"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser numérico o LOGICAL"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 #| msgid "Argument types of '%s' intrinsic at %L must match (%s/%s)"
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
@@ -79308,703 +79490,703 @@ msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser una constante"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "El intrínseco '%s' en %L debe tener al menos dos argumentos"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 #| msgid "Missing argument to '%s' at %C"
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Faltan argumentos para '%s' en %C"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 #| msgid "arguments '%s' and '%s' for intrinsic %s"
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "argumentos '%s' y '%s' para el intrínseco %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 #| msgid "arguments '%s' and '%s' for intrinsic %s"
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "argumentos '%s' y '%s' para el intrínseco %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different character kinds at %L"
 msgstr "Extensión: Diferentes tipos de géneros en %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "El argumento 'a%d' del intrínseco '%s' en %L debe ser %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' intrinsic with CHARACTER argument at %L"
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "Fortran 2003: Intrínseco '%s' con argumento CHARACTER en %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "El argumento 'a1' del intrínseco '%s' en %L debe ser INTEGER, REAL o CHARACTER"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "El argumento 'a1' del intrínseco '%s' en %L debe ser INTEGER, REAL o CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 #| msgid "Different shape on dimension 1 for arguments '%s' and '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Formas diferentes en la dimensión 1 para los argumentos '%s' y '%s' en %L para el intrínseco matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 #| msgid "Different shape on dimension 2 for argument '%s' and dimension 1 for argument '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Formas diferentes en la dimensión 2 para el argumento '%s' y en la dimensión 1 para el argumento '%s' en %L para el intrínseco matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2"
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser de rango 1 o 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be conformable with '%s' argument"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser conformable con el argumento '%s'"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser INTEGER o REAL"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser INTEGER"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "El argumento '%s' del intrínseco '%s' en %L no debe ser coindizado"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "El argumento '%s' del intrínseco '%s' en %L no debe ser coindizado"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "Los argumentos TO en MOVE_ALLOC en %L deben ser polimórficos si FROM es polimórfico"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "Los argumentos '%s' y '%s' del intrínseco '%s' en %L deben tener el mismo rango %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "Los argumentos '%s' y '%s' del intrínseco '%s' en %L deben tener el mismo rango %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "Argument 'S' of NEAREST at %L shall not be zero"
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "El argumento 'S' de NEAREST en %L no puede ser cero"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser POINTER, ALLOCATABLE o un puntero a procedimiento"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: NULL intrinsic with allocatable MOLD at %L"
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "Fortran 2003: Intrínseco NULL con MOLD alojable en %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must have a type of either REAL or INTEGER"
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser de tipo REAL o INTEGER"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must provide at least as many elements as there are .TRUE. values in '%s' (%ld/%d)"
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe proveer por lo menos tantos elementos como valores .TRUE. presentes en '%s' (%ld/%d)"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser de una variable dummy"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser de una variable dummy OPTIONAL"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must not be a subobject of '%s'"
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "El argumento '%s' del intrínseco '%s' en %L no debe ser un subobjeto de '%s'"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "El argumento del intrínseco RANK en %L debe ser objeto de datos"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be polymorphic"
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "El argumento actual para '%s' en %L debe ser polimórfico"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "El argumento STAT= en %L debe ser una variable INTEGER escalar"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must be scalar"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "El argumento dummy de objeto pasado de '%s' en %L debe ser escalar"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "El argumento 'shape' del intrínseco 'reshape' en %L debe ser una matriz de tamaño constante"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L is empty"
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe estar vacío"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "El argumento 'shape' del intrínseco 'reshape' en %L tiene más de %d elementos"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L has negative element (%d)"
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "El argumento '%s' del intrínseco '%s' en %L tiene un elemento negativo (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L has wrong number of elements (%d/%d)"
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "El argumento '%s' del intrínseco '%s' en %L tiene el número erróneo de elementos (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L has out-of-range dimension (%d)"
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "el argumento '%s' del intrínseco '%s' en %L tiene una dimensión fuera de rango (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L has invalid permutation of dimensions (dimension '%d' duplicated)"
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "el argumento '%s' del intrínseco '%s' en %L tiene una permutación no válida de dimensiones (dimensión '%d' duplicada)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Sin relleno, no hay suficientes elementos en el intrínseco RESHAPE fuente en %L para coincidir con la forma"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of an extensible type"
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser un tipo extensible"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: SELECTED_REAL_KIND with neither 'P' nor 'R' argument at %L"
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "Fortran 2008: SELECTED_REAL_KIND sin un argumento 'P' ni 'R' en %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: '%s' intrinsic with RADIX argument at %L"
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "Fortran 2008: Intrínseco '%s' con argumento RADIX en %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "El argumento 'source' del intrínseco 'shape' en %L no debe ser una matriz de tamaño asumido"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L may not be a procedure"
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "El argumento '%s' del intrínseco '%s' en %L no puede ser un procedimiento"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "El argumento '%s' del intrínseco '%s' en %L no debe ser coindizado"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "El argumento 'source' del intrínseco 'shape' en %L no debe ser una matriz de tamaño asumido"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be an interoperable data entity"
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser una entidad de datos interoperables"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "el argumento %d de %qE debe ser un tipo puntero"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be polymorphic"
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "El argumento actual para '%s' en %L debe ser polimórfico"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "El objeto puntero en %C no debe tener un coíndice"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FIELD argument at %L of UNPACK must have the same rank as MASK or be a scalar"
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "El argumento FIELD en %L de UNPACK debe tener el mismo rango que MASK o ser un escalar"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be polymorphic"
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "El argumento actual para '%s' en %L debe ser polimórfico"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FIELD argument at %L of UNPACK must have the same rank as MASK or be a scalar"
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "El argumento FIELD en %L de UNPACK debe tener el mismo rango que MASK o ser un escalar"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FIELD argument at %L of UNPACK must have the same rank as MASK or be a scalar"
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "El argumento FIELD en %L de UNPACK debe tener el mismo rango que MASK o ser un escalar"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD is not a function template"
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "%qD no es una plantilla de función"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment to non-POINTER at %L"
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Asignación de puntero a un no-POINTER en %L"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "El objeto puntero en %C no debe tener un coíndice"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "El objeto puntero en %C no debe tener un coíndice"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L has no IMPLICIT type"
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "El resultado de la función '%s' en %L no es de tipo IMPLICIT"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "El procedimiento de operador de usuario '%s' en %L debe ser FUNCTION"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "El objeto puntero en %C no debe tener un coíndice"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be polymorphic"
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "El argumento actual para '%s' en %L debe ser polimórfico"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "El componente en %C debe tener el atributo POINTER"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument 'S' of NEAREST at %L shall not be zero"
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "El argumento 'S' de NEAREST en %L no puede ser cero"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be polymorphic"
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "El argumento actual para '%s' en %L debe ser polimórfico"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array section in '%s' call at %L"
 msgid "Array section at %L to C_LOC"
 msgstr "Sección de matriz en la llamada '%s' en %L"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "GNU extension: non double precision REAL argument to %s intrinsic at %L"
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "Extensión de GNU: argumento de precisión REAL que no es doble para el intrínseco %s en %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser menor que el rango %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "el argumento '%s' del intrínseco '%s' en %L no es un índice de dimensión válido"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be default real"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser real por defecto"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "El argumento %s para IMAGE_INDEX debe ser una matriz de rango uno en %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "El número de elementos de matriz del argumento SUB para IMAGE_INDEX en %L debe ser %d (corango) y no %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Demasiados argumentos para %s en %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, fuzzy, gcc-internal-format
 #| msgid "DIM argument without ARRAY argument not allowed for THIS_IMAGE intrinsic at %L"
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "No se permite el argumento DIM sin un argumento ARRAY para el intrínseco THIS_IMAGE en %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Demasiados argumentos para %s en %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "El argumento 'MOLD' del intrínseco 'TRANSFER' en %L no debe ser %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "El argumento 'MOLD' del intrínseco 'TRANSFER' en %L no debe ser %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 #| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "El argumento 'MOLD' del intrínseco 'TRANSFER' en %L no debe ser %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 #, fuzzy
 #| msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld"
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "El TRANSFER intrínseco en %L tiene un resultado parcialmente indefinido: tamaño de la fuente %ld < tamaño del resultado %ld"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must have the same rank as '%s' or be a scalar"
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser del mismo rango que '%s' o ser un escalar"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have identical shape."
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "Los argumentos '%s' y '%s' del intrínseco '%s' en %L deben tener forma idéntica."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "El argumento de ATANH en %L debe estar dentro del rango -1 a 1"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 #| msgid "Size of '%s' argument of '%s' intrinsic at %L too small (%i/%i)"
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "El tamaño del argumento '%s' del intrínseco '%s' en %L es demasiado pequeño (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Demasiados argumentos para %s en %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "número erróneo de argumentos de plantilla (%d, debe ser %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "arguments 1 and 2 have different types"
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "los argumentos 1 y 2 tienen tipos diferentes"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser de un género que no sea más ancho que el género por defecto (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "ATOM argument at %L of the %s intrinsic function shall be a coarray or coindexed"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "El argumento ATOM en %L de la función intrínseca %s debe ser una comatriz o coíndice"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser INTEGER o LOGICAL"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "Maximum extension level reached with type '%s' at %L"
 msgid "Maximum extension level reached with type %qs at %L"
@@ -80079,12 +80261,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "Se truncó la cadena de inicialización que inicia en %L para coincidir con la variable (%d%d)"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "El índice de inicio de la subcadena en %L es menor a uno"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "El índice de final de la subcadena en %L excede la longitud de la cadena"
@@ -80139,527 +80321,527 @@ msgstr "La variable '%s' en %C con un inicializador ya aparecía en una declarac
 msgid "Simplification error"
 msgstr "falló la gimplificación"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 #| msgid "Host associated variable '%s' may not be in the DATA statement at %C"
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "La variable asociada al anfitrión '%s' no debe estar en la declaración DATA en %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 #| msgid "Extension: initialization of common block variable '%s' in DATA statement at %C"
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Extensión: inicialización de la variable de bloque común '%s' en la declaración DATA en %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C"
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "El símbolo '%s' debe ser un PARAMETER en la declaración DATA en %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Inicializador %s no válido en la declaración Data en %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%<constexpr%> cannot appear in a typedef declaration"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%<constexpr%> no puede aparecer en una declaración typedef"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "No se permite la inicialización de %C en un procedimiento PURE"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un INTERFACE"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid initializer %s in Data statement at %C"
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Inicializador %s no válido en la declaración Data en %C"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un procedimiento contenido"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "No se permite la declaración DATA en %C en un procedimiento PURE"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Empty old style initializer list at %C"
 msgstr "Extensión: Inicialización de estilo antiguo en %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array component of structure at %C must have an explicit shape"
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "El componente de matriz de la estructura en %C debe tener una forma explícita"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "elementos extras en el inicializador escalar"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C must be an integer"
 msgid "Repeat spec must be an integer at %C"
 msgstr "El puntero Cray en %C debe ser un entero"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Se esperaba la etiqueta de devolución alterna en %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "End of scalar initializer expected at %C"
 msgstr "Se esperaba una expresión de inicialización escalar en %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "exceso de elementos en el inicializador de matriz"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "exceso de elementos en el inicializador de matriz"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in OpenMP variable list at %C"
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Error sintáctico en la lista de variables OpenMP en %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data target at %L shall not have a coindex"
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "El objetivo de datos en %L no puede tener un coíndice"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Especificación INTENT errónea en %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: deferred type parameter at %C"
 msgid "deferred type parameter at %C"
 msgstr "Fortran 2003: parámetro de tipo diferido en %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolescent feature: Old-style character length at %C"
 msgid "Old-style character length at %C"
 msgstr "Característica obsoleta: Longitud de carácter de estilo antiguo en %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Error sintáctico en la especificación de longitud de carácter en %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "El procedimiento '%s' en %C ya se había definido en %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "El procedimiento '%s' en %C ya se había definido en %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is already defined as a generic interface at %L"
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "El nombre '%s' en %C ya se definió como una interfaz genérica en %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "El procedimiento '%s' en %C tiene una interfaz explícita y no debe tener atributos declarados en %L"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L must have the BIND(C) attribute to be C interoperable"
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "El procedimiento '%s' en %L debe tener el atributo BIND(C) para que sea interoperable con C"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is a dummy argument to the BIND(C) procedure '%s' but is not C interoperable because derived type '%s' is not C interoperable"
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "La variable '%s' en %L es un argumento dummy del procedimiento BIND(C) '%s' pero no es interoperable con C porque el tipo derivado '%s' no es interoperable con C"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is a dummy argument to the BIND(C) procedure '%s' but is not C interoperable because it is polymorphic"
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "La variable '%s' en %L es un argumento dummy del procedimiento BIND(C) '%s' pero puede no ser interoperable con C porque es polimórfica"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is a parameter to the BIND(C) procedure '%s' but may not be C interoperable"
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "La variable '%s' en %L es un parámetro del procedimiento BIND(C) '%s' pero puede no ser interoperable con C"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the POINTER attribute because procedure '%s' is BIND(C)"
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "La variable '%s' en %L no puede tener el atributo POINTER porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "No se permite la variable dummy comatriz '%s' en %L en el procedimiento BIND(C) '%s'"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "El argumento de carácter '%s' en %L debe ser de longitud 1 porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "El argumento de carácter '%s' en %L debe ser de longitud 1 porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "El argumento de carácter '%s' en %L debe ser de longitud 1 porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "El argumento de carácter '%s' en %L debe ser de longitud 1 porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "El argumento de carácter '%s' en %L debe ser de longitud 1 porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, fuzzy, gcc-internal-format
 #| msgid "TS29113: Variable '%s' at %L with OPTIONAL attribute in procedure '%s' which is BIND(C)"
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "TS29113: La variable '%s' en %L con atributo OPTIONAL en el procedimiento '%s' que es BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, fuzzy, gcc-internal-format
 #| msgid "TS29113: Variable '%s' at %L with OPTIONAL attribute in procedure '%s' which is BIND(C)"
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "TS29113: La variable '%s' en %L con atributo OPTIONAL en el procedimiento '%s' que es BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the OPTIONAL and the VALUE attribute because procedure '%s' is BIND(C)"
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "La variable '%s' en %L no puede tener los atributos OPTIONAL y VALUE al mismo tiempo porque el procedimiento '%s' es BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, fuzzy, gcc-internal-format
 #| msgid "TS29113: Variable '%s' at %L with OPTIONAL attribute in procedure '%s' which is BIND(C)"
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "TS29113: La variable '%s' en %L con atributo OPTIONAL en el procedimiento '%s' que es BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed-shape array '%s' at %L cannot be an argument to the procedure '%s' at %L because the procedure is BIND(C)"
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "La matriz de forma asumida '%s' en %L no puede ser un argumento para el procedimiento '%s' en %L porque el procedimiento es BIND(C)"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L already has basic type of %s"
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "El símbolo '%s' en %L ya tenía el tipo básico de %s"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is BIND(C)"
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "La variable '%s' en el bloque común '%s' en %C se debe declarar con un género interoperable con C porque el bloque común '%s' es BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different CHARACTER lengths (%d/%d) in array constructor at %L"
 msgid "CHARACTER length must be a constant at %L"
 msgstr "Longitudes de CHARACTER diferentes (%d/%d) en el constructor de matriz en %L"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CHARACTER expression at %L is being truncated (%d/%d)"
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "Se trunca la expresión CHARACTER en %L (%d/%d)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The CHARACTER elements of the array constructor at %L must have the same length (%d/%d)"
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Los elementos CHARACTER del constructor de matriz en %L deben tener la misma longitud (%d/%d)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 #| msgid "Initializer not allowed for PARAMETER '%s' at %C"
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "No se permite un inicializador para el PARAMETER '%s' en %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "Falta un inicializador para el PARAMETER en %L"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C with an initializer already appears in a DATA statement"
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "La variable '%s' en %C con un inicializador ya aparecía en una declaración DATA"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't initialize implied-shape array at %L with scalar"
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "No se puede inicializar la matriz de tamaño implícito en %L con un escalar"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "El rango no coincide en la referencia de matriz en %L (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't initialize implied-shape array at %L with scalar"
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "No se puede inicializar la matriz de tamaño implícito en %L con un escalar"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Blank common initialized at %0"
 msgid "Bad shape of initializer at %L"
 msgstr "Común en blanco inicializado en %0"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "El dummy '%s' en %L no puede tener un inicializador"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "El límite inferior no es constante en la declaración de forma implícita en %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "'I' at %L and 'J' at %L cannot both be BOZ literal constants"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "'I' en %L y 'J' en %L no pueden ser constantes literal BOZ al mismo tiempo"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "El componente en %C debe tener el atributo POINTER"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' with CLASS at %L must be allocatable or pointer"
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "El componente '%s' con CLASS en %L debe ser allocatable o pointer"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "El componente de matriz de la estructura en %C debe tener una forma explícita o diferida"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "Component %qs at %C already declared at %L"
 msgstr "El componente '%s' en %C ya se había declarado en %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "El componente de matriz de puntero de la estructura en %C debe tener una forma diferida"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "El componente allocatable de la estructura en %C debe tener una forma diferida"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "El componente de matriz de la estructura en %C debe tener una forma explícita"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "una lista de parámetros con una elipsis no puede coincidir con una declaración de nombre de lista de parámetros vacía."
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "La inicialización NULL() en %C es ambigua"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NULL() initialization at %C is ambiguous"
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "La inicialización NULL() en %C es ambigua"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "No se permite la inicialización de un puntero en %C en un procedimiento PURE"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Error en la inicialización de puntero en %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: non-NULL pointer initialization at %C"
 msgid "non-NULL pointer initialization at %C"
 msgstr "Fortran 2008: inicialización de puntero que no es NULL en %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, fuzzy, gcc-internal-format
 #| msgid "RETURN not allowed outside PROC"
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "no se permite RETURN fuera de PROC"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is not a member of the '%s' structure"
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "'%s' en %C no es un miembro de la estructura '%s'"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "la función %qs no puede tener argumentos"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Carácter no válido en el nombre en %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 #| msgid "Non-PARAMETER symbol '%s' at %L can't be implied-shape"
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "El símbolo '%s' que no es PARAMETER en %L no puede ser de forma implícita"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: Implied-shape array at %L"
 msgid "Implied-shape array at %L"
 msgstr "Fortran 2008: Matriz de forma implícita en %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Not yet implemented: LCOBOUND for coarray with non-constant cobounds at %L"
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr "Aún sin implementar: LCOBOUND para una comatriz con colímites que no son constantes en %L"
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
@@ -80670,1063 +80852,1063 @@ msgstr "El dummy '%s' en %L no puede tener un inicializador"
 # como `apuntado'. cfuga
 # Referencia: http://gcc.gnu.org/onlinedocs/gfortran/Cray-pointers.html
 #
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Especificación de matriz duplicada para el apuntado Cray en %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set pointee array spec."
 msgstr "no se puede convertir a un tipo puntero"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Old-style initialization at %C"
 msgstr "Extensión: Inicialización de estilo antiguo en %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid value-initialization of reference type"
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "inicialización por valor no válida del tipo de referencia"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Error in pointer initialization at %C"
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Error en la inicialización de puntero en %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "La inicialización en %C no es para una variable puntero"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "La inicialización de puntero en %C requiere '=>', no '='"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Se esperaba una expresión de inicialización en %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "No se permite la inicialización de una variable en %C en un procedimiento PURE"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "No se permite la inicialización del componente allocatable en %C"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of allocatable component at %C is not allowed"
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "No se permite la inicialización del componente allocatable en %C"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Entity '%s' at %L has a deferred type parameter and requires either the pointer or allocatable attribute"
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr "La entidad '%s' en %L tiene un parámetro de tipo diferido y requiere el atributo pointer o allocatable"
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The pointer component '%s' of '%s' at %L is a type that has not been declared"
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "El componente puntero '%s' de '%s' en %L es de un tipo que no se ha declarado"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un procedimiento contenido"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "No se admite la declaración de tipo de estilo antiguo %s*%d en %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Declaración de tipo %s*%d no estándar en %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Falta el paréntesis derecho en %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Se esperaba una expresión de inicialización en %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Se esperaba una expresión de inicialización escalar en %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "No se admite el género %d para el tipo %s en %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "El parámetro de tipo de género C es para el tipo %s, pero el tipo en %L es %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Falta el paréntesis derecho o una coma en %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "No se admite el género %d para CHARACTER en %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Error sintáctico en la declaración CHARACTER en %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is not a member of the '%s' structure"
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "'%s' en %C no es un miembro de la estructura '%s'"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Interface-name expected after '(' at %C"
 msgid "Structure name expected after RECORD at %C"
 msgstr "Se esperaba un nombre de interfaz después de '(' en %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Kind type parameter for entity at %L differs from the kind type parameter of the typespec"
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "El parámetro de tipo de género para la entidad en %L difiere del parámetro de tipo de género de la especificación de tipo"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 #| msgid "the first parameter of %<operator new%> cannot have a default argument"
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "el primer parámetro de %<operator new%> no puede tener un argumento por defecto"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "La matriz '%s' en %L es una variable, lo cual no se reduce a una expresión constante"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parametrized derived type argument"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "argumento de tipo derivado parametrizado"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: BYTE type at %C"
 msgid "BYTE type at %C"
 msgstr "Extensión: tipo BYTE en %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "El tipo BYTE usado en %C no está disponible en la máquina objetivo"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L is not allowed in this context"
 msgid "Assumed type at %C is not allowed for components"
 msgstr "El argumento por valor en %L no se permite en este contexto"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: TYPE with intrinsic-type-spec at %C"
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "Fortran 2008: TYPE con especificación de tipo intrínseco en %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid type-spec at %C"
 msgid "Malformed type-spec at %C"
 msgstr "Especificación de tipo no válida en %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: DOUBLE COMPLEX at %C"
 msgid "DOUBLE COMPLEX at %C"
 msgstr "Extensión: DOUBLE COMPLEX en %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C is ambiguous"
 msgid "Type name %qs at %C is ambiguous"
 msgstr "El nombre de tipo '%s' en %C es ambiguo"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: CLASS statement at %C"
 msgid "CLASS statement at %C"
 msgstr "Fortran 2003: Declaración CLASS en %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C conflicts with previously declared entity at %L, which has the same name"
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "El nombre de tipo '%s' en %C tiene conflictos con la entidad declarada previamente en %L, la cual tiene el mismo nombre"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Declaración IMPLICIT NONE duplicada en %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate IMPLICIT NONE statement at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "Declaración IMPLICIT NONE duplicada en %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Falta el rango de carácter en IMPLICIT en %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Las letras debe estar en orden alfabético en la declaración IMPLICIT en %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE statement at %C follows blanket SAVE statement"
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "Declaración SAVE en %C después de una declaración SAVE incondicional"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Declaración IMPLICIT vacía en %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "La declaración IMPORT en %C sólo se permite en un cuerpo INTERFACE"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "La declaración IMPORT en %C sólo se permite en un cuerpo INTERFACE"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "IMPORT statement at %C"
 msgstr "Declaración IMPLICIT vacía en %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-name %qs at %C is in the local scope"
 msgstr "declaración de uso para un no miembro en el ámbito de la clase"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot IMPORT '%s' from host scoping unit at %C - does not exist."
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "No se puede IMPORTar '%s' desde la unidad de ámbito del anfitrión en %C - no existe."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is already IMPORTed from host scoping unit at %C."
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "'%s' ya se IMPORTó desde la unidad de ámbito del anfitrión en %C."
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Error sintáctico en la declaración IMPORT en %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "La declaración IMPORT en %C sólo se permite en un cuerpo INTERFACE"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "La declaración IMPORT en %C sólo se permite en un cuerpo INTERFACE"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Se espera la lista de entidades nombradas %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Falta la especificación de codimensión en %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Falta la especificación de dimensión en %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Atributo %s duplicado en %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Fortran 2003: atributo ALLOCATABLE en %C en una definición TYPE"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003: atributo ALLOCATABLE en %C en una definición TYPE"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Fortran 2003: Atributo %s en %L en una definición TYPE"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003: Atributo %s en %L en una definición TYPE"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL Iteration variable at %L must be INTEGER"
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "La variable de iteración FORALL en %L debe ser INTEGER"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Fortran 2003: atributo ALLOCATABLE en %C en una definición TYPE"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003: atributo ALLOCATABLE en %C en una definición TYPE"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL Iteration variable at %L must be INTEGER"
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "La variable de iteración FORALL en %L debe ser INTEGER"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "No se permite el atributo %L en una definición TYPE"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "No se permite el atributo %L en una definición TYPE"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Fortran 2003: Atributo %s en %L en una definición TYPE"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "No se permite el atributo %s en %L fuera de la parte de especificación de un módulo"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "No se permite el atributo %L en una definición TYPE"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ASYNCHRONOUS attribute at %C"
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "Fortran 2003: Atributo ASYNCHRONOUS en %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: CONTIGUOUS attribute at %C"
 msgid "CONTIGUOUS attribute at %C"
 msgstr "Fortran 2008: Atributo CONTIGUOUS en %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "Sólo se permite PROTECTED en %C en la parte de especificación de un módulo"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: PROTECTED attribute at %C"
 msgid "PROTECTED attribute at %C"
 msgstr "Fortran 2003: Atributo PROTECTED en %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VALUE attribute at %C"
 msgid "VALUE attribute at %C"
 msgstr "Fortran 2003: Atributo VALUE en %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VOLATILE attribute at %C"
 msgid "VOLATILE attribute at %C"
 msgstr "Fortran 2003: Atributo VOLATILE en %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Se proveen múltiples identificadores con un sólo especificador NAME= en %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, fuzzy, gcc-internal-format
 #| msgid "Implicitly declared BIND(C) function '%s' at %L may not be C interoperable"
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "La función implícitamente declarada BIND(C) '%s' en %L no puede ser interoperable con C"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' in common block '%s' at %L may not be a C interoperable kind though common block '%s' is BIND(C)"
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "La variable '%s' en el bloque común '%s' en %L no puede ser un género interoperable con C ya que el bloque común '%s' es BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, fuzzy, gcc-internal-format
 #| msgid "Type declaration '%s' at %L is not C interoperable but it is BIND(C)"
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "La declaración de tipo '%s' en %L no es interoperable con C pero es BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L may not be a C interoperable kind but it is bind(c)"
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "La variable '%s' en %L no es de un género interoperable con C pero es BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' in common block '%s' at %L cannot be declared with BIND(C) since it is not a global"
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "La variable '%s' en el bloque común '%s' en %L no se puede declarar con BIND(C) porque no es un global"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "La variable '%s' en %L no puede tener los atributos POINTER y BIND(C) al mismo tiempo"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "La variable '%s' en %L no puede tener los atributos ALLOCATABLE y BIND(C) al mismo tiempo"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 #| msgid "Return type of BIND(C) function '%s' at %L cannot be an array"
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "El tipo de devolución de la función BIND(C) '%s' en %L no puede ser una matriz"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "Return type of BIND(C) function '%s' at %L cannot be a character string"
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "El tipo de devolución de la función BIND(C) '%s' en %L no puede ser una cadena de caracteres"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is marked PRIVATE but has been given the binding label '%s'"
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "El símbolo '%s' en %L se marcó PRIVATE pero se le dio la etiqueta de asignación '%s'"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Se necesita una entidad o un nombre de bloque común para la declaración de especificación de atributo en %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Falta la entidad o el nombre de bloque común para la declaración de especificación de atributo en %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "Missing name"
 msgid "Missing symbol"
 msgstr "Falta el nombre"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "BIND(C) statement at %C"
 msgstr "Declaración IMPLICIT vacía en %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COMMON block '%s' at %L can not have the EXTERNAL attribute"
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "El bloque COMMON '%s' en %L no puede tener el atributo EXTERNAL"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "El tipo derivado en %C no se definió previamente y no puede aparecer en una definición de tipo derivado"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Error sintáctico en la declaración de datos en %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Error sintáctico en la declaración de datos en %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "MODULE PROCEDURE en %C debe estar en una interfaz genérica de módulo"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: IMPURE procedure at %C"
 msgid "IMPURE procedure at %C"
 msgstr "Fortran 2008: Procedimiento IMPURE en %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "No deben aparecer PURE con IMPURE en %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Left parenthesis required after %<*%>"
 msgid "A type parameter list is required at %C"
 msgstr "Se requiere paréntesis izquierdo después de %<*%>"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Alternate-return argument at %C"
 msgstr "Se esperaba la etiqueta de devolución alterna en %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Left parenthesis required after %<*%>"
 msgid "A parameter name is required at %C"
 msgstr "Se requiere paréntesis izquierdo después de %<*%>"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "El nombre '%s' en %C es el nombre del procedimiento"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Se esperaba otra dimensión en la declaración de matriz %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Basura inesperada en la lista de argumentos formales en %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate name '%s' in association at %C"
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Nombre '%s' duplicado en la asociación en %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Símbolo '%s' duplicado en la lista de argumentos formales en %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with SAVE attribute in '%s' at %L"
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "El atributo PROCEDURE genera un conflicto con el atributo SAVE en '%s' en %L"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "La variable RESULT en %C debe ser diferente que el nombre de la función"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Basura inesperada después de la declaración de la función en %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: BIND(C) attribute at %L may not be specified for an internal procedure"
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Fortran 2008: El atributo BIND(C) en %L no se puede especificar para un procedimiento internal"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "El atributo BIND(C) en %C requiere una interfaz con BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "El procedimiento BIND(C) con NAME no debe tener atributo POINTER en %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "El procedimiento dummy en %C no puede tener atributo BIND(C) con NAME"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L already has basic type of %s"
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "El procedimiento '%s' en %L ya tenía el tipo básico de %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Error sintáctico en la declaración PROCEDURE en %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '::' after binding-attributes at %C"
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Se esperaba '::' después de los atributos de enlazado en %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "Se requiere NOPASS o una interfaz explícita en %C"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Procedure pointer component at %C"
 msgid "Procedure pointer component at %C"
 msgstr "Fortran 2003: Procedimiento de componente puntero en %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Error sintáctico en el procedimiento de componente puntero en %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE en %C debe estar en una interfaz genérica"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: double colon in MODULE PROCEDURE statement at %L"
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "Fortran 2008: dos puntos dobles en la declaración MODULE PROCEDURE en %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: PROCEDURE statement at %C"
 msgid "PROCEDURE statement at %C"
 msgstr "Fortran 2003: Declaración PROCEDURE en %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Se esperaba una lista de argumentos formales en la definición de la función en %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "El atributo BIND(C) en %L sólo se puede usar para variables o bloques comunes"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "ENTRY statement at %C"
 msgstr "Declaración IMPLICIT vacía en %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un PROGRAM"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un MODULE"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un MODULE"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un BLOCK DATA"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un INTERFACE"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque SELECT"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque DERIVED TYPE"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque IF-THEN"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque DO"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque SELECT"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque FORALL"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un bloque WHERE"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un subprograma contenido"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Declaración END inesperada en %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un procedimiento contenido"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Faltan los paréntesis requeridos antes de BIND(C) en %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un procedimiento contenido"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Alternate return cannot appear in operator interface at %L"
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "No puede aparecer una devolución alternativa en la interfaz de operador en %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid C name in NAME= specifier at %C"
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Nombre C no válido en el especificador NAME= en %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Error sintáctico en el especificador NAME= para la etiqueta de asignación %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "El especificador ASYNCHRONOUS= en %L debe ser una expresión de inicialización"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Falta el paréntesis que cierra en la etiqueta de asignación en %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "No se permite un nombre de enlazado en BIND(C) en %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "Para el procedimiento dummy %s, no se permite un nombre de enlazado en BIND(C) en %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "No se permite NAME en BIND(C) para ABSTRACT INTERFACE en %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Declaración END inesperada en %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: END statement instead of %s statement at %L"
 msgid "END statement instead of %s statement at %L"
 msgstr "Fortran 2008: Declaración END en lugar de una declaración %s en %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "Se esperaba %s en la declaración en %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting %s statement at %L"
 msgstr "Se esperaba la declaración %s en %C"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Se esperaba el nombre de bloque de '%s' en la declaración %s en %C"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Se esperaba un nombre terminal en %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 #| msgid "Expected label '%s' for %s statement at %C"
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Se esperaba la etiqueta '%s' para la declaración %s en %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Falta la especificación de matriz en %L en la declaración DIMENSION"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dimensions specified for %s at %L after its initialisation"
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Se especificarion dimensiones para %s en %L después de su inicialización"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Falta la especificación de matriz en %L en la declaración CODIMENSION"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "La especificación de matriz se debe diferir en %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Carácter inesperado en la lista de variables en %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<(%> at %C"
 msgstr "Se esperaba '(' en %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "se esperaba un nombre variable en %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "El puntero Cray en %C debe ser un entero"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "El puntero Cray en %C tiene %d bytes de precisión; las direcciones de memoria requieren %d bytes"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Se esperaba \",\" en %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
@@ -81737,698 +81919,698 @@ msgstr "no se puede convertir a un tipo puntero"
 # como `apuntado'. cfuga
 # Referencia: http://gcc.gnu.org/onlinedocs/gfortran/Cray-pointers.html
 #
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Especificación de matriz duplicada para el apuntado Cray en %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Se esperaba \")\" en %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" or end of statement at %C"
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "Se esperaba \",\" o el final de la declaración en %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "No se permite INTENT dentro de BLOCK en %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "No se permite OPTIONAL dentro de BLOCK en %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer declaration at %C requires -fcray-pointer flag"
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "La declaración de punteros Cray en %C requiere la opción -fcray-pointer"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: CONTIGUOUS statement at %C"
 msgid "CONTIGUOUS statement at %C"
 msgstr "Fortran 2008: Declaración CONTIGUOUS en %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "La especificación de acceso del operador %s en %C ya se había especificado"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "La especificación de acceso del operador .%s. en %C ya se había especificado"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: PROTECTED statement at %C"
 msgid "PROTECTED statement at %C"
 msgstr "Fortran 2003: Declaración PROTECTED en %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Error sintáctico en la declaración PROTECTED en %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "Sólo se permite la declaración PRIVATE en %C en la parte de especificación de un módulo"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "Sólo se permite la declaración PRIVATE en %C en la parte de especificación de un módulo"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Se esperaba un nombre de variable en %C en la declaración PARAMETER"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Se esperaba un signo = en la declaración PARAMETER en %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Se esperaba una expresión en %C en la declaración PARAMETER"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Se inicializa una variable ya inicializada en %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Caracteres inesperados en la declaración PARAMETER en %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Se esperaba una variable en la declaración READ en %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in VOLATILE statement at %C"
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Error sintáctico en la declaración VOLATILE en %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Se esperaba una variable en la declaración READ en %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Error sintáctico en la declaración SAVE en %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Declaración SAVE incondicional en %C después de una declaración SAVE previa"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "Declaración SAVE en %C después de una declaración SAVE incondicional"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: COMMON block '%s' at %L that is also a function result"
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "Fortran 2003: El bloque COMMON '%s' en %L también es un resultado de función"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Error sintáctico en la declaración SAVE en %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "No se permite VALUE dentro de BLOCK en %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VALUE statement at %C"
 msgid "VALUE statement at %C"
 msgstr "Fortran 2003: Declaración VALUE en %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Error sintáctico en la declaración VALUE en %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VOLATILE statement at %C"
 msgid "VOLATILE statement at %C"
 msgstr "Fortran 2003: Declaración VOLATILE en %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, fuzzy, gcc-internal-format
 #| msgid "Specifying VOLATILE for coarray variable '%s' at %C, which is use-/host-associated"
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "Se especifica VOLATILE para la variable de comatriz '%s' en %C, la cual es asociada a uso/anfitrión"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Error sintáctico en la declaración VOLATILE en %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ASYNCHRONOUS statement at %C"
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Fortran 2003: Declaración ASYNCHRONOUS en %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Error sintáctico en la declaración ASYNCHRONOUS en %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after PROCEDURE declaration at %C"
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "Basura después de la declaración PROCEDURE en %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE en %C debe estar en una interfaz genérica de módulo"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "El procedimiento intrínseco en %L no puede ser un MODULE PROCEDURE"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Símbolo ambiguo en la definición TYPE en %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "El símbolo '%s' en %C ya se había asociado con el anfitrión"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in EXTENDS expression at %C is not a derived type"
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "'%s' en la expresión EXTENDS en %C no es un tipo derivado"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' cannot be extended at %C because it is BIND(C)"
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "'%s' no se puede extender en %C porque es BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' cannot be extended at %C because it is a SEQUENCE type"
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "'%s' no se puede extender en %C porque es un tipo SEQUENCE"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "El tipo derivado en %C sólo puede ser PRIVATE en la parte de especificación de un módulo"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "El tipo derivado en %C sólo puede ser PUBLIC en la parte de especificación de un módulo"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ABSTRACT type '%s' used at %L"
 msgid "ABSTRACT type at %C"
 msgstr "El tipo ABSTRACT '%s' se usa en %L"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate construct label '%s' at %C"
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Etiqueta construct '%s' duplicada en %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "La definición del tipo derivado de '%s' en %C ya se había definido"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after ASSOCIATE statement at %C"
 msgid "Junk after MAP statement at %C"
 msgstr "Basura después de la declaración ASSOCIATE en %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after ASSOCIATE statement at %C"
 msgid "Junk after UNION statement at %C"
 msgstr "Basura después de la declaración ASSOCIATE en %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is not a member of the '%s' structure"
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "'%s' en %C no es un miembro de la estructura '%s'"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing structure name for outer structure definition at %0"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Falta el nombre de la estructura para la definición de la estructura externa en %0"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after ASSOCIATE statement at %C"
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Basura después de la declaración ASSOCIATE en %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "El nombre de tipo '%s' en %C no puede ser el mismo que un tipo intrínseco"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Se esperaba :: en la definición TYPE en %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003:  CONTAINS block in derived type definition at %C"
 msgid "Mangled derived type definition at %C"
 msgstr "Fortran 2003: Bloque CONTAINS en una definición de tipo derivado en %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "El nombre de tipo '%s' en %C no puede ser el mismo que un tipo intrínseco"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "El nombre de tipo derivado '%s' en %C ya tiene un tipo básico de %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "El nombre de tipo derivado '%s' en %C ya tiene un tipo básico de %s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "El argumento dummy '%s' en %L no puede ser OPTIONAL"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "La definición del tipo derivado de '%s' en %C ya se había definido"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Error sintáctico en la declaración CHARACTER en %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "El Apuntado Cray en %C no puede ser una matriz de forma asumida"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ENUM and ENUMERATOR at %C"
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "Fortran 2003: ENUM y ENUMERATOR en %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "El enumerador excede el tipo entero de C en %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L no se inicializó con una expresión entera"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "Se esperaba una declaración de definición ENUM antes de %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Error sintáctico en la definición ENUMERATOR en %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Especificador de acceso duplicado en %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Los atributos de enlace ya especifican paso, NOPASS ilegal en %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Los atributos de enlace ya especifican paso, PASS ilegal en %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Atributo POINTER duplicado en %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "NON_OVERRIDABLE duplicado en %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "DEFERRED duplicado en %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Se esperaba un especificador de acceso en %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Se esperaba un atributo de enlace en %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NON_OVERRIDABLE and DEFERRED can't both appear at %C"
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "No pueden aparecer NON_OVERRIDABLE y DEFERRED al mismo tiempo en %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "Se requiere el atributo POINTER para el procedimiento de componente puntero en %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 #| msgid "Interface-name expected after '(' at %C"
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Se esperaba un nombre de interfaz después de '(' en %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 #| msgid "')' expected at %C"
 msgid "%<)%> expected at %C"
 msgstr "Se esperaba ')' en %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Se debe especificar una interfaz para el enlace DEFERRED en %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDURE(interface) en %C se debe declarar DEFERRED"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Se esperaba un nombre de enlace en %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: PROCEDURE list at %C"
 msgid "PROCEDURE list at %C"
 msgstr "Fortran 2008: Lista PROCEDURE en %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, fuzzy, gcc-internal-format
 #| msgid "'=> target' is invalid for DEFERRED binding at %C"
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "'=> objetivo' es no válido para el enlace DEFERRED en %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, fuzzy, gcc-internal-format
 #| msgid "'::' needed in PROCEDURE binding with explicit target at %C"
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "Se necesita '::' en el enlace PROCEDURE con objetivo explícito en %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 #| msgid "Expected binding target after '=>' at %C"
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Se esperaba un objetivo de enlace después de '=>' en %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, fuzzy, gcc-internal-format
 #| msgid "Type '%s' containing DEFERRED binding at %C is not ABSTRACT"
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "El tipo '%s' que contiene el enlace DEFERRED en %C no es ABSTRACT"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, fuzzy, gcc-internal-format
 #| msgid "There is already a procedure with binding name '%s' for the derived type '%s' at %C"
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Ya existe un procedimiento con nombre de enlazado '%s' para el tipo derivado '%s' en %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '::' at %C"
 msgid "Expected %<::%> at %C"
 msgstr "Se esperaba '::' en %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Se esperaba un nombre genérico o un descriptor de operador en %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Malformed GENERIC statement at %C"
 msgstr "Forma no válida de la declaración PROGRAM en %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '=>' at %C"
 msgid "Expected %<=>%> at %C"
 msgstr "Se esperaba '=>' en %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Shape specification at %L cannot be the null array"
 msgid "The access specification at %L not in a module"
 msgstr "La especificación de forma en %L no puede ser la matriz nula"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr "El nombre '%s' en %C es el nombre del procedimiento"
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a non-generic procedure with binding name '%s' for the derived type '%s' at %C"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Ya existe un procedimiento que no es genérico con el nombre de enlace '%s' para el tipo derivado '%s' en %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "La especificación de acceso del operador %s en %C ya se había especificado"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "La especificación de acceso del operador %s en %C ya se había especificado"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding '%s'"
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "El enlace en %C debe tener el mismo acceso que el enlace '%s' que ya está definido"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected module procedure name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Se esperaba un nombre de procedimiento de módulo en %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' already defined as specific binding for the generic '%s' at %C"
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "Ya se definió '%s' como un enlace específico para el genérico '%s' en %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after ASSOCIATE statement at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Basura después de la declaración ASSOCIATE en %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "GENERIC en %C debe estar dentro de un tipo derivado CONTAINS"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a non-generic procedure with binding name '%s' for the derived type '%s' at %C"
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Ya existe un procedimiento que no es genérico con el nombre de enlace '%s' para el tipo derivado '%s' en %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding '%s'"
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "El enlace en %C debe tener el mismo acceso que el enlace '%s' que ya está definido"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Se esperaba un nombre de enlace específico en %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' already defined as specific binding for the generic '%s' at %C"
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "Ya se definió '%s' como un enlace específico para el genérico '%s' en %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Basura después del enlace GENERIC en %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "La declaración FINAL en %C debe estar dentro de una sección de tipo derivado CONTAINS"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "La declaración de tipo derivado con FINAL en %C debe estar en la parte de especificación de un MODULE"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "FINAL vacío en %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Se esperaba un nombre de procedimiento de módulo en %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" at %C"
 msgid "Expected %<,%> at %C"
 msgstr "Se esperaba \",\" en %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown procedure name \"%s\" at %C"
 msgid "Unknown procedure name %qs at %C"
 msgstr "Nombre de procedimiento \"%s\" desconocido en %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is already defined as FINAL procedure!"
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "¡'%s' en %C ya se había definido como un procedimiento FINAL!"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Atributo desconocido en la declaración !GCC$ ATTRIBUTES en %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Error sintáctico en la declaración !GCC$ ATTRIBUTES en %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Error sintáctico en el iterador FORALL en %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Error sintáctico en el iterador FORALL en %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Error sintáctico en el iterador FORALL en %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -82583,453 +82765,453 @@ msgstr "Fortran 2008: Procedimiento IMPURE en %C"
 msgid "IM part_ref at %C"
 msgstr "Fortran 2008: Procedimiento IMPURE en %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "los argumentos de la función elemental en %C no cumplen"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Se requieren operandos numéricos o CHARACTER en la expresión en %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "El operador de concatenación en la expresión en %L debe tener dos operandos CHARACTER"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "El operador de concatenación en %L debe concatenar cadenas del mismo género"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "El operador .NOT. en la expresión en %L debe tener un operando LOGICAL"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "Se requieren operandos LOGICAL en la expresión en %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Sólo se pueden usar operandos intrínsecos en la expresión en %L"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Se requieren operandos numéricos en la expresión en %L"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid initialization expression for ALLOCATABLE component '%s' in structure constructor at %L"
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Expresión de inicialización no válida para el componente ALLOCATABLE '%s' en el constructor de estructura en %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed or deferred character length variable '%s'  in constant expression at %L"
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Se asume o difiere el carácter de longitud variable '%s' en la expresión constante en %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "no se permite el intrínseco transformacional '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Evaluation of nonstandard initialization expression at %L"
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Extensión: Evaluación de una expresión de inicialización no estándar en %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' in initialization expression at %L must be an intrinsic function"
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "La función '%s' en la expresión de inicialización en %L debe ser una funión intrínseca"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic function '%s' at %L is not permitted in an initialization expression"
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "No se permite la función intrínseco '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 #| msgid "PARAMETER '%s' is used at %L before its definition is complete"
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "Se usa el PARAMETER '%s' en %L antes de que su definición esté completa"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "No se permite la matriz de tamaño asumido '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "No se permite la matriz de forma asumida '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "No se permite la matriz de forma asumida '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "Deferred array '%s' at %L is not permitted in an initialization expression"
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "No se permite la matriz diferida '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "La matriz '%s' en %L es una variable, lo cual no se reduce a una expresión constante"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "No se permite la matriz de forma asumida '%s' en %L en una expresión de inicialización"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "El parámetro '%s' en %L no se ha declarado o es una variable, lo cual no se reduce a una expresión constante"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_init_expr(): Unknown expression type"
 msgstr "Se esperaba un tipo de expresión"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "La función de especificación '%s' en %L no puede ser una función de declaración"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be an internal function"
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "La función de especificación '%s' en %L no puede ser una función interna"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Specification function %qs at %L must be PURE"
 msgstr "La función de especificación '%s' en %L debe ser PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be RECURSIVE"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "La función de especificación '%s' en %L no puede ser RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' not allowed in expression at %L"
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "No se permite el argumento dummy '%s' en la expresión en %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "El argumento dummy '%s' en %L no puede ser OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "El argumento dummy '%s' en %L no puede ser INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "La variable '%s' no puede aparecer en la expresión en %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_restricted(): Unknown expression type"
 msgstr "Se esperaba un tipo de expresión"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L must be PURE"
 msgid "Function %qs at %L must be PURE"
 msgstr "La función '%s' en %L debe ser PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "La expresión en %L debe ser escalar"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Rangos incompatibles en %s (%d y %d) en %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Forma diferente para %s en %L en la dimensión %d (%d y %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "usando el parámetro de tipo plantilla %qT después de %qs"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Deferred-length character component '%s' at %L is not yet supported"
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "El componente de caractér de longitud diferida '%s' en %L aún no se admite"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a VALUE"
 msgid "%qs at %L is not a VALUE"
 msgstr "'%s' en %L no es un VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Tranco ilegal de cero en %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Rangos %d y %d incompatibles en la asignación en %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "El tipo de la variable es UNKNOWN en la asignación en %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL aparece en el lado derecho de una asignación en %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "POINTER valued function appears on right-hand side of assignment at %L"
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Una función valuada como POINTER aparece en el lado derecho de la asignación en %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Deferred-length character component '%s' at %L is not yet supported"
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "El componente de caractér de longitud diferida '%s' en %L aún no se admite"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Tipos incompatible en la declaración DATA en %L; se intentó la conversión de %s a %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "El objetivo de asignación de puntero no es un POINTER en %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "'%s' en la asignación de puntero en %L no puede ser un l-valor ya que es un procedimiento"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 #| msgid "Expected bounds specification for '%s' at %L"
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Se esperaba una especificación de límites para '%s' en %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: Bounds specification for '%s' in pointer assignment at %L"
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Fortran 2003: Especificación de límites para '%s' en una asignación de puntero en %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "El tranco no debe ser estar presente en %L"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "El objeto puntero en %L no debe tener un coíndice"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Asignación de puntero de procedimiento no válida en %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' is invalid in procedure pointer assignment at %L"
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "La función de declaración '%s' es no válida en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "La interfaz abstracta '%s' es no válida en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' is invalid in procedure pointer assignment at %L"
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "La función de declaración '%s' es no válida en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "El procedimiento interno '%s' es no válido en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "El procedimiento interno '%s' es no válido en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 #| msgid "Nonintrinsic elemental procedure '%s' is invalid in procedure pointer assigment at %L"
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "El procedimiento elemental que no es intrínseco '%s' es no válido en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "No hay coincidencia en la asignación de puntero a procedimiento en %L: no hay coincidencia en la convención a llamada"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 #| msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "No coincide la interfaz en la asignación de puntero a procedimiento en %L: %s"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 #| msgid "NOPASS or explicit interface required at %C"
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Se requiere NOPASS o una interfaz explícita en %C"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 #| msgid "NOPASS or explicit interface required at %C"
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Se requiere NOPASS o una interfaz explícita en %C"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "No coincide la interfaz en la asignación de puntero a procedimiento en %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "El objetivo de asignación de puntero no es un POINTER en %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Tipos diferentes en la asignación de puntero en %L; se intentó la asignación de %s a %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Parámetros de tipo de género diferentes en la asignación de puntero en %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Rangos diferentes en la asignación de puntero en %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "El objetivo de remapeo de rango es menor que el tamaño del puntero (%ld < %ld) en %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "El objetivo de remapeo de rango de debe ser de rango 1 o simplemente contiguo en %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: Rank remapping target is not rank 1 at %L"
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Fortran 2008: El objetivo de remapeo de rango no es rango 1 en %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data target at %L shall not have a coindex"
 msgid "The assumed rank data-target at %L must be contiguous"
@@ -83038,218 +83220,218 @@ msgstr "El objetivo de datos en %L no puede tener un coíndice"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "El objetivo de datos en %L no puede tener un coíndice"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "La expresión objetivo en la asignación de puntero en %L debe entregar un resultado puntero"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer initialization target at %C must have the TARGET attribute"
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "El objetivo de inicialización de puntero en %C debe tener el atributo TARGET"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "El especificador ASYNCHRONOUS= en %L debe ser una expresión de inicialización"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "El objetivo de asignación de puntero no es TARGET ni POINTER en %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Objetivo erróneo en la asignación de puntero en el procedimiento PURE en %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Asignación de puntero con subíndice vectorial del lado derecho en %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "El objetivo de asignación de puntero tiene atributo PROTECTED en %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "La expresión objetivo en la asignación de puntero en %L debe entregar un resultado puntero"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer initialization target at %L must not be ALLOCATABLE "
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "El objetivo de inicialización de puntero en %L no debe ser ALLOCATABLE"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer initialization target at %C must have the TARGET attribute"
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "El objetivo de inicialización de puntero en %C debe tener el atributo TARGET"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "El objetivo de inicialización de puntero en %L debe tener el atributo SAVE"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "El objetivo de inicialización de puntero a procedimiento en %L tal vez no es un puntero a procedimiento"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "El procedimiento interno '%s' es no válido en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "El procedimiento interno '%s' es no válido en la asignación de puntero de procedimiento en %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008: Funciones puntero en un contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Expresión que no es variable en el contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "Named constant '%s' in variable definition context (%s) at %L"
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "Constante nombrada '%s' en el contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in variable definition context (%s) at %L is not a variable"
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "'%s' en el contexto de definición variable (%s) en %L no es una variable"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Uno que no es POINTER en el contexto de asociación de puntero (%s) en %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Named constant '%s' in variable definition context (%s) at %L"
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "Constante nombrada '%s' en el contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE en el contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE en el contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "Named constant '%s' in variable definition context (%s) at %L"
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "Constante nombrada '%s' en el contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' with INTENT(IN) in pointer association context (%s) at %L"
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "Argumento dummy '%s' con INTENT(IN) en el contexto de asociación de puntero (%s) en %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' with INTENT(IN) in variable definition context (%s) at %L"
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "Argumento dummy '%s' con INTENT(IN) en el contexto de definición de variable (%s) en %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' is PROTECTED and can not appear in a pointer association context (%s) at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "La variable '%s' es PROTECTED y no puede aparecer en un contexto de asociación de puntero (%s) en %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' is PROTECTED and can not appear in a variable definition context (%s) at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "La variable '%s' es PROTECTED y no puede aparecer en un contexto de definición variable (%s) en %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' can not appear in a variable definition context (%s) at %L in PURE procedure"
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "La variable '%s' no puede aparecer en un contexto de definición variable (%s) en %L en el procedimiento PURE"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L associated to vector-indexed target can not be used in a variable definition context (%s)"
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "No se puede usar '%s' en %L asociado al objetivo con índice vectorial en un contexto de definición variable (%s)"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L associated to expression can not be used in a variable definition context (%s)"
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "No se puede usar '%s' en %L asociado a una expresión en un contexto de definición variable (%s)"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L associated to expression can not be used in a variable definition context (%s)"
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "No se puede usar '%s' en %L asociado a una expresión en un contexto de definición variable (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 #| msgid "Associate-name '%s' can not appear in a variable definition context (%s) at %L because its target at %L can not, either"
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "El nombre asociado '%s' no puede aparecer en un contexto de definición variable (%s) en %L porque su obtetivo en %L tampoco puede aparecer"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' at %L associated to expression can not be used in a variable definition context (%s)"
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
@@ -83273,7 +83455,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -83343,47 +83525,47 @@ msgstr "La variable '%s' en %C no se puede redefinir dentro del inicio de un buc
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "La variable '%s' en %C no se puede redefinir dentro del inicio de un bucle en %L"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "La referencia de matriz en %L está fuera de los límites (%ld < %ld) en la codimensión %d"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "La referencia de matriz en %L está fuera de los límites (%ld > %ld) en la codimensión %d"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "La variable '%s' en %C no se puede redefinir dentro del inicio de un bucle en %L"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "La variable '%s' en %C no se puede redefinir dentro del inicio de un bucle en %L"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%<continue%> must be in loop"
 msgid "Interchanging loops at %L"
 msgstr "%<continue%> debe estar dentro de un bucle"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "%s between %L and %L"
@@ -83517,12 +83699,12 @@ msgstr "El primer argumento de la asignación definida en %L debe ser INTENT(OUT
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "El segundo argumento de la asignación definida en %L debe ser INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "El primer argumento de la interfaz de operador en %L debe ser INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "El segundo argumento de la interfaz de operador en %L debe ser INTENT(IN)"
@@ -84018,357 +84200,363 @@ msgstr "El argumento actual para '%s' debe ser ALLOCATABLE en %L"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, fuzzy, gcc-internal-format
 #| msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument '%s'"
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "El argumento actual de sección de matriz con subíndices vectoriales en %L es incompatible con el atributo INTENT(OUT), INTENT(INOUT), VOLATILE o ASYNCHRONOUS del argumento dummy '%s'"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "El argumento actual de forma asumida en %L es incompatible con el argumento dummy de forma no asumida '%s' debido al atributo VOLATILE"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, fuzzy, gcc-internal-format
 #| msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "El argumento actual de sección de matriz en %L es incompatible con el argumento dummy de forma no asumida '%s' debido al atributo VOLATILE"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument '%s' due to VOLATILE attribute"
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "El argumento actual de matriz de puntero en %L requiere un argumento dummy de forma asumida o matriz de puntero '%s' debido al atributo VOLATILE"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "El argumento actual de forma asumida en %L es incompatible con el argumento dummy de forma no asumida '%s' debido al atributo VOLATILE"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Falta la especificación de devolución alternativa en la llamada a subrutina en %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 #| msgid "Missing actual argument for argument '%s' at %L"
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Falta el argumento actual para el argumento '%s' en %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, fuzzy, gcc-internal-format
 #| msgid "Same actual argument associated with INTENT(%s) argument '%s' and INTENT(%s) argument '%s' at %L"
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "El mismo argumento actual está asociado con el argumento INTENT(%s) '%s' y el argumento INTENT(%s) '%s' en %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "El argumento del procedimiento en %L es local a un procedimiento PURE y tiene el atributo POINTER"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "El argumento coindizado en %L en un procedimiento PURE se pasa a un argumento INTENT(%s)"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "El argumento actual coindizado en %L es un procedimiento PURE se pasa a un argumento dummy POINTER"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument '%s'"
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "El argumento actual polimórfico coindizado en %L se pasa al argumento dummy polimórfico '%s'"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called at %L is not explicitly declared"
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "El procedimiento '%s' que se llama en %L no tiene una interfaz explícita"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called at %L is not explicitly declared"
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "El procedimiento '%s' que se llama en %L no tiene una interfaz explícita"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Se llamó al procedimiento '%s' con una interfaz implícita en %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, fuzzy, gcc-internal-format
 #| msgid "The pointer object '%s' at %L must have an explicit function interface or be declared as array"
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "El objeto puntero '%s' en %L debe tener una interfaz de función explícita o declrararse como matriz"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, fuzzy, gcc-internal-format
 #| msgid "The allocatable object '%s' at %L must have an explicit function interface or be declared as array"
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "El objeto allocatable '%s' en %L debe tener una interfaz de función explícita o declararse como matriz"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable function '%s' at %L must have an explicit function interface"
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "La función allocatable '%s' en %L debe tener una interfaz de función explícita"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NOPASS or explicit interface required at %C"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Se requiere NOPASS o una interfaz explícita en %C"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "El argumento de palabra clave requiere una interfaz explícita para el procedimiento '%s' en %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "El símbolo '%s' en %L ya tenía una interfaz explícita"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure '%s'"
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "El argumento actual de LOCK_TYPE o con componente LOCK_TYPE en %L requiere una interfaz explícita para el procedimiento '%s'"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure '%s'"
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "El argumento actual de LOCK_TYPE o con componente LOCK_TYPE en %L requiere una interfaz explícita para el procedimiento '%s'"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "se requiere el argumento MOLD para NULL en %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "El símbolo '%s' en %L ya tenía una interfaz explícita"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "El argumento de palabra clave requiere una interfaz explícita para el procedimiento '%s' en %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer component '%s' called with an implicit interface at %L"
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Se llamó al procedimiento de componente puntero '%s' con una interfaz implícita en %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure pointer component '%s' at %L"
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "El argumento de palabra clave requiere una interfaz explícita para el procedimiento de componente puntero '%s' en %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "Se require MOLD= en un argumento NULL en %L: Ambigüedad entre las funciones específicas %s y %s "
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D aliased to undefined symbol %qE"
 msgid "Unable to find symbol %qs"
 msgstr "%q+D es un alias del símbolo sin definir %qE"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 #| msgid "Entity '%s' at %C is already present in the interface"
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "La entidad '%s' en %C ya está presente en la interfaz"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, fuzzy, gcc-internal-format
 #| msgid "internal error - too many interface type"
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "error interno - demasiados tipos de interfaz"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 #| msgid "Can't overwrite GENERIC '%s' at %L"
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "No se puede sobreescribir el GENERIC '%s' en %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "'%s' en %L sobreescribe un enlace de procedimiento declarad como NON_OVERRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "'%s' en %L no debe ser DEFERRED porque sobreescribe un enlazado que no es DEFERRED"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a PURE procedure and must also be PURE"
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "'%s' en %L sobreescribe un procedimiento PURE y también debe ser PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "'%s' en %L sobreescribe un procedimiento ELEMENTAL y también debe ser ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "'%s' en %L sobreeescribe un procedimiento que no es ELEMENTAL y tampoco debe ser ELEMENTAL"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "'%s' en %L sobreescribe una SUBROUTINE y también debe ser una SUBROUTINE"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a FUNCTION and must also be a FUNCTION"
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "'%s' en %L sobreescribe una FUNCTION y también debe ser una FUNCTION"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "Argument mismatch for the overriding procedure '%s' at %L: %s"
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "La interfaz no coincide en el procedimiento '%s' que sobreescribe en %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "'%s' en %L sobreescribe un procedimiento PUBLIC y no debe ser PRIVATE"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' of '%s' at %L should be named '%s' as to match the corresponding argument of the overridden procedure"
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "El argumento dummy '%s' de '%s' en %L se debe llamar '%s' para que coincida con el argumento correspondiente al procedimiento sobreescrito"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, fuzzy, gcc-internal-format
 #| msgid "Argument mismatch for the overriding procedure '%s' at %L: %s"
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "La interfaz no coincide en el procedimiento '%s' que sobreescribe en %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have the same number of formal arguments as the overridden procedure"
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "'%s' en %L debe tener el mismo nombre de argumentos formales que el procedimiento sobreeescrito"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a NOPASS binding and must also be NOPASS"
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "'%s' en %L sobreescribe un enlace NOPASS y también debe ser NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a binding with PASS and must also be PASS"
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "'%s' en %L sobreescribe un enlace con PASS y también debe ser PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, fuzzy, gcc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "El argumento dummy del objeto pasado de '%s' en %L debe estar en la misma posición que el argumento dummy del objeto pasado del procedimiento sobreescrito"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "La etiqueta %s en %L debe ser de tipo %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "El argumento dim en %L debe ser de tipo entero"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must be scalar"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "El argumento dummy de objeto pasado de '%s' en %L debe ser escalar"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "El argumento %s en %L debe ser de longitud uno"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Character-valued %s '%s' at %L must not be assumed length"
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "La función %s valuada con carácter '%s' en %L no debe tener longitud asumida"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "El argumento actual para '%s' debe ser un puntero en %L"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "No se permite la declaración DATA en %C en un procedimiento PURE"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL procedure '%s' at %L must have an explicit interface"
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "El procedimiento ELEMENTAL '%s' en %L debe tener una interfaz explícita"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to procedure `%s'"
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "faltan argumentos para el procedimiento `%s'"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to procedure `%s'"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -84585,7 +84773,7 @@ msgstr "Conversión de %s a %s en %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -85196,7 +85384,7 @@ msgstr "NAMELIST '%s' en la declaración READ en %L contiene el símbolo '%s' el
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "El objeto NAMELIST '%s' en la lista de nombres '%s' en %L es polimórfico y requiere un procedimiento de entrada/salida definido"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: NAMELIST object '%s' in namelist '%s' at %L with ALLOCATABLE or POINTER components"
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
@@ -85384,12 +85572,12 @@ msgstr "Desbordamiento entero"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -85948,7 +86136,7 @@ msgstr "El código STOP en %L debe ser un carácter por defecto KIND=%d"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "El código STOP en %L debe ser un entero por defecto KIND=%d"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -86521,98 +86709,98 @@ msgstr "Se esperaba el nombre de bloque '%s' de la construcción SELECT en %C"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "La declaración ENTRY en %C no puede aparecer dentro de un subprograma contenido"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in PROTECTED statement at %C"
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Error sintáctico en la declaración PROTECTED en %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "El selector en SELECT TYPE en %C no es una variable nombrada; use nombre-asociado =>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: LOCK statement at %C"
 msgid "SELECT RANK statement at %C"
 msgstr "Fortran 2008: Declaración LOCK en %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in PROTECTED statement at %C"
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Error sintáctico en la declaración PROTECTED en %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Declaración CASE inesperada en %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Error sintáctico en la especificación CASE en %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Declaración TYPE IS inesperada en %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Error sintáctico en la especificación TYPE IS en %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Error sintáctico en la especificación CLASS IS en %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "Declaración END inesperada en %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "La expresión de tranco FORALL en %L debe ser un %s escalar"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE specification at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "Error sintáctico en la especificación CASE en %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "La declaración ELSEWHERE en %C no está dentro de un bloque WHERE"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 #| msgid "Label '%s' at %C doesn't match WHERE label '%s'"
 msgid "Label %qs at %C doesn't match WHERE label %qs"
@@ -87692,7 +87880,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
@@ -87730,12 +87918,12 @@ msgstr "la cláusula %<linear%> no puede especificarse junto con la cláusula %<
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Basura inesperada después de la declaración $OMP FLUSH en %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -88262,7 +88450,7 @@ msgstr "Basura inesperada después de la cláusula NOWAIT en %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "La cláusula NUM_THREADS en %L requiere una expresión INTEGER escalar"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SIZE at %L must be positive"
 msgid "INTEGER expression of %s clause at %L must be positive"
@@ -88286,7 +88474,7 @@ msgstr "El puntero Cray '%s' en la cláusula %s en %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "El apuntado Cray '%s' en la cláusula %s en %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
@@ -88322,19 +88510,19 @@ msgstr "Matriz de tamaño asumido '%s' en la cláusula %s en %L"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "El objeto POINTER '%s' en la cláusula %s en %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "El puntero Cray '%s' en la cláusula %s en %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointee '%s' in %s clause at %L"
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "El apuntado Cray '%s' en la cláusula %s en %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "ALLOCATABLE object %qs in %s clause at %L"
@@ -88463,8 +88651,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "La cláusula IF en %L requiere una expresión LOGICAL escalar"
@@ -88551,7 +88739,7 @@ msgstr "El objeto '%s' no es una variable en %L"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' is not a variable at %L"
 msgid "Object %qs is not a variable at %L"
@@ -88577,7 +88765,7 @@ msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' present on multiple clauses at %L"
 msgid "Symbol %qs present on multiple clauses at %L"
@@ -88621,7 +88809,7 @@ msgstr "El símbolo '%s' está presente en múltiples cláusulas en %L"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE aparece más de una vez en las cláusulas de datos"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -88967,656 +89155,666 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 #| msgid "%s REDUCTION variable '%s' must be INTEGER at %L"
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "La variable REDUCTION %s '%s' debe ser INTEGER en %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "El argumento actual para '%s' debe ser un puntero en %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 #| msgid "FINAL clause at %L requires a scalar LOGICAL expression"
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "La cláusula FINAL en %L requiere una expresión LOGICAL escalar"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, fuzzy, gcc-internal-format
 #| msgid "FINAL clause at %L requires a scalar LOGICAL expression"
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "La cláusula FINAL en %L requiere una expresión LOGICAL escalar"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "el tipo de vector delete no es del tipo puntero ni matriz"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the value of %qD is not usable in a constant expression"
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "el valor de %qD no se puede usar en una expresión constante"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "El chunk_size de la cláusula SCHEDULE en %L requiere una expresión INTEGER escalar"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Rangos incompatibles en %s (%d y %d) en %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "SIZES requires constant expression at %L"
 msgstr "%qE no es una expresión constante"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "The event handle at %L must not be an array element"
 msgstr "El objeto puntero en %C no debe tener un coíndice"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "El objeto puntero en %C no debe tener un coíndice"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "la cláusula %<nowait%> no debe utilizarse junto con %<copyprivate%>"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Se esperaba una expresión de inicialización escalar en %C"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "La declaración !$OMP ATOMIC debe definir una variable escalar de tipo intrínseco en %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "La declaración !$OMP ATOMIC debe definir una variable escalar de tipo intrínseco en %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "La declaración !$OMP ATOMIC READ debe leer de una variable escalar de tipo intrínseco en %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr en la asignación !$OMP ATOMIC WRITE var =  expr debe ser escalar y no puede referenciar a var en %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "La declaración !$OMP ATOMIC debe definir una variable escalar de tipo intrínseco en %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC CAPTURE capture statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "La declaración de captura !$OMP ATOMIC CAPTURE debe definir una variable escalar de tipo intrínseco en %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "La declaración de captura !$OMP ATOMIC CAPTURE lee de una variable diferente a la que escribe la declaración de captura en %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, fuzzy, gcc-internal-format
 #| msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "La declaración de captura !$OMP ATOMIC CAPTURE lee de una variable diferente a la que escribe la declaración de captura en %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr en la asignación !$OMP ATOMIC WRITE var =  expr debe ser escalar y no puede referenciar a var en %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC assignment operator must be +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "El operador de la asignación !$OMP ATOMIC debe ser +, -, /, .AND., .OR., .EQV. ó .NEQV. en %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "El operador de la asignación !$OMP ATOMIC debe ser var = var op expr ó var = expr op var en %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP ATOMIC var = var op expr no es matemáticamente equivalente a var = var op (expr) en %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "expr en la asignación !$OMP ATOMIC var = var op expr debe ser escalar y no puede referenciar a var en %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "El intrínseco IAND, IOR ó IEOR de la asignación !$OMP ATOMIC debe tener dos argumentos en %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "El intrínseco de la asignación !$OMP ATOMIC debe ser MIN, MAX, IAND, IOR ó IEOR en %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, fuzzy, gcc-internal-format
 #| msgid "!$OMP ATOMIC intrinsic arguments except one must not reference '%s' at %L"
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "Los argumentos del intrínseco !$OMP ATOMIC, excepto uno, no deben referenciar a '%s' en %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "Los argumentos del intrínseco !$OMP ATOMIC deben ser escalares en %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, fuzzy, gcc-internal-format
 #| msgid "First or last !$OMP ATOMIC intrinsic argument must be '%s' at %L"
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "El primer o último argumentos del intrínseco !$OMP ATOMIC deben ser '%s' en %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "La asignación !$OMP ATOMIC debe tener un operador o intrínseco del lado derecho en %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after $OMP ATOMIC statement at %C"
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Basura inesperada después de la declaración $OMP ATOMIC en %C"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP DO no puede ser un DO WHILE ó DO sin control de bucle en %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "La variable de iteración !$OMP DO debe ser de tipo entero en %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must not be THREADPRIVATE at %L"
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "La variable de iteración !$OMP DO no puede ser THREADPRIVATE en %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "La variable de iteración !$OMP DO está presente en una cláusula diferente de PRIVATE o LASTPRIVATE en %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "La variable de iteración !$OMP DO está presente en una cláusula diferente de PRIVATE o LASTPRIVATE en %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "La variable de iteración !$OMP DO debe ser de tipo entero en %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Hiteration variable %qD should not be reduction"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "%Hla variable de iteración %qD no debe ser reduction"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad kind expression for function '%s' at %L"
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "Expresión de género errónea para la función '%s' en %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "condition expression refers to iteration variable %qD"
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "la expresión de la condición hace referencia a la variable de iteración %qD"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "not enough DO loops for collapsed !$OMP DO at %L"
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "no hay suficientes bucles DO para los !$OMP DO colapsados en %L"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "Los bucles !$OMP DO colapsados no están perfectamente anidados en %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "Los bucles !$OMP DO colapsados no están perfectamente anidados en %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "el argumento de collapse necesita una expresión entera constante positiva"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must be nonnegative"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "'%s' en %L debe ser no negativo"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be a logical expression at %L"
 msgstr "se esperaba una expresión entera"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be an integer expression at %L"
 msgstr "se esperaba una expresión entera"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be a constant logical expression at %L"
 msgstr "se esperaba una expresión entera"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be a constant integer expression at %L"
 msgstr "se esperaba una expresión entera"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be a conforming device number at %L"
 msgstr "se esperaba una expresión entera"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "A format cannot be specified with a namelist"
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr "No se puede especificar un formato con una lista de nombres"
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP DO no puede ser un DO WHILE ó DO sin control de bucle en %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "!$OMP DO no puede ser un DO WHILE ó DO sin control de bucle en %L"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "La variable de iteración !$OMP DO debe ser de tipo entero en %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO collapsed loops don't form rectangular iteration space at %L"
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "Los bucles !$OMP DO colapsados no forman un espacio de iteración rectangular en %L"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "Los bucles !$OMP DO colapsados no están perfectamente anidados en %L"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "not enough DO loops for collapsed !$OMP DO at %L"
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "no hay suficientes bucles DO para los !$OMP DO colapsados en %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "TILE requires constant expression at %L"
 msgstr "%qE no es una expresión constante"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' is not a variable at %L"
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "El objeto '%s' no es una variable en %L"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, fuzzy, gcc-internal-format
 #| msgid "action not allowed in SPEC MODULE"
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "no se pertite una acción en SPEC MODULE"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Error sintáctico en la declaración !GCC$ ATTRIBUTES en %C"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Error sintáctico en la declaración !GCC$ ATTRIBUTES en %C"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "se esperaba una expresión entera"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Se esperaba otra dimensión en la declaración de matriz %C"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -90346,69 +90544,69 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %C is already ambiguous"
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "El procedimiento contenido '%s' en %C ya es ambiguo"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Declaración %s inesperada en la sección CONTAINS en %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: CONTAINS statement without FUNCTION or SUBROUTINE statement at %C"
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Fortran 2008: Declaración CONTAINS sin una declaración FUNCTION o SUBROUTINE en %C"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORMAT statement at %L does not have a statement label"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "La declaración FORMAT en %L no tiene una etiqueta de declaración"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "La declaración CONTAINS en %C ya está contenida en una unidad de programa"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "El nombre global '%s' en %L ya se está usando como un %s en %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "El nombre global '%s' en %L ya se está usando como un %s en %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "El nombre global '%s' en %L ya se está usando como un %s en %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "El nombre global '%s' en %L ya se está usando como un %s en %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "BLOCK DATA en blanco en %C genera un conflicto con un BLOCK DATA previo en %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Declaración %s inesperada en BLOCK DATA en %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Declaración %s inesperada en MODULE en %C"
@@ -90416,7 +90614,7 @@ msgstr "Declaración %s inesperada en MODULE en %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Dos PROGRAMas principales en %L y %C"
@@ -90926,139 +91124,139 @@ msgstr "La variable '%s' en %C con un inicializador ya aparecía en una declarac
 msgid "%qs at %C is not a variable"
 msgstr "'%s' en %C no es una variable"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is of the ABSTRACT type '%s'"
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "'%s' en %L es del tipo ABSTRACT '%s'"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, fuzzy, gcc-internal-format
 #| msgid "ABSTRACT type '%s' used at %L"
 msgid "ABSTRACT type %qs used at %L"
 msgstr "El tipo ABSTRACT '%s' se usa en %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s', used by procedure '%s' at %L, is declared in a later PROCEDURE statement"
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "La interfaz '%s', usada por el procedimiento '%s' en %L, se declara en una declaración PROCEDURE posterior"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' at %C may not be generic"
 msgid "Interface %qs at %L may not be generic"
 msgstr "La interfaz '%s' en %C puede no ser generic"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' at %C may not be a statement function"
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "La interfaz '%s' en %C puede no ser una función de declaración"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic procedure '%s' not allowed in PROCEDURE statement at %C"
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "El procedimiento intrínseco '%s' no se permite en la declaración PROCEDURE en %C"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
 msgid "Interface %qs at %L must be explicit"
 msgstr "La interfaz '%s' del procedimiento '%s' en %L debe ser explícita"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE '%s' at %L may not be used as its own interface"
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROCEDURE '%s' en %L no se puede usar como su propia interfaz"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in elemental subroutine '%s' at %L is not allowed"
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "No se permite el especificador de devolución alternativa en la subrutina elemental '%s' en %L"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in function '%s' at %L is not allowed"
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "No se permite el especificador de devolución alternativa en la función '%s' en %L"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L is not allowed in this context"
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "El argumento por valor en %L no se permite en este contexto"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "El procedimiento de prueba '%s' del procedimiento PURE en %L también debe ser PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: Argument '%s' of pure function '%s' at %L with VALUE attribute but without INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Fortran 2008: El argumento '%s' de la función pure '%s' en %L debe tener el atributo VALUE pero sin INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN) or VALUE"
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "El argumento '%s' de la función pure '%s' en %L debe ser INTENT(IN) o VALUE"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: Argument '%s' of pure subroutine '%s' at %L with VALUE attribute but without INTENT"
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Fortran 2008: El argumento '%s' de la subrutina pure '%s' en %L debe tener atributo VALUE pero sin INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified or have the VALUE attribute"
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "El argumento '%s' de la subrutina pure '%s' en %L debe tener especificado su INTENT o tener el atributo VALUE"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' to '%s' at %L must not be polymorphic"
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "El parámetro '%s' para '%s' en %L no debe ser polimórfico"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray dummy argument '%s' at %L to elemental procedure"
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "El argumento dummy de comatriz '%s' en %L para un procedimiento elemental"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "El argumento '%s' del procedimiento elemental en %L debe ser escalar"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "El argumento '%s' del procedimiento elemental en %L no puede tener el atributo ALLOCATABLE"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "El argumento '%s' del procedimiento elemental en %L no puede tener el atributo POINTER"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' not allowed in elemental procedure '%s' at %L"
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "No se permite el procedimiento dummy '%s' en el procedimiento elemental '%s' en %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified or have the VALUE attribute"
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
@@ -91066,784 +91264,784 @@ msgstr "El argumento '%s' de la subrutina pure '%s' en %L debe tener especificad
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "El argumento '%s' de la función de declaración en %L debe ser escalar"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued argument '%s' of statement function at %L must have constant length"
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "El argumento con valor de carácter '%s' de la función de declaración en %L debe tener longitud constante"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "El procedimiento INTERFACE '%s' en %L tiene el mismo nombre que el procedimiento que lo incluye"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 #| msgid "Contained function '%s' at %L has no IMPLICIT type"
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "La función contenida '%s' en %L no es de tipo IMPLICIT"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 #| msgid "Result '%s' of contained function '%s' at %L has no IMPLICIT type"
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "El resultado '%s ' de la función contenida '%s' en %L no es de tipo IMPLICIT"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued %s '%s' at %L must not be assumed length"
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "La función %s valuada con carácter '%s' en %L no debe tener longitud asumida"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued %s '%s' at %L must not be assumed length"
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "La función %s valuada con carácter '%s' en %L no debe tener longitud asumida"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "El procedimiento %s en %L tiene entradas con especificaciones de matriz no coincidentes"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function %s at %L has entries with mismatched array specifications"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "El procedimiento %s en %L tiene entradas con especificaciones de matriz no coincidentes"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Function %s at %L with entries returning variables of different string lengths"
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "Extensión: La función %s en %L con entradas que devuelven variables de longitudes de cadena diferentes"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "El resultado de FUNCTION %s no puede ser una matriz en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "El resultado de ENTRY %s no puede ser una matriz en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "El resultado de FUNCTION %s no puede ser un POINTER en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "El resultado de ENTRY %s no puede ser un POINTER en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "El resultado de FUNCTION %s no puede ser un POINTER en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "El resultado de ENTRY %s no puede ser un POINTER en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "El resultado de FUNCTION %s no puede ser de tipo %s en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "El resultado de ENTRY %s no puede ser de tipo %s en FUNCTION %s en %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "El símbolo '%s' en %C ya está en un bloque COMMON"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "El símbolo '%s' en %C ya está en un bloque COMMON"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COMMON block /%s/ not found at %C"
 msgid "COMMON block at %L"
 msgstr "No se encontró el bloque COMMON /%s/ en %C"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "La variable '%s' en %L está en COMMON pero sólo se permite la inicialización en BLOCK DATA"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, fuzzy, gcc-internal-format
 #| msgid "Initialized variable '%s' at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "La variable inicializada '%s' en %L está en un COMMON vacío pero la inicialización sólo se permite en bloques common nombrados"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 #| msgid "Allocate-object at %L also appears at %L"
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "El objeto de alojamiento en %L también aparece en %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "La variable de tipo derivado '%s' en COMMON en %L no tiene el atributo SEQUENCE ni el atributo BIND(C)"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' in COMMON at %L has an ultimate component that is allocatable"
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "La variable de tipo derivado '%s' en COMMON en %L tiene un componente ultimate que es allocatable"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' in COMMON at %L may not have default initializer"
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "La variable de tipo derivado '%s' en COMMON en %L tal vez no tiene inicializador por defecto"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "El bloque COMMON '%s' en %L se usa como PARAMETER en %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, fuzzy, gcc-internal-format
 #| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "La etiqueta enlazante '%s' en %L colisiona con la entidad global '%s' en %L"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "El bloque COMMON '%s' en %L se usa como PARAMETER en %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L can not have the EXTERNAL attribute"
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "El bloque COMMON '%s' en %L no puede tener el atributo EXTERNAL"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is also an intrinsic procedure"
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "El bloque COMMON '%s' en %L también es un procedimiento intrínseco"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: COMMON block '%s' at %L that is also a function result"
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "Fortran 2003: El bloque COMMON '%s' en %L también es un resultado de función"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: COMMON block '%s' at %L that is also a global procedure"
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "Fortran 2003: El bloque COMMON '%s' en %L también es un procedimiento global"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "El rango del elemento en el constructor de estructura en %L no coincide con el del componente (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the structure constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "El elemento en el constructor de estructura en %L, para el componente puntero '%s', es %s pero debería ser %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "Unequal character lengths (%ld/%ld) in %s at %L"
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Longitudes de caracteres desiguales (%ld/%ld) en %s en %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, fuzzy, gcc-internal-format
 #| msgid "The NULL in the structure constructor at %L is being applied to component '%s', which is neither a POINTER nor ALLOCATABLE"
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "El NULL en el constructor de estructura en %L se aplica para el componente '%s', el cual no es ni POINTER ni ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 #| msgid "Interface mismatch for procedure-pointer component '%s' in structure constructor at %L: %s"
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "No coincide la interfaz en el componente puntero-a-procedimiento '%s' en el constructor de estructura en %L: %s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %L!"
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "¡Demasiados componentes en el constructor de estructura en %L!"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 #| msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "El rango del elemento en el constructor de estructura en %L no coincide con el del componente (%d/%d)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the structure constructor at %L, for pointer component '%s' should be a POINTER or a TARGET"
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "El elemento en el constructor de estructura en %L, para el componente puntero '%s', debe ser un POINTER o un TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Asignación de puntero con subíndice vectorial del lado derecho en %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid expression in the structure constructor for pointer component '%s' at %L in PURE procedure"
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Expresión no válida en el constructor de estructura para el componente puntero '%s' en %L en el procedimiento PURE"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, fuzzy, gcc-internal-format
 #| msgid "The upper bound in the last dimension must appear in the reference to the assumed size array '%s' at %L"
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "El límite superior en la última dimensión debe aparecer en la referencia a la matriz de tamaño asumido '%s' en %L"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is ambiguous"
 msgid "%qs at %L is ambiguous"
 msgstr "'%s' en %L es ambiguo"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "El procedimiento GENERIC '%s' no se permite como un argumento actual en %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 #| msgid "Type specified for intrinsic function '%s' at %L is ignored"
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Se descarta el tipo para la función intrínseca '%s' en %L"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic subroutine '%s' at %L shall not have a type specifier"
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "La subrutina intrínseca '%s' en %L no debe tener un especificador de tipo"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' declared INTRINSIC at %L does not exist"
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "No existe '%s' declarado como INTRINSIC en %L"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, fuzzy, gcc-internal-format
 #| msgid "The intrinsic '%s' declared INTRINSIC at %L is not available in the current standard settings but %s.  Use an appropriate -std=* option or enable -fall-intrinsics in order to use it."
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "El intrínseco '%s' declarado como INTRINSIC en %L no está disponible en la configuración actual de estándares pero %s.  Use una opción -std=* apropiada o active -fall-intrinsics para poder usarlo."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, fuzzy, gcc-internal-format
 #| msgid "Non-RECURSIVE procedure '%s' at %L is possibly calling itself recursively.  Declare it RECURSIVE or use -frecursive"
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "El procedimiento que no es RECURSIVE '%s' en %L posiblemente se está llamando a sí mismo recursivamente. Declárelo RECURSIVE o utilice -frecursive"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, fuzzy, gcc-internal-format
 #| msgid "Non-RECURSIVE procedure '%s' at %L is possibly calling itself recursively.  Declare it RECURSIVE or use -frecursive"
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "El procedimiento que no es RECURSIVE '%s' en %L posiblemente se está llamando a sí mismo recursivamente. Declárelo RECURSIVE o utilice -frecursive"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "La etiqueta %d referenciada en %L nunca se define"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: Internal procedure '%s' is used as actual argument at %L"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Fortran 2008: Se usa el procedimiento interno '%s' como un argumento actual en %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "La función de declaración '%s' en %L no se permite como un argumento actual"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not allowed as an actual argument"
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "El intrínseco '%s' en %L no se permite como un argumento actual"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: Internal procedure '%s' is used as actual argument at %L"
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Fortran 2008: Se usa el procedimiento interno '%s' como un argumento actual en %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "El procedimiento ELEMENTAL que no es INTRINSIC '%s' no se permite como un argumento actual en %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to find a specific INTRINSIC procedure for the reference '%s' at %L"
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "No se puede encontrar un procedimiento INTRINSIC específico para la referencia '%s' en %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "El símbolo '%s' en %L es ambiguo"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "El argumento por valor en %L no es de tipo numérico"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "El argumento por valor en %L no puede ser una matriz o una sección de matriz"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "El argumento por valor en %L no se permite en este contexto"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "No se permite el paso del procedimiento interno en %L por ubicación"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "El procedimiento ELEMENTAL que no es INTRINSIC '%s' no se permite como un argumento actual en %L"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Argumento actual coindizado en %L con componente puntero último"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L with assumed-shape dummy argument '%s' must have an explicit interface"
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "El procedimiento '%s' en %L con argumento dummy de forma asumida '%s' debe tener una interfaz explícita"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (12.4.1.5)"
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "'%s' en %L es una matriz y OPTIONAL; SI FALTA, no puede ser el argumento actual de un procedimiento ELEMENTAL a menos que exista un argumento que no sea opcional con el mismo rango (12.4.1.5)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument at %L for INTENT(%s) dummy '%s' of ELEMENTAL subroutine '%s' is a scalar, but another actual argument is an array"
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "El argumento actual en %L para el dummy INTENT(%s) '%s' de la subrutina ELEMENTAL '%s' es un escalar, pero otro argumento actual es una matriz"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 #| msgid "Return type mismatch of function '%s' at %L (%s/%s)"
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "No coincide el tiop de devolución de la función '%s' en %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 #| msgid "Interface mismatch in dummy procedure '%s' at %L: %s"
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "La interfaz no coincide en el procedimiento dummy '%s' en %L: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific function for the generic '%s' at %L"
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "No hay una función específica para el genérico '%s' en %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 #| msgid "Generic function '%s' at %L is not consistent with a specific intrinsic interface"
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "La función genérica '%s' en %L no es consistente con una interfaz intrínseca específica"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "La función '%s' en %L es INTRINSIC pero no es compatible con un intrínseco"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "No se puede resolver la función específica '%s' en %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "La función '%s' en %L no es de tipo IMPLICIT"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "La función '%s' en %L no es de tipo IMPLICIT"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Reference to non-PURE function '%s' at %L inside a DO CONCURRENT %s"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "La referencia a la función '%s' que no es PURE en %L está dentro de un DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 #| msgid "Reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "La referencia a la función '%s' que no es PURE en %L está dentro de un FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, fuzzy, gcc-internal-format
 #| msgid "Reference to non-PURE function '%s' at %L inside a DO CONCURRENT %s"
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "La referencia a la función '%s' que no es PURE en %L está dentro de un DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "La referencia a la función '%s' que no es PURE en %L está dentro de un FORALL %s"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after NOWAIT clause at %C"
 msgid "Unexpected junk after %qs at %L"
 msgstr "Basura inesperada después de la cláusula NOWAIT en %C"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "%qs at %L is not a function"
 msgstr "'%s' en %L no es una función"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, fuzzy, gcc-internal-format
 #| msgid "ABSTRACT INTERFACE '%s' must not be referenced at %L"
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "La ABSTRACT INTERFACE '%s' no se debe referenciar en %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "La función '%s' se declara CHARACTER(*) y no se puede usar en %L ya que no es un argumento de prueba"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Faltan la lista de argumentos en la función '%s' en %C"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 #| msgid "<unresolved overloaded function type>"
 msgid "resolve_function(): bad function type"
 msgstr "<tipo de función sobrecargada sin resolver>"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, fuzzy, gcc-internal-format
 #| msgid "User defined non-ELEMENTAL function '%s' at %L not allowed in WORKSHARE construct"
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "La función definida por el usuario '%s' que no es ELEMENTAL en %L no se permite en la construcción WORKSHARE"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L cannot be called recursively, as function '%s' is not RECURSIVE"
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "ENTRY '%s' en %L no se puede llamar recursivamente, porque la función '%s' no es RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot be called recursively, as it is not RECURSIVE"
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "La función '%s' en %L no se puede llamar recursivamente, porque no es RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "builtin %qF is deprecated."
 msgid "Using function %qs at %L is deprecated"
 msgstr "la interna %qF es obsoleta."
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "No se permite el procedimiento de prueba en %L en un procedimiento ELEMENTAL"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Subroutine call to '%s' in DO CONCURRENT block at %L is not PURE"
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "La llamada a subrutina a '%s' en el bloque DO CONCURRENT en %L no es PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "La llamada a subrutina a '%s' en el bloque FORALL en %L no es PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in DO CONCURRENT block at %L is not PURE"
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "La llamada a subrutina a '%s' en el bloque DO CONCURRENT en %L no es PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' at %L is not PURE"
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "La llamada a subrutina a '%s' en %L no es PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific subroutine for the generic '%s' at %L"
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "No hay una subrutina específica para el genérico '%s' en %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "Generic subroutine '%s' at %L is not consistent with an intrinsic subroutine interface"
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "La subrutina genérica '%s' en %L no es consistente con una interfaz de subrutina intrínseca"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "La subrutina '%s' en %L es INTRINSIC pero no es compatible con un intrínseco"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific subroutine '%s' at %L"
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "No se puede resolver la subrutina específica '%s' en %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "'%s' en %L tiene un tipo, el cual no es consistente con CALL en %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L cannot be called recursively, as subroutine '%s' is not RECURSIVE"
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "ENTRY '%s' en %L no se puede llamar recursivamente, porque la subrutina '%s' no es RECURSIVE"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 #| msgid "SUBROUTINE '%s' at %L cannot be called recursively, as it is not RECURSIVE"
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "SUBROUTINE '%s' en %L no se puede llamar recursivamente, porque no es RECURSIVE"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 #| msgid "<unresolved overloaded function type>"
 msgid "resolve_subroutine(): bad function type"
 msgstr "<tipo de función sobrecargada sin resolver>"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 #| msgid "builtin %qF is deprecated."
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "la interna %qF es obsoleta."
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Las formas para los operandos en %L y %L no son conformables"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "La función CHARACTER(*) '%s' en %L no puede ser puntero-valuada"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "always_inline function might not be inlinable"
 msgid "Impure function at %L might not be evaluated"
 msgstr "una función always_inline tal vez no se puede incluir en línea"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "El argumento por valor en %L no puede ser una matriz o una sección de matriz"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "la comparación de una expresión unsigned >= 0 siempre es verdadera"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Contexto no válido para el puntero NULL() en %%L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "El operando del operador numérico unitario %%<%s%%> en %%L es %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Los operandos del operador numérico binario %%<%s%%> en %%L son %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Rangos inconsistentes para el operador en %%L y %%L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected derived-type entities in binary intrinsic numeric operator %%<%s%%> at %%L"
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "Entidades de tipos derivados no esperadas en el operador numérico intrínseco binario %%<%s%%> en %%L"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Los operandos del operador de concatenación de cadenas en %%L son %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Los operandos del operador lógico %%<%s%%> en %%L son %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .not. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "El operando del operador .not. en %%L es %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "Las cantidades COMPLEX no se pueden comparar en %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "El argumento por valor en %L no puede ser una matriz o una sección de matriz"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
@@ -91851,7 +92049,7 @@ msgstr "Rangos inconsistentes para el operador en %%L y %%L"
 
 # 'kind' es el tipo del tipo de dato en Fortran. Lo traduzco como 
 # 'género', para evitar confusión con 'type' = 'tipo'. cfuga
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
@@ -91859,309 +92057,309 @@ msgstr "Género no válido para %s en %L"
 
 # 'kind' es el tipo del tipo de dato en Fortran. Lo traduzco como 
 # 'género', para evitar confusión con 'type' = 'tipo'. cfuga
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "Género no válido para %s en %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Los lógicos en %%L se deben comparar con %s en lugar de %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Los operandos del operador de comparación %%<%s%%> en %%L son %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator %%<%s%%> at %%L; did you mean '%s'?"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "Operador %%<%s%%> desconocido en %%L; ¿quiso decir '%s'?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator %%<%s%%> at %%L"
 msgid "Unknown operator %qs at %L"
 msgstr "Operador %%<%s%%> desconocido en %%L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator %%<%s%%> at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "El operando del operador de usuario %%<%s%%>  en %%L es %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Los operandos del operador de usuario %%<%s%%> en %%L son %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Coindex of codimension %d must be a scalar at %L"
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "El coíndice en la codimensión %d debe ser un escalar en %L"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must have the same declared type"
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "El argumento actual para '%s' en %L debe tener el mismo tipo declarado"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "El objeto de alojamiento en %L y la expresión fuente en %L deben tener el mismo parámetro de tipo de género"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "La expresión fuente en %L y el objeto de alojamiento en %L deben tener la misma forma"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "La referencia de matriz en %L está fuera de los límites (%ld < %ld) en la dimensión %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "La referencia de matriz en %L está fuera de los límites (%ld < %ld) en la codimensión %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "La referencia de matriz en %L está fuera de los límites (%ld > %ld) en la dimensión %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "La referencia de matriz en %L está fuera de los límites (%ld > %ld) en la codimensión %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Tranco ilegal de cero en %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "La referencia de matriz inferior en %L está fuera de los límites (%ld < %ld) en la dimensión %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "La referencia de matriz inferior en %L está fuera de los límites (%ld > %ld) en la dimensión %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "La referencia de matriz superior en %L está fuera de los límites (%ld < %ld) en la dimensión %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "La referencia de matriz superior en %L está fuera de los límites (%ld > %ld) en la dimensión %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "falta el subíndice en la referencia de la matriz"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "No se especificó el límite superior a la derecha de la sección de matriz de tamaño asumido en %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "El rango no coincide en la referencia de matriz en %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "El rango de coíndice no coincide en la referencia de matriz en %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "El coíndice en la codimensión %d debe ser un escalar en %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "El índice de matriz en %L debe ser escalar"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "El índice de matriz en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: REAL array index at %L"
 msgid "REAL array index at %L"
 msgstr "Extensión: índice de matriz REAL en %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "El argumento dim en %L debe ser escalar"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "El argumento dim en %L debe ser de tipo entero"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid array initializer for non-array type %qs"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Inicializador de matriz no válido para el tipo %qs que no es matriz"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "El índice de matriz en %L es una matriz de rango %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "El argumento dim en %L debe ser escalar"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "El argumento dim en %L debe ser escalar"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "El argumento dim en %L debe ser escalar"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "La expresión en %L debe ser escalar"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "El índice de inicio de la subcadena en %L debe ser de tipo INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "El índice de inicio de la subcadena en %L debe ser escalar"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "El índice de final de la subcadena en %L debe ser de tipo INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "El índice de final de la subcadena en %L debe ser escalar"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "El índice de final de la subcadena en %L es demasiado grande"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "resolve_ref(): Bad array reference"
 msgstr "Referencia de matriz errónea en %L"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "El componente a la derecha de una referencia de parte con rango que no es cero no debe tener el atributo POINTER en %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "El componente a la derecha de una referencia de parte con rango que no es cero no debe tener el atributo ALLOCATABLE en %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "No se deben especificar dos o más referencias de parte con rango que no es cero en %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "Illegal coarray index"
 msgstr "operando ilegal"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
@@ -92171,12 +92369,12 @@ msgstr "La matriz de forma asumida en %L debe ser un argumento de prueba"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
@@ -92186,448 +92384,448 @@ msgstr "La matriz de forma asumida en %L debe ser un argumento de prueba"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure '%s' at %L with BIND(C) attribute must have an explicit interface"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "El procedimiento '%s' en %L con atributo BIND(C) debe tener una interfaz explícita"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape"
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "La variable de comatriz '%s' en %L no debe tener codimensiones con forma diferida"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape"
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "La variable de comatriz '%s' en %L no debe tener codimensiones con forma diferida"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of references"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "se crea la matriz de referencias"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s', used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "La variable '%s', usada en una expresión de especificación, se referencía en %L antes de la declaración ENTRY en la cual es un parámetro"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' is used at %L before the ENTRY statement in which it is a parameter"
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "La variable '%s' se usa en %L antes de la declaración ENTRY en la cual es un parámetro"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Subobjecto polimórfico de un objeto coindizado en %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Objeto coindizado con subcomponente alojable polimórfico en %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%qs es obsoleto"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "Referencia de matriz errónea en %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Error in type-spec at %L"
 msgid "Error in typebound call at %L"
 msgstr "Error en la especificación de tipo en %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "El objeto pasado en %L debe ser escalar"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, fuzzy, gcc-internal-format
 #| msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type '%s'"
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "El objeto base para la llamada a componente procedimiento-puntero en %L es de tipo ABSTRACT '%s'"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, fuzzy, gcc-internal-format
 #| msgid "Base object for type-bound procedure call at %L is of ABSTRACT type '%s'"
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "El objeto base para la llamada a procedimiento enlazada a tipo en %L es de tipo ABSTRACT '%s'"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "El objeto base para la llamada a procedimiento enlazada a tipo NOPASS en %L debe ser escalar"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, fuzzy, gcc-internal-format
 #| msgid "Found no matching specific binding for the call to the GENERIC '%s' at %L"
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "No se encontró un enlace específico coincidente para la llamada al GENERIC '%s' en %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L should be a SUBROUTINE"
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "'%s' en %L debe ser una SUBROUTINE"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L should be a FUNCTION"
 msgid "%qs at %L should be a FUNCTION"
 msgstr "'%s' en %L debe ser una FUNCTION"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "Se esperaba un tipo de expresión"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s en %L debe ser un escalar"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' at %L must be nonnegative"
 msgid "%s at %L must be integer"
 msgstr "'%s' en %L debe ser no negativo"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s en %L debe ser INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "La expresión de paso en el bucle DO en %L no puede ser cero"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "El bucle DO en %L se ejecutará cero veces"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "se esperaba un nombre variable en %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "No se ha asignado una etiqueta de formato a la variable '%s' en %L"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "El atributo SAVE en %L no se puede especificar en un procedimiento PURE"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in %s clause at %L"
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Matriz de tamaño asumido '%s' en la cláusula %s en %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "El objeto POINTER '%s' en la cláusula %s en %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed argument not permitted in '%s' call at %L"
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr "No se permite un argumento coindizado en la llamada '%s' en %L"
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointee '%s' in %s clause at %L"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "El apuntado Cray '%s' en la cláusula %s en %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed argument not permitted in '%s' call at %L"
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr "No se permite un argumento coindizado en la llamada '%s' en %L"
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected NULL() intrinsic at %L to dummy '%s'"
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Intrínseco NULL inesperado en %L para el dummy '%s'"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "Se esperaba el nombre de bloque de '%s' en la declaración %s en %C"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "se define la variable %qD pero no se usa"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "El nombre de índice FORALL en %L debe ser un INTEGER escalar"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "La expresión de inicio FORALL en %L debe ser un INTEGER escalar"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "La expresión de fin FORALL en %L debe ser un INTEGER escalar"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "La expresión de tranco FORALL en %L debe ser un %s escalar"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "La expresión de tranco FORALL en %L no puede ser cero"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 #| msgid "FORALL index '%s' may not appear in triplet specification at %L"
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "El índice FORALL '%s' no puede aparecer en la especificación triplet en %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "El objeto de alojamiento en %L debe ser ALLOCATABLE o un POINTER"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Objeto alojable coindizado en %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Allocate-object at %L also appears at %L"
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "El objeto de alojamiento en %L también aparece en %L"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "La expresión fuente en %L debe ser escalar o tener el mismo rango que el objeto de alojamiento en %L"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "La expresión fuente en %L y el objeto de alojamiento en %L deben tener la misma forma"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Sólo se pueden usar operandos intrínsecos en la expresión en %L"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "El tipo de entidad en %L es de tipo incompatible con la expresión fuente en %L"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "El objeto de alojamiento en %L y la expresión fuente en %L deben tener el mismo parámetro de tipo de género"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "La expresión fuente en %L no puede ser de tipo LOCK_TYPE ni tener un componente LOCK_TYPE si el objeto-alojado en %L es una comatriz"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "La expresión fuente en %L no puede ser de tipo LOCK_TYPE ni tener un componente LOCK_TYPE si el objeto-alojado en %L es una comatriz"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "El alojamiento %s del tipo de base ABSTRACT en %L requiere una especificación de tipo o una expresión source"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "Alojar %s en %L con especificación de tipo requiere el mismo parámetro de longitud de carácter que el de la declaración"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Se requiere una especificación de matriz en la declaración ALLOCATE en %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Se requiere una especificación de matriz en la declaración ALLOCATE en %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Se requiere una especificación de comatriz en la declaración ALLOCATE en %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Especificación de comatriz errónea en la declaración ALLOCATE en %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Especificación de matriz errónea en la declaración ALLOCATE en %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "'%s' no debe aparecer en la especificación de matriz en %L en la misma declaración ALLOCATE donde se aloja a sí misma"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '*' in coindex specification in ALLOCATE statement at %L"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "Se esperaba '*' en la especificación de comatriz en la declaración ALLOCATE en %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "La variable stat en %L debe ser una variable INTEGER escalar"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "La variable stat en %L no no debe ser %sd dentro de la misma declaración %s"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "ERRMSG en %L es inútil sin una etiqueta STAT"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "El argumento ERRMSG= en %L debe ser una variable CHARACTER escalar"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "La variable errmsg en %L no debe ser %sd dentro de la misma declaración %s"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "El objeto de alojamiento en %L también aparece en %L"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "El objeto de alojamiento en %L es un subobjeto del objeto en %L"
@@ -92636,337 +92834,337 @@ msgstr "El objeto de alojamiento en %L es un subobjeto del objeto en %L"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "La etiqueta CASE en %L se encima con la etiqueta CASE en %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "La expresión en la declaración CASE en %L debe ser de tipo %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "La expresión en la declaración CASE en %L debe ser de género %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "La expresión en la declaración CASE en %L debe ser escalar"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "La expresión de selección en una declaración GOTO computada en %L debe ser una expresión entera escalar"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "El argumento de la declaración SELECT en %L no puede ser %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "El argumento de la declaración SELECT en %L debe ser una expresión escalar"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "La expresión en la declaración CASE en %L no está en el rango de %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "El DEFAULT CASE en %L no puede tener después un segundo DEFAULT CASE en %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "No se permite un rango lógico en una declaración CASE en %L"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "Se repite un valor lógico constante en una declaración CASE en %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "La especificación de rango en %L nunca puede coincidir"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "El bloque SELECT CASE lógico en %L tiene más de dos cases"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "No se puede resolver la función específica '%s' en %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "El procedimiento interno '%s' es no válido en la asignación de puntero de procedimiento en %L"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "El nombre '%s' no se puede usar como un operador definido en %C"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 #| msgid "Associate-name '%s' at %L is used as array"
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "Se usa el nombre asociado '%s' en %L como una matriz"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Association target at %C must not be coindexed"
 msgid "Selector at %L cannot be NULL()"
 msgstr "El objetivo de asociación en %C no debe estar coindizado"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Association target at %C must not be coindexed"
 msgid "Selector at %L has no type"
 msgstr "El objetivo de asociación en %C no debe estar coindizado"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, fuzzy, gcc-internal-format
 #| msgid "Associate-name '%s' at %L is used as array"
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Se usa el nombre asociado '%s' en %L como una matriz"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "El selector debe ser polimórfico en la declaración SELECT TYPE en %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Association target at %C must not be coindexed"
 msgid "Selector at %L must not be coindexed"
 msgstr "El objetivo de asociación en %C no debe estar coindizado"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CASE label at %L overlaps with CASE label at %L"
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "La etiqueta CASE en %L se encima con la etiqueta CASE en %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L must be extensible"
 msgid "Derived type %qs at %L must be extensible"
 msgstr "El tipo derivado '%s' en %L debe ser extensible"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L must be an extension of '%s'"
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "El tipo derivado '%s' en %L debe ser una extensión de '%s'"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected NULL() intrinsic at %L to dummy '%s'"
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Intrínseco NULL inesperado en %L para el dummy '%s'"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Type-spec at %L cannot contain a deferred type parameter"
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "La especificación de tipo en %L no puede tener un parámetro de tipo diferido"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Bloque CLASS IS doble en la declaración SELECT TYPE  en %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Contexto no válido para el puntero NULL() en %%L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STOP code at %L must be scalar"
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "El código STOP en %L debe ser escalar"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "El elemento de transferencia de datos en %L no puede ser polimórfico a menos que se procese con un procedimiento de entrada/salida definido"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "El elemento de transferencia de datos en %L no puede tener componentes POINTER a menos que se procese con un procedimiento de entrada/salida definido"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "El elemento de transferencia de datos en %L no puede tener componentes de puntero a procedimiento"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "El elemento de transferencia de datos en %L no puede tener componentes ALLOCATABLE a menos que se procese con un procedimiento de entrada/salida definido"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "El elemento de transferencia de datos en %L no puede tener componentes PRIVATE"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "El elemento de transferencia de datos en %L no puede tener componentes POINTER a menos que se procese con un procedimiento de entrada/salida definido"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "El elemento de transferencia de datos en %L no puede ser una referencia completa a una matriz de tamaño asumido"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "La variable lock en %L debe ser un escalar de tipo LOCK_TYPE"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "La variable lock en %L debe ser un escalar de tipo LOCK_TYPE"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be a coarray"
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "El argumento actual para '%s' en %L debe ser una comatriz"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to '%s' at %L must be a coarray"
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "El argumento actual para '%s' en %L debe ser una comatriz"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "El argumento STAT= en %L debe ser una variable INTEGER escalar"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "El argumento ERRMSG= en %L debe ser una variable CHARACTER escalar"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "El argumento ACQUIRED_LOCK= en %L debe ser una variable LOGICAL escalar"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "El argumento de conjunto de imagen %L debe ser un escalar o una expresión INTEGER de rango 1"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr "El argumento de la declaración SELECT en %L debe ser una expresión escalar"
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "El argumento STAT= en %L debe ser una variable INTEGER escalar"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be a character string of default kind"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "La etiqueta %s en %L debe ser una cadena de caracteres del género por defecto"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "El argumento de conjunto de imagen %L debe ser un escalar o una expresión INTEGER de rango 1"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "El argumento de conjunto de imagen en %L debe estar entre 1 y num_images()"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "La declaración en %L no es una declaración de objetivo de ramificación válida para la declaración de ramificación en %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "La ramificación en %L puede resultar en un bucle infinito"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "La declaración GOTO en %L deja la construcción CRITICAL por la etiqueta en %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "La declaración GOTO en %L deja la construcción DO CONCURRENT por la etiqueta en %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
@@ -92975,227 +93173,227 @@ msgstr "La declaración GOTO en %L deja la construcción CRITICAL por la etiquet
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "La etiqueta en %L no está en el mismo bloque que la declaración GOTO en %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "La máscara WHERE en %L tiene forma inconsistente"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "El objetivo de asignación WHERE en %L tiene forma inconsistente"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Asignación definida por el usuario de un no-ELEMENTAL en WHERE en %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Declaración sin soporte dentro de WHERE en %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Asignación a una variable de índice FORALL en %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, fuzzy, gcc-internal-format
 #| msgid "The FORALL with index '%s' is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "No se usa el FORALL con índice '%s' en el lado izquierdo de la asignación en %L y podría causar múltiples asignaciones a este objeto"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: BLOCK construct at %C"
 msgid "FORALL construct at %L"
 msgstr "Fortran 2008: Constructor BLOCK en %C"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "El nombre de índice FORALL en %L debe ser un INTEGER escalar"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Una construcción FORALL externa ya tiene un índice con este nombre %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "se esperaba un nombre variable en %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "la cláusula WHERE/ELSEWHERE en %L requiere una matriz LOGICAL"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have procedure pointer components"
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "El elemento de transferencia de datos en %L no puede tener componentes de puntero a procedimiento"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "No se puede convertir %s a %s en %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER expression will be truncated in assignment (%d/%d) at %L"
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "Se truncará la expresión CHARACTER en la asignación (%d/%d) en %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "La expresión con coíndice en %L se asigna a una variable de tipo derivado con un componente POINTER en un procedimiento PURE"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Asignación a una variable coindizada en %L en un procedimiento PURE"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Polymorphic array at %C not yet supported"
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "Aún no se admite la matriz polimórfica en %C"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Asignación a una variable de índice FORALL en %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "Variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for '=' operator"
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "La variable no debe ser polimórfica en la asignación intrínseca en %L - revise que hay una subrutina específica coincidente para el operador '='"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Coindexed variable must not be have an allocatable ultimate component in assignment at %L"
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "La variable coindizada no debe tener un componente último alojable en la asignación en %L"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid procedure pointer assignment at %L"
 msgid "Pointer procedure assignment at %L"
 msgstr "Asignación de puntero de procedimiento no válida en %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "La expresión objetivo en la asignación de puntero en %L debe entregar un resultado puntero."
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "La declaración ASSIGNED GOTO en %L requiere una variable INTEGER"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' has not been assigned a target label at %L"
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "La variable '%s' no se ha asignado a una etiqueta objetivo en %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "La declaración RETURN alternativa en %L requiere de un especificador de devolución SCALAR-INTEGER"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Se esperaba la inicialización de la expresión en CASE en %C"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "La declaración de ASSIGN en %L requiere una variable INTEGER escalar por defecto"
 
 # 'kind' es el tipo del tipo de dato en Fortran. Lo traduzco como 
 # 'género', para evitar confusión con 'type' = 'tipo'. cfuga
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "Género no válido para %s en %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Arithmetic IF statement at %L requires a numeric expression"
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "La declaración IF aritmética en %L requiere una expresión numérica"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "La condición de salida del bucle DO WHILE en %L debe ser una expresión LOGICAL escalar"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "La cláusula de máscara FORALL en %L requiere una expresión LOGICAL escalar"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_trans_code(): Código de declaración erróneo"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter '%s' declared at %L"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Se declaró el parámetro '%s' sin uso en %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, fuzzy, gcc-internal-format
 #| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
@@ -93203,7 +93401,7 @@ msgstr "La etiqueta enlazante '%s' en %L colisiona con la entidad global '%s' en
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, fuzzy, gcc-internal-format
 #| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
@@ -93212,72 +93410,72 @@ msgstr "La etiqueta enlazante '%s' en %L colisiona con la entidad global '%s' en
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, fuzzy, gcc-internal-format
 #| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "La etiqueta enlazante '%s' en %L colisiona con la entidad global '%s' en %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "La longitud de la cadena en %L es demasiado grande"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "La matriz allocatable '%s' en %L debe tener una forma diferida"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 #| msgid "Scalar object '%s' at %L may not be ALLOCATABLE"
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "El objeto escalar '%s' en %L no puede ser ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "La matriz de puntero '%s' en %L debe tener una forma diferida"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L cannot have a deferred shape"
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "La matriz '%s' en %L no puede tener una forma diferida"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, fuzzy, gcc-internal-format
 #| msgid "Type '%s' of CLASS variable '%s' at %L is not extensible"
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "El tipo '%s' de la variable CLASS '%s' en %L no es extensible"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable '%s' at %L must be dummy, allocatable or pointer"
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "La variable CLASS '%s' en %L debe ser dummy, allocatable o pointer"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, fuzzy, gcc-internal-format
 #| msgid "The type '%s' cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "El tipo '%s' no se puede asociar al anfitrión en %L porque está bloqueado por un objeto incompatible del mismo nombre declarado en %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2008: Implied SAVE for module variable '%s' at %L, needed due to the default initialization"
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Fortran 2008: SAVE implícito para la variable de módulo '%s' en %L, se necesita por la inicialización por defecto"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, fuzzy, gcc-internal-format
 #| msgid "Entity '%s' at %L has a deferred type parameter and requires either the pointer or allocatable attribute"
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "La entidad '%s' en %L tiene un parámetro de tipo diferido y requiere el atributo pointer o allocatable"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L can not have the EXTERNAL attribute"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -93285,1043 +93483,1043 @@ msgstr "El bloque COMMON '%s' en %L no puede tener el atributo EXTERNAL"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "The module or main program array '%s' at %L must have constant shape"
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "El módulo o la matriz del programa principal '%s' en %L deben tener una forma constante"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "La entidad con longitud de carácter asumida en %L debe ser un argumento de prueba o un PARAMETER"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "%qs at %L must have constant character length in this context"
 msgstr "'%s' en %L debe tener longitud de cáracter constante en este contexto"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON variable '%s' at %L must have constant character length"
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "La variable COMMON '%s' en %L debe tener longitud de cáracter constante en este contexto"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "El allocatable '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "External %qs at %L cannot have an initializer"
 msgstr "El external '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "El dummy '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "El intrinsic '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "El resultado de la función '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "La matriz automática '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "fstat %s"
 msgid "%s at %L"
 msgstr "fstat %s"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued statement function '%s' at %L must have constant length"
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "La función de declaración valuada con carácter '%s' en %L debe tener longitud constante"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' is of a PRIVATE type and cannot be a dummy argument of '%s', which is PUBLIC at %L"
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003: '%s' es de un tipo PRIVATE y no puede ser un argumento dummy de '%s', el cual es PUBLIC en %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: Procedure '%s' in PUBLIC interface '%s' at %L takes dummy arguments of '%s' which is PRIVATE"
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Fortran 2003: El procedimiento '%s' en la interfaz PUBLIC '%s' en %L toma argumentos dummy de '%s' el cual es PRIVATE"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot have an initializer"
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "La función '%s' en %L no puede tener un inicializador"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "External object %qs at %L may not have an initializer"
 msgstr "El objeto external '%s' en %L puede no tener un inicializador"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL function '%s' at %L must have a scalar result"
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "La función ELEMENTAL '%s' en %L debe tener un resultado escalar"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L may not have pointer or allocatable attribute"
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "La función de declaración '%s' en %L no debe tener atributo puntero o alojable"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "La función CHARACTER(*) '%s' en %L no puede ser matriz-valuada"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "La función CHARACTER(*) '%s' en %L no puede ser puntero-valuada"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "La función CHARACTER(*) '%s' en %L no puede ser pura"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be recursive"
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "La función CHARACTER(*) '%s' en %L no puede ser recursiva"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "La función CHARACTER(*) '%s' en %L no puede ser pura"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L has no explicit interface"
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "El procedimiento '%s' en %s en %L no tiene una interfaz explícita"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' at %C cannot have a generic interface"
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "El procedimiento dummy '%s' en %C no puede tener una interfaz genérica"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "La variable '%s' en %L no puede tener los atributos ALLOCATABLE y BIND(C) al mismo tiempo"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Objeto coindizado con subcomponente alojable polimórfico en %L"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with SAVE attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "El atributo PROCEDURE genera un conflicto con el atributo SAVE en '%s' en %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "El atributo PROCEDURE genera un conflicto con el atributo INTENT en '%s' en %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with RESULT attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "El atributo PROCEDURE genera un conflicto con el atributo RESULT en '%s' en %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 #| msgid "EXTERNAL attribute conflicts with FUNCTION attribute in '%s' at %L"
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "El atributo EXTERNAL genera un conflicto con el atributo FUNCTION en '%s' en %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer result '%s' at %L is missing the pointer attribute"
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "Al resultado del puntero de procedimiento '%s' en %L le falta el atributo puntero"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "La interfaz '%s' del procedimiento '%s' en %L debe ser explícita"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, fuzzy, gcc-internal-format
 #| msgid "FINAL procedure '%s' at %L is not a SUBROUTINE"
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "El procedimiento FINAL '%s' en %L no debe ser una SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "El procedimiento FINAL en %L debe tener exactamente un argumento"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of FINAL procedure at %L must be of type '%s'"
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "El argumento del procedimiento FINAL en %L debe ser de tipo '%s'"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "El argumento del procedimiento FINAL en %L no debe ser un POINTER"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "El argumento del procedimiento final en %L no debe ser ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "El argumento del procedimiento FINAL en %L no debe ser OPTIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "El argumento del procedimiento FINAL en %L no debe ser INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "El procedimiento FINAL que no es escalar en %L debe tener un argumento sharp asumido"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 #| msgid "FINAL procedure '%s' declared at %L has the same rank (%d) as '%s'"
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "El procedimiento FINAL '%s' declarado en %L tiene el mismo rango (%d) que '%s'"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, fuzzy, gcc-internal-format
 #| msgid "Only array FINAL procedures declared for derived type '%s' defined at %L, suggest also scalar one"
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Sólo se declaran procedimientos FINAL de matriz para el tipo derivado '%s' definido en %L, se sugiere también uno escalar"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' can't be mixed FUNCTION/SUBROUTINE for GENERIC '%s' at %L"
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "'%s' y '%s' no pueden ser FUNCTION/SUBROUTINE mezcladas para el GENERIC '%s' en %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' for GENERIC '%s' at %L are ambiguous"
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "'%s' y '%s' para el GENERIC '%s' en %L son ambiguos"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, fuzzy, gcc-internal-format
 #| msgid "Undefined specific binding '%s' as target of GENERIC '%s' at %L"
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "El enlace específico '%s' no está definido como objetivo del GENERIC '%s' en %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC '%s' at %L must target a specific binding, '%s' is GENERIC, too"
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "El GENERIC '%s' en %L debe apuntar a un enlace específico, '%s' es GENERIC también"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC '%s' at %L can't overwrite specific binding with the same name"
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "El GENERIC '%s' en %L no puede sobreescribir el enlace específico con el mismo nombre"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Type-bound operator at %L can't be NOPASS"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "El operador enlazado a tipo en %L no puede ser NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' must be a module procedure or an external procedure with an explicit interface at %L"
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "'%s' debe ser un procedimiento de módulo o un procedimiento externo con una interfaz explícita en %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' with PASS(%s) at %L has no argument '%s'"
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "El procedimiento '%s' con PASS(%s) en %L no tiene un argumento '%s'"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' with PASS at %L must have at least one argument"
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "El procedimiento '%s' con PASS en %L debe tener al menos un argumento"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, fuzzy, gcc-internal-format
 #| msgid "Non-polymorphic passed-object dummy argument of '%s' at %L"
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Argumento dummy pasado como objeto no polimórfico de '%s' en %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "El argumento '%s' de '%s' con PASS(%s) en %L debe ser del tipo derivado '%s'"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "El argumento '%s' de '%s' con PASS(%s) en %L debe ser del tipo derivado '%s'"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must be scalar"
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "El argumento dummy de objeto pasado de '%s' en %L debe ser escalar"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must not be ALLOCATABLE"
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "El argumento dummy de objeto pasado de '%s' en %L no debe ser ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must not be POINTER"
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "El argumento dummy de objeto pasado de '%s' en %L no debe ser POINTER"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L has the same name as a component of '%s'"
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "El procedimiento '%s' en %L tiene el mismo nombre que un componente de '%s'"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L has the same name as an inherited component of '%s'"
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "El procedimiento '%s' en %L tiene el mismo nombre que un componente heredado de '%s'"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, fuzzy, gcc-internal-format
 #| msgid "Derived-type '%s' declared at %L must be ABSTRACT because '%s' is DEFERRED and not overridden"
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "El tipo derivado '%s' declarado en %L debe ser ABSTRACT porque '%s' es DEFERRED y no se sobreescribió"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray component '%s' at %L must be allocatable with deferred shape"
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "El componente de comatriz '%s' en %L debe sel alojable con forma diferida"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "El componente '%s' en %L de TYPE(C_PTR) o TYPE(C_FUNPTR) no debe ser una comatriz"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "El componenten '%s' en %L con componente comatriz debe ser un escalar que no sea puntero alojable"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "El componente '%s' en %L tiene el atributo CONTIGUOUS porque no es un puntero de matriz"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "El argumento de ICHAR en %L debe ser de longitud uno"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer component '%s' with PASS(%s) at %L has no argument '%s'"
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "El procedimiento de componente puntero '%s' con PASS(%s) en %L no tiene un argumento '%s'"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer component '%s' with PASS at %L must have at least one argument"
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "El procedimiento de componente puntero '%s' con PASS en %L debe tener al menos un argumento"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "El argumento '%s' de '%s' con PASS(%s) en %L debe ser del tipo derivado '%s'"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be scalar"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "El argumento '%s' de '%s' con PASS(%s) en %L debe ser escalar"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L may not have the POINTER attribute"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "El argumento '%s' de '%s' con PASS(%s) en %L no puede tener el atributo POINTER"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L may not be ALLOCATABLE"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "El argumento '%s' de '%s' con PASS(%s) en %L no puede ser ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' of '%s' at %L has the same name as an inherited type-bound procedure"
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "El componente '%s' de '%s' en %L tiene el mismo nombre que un procedimiento enlazado a tipo heredado"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, fuzzy, gcc-internal-format
 #| msgid "Character length of component '%s' needs to be a constant specification expression at %L"
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "La longitud de carácter del componente '%s' necesita ser una expresión de especificación constante en %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "La expresión en %L debe ser de tipo INTEGER, se encontró %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, fuzzy, gcc-internal-format
 #| msgid "Character component '%s' of '%s' at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "El componente de carácter '%s' de '%s' en %L con longitud diferida debe ser POINTER o ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: the component '%s' is a PRIVATE type and cannot be a component of '%s', which is PUBLIC at %L"
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003: el componente '%s' es un tipo PRIVATE y no puede ser un componente de '%s' el cual es PUBLIC en %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "El componente polimórfico %s en %L en SEQUENCE o de tipo BIND(C) %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "El componente %s del tipo SEQUENCE declarado en %L no tiene el atributo SEQUENCE"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Conflicting I/O control specifications at %0 and %1"
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Especificaciones de control de E/S en conflicto en %0 y %1"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, fuzzy, gcc-internal-format
 #| msgid "As extending type '%s' at %L has a coarray component, parent type '%s' shall also have one"
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "Como al extender el tipo '%s' en %L tiene un componente de comatriz, el tipo padre '%s' también debe tener uno"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, fuzzy, gcc-internal-format
 #| msgid "Non-extensible derived-type '%s' at %L must not be ABSTRACT"
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "El tipo derivado '%s' que no es extensible en %L no debe ser ABSTRACT"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: Generic name '%s' of function '%s' at %L being the same name as derived type at %L"
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Fortran 2003: El nombre genérico '%s' de la función '%s' en %L tiene el mismo nombre que el tipo derivado en %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L must be extensible"
 msgid "Derived type %qs at %L has not been declared"
 msgstr "El tipo derivado '%s' en %L debe ser extensible"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate construct label '%s' at %C"
 msgid "Failed to build PDT class component at %L"
 msgstr "Etiqueta construct '%s' duplicada en %C"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s' at %L is not allowed"
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "No se permite la matriz de tamaño asumido '%s' en la lista de nombres '%s' en %L"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: NAMELIST array object '%s' with assumed shape in namelist '%s' at %L"
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "Fortran 2003: Objeto de matriz NAMELIST '%s' con forma asumida en la lista de nombres '%s' en %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: NAMELIST array object '%s' with nonconstant shape in namelist '%s' at %L"
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "Fortran 2003: El objeto de matriz NAMELIST '%s' con forma que no es constante en la lista de nombres '%s' en %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: NAMELIST object '%s' with nonconstant character length in namelist '%s' at %L"
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "Fortran 2003: El objeto de matriz NAMELIST '%s' con longitud de carácter que no es constante en la lista de nombres '%s' en %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' was declared PRIVATE and cannot be member of PUBLIC namelist '%s' at %L"
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "El objeto NAMELIST '%s' se declaró PRIVATE y no puede ser miembro de una lista de nombres PUBLIC '%s' en %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' has use-associated PRIVATE components and cannot be member of namelist '%s' at %L"
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "El objeto NAMELIST '%s' tiene componentes PRIVATE asociados a uso y no puede ser miembro de la lista de nombres '%s' en %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' has PRIVATE components and cannot be a member of PUBLIC namelist '%s' at %L"
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "El objeto NAMELIST '%s' tiene componentes PRIVATE y no puede ser un miembro de la lista de nombres PUBLIC '%s' en %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "El atributo PROCEDURE genera un conflicto con el atributo NAMELIST en '%s' en %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter array '%s' at %L cannot be automatic or of deferred shape"
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "La matriz de parámetro '%s' en %L no puede ser automática ni de forma diferida"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, fuzzy, gcc-internal-format
 #| msgid "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type"
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "El PARAMETER de tipo implícito '%s' en %L no coincide con un tipo IMPLICIT posterior"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Tipo derivado incompatible en PARAMETER en %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L can not have the EXTERNAL attribute"
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "El bloque COMMON '%s' en %L no puede tener el atributo EXTERNAL"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "Expecting constant expression near %L"
 msgstr "%qE no es una expresión constante"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "Entity '%s' at %L has a deferred type parameter and requires either the pointer or allocatable attribute"
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "La entidad '%s' en %L tiene un parámetro de tipo diferido y requiere el atributo pointer o allocatable"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "El atributo PROTECTED genera un conflicto con el atributo EXTERNAL en %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "El atributo PROCEDURE genera un conflicto con el atributo PROTECTED en %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape array"
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "'%s' en %L tiene el atributo CONTIGUOUS pero no es un puntero de matriz o una matriz de forma asumida"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad specification for assumed size array at %C"
 msgid "Bad specification for assumed size array at %L"
 msgstr "Especificación errónea para la matriz de tamaño asumido en %C"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "La matriz de tamaño asumido en %L debe ser un argumento de prueba"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "La matriz de forma asumida en %L debe ser un argumento de prueba"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "La matriz de forma asumida en %L debe ser un argumento de prueba"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "El símbolo en %L no es una variable DUMMY"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "'%s' en %L no puede tener el atributo VALUE porque no es un argumento dummy"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 #| msgid "Character dummy variable '%s' at %L with VALUE attribute must have constant length"
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "La variable dummy de carácter '%s' en %L con atributo VALUE debe tener longitud constante"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, fuzzy, gcc-internal-format
 #| msgid "C interoperable character dummy variable '%s' at %L with VALUE attribute must have length one"
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "La variable dummy de carácter interoperable con C '%s' en %L con atributo VALUE debe ser de longitud uno"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, fuzzy, gcc-internal-format
 #| msgid "The derived type '%s' at %L is of type '%s', which has not been defined"
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "El tipo derivado '%s' en %L es de tipo '%s', el cual no se ha definido"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "La variable '%s' en %L no puede tener los atributos ALLOCATABLE y BIND(C) al mismo tiempo"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "La variable '%s' en %L no puede tener los atributos POINTER y BIND(C) al mismo tiempo"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape array"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "'%s' en %L tiene el atributo CONTIGUOUS pero no es un puntero de matriz o una matriz de forma asumida"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "No se permite la matriz de forma asumida '%s' en %L en una expresión de inicialización"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "La variable '%s' en %L no puede tener los atributos ALLOCATABLE y BIND(C) al mismo tiempo"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "La variable '%s' en %L no puede tener los atributos POINTER y BIND(C) al mismo tiempo"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Loop variable at %C cannot be a coarray"
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "La variable de bucle en %C no puede ser una comatriz"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "La variable '%s' en %L no puede ser BIND(C) porque no es un bloque COMMON ni se declaró en el ámbito de nivel de módulo"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON variable '%s' at %L must have constant character length"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "La variable COMMON '%s' en %L debe tener longitud de cáracter constante en este contexto"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: PUBLIC %s '%s' at %L of PRIVATE derived type '%s'"
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "Fortran 2003: La función PUBLIC %s '%s' en %L es de tipo derivado PRIVATE '%s'"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "La variable %s en %L de tipo LOCK_TYPE o con un subcomponente de tipo LOCK_TYPE debe ser una comatriz"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "La variable %s en %L de tipo LOCK_TYPE o con un subcomponente de tipo LOCK_TYPE debe ser una comatriz"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, fuzzy, gcc-internal-format
 #| msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "El argumento dummy INTENT(OUT) '%s' en %L es ASSUMED SIZE y por lo tanto no puede tener un inicializador por defecto"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "El argumento dummy '%s' en %L de LOCK_TYPE no puede ser INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "El argumento dummy '%s' en %L de LOCK_TYPE no puede ser INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L shall not be a coarray or have a coarray component"
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "El resultado de la función '%s' en %L no puede ser una comatriz o tener un componente comatriz"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "La variable '%s' en %L de TYPE(C_PTR) o TYPE(C_FUNPTR) no debe ser una comatriz"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "La variable '%s' en %L con componente de comatriz debe ser un escalar que no sea puntero alojable"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "La variable '%s' en %L es una comatriz y no es ALLOCATABLE, SAVE ni un argumento dummy"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape"
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "La variable de comatriz '%s' en %L no debe tener codimensiones con forma diferida"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable coarray variable '%s' at %L must have deferred shape"
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "La variable comatriz allocatable '%s' en %L debe tener forma diferida"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "La variable '%s' en %L es INTENT(OUT) y por lo tanto no puede ser una comatriz allocatable o tener componentes comatriz"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "No se permite la variable dummy comatriz '%s' en %L en el procedimiento BIND(C) '%s'"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "No se permite la variable dummy comatriz '%s' en %L en el procedimiento BIND(C) '%s'"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "No se permite la variable dummy comatriz '%s' en %L en el procedimiento BIND(C) '%s'"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist %s cannot be renamed by USE association to %s"
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "La lista de nombres %s no se puede renombrar por asociación de USE a %s"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "No se guarda (SAVE) el threadprivate en %L"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "El objetivo de inicialización de puntero en %L debe tener el atributo SAVE"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object %qD may not be initialized"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "el objeto de tamaño variable %qD no se puede inicializar"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting list of named entities at %C"
 msgid "Expecting definable entity near %L"
 msgstr "Se espera la lista de entidades nombradas %C"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 #| msgid "BLOCK DATA element '%s' at %L must be in COMMON"
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "El elemento BLOCK DATA '%s' en %L debe estar en COMMON"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, fuzzy, gcc-internal-format
 #| msgid "DATA array '%s' at %L must be specified in a previous declaration"
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "La matriz DATA '%s' en %L se debe especificar en una declaración previa"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 #| msgid "DATA element '%s' at %L cannot have a coindex"
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "El elemento DATA '%s' en %L no puede tener un coíndice"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, fuzzy, gcc-internal-format
 #| msgid "DATA element '%s' at %L is a pointer and so must be a full array"
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "El elemento DATA '%s' en %L es un puntero y entonces debe ser una matriz completa"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "El argumento '%s' del procedimiento elemental en %L no puede tener el atributo ALLOCATABLE"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Sección de matriz no constante en %L en la declaración DATA"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "La declaración DATA en %L tiene más variables que valores"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Sección de matriz no constante en %L en la declaración DATA"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "el inicio del bucle do implícito en %L no se puede simplificar a un valor constante"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "el final del bucle do implícito en %L no se puede simplificar a un valor constante"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "el paso del bucle do implícito en %L no se puede simplificar a un valor constante"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "el paso del bucle do implícito en %L no se puede simplificar a un valor constante"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "La declaración DATA en %L tiene más valores que variables"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Se define la etiqueta %d en %L pero no se usa"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Se define la etiqueta %d en %L pero no se puede usar"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "La variable de tipo derivado '%s' en %L debe tener el atributo SEQUENCE para ser un objeto EQUIVALENCE"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "La variable de tipo derivado '%s' en %L no puede tener componentes ALLOCATABLE que sean un objeto EQUIVALENCE"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "La variable de tipo derivado '%s' en %L con inicializadores por defecto no puede ser un objeto EQUIVALENCE con una variable en COMMON"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "La variable de tipo derivado '%s' en %L con componente(s) de puntero no puede ser un objeto EQUIVALENCE"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Error sintáctico en la declaración EQUIVALENCE en %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Todos o ninguno de los objetos en el conjunto EQUIVALENCE en %L deben tener el atributo PROTECTED"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 #| msgid "Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure procedure '%s'"
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "El miembro de bloque común '%s' en %L no puede ser un objeto EQUIVALENCE en el procedimiento puro '%s'"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, fuzzy, gcc-internal-format
 #| msgid "Named constant '%s' at %L cannot be an EQUIVALENCE object"
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
@@ -94329,97 +94527,97 @@ msgstr "La constante nombrada '%s' en %L no puede ser un objeto EQUIVALENCE"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, fuzzy, gcc-internal-format
 #| msgid "Substring of non-CHARACTER entity `%A' in EQUIVALENCE statement"
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr "Subcadena de la entidad `%A' que no es CHARACTER en la declaración EQUIVALENCE"
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Error sintáctico en la declaración EQUIVALENCE en %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "La matriz '%s' en %L con límites que no son constantes no puede ser un objeto EQUIVALENCE"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, fuzzy, gcc-internal-format
 #| msgid "Structure component '%s' at %L cannot be an EQUIVALENCE object"
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "El componente de estructura '%s' en %L no puede ser un objeto EQUIVALENCE"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "La subcadena en %L tiene longitud cero"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Longitudes de carácter diferentes en la asignación de puntero en %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 #| msgid "PUBLIC function '%s' at %L cannot be of PRIVATE type '%s'"
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "La función PUBLIC '%s' en %L no puede ser del tipo PRIVATE '%s'"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L has no IMPLICIT type"
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY '%s' en %L no tiene tipo IMPLICIT"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "El procedimiento de operador de usuario '%s' en %L debe ser FUNCTION"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L cannot be assumed character length"
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "El procedimiento de operador de usuario '%s' en %L no puede ser de longitud de carácter asumido"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "El procedimiento de operador de usuario '%s' en %L debe tener al menos un argumento"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "El primer argumento de la interfaz de operador en %L no puede ser opcional"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "El segundo argumento de la interfaz de operador en %L no puede ser opcional"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "La interfaz de operador en %L debe tener, cuando mucho, dos argumentos"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
@@ -94443,107 +94641,107 @@ msgstr "se descarta el directorio inexistente \"%s\"\n"
 msgid "%qs is not a directory"
 msgstr "%s: No es un directorio"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP en %C inicia una línea comentada y no está seguido de un espacio ni es una continuación de línea"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP en %C inicia una línea comentada y no está seguido de un espacio ni es una continuación de línea"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Se truncó la línea en %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Se excedió el límite de %d continuaciones en la declaración en %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 #| msgid "Missing '&' in continued character constant at %C"
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Falta un '&' en la constante de carácter continuado en %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Carácter de tabulación que no es conforme en %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character 0x%s at %C"
 msgstr "Carácter no válido en el nombre en %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, fuzzy, gcc-internal-format
 #| msgid "'&' not allowed by itself in line %d"
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "no se permite '&' por sí solo en la línea %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Carácter de tabulador que no es conformante en la columna %d de la línea %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: file %s left but not entered"
 msgid "file %qs left but not entered"
 msgstr "%s:%d: se dejó el fichero %s pero no se entró"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Illegal preprocessor directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s:%d: Directiva de preprocesamiento ilegal"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, fuzzy, gcc-internal-format
 #| msgid "File '%s' is being included recursively"
 msgid "File %qs is being included recursively"
 msgstr "El fichero '%s' se está incluyendo recursivamente"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file '%s'"
 msgid "Cannot open file %qs"
 msgstr "No se puede abrir el fichero '%s'"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open included file %qs"
 msgstr "No se puede abrir el fichero incluído '%s'"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "No se puede abrir el fichero incluído '%s'"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "input file %qs is the same as output file"
 msgid "Included file %qs is not a regular file"
@@ -94718,229 +94916,229 @@ msgstr "Si el primer argumento de ATAN2 %L es cero, entonces el segundo argument
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "El argumento de IACHAR en %L debe ser de longitud uno"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "El argumento de la función IACHAR en %L está fuera de rango 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "La suma del segundo y tercer argumentos de IBITS excede el tamaño de bit en %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "El argumento de ICHAR en %L debe ser de longitud uno"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "El segundo argumento de %s es negativo en %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "La magnitud del segundo argumento de %s excede el tamaño de bit en %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %L"
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "La magnitud del segundo argumento de ISHFTC excede el BIT_SIZE del primer argumento en %L"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The absolute value of SHIFT at %L must be less than or equal to SIZE at %L"
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "El valor absoluto de SHIFT en %L debe ser menor o igual a SIZE en %L"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "El argumento DIM en %L está fuera de los límites"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "El argumento de LOG en %L no puede ser menor o igual a cero"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "El argumento complejo de LOG en %L no puede ser cero"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "El argumento de LOG10 en %L no puede ser menor o igual a cero"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 #| msgid "Argument 'S' of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "El argumento 'S' de NEAREST en %L no puede ser cero"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_trans_code(): Código de declaración erróneo"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "Argument 'S' of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "El argumento 'S' de NEAREST en %L no puede ser cero"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "El resultado de NEAREST es NaN en %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "El argumento NCOPIES del intrínseco REPEAT es negativo en %L"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "El argumento NCOPIES del intrínseco REPEAT es demasiado grande en %L"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer too large at %C"
 msgid "Reshaped array too large at %C"
 msgstr "Entero demasiado grande en %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "El resultado de SCALE desborda su género en %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "El argumento '%s' del intrínseco '%s' en %L debe ser del rango %d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Tipo erróneo en la expresión constante"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, fuzzy, gcc-internal-format
 #| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "El número de elementos en el constructor de matriz en %L requiere un incremento del límite superior %d permitido.  Vea la opción -fmax-array-constructor."
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Finalization at %L is not yet implemented"
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Aún no se admite la finalización en %L"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "El argumento de SQRT en %L tiene un valor negativo"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid second argument of IBSET at %L"
 msgid "invalid argument of SQRT at %L"
 msgstr "Segundo argumento de IBSET no válido en %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "Fuera de límites en IMAGE_INDEX en %L para la dimensión %d, SUB tiene %ld y el límite inferior de COARRAY  es %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "Fuera de límites en IMAGE_INDEX en %L para la dimensión %d, SUB tiene %ld y el límite superior de COARRAY es %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, fuzzy, gcc-internal-format
 #| msgid "Character '%s' in string at %L cannot be converted into character kind %d"
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
@@ -95312,86 +95510,86 @@ msgstr "Se esperaba un nombre terminal en %C"
 msgid "Labeled DO statement at %L"
 msgstr "Fortran 2008: Declaración LOCK en %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'"
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "El nombre '%s' en %C es una referencia ambigua a '%s' del módulo '%s'"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from current program unit"
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "El nombre '%s' en %C es una referencia ambigua a '%s' de la unidad de programa actual"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "El símbolo '%s' en %C ya se había asociado con el anfitrión"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' declared at %L must have the BIND attribute to be C interoperable"
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "El tipo derivado '%s' declarado en %L debe tener el atributo BIND para ser interoperable con C"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L has PRIVATE components"
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "El tipo derivado '%s' en %L tiene componentes PRIVATE"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "El tipo derivado '%s' con atributo BIND(C) en %L está vacío, y puede ser inaccesible para el procesador acompañante de C"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "El componente '%s' en %L no puede tener el atributo POINTER porque es un miembro del tipo derivado BIND(C) '%s' en %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer component '%s' at %L cannot be a member of the BIND(C) derived type '%s' at %L"
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "El procedimiento de componente puntero '%s' en %L no puede ser un miembro del tipo derivado BIND(C) '%s' en %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "El componente '%s' en %L no puede tener el atributo ALLOCATABLE porque es un miembro del tipo derivado BIND(C) '%s' en %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' in derived type '%s' at %L may not be C interoperable, even though derived type '%s' is BIND(C)"
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "El componente '%s' en el tipo derivado '%s' en %L tal vez no es interoperable con C, aún cuando el tipo derivado '%s' es BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' in derived type '%s' at %L may not be C interoperable"
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "El componente '%s' en el tipo derivado '%s' en %L tal vez no es interoperable con C"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "El tipo derivado '%s' en %L no puede tener el atributo SEQUENCE porque es BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' is used before it is typed at %L"
 msgid "Symbol %qs is used before it is typed at %L"
@@ -95424,31 +95622,37 @@ msgstr "Se sobreescriben los inicializadores desiguales en EQUIVALENCE en %L"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Se sobreescriben los inicializadores desiguales en EQUIVALENCE en %L"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "La matriz '%s' en %L es una variable, lo cual no se reduce a una expresión constante"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, fuzzy, gcc-internal-format
 #| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "El número de elementos en el constructor de matriz en %L requiere un incremento del límite superior %d permitido.  Vea la opción -fmax-array-constructor"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 #| msgid "Creating array temporary at %L for argument '%s'"
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Se crea una matriz temporal en %L para el argumento '%s'"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "tipo de expresión errónea durante la caminata (%d)"
@@ -95562,128 +95766,128 @@ msgstr "Asignar un valor diferente de 0 o 1 a LOGICAL tiene un resultado sin def
 msgid "non-constant initialization expression at %L"
 msgstr "expresión de inicialización que no es constante en %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Association target at %C must not be coindexed"
 msgid "%s at %L has no default type"
 msgstr "El objetivo de asociación en %C no debe estar coindizado"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "variable intrínseca que no es un procedimiento"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 #| msgid "Return value of function '%s' at %L not set"
 msgid "Return value of function %qs at %L not set"
 msgstr "No se define el valor de devolución de la función '%s' en %L"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "Aún no se admite un parámetro de tipo diferido"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, fuzzy, gcc-internal-format
 #| msgid "backend decl for module variable %s already exists"
 msgid "backend decl for module variable %qs already exists"
 msgstr "ya existe la declaración del extremo trasero para la variable de módulo %s"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable '%s' declared at %L"
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Se declaró la variable '%s' sin uso en %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "'%s' en %L no puede tener el atributo VALUE porque no es un argumento dummy"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "El componente '%s' en %L tiene el atributo CONTIGUOUS porque no es un puntero de matriz"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L was declared INTENT(OUT) but was not set"
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "El argumento dummy '%s' en %L se declaró INTENT(OUT) pero no se estableció"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 #| msgid "Derived-type dummy argument '%s' at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "El argumento dummy de tipo derivado '%s' en %L se declaró INTENT(OUT) pero no se estableció y no tiene un inicializador por defecto"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 #| msgid "Unused dummy argument '%s' at %L"
 msgid "Unused dummy argument %qs at %L"
 msgstr "Argumento dummy sin uso '%s' en %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 #| msgid "Unused module variable '%s' which has been explicitly imported at %L"
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Variable de módulo '%s' sin uso la cual se importó explícitamente en %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable '%s' declared at %L"
 msgid "Unused variable %qs declared at %L"
 msgstr "Se declaró la variable '%s' sin uso en %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter '%s' declared at %L"
 msgid "Unused parameter %qs declared at %L"
 msgstr "Se declaró el parámetro '%s' sin uso en %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter '%s' which has been explicitly imported at %L"
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Parámetro '%s' sin uso el cual se importó explícitamente en %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 #| msgid "Return value '%s' of function '%s' declared at %L not set"
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "No se define el valor de devolución '%s' de la función '%s' declarada en %L"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "VARYING bit-strings not implemented"
 msgid "Unsigned not yet implemented"
 msgstr "no se han implementado las cadenas de bit VARYING"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -95717,12 +95921,12 @@ msgstr "Lo siento, aún no se admiten las comatrices escalares alojables en %L"
 msgid "Unknown intrinsic op"
 msgstr "Operador intrínseco desconocido"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Lista de argumentos de función desconocida en %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -95740,13 +95944,13 @@ msgstr "No se reconoce la función intrínseca %s(%d)"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "el argumento 'dim' del intrínseco '%s' en %L no es un índice de dimensión válido"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Deferred-length character component '%s' at %L is not yet supported"
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "El componente de caractér de longitud diferida '%s' en %L aún no se admite"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer object at %C shall not be coindexed"
 msgid "The event variable at %L shall not be coindexed"
@@ -95773,202 +95977,202 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr "Especificación errónea para la matriz de tamaño asumido en %C"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "optional argument"
 msgid "optional class parameter"
 msgstr "argumento opcional"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "Se esperaba un tipo de expresión"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "se esperaba una expresión"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "Used here"
 msgstr "se definió union aquí"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Código de declaración erróneo"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, fuzzy, gcc-internal-format
 #| msgid "Either all or none of the upper bounds must be specified at %L"
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "Se deben especificar todos o ninguno de los límites superiores en %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "El nombre '%s' en %C es el nombre del procedimiento"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgid "The base name at %L must not be an entry name"
 msgstr "El argumento STAT= en %L debe ser una variable INTEGER escalar"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Interface '%s' at %C may not be generic"
 msgid "The base name at %L must not be a generic name"
 msgstr "La interfaz '%s' en %C puede no ser generic"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "El objetivo de inicialización de puntero a procedimiento en %L tal vez no es un puntero a procedimiento"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure '%s' in %s at %L has no explicit interface"
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "El procedimiento '%s' en %s en %L no tiene una interfaz explícita"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D aliased to undefined symbol %qE"
 msgid "Cannot find symbol %qs at %L"
 msgstr "%q+D es un alias del símbolo sin definir %qE"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "El procedimiento '%s' en %s en %L no es ni función ni subrutina"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is the same as base function"
 msgstr "El procedimiento '%s' en %s en %L no es ni función ni subrutina"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "%qs and %qs are incompatible"
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "%qs y %qs son incompatibles"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "Se esperaba una lista de argumentos en %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Kargument %i value %qE exceeds maximum object size %E"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "%Kargumento %i, valor %qE, supera el tamaño máximo %E del objeto"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Una devolución alternativa en %L sin un argumento dummy *"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "El argumento '%s' de la función de declaración en %L debe ser escalar"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "El argumento '%s' del procedimiento elemental en %L no puede tener el atributo ALLOCATABLE"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "specified option %qs more than once"
 msgid "%qs at %L is specified more than once"
 msgstr "opción %qs especificada más de una vez"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe not supported"
 msgid "%<need_device_addr%> not yet supported"
@@ -96342,7 +96546,7 @@ msgstr "cerrar: %s"
 msgid "two or more sections for %s"
 msgstr "dos o más secciones para %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -96701,34 +96905,34 @@ msgstr "se usó una matriz como inicializador"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not an integer constant"
 msgid "requested alignment is not a constant"
 msgstr "la alineación solicitada no es una constante entera"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a positive power of 2"
 msgid "requested alignment is not a power of 2"
 msgstr "la alineación solicitada no es una potencia positiva de 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "la alineación solicitada es demasiado grande"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -98261,11 +98465,6 @@ msgstr ""
 #~ msgid "original declaration here"
 #~ msgstr "la definición original apareció aquí"
 
-#, fuzzy, gcc-internal-format
-#~| msgid "lambda-expression in unevaluated context"
-#~ msgid "lambda-expression in template parameter type"
-#~ msgstr "expresión lambda en un contexto sin evaluar"
-
 #, fuzzy, gcc-internal-format
 #~| msgid "constructor cannot be static member function"
 #~ msgid "preconditions cannot be statements"
@@ -101060,11 +101259,6 @@ msgstr ""
 #~ msgid "looser throw specifier for %q+#F"
 #~ msgstr "especificador throw más flexible para %q+#F"
 
-#, fuzzy
-#~| msgid "cannot disable built-in function %qs"
-#~ msgid "cannot call function %qD"
-#~ msgstr "no se puede desactivar la función interna %qs"
-
 #~ msgid "right rotate count is negative"
 #~ msgstr "la cuenta de rotación derecha es negativa"
 
@@ -103877,9 +104071,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "el método %q+D que no es estático anula al método estático"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "se usa %q+D antes de la declaración"
-
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "En %+D: variable sobreescrita y rangos de excepción en %d"
 
@@ -115020,9 +115211,6 @@ msgstr ""
 #~ msgid "SEND without a destination instance"
 #~ msgstr "SEND sin una instancia de destino"
 
-#~ msgid " and no destination process specified"
-#~ msgstr " y no se especificó un proceso destino"
-
 #~ msgid " for the signal"
 #~ msgstr " para la señal"
 
--- a/src/gcc/po/fi.po
+++ b/src/gcc/po/fi.po
@@ -32,7 +32,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 11.1-b20210321\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2021-03-23 21:16+0200\n"
 "Last-Translator: Lauri Nurmi <lanurmi@iki.fi>\n"
 "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
@@ -1347,12 +1347,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "epäkelpo osoitintila %qs"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "Käytössä olevan C++-ABIn versio."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 msgid "Initialize ptx registers."
 msgstr "Käytä liukulukurekistereitä"
@@ -2174,13 +2174,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, fuzzy, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "Kelvolliset argumentit ovat:\n"
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2632,7 +2632,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Tuota koodia big-endian-tilassa"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Tuota koodia big-endian-tilassa"
@@ -2707,7 +2707,7 @@ msgstr "virheellinen ei-staattisen jäsenfunktion käyttö"
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 msgid "Specify the code model."
@@ -2744,7 +2744,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "indeksoitu arvo on osoitin funktioon"
@@ -2854,7 +2854,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2900,7 +2900,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr "I/O mahdollista"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, fuzzy, no-c-format
 msgid "Specify TLS dialect."
@@ -5169,7 +5169,7 @@ msgstr "sisäistä funktiota %qs ei voi ottaa pois käytöstä"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5524,7 +5524,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, fuzzy, no-c-format
 msgid "Use branch-protection features."
 msgstr "Kelvolliset argumentit ovat:\n"
@@ -5829,212 +5829,217 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "  -L, --logfile     anna lokitiedoston nimi\n"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Määrittele käytettävä ABI"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "Tuota little-endian-koodia"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "Tuota little-endian-koodia"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, fuzzy, no-c-format
 msgid "Optimize for CPU."
 msgstr "-m64 vaatii PowerPC64-suorittimen"
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Tuota 68040-koodia"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, fuzzy, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "epäkelpo osoitintila %qs"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, fuzzy, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "epäkelpo osoitintila %qs"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, fuzzy, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "I/O mahdollista"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "indeksoitu arvo on osoitin funktioon"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "This option is deprecated and has no effect."
 msgid "This option is deprecated."
@@ -11378,7 +11383,7 @@ msgstr "ehtolausekkeessa ei-lvalue-taulukko"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18338,88 +18343,88 @@ msgstr "Noudata ISO 2014 C++ -standardia."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Noudata ISO 202X C -standardiluonnosta (kokeellinen ja epätäydellinen tuki)."
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 msgid "argument must be passed by copying"
 msgstr "argumentin 1 on oltava 5-bittinen etumerkillinen literaali"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 msgid "callee does not return"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "muuttujalla %qD on funktiotyyppi"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 msgid "nested function"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 msgid "inconsistent number of popped arguments"
 msgstr "useita parametreja nimellä %qD"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s ei tue: split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "value argument"
 msgid "variable size arguments"
 msgstr "arvoargumentti"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 msgid "hidden string length argument passed on stack"
 msgstr "blocks-argumentti on liian suuri, maksimi on %llu"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "static assertion failed"
 msgid "tail call production failed"
@@ -18542,12 +18547,12 @@ msgstr "FORMAT-nimiö %d kohdassa %L ei ole määritelty"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "liukulukuvakiota käytetty väärin"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19866,12 +19871,12 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "tämä on käsky:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 msgid "unable to reload address in "
 msgstr "PRINT_OPERAND_ADDRESS, null-osoitin"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 #, fuzzy
 msgid "unable to generate reloads for:"
 msgstr "%s: Tätä tiedostoa ei voitu varmuuskopioida"
@@ -20104,7 +20109,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC heuristinen/heuristiikka??: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<nimetön>"
@@ -20494,20 +20499,20 @@ msgstr "fr30_print_operand: tuntematon koodi"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "virheellinen const_double-operandi"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 msgid "invalid vector constant"
 msgstr "virheellinen rotate-käsky"
@@ -20552,85 +20557,85 @@ msgstr "virheellinen etuliite ”0b” liukulukuvakiolle"
 msgid "invalid address mode"
 msgstr "virheellinen %%G-tila"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "lisäykselle annettu väärä tyyppiargumentti"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "vähennykselle annettu väärä tyyppiargumentti"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "lisäykselle annettu väärä tyyppiargumentti"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "vähennykselle annettu väärä tyyppiargumentti"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 msgid "negation operation not permitted on svbool_t"
 msgstr "parametri esitelty %<auto%>:ksi"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 #, fuzzy
 msgid "plus operation not permitted on svbool_t"
 msgstr "osoittimet eivät ole sallittuja case-arvoja"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 #, fuzzy
 msgid "minus operation not permitted on svbool_t"
 msgstr "kaksoiskappale-rajapintaesittely luokalle %qE"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 #, fuzzy
 msgid "multiply operation not permitted on svbool_t"
 msgstr "kaksoiskappale-rajapintaesittely luokalle %qE"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 #, fuzzy
 msgid "divide operation not permitted on svbool_t"
 msgstr "kaksoiskappale-rajapintaesittely luokalle %qE"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 msgid "subscript operation not supported on svbool_t"
 msgstr "säiekohtaista muistia ei tueta tälle kohteelle"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 #, fuzzy
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "kaksoiskappale-rajapintaesittely luokalle %qE"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "Virheellinen liukulukuoperaatio"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20647,13 +20652,13 @@ msgid "invalid %%r value"
 msgstr "virheellinen %%r-arvo"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "virheellinen %%R-arvo"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "virheellinen %%N-arvo"
@@ -20668,7 +20673,7 @@ msgstr "virheellinen %%P-arvo"
 msgid "invalid %%h value"
 msgstr "virheellinen %%h-arvo"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "virheellinen %%L-arvo"
@@ -20683,7 +20688,7 @@ msgstr "virheellinen %%m-arvo"
 msgid "invalid %%M value"
 msgstr "virheellinen %%M-arvo"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "virheellinen %%U-arvo"
@@ -21033,7 +21038,7 @@ msgstr "odottamaton siirros"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21314,131 +21319,131 @@ msgstr "virheellinen rotate-käsky"
 msgid "Expected register or constant integer."
 msgstr "Odotettiin nimetöntä rajapintaa kohdassa %C"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, fuzzy, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "virheellinen const_double-operandi"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "virheellinen rekisterin ”%s” käyttö"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 msgid "invalid use of asm flag output"
 msgstr "virheellinen lvalue asm-tulosteessa %d"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "fr30_print_operand: virheellinen %%x-koodi"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "fr30_print_operand: virheellinen %%x-koodi"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "fr30_print_operand: virheellinen %%x-koodi"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "fr30_print_operand: virheellinen %%x-koodi"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "fr30_print_operand: virheellinen %%x-koodi"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "fr30_print_operand: virheellinen %%F-koodi"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, fuzzy, c-format
 msgid "invalid operand code '%c'"
 msgstr "fr30_print_operand: virheellinen %%x-koodi"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, fuzzy, c-format
 msgid "invalid constraints for operand"
 msgstr "virheellinen lauseke kohdemuuttujana"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 msgid "invalid vector immediate"
 msgstr "Muotoillun tulosteen hallinta:"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 #, fuzzy
 msgid "unknown insn mode"
 msgstr "tuntematon move-käsky:"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21521,9 +21526,9 @@ msgstr "Nolla ei ole kelvollinen lausekenimiö kohdassa %C"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "virheellinen ”%%%c”:n käyttö"
@@ -21594,7 +21599,7 @@ msgid "insn contains an invalid address !"
 msgstr "virheellinen käsky:"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 #, fuzzy
 msgid "invalid address"
 msgstr "virheellinen %%G-tila"
@@ -21680,7 +21685,7 @@ msgstr "Varoita implisiittisistä funktioesittelyistä"
 msgid "invalid %%H value"
 msgstr "virheellinen %%H-arvo"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "virheellinen %%d-arvo"
@@ -21730,33 +21735,33 @@ msgstr "yritettiin käyttää ominaisuutta, jolle ei ole tukea: ”%s”"
 msgid "unsupported memory expression:"
 msgstr "kiintopistevakiot ovat GCC-laajennos"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%r operand"
 msgid "invalid vector operand"
 msgstr "virheellinen %%r-operandi"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 msgid "invalid register number for 'N' modifier"
 msgstr "fr30_print_operand: tunnistamaton %%b-koodi"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr "fr30_print_operand: tuntematon koodi"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr "osoitealueattribuuttia ei voi määritellä paikallisille muuttujille"
@@ -21821,7 +21826,7 @@ msgstr "Käytä 128-bittistä long double -tyyppiä"
 msgid "invalid %%A value"
 msgstr "virheellinen %%J-arvo"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "virheellinen %%D-arvo"
@@ -21861,7 +21866,7 @@ msgstr "virheellinen %%J-koodi"
 msgid "invalid %%k value"
 msgstr "virheellinen %%k-arvo"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "virheellinen %%K-arvo"
@@ -21891,17 +21896,17 @@ msgstr "virheellinen %%T-arvo"
 msgid "invalid %%u value"
 msgstr "virheellinen %%u-arvo"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "virheellinen %%v-arvo"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 msgid "invalid %%V value"
 msgstr "virheellinen %%J-arvo"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "virheellinen %%x-arvo"
@@ -22125,27 +22130,27 @@ msgstr "virheellinen %%s-operandi"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "muotomerkkijonolla on epäkelpo operandinumero"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, fuzzy, c-format
 msgid "'B' operand is not constant"
 msgstr "fr30_print_operand: tunnistamaton %%b-koodi"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, fuzzy, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "fr30_print_operand: tunnistamaton %%b-koodi"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, fuzzy, c-format
 msgid "'o' operand is not constant"
 msgstr "puuttuva operandi"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 msgid "'h' operand is not SImode register"
 msgstr "fr30_print_operand: tunnistamaton %%b-koodi"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: tuntematon koodi"
@@ -22208,27 +22213,27 @@ msgstr "Virheellinen operandi"
 msgid "Unable to load DLL."
 msgstr "Tuota koodia DLL:lle."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 #, fuzzy
 msgid "bad test"
 msgstr "test ja/tai ["
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 #, fuzzy
 msgid "invalid mask"
 msgstr "PEITE"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "virheellinen %%t/%%b-arvo"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 #, fuzzy
 msgid "no register in address"
 msgstr "Rekisteröi"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 #, fuzzy
 msgid "address offset not a constant"
 msgstr "siirros vakiomerkkijonon rajojen ulkopuolelle"
@@ -22267,7 +22272,7 @@ msgstr "{nimetön}"
 msgid "aka"
 msgstr "eli"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({nimetön})"
 
@@ -22292,8 +22297,8 @@ msgstr "({nimetön})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "”)” oli odotus"
@@ -22321,7 +22326,7 @@ msgstr "odotettiin %<,%> tai %<;%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "”)” oli odotus"
@@ -22329,7 +22334,7 @@ msgstr "”)” oli odotus"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "”)” oli odotus"
@@ -22350,13 +22355,13 @@ msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "”)” oli odotus"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "”)” oli odotus"
@@ -22365,7 +22370,7 @@ msgstr "”)” oli odotus"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, fuzzy, gcc-internal-format
 msgid "expected %<{%>"
@@ -22382,13 +22387,13 @@ msgstr "”)” oli odotus"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "”)” oli odotus"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "odotettiin %<,%> tai %<;%>"
@@ -22398,7 +22403,7 @@ msgstr "odotettiin %<,%> tai %<;%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "”)” oli odotus"
@@ -22409,18 +22414,18 @@ msgid "expected %<.%>"
 msgstr "”)” oli odotus"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "odotettiin %<(%> tai rivin loppu"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "”)” oli odotus"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "odotettiin %<,%> tai %<;%>"
@@ -22430,46 +22435,46 @@ msgstr "odotettiin %<,%> tai %<;%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "”)” oli odotus"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "”)” oli odotus"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<else%>"
 msgstr "odotettiin %<delete%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "odotettiin merkkijonoa ilmaisun %<#pragma message%> jälkeen"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(nimetön)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "”)” oli odotus"
@@ -22497,7 +22502,7 @@ msgstr "ehdokas on:"
 msgid "  after user-defined conversion:"
 msgstr "Ota käyttöön käyttäjän määrittelemät käskyt"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "ehdokas on:"
@@ -22605,7 +22610,7 @@ msgstr "jäsennysvirhe malliargumenttien luettelossa"
 msgid "<statement>"
 msgstr "Ei välitetä lausenimiöstä tyhjässä lauseessa kohdassa %L"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<tuntematon>"
@@ -22633,302 +22638,345 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<lausekevirhe>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<tuntematon operaattori>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "Globaalilla näkyvyysalueella:"
 
-#: cp/reflect.cc:565
+#: cp/reflect.cc:408
 #, fuzzy
-msgid "array element not a constant integer"
-msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
+msgid "reflect_constant_array failed"
+msgstr "vektoriylivuoto lausekkeessa"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 msgid "reflect_constant failed"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+msgid "array element not a constant integer"
+msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 msgid "reflection does not have template arguments"
 msgstr "strftime-muotoilut eivät voi muotoilla argumentteja"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 msgid "reflection does not represent a function or function type"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "%<-Werror=%> argument %qs is not valid for %s"
 msgid "operators argument is not a valid operator"
 msgstr "%<-Werror=%>-argumentti %qs ei ole kelvollinen %s-kielelle"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 #| msgid "non-constant condition for static assertion"
 msgid "non-constant offset for offset_of"
 msgstr "ei-vakio ehto staattiselle väitteelle"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 msgid "reflection with incomplete type in size_of"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 msgid "reflection not suitable for alignment_of"
 msgstr "Käytä H8/300-kohdistussääntöjä"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "assignment of function %qD"
 msgid "alignment_of on function type"
 msgstr "funktion %qD sijoitus"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 msgid "reflection with incomplete type in alignment_of"
 msgstr "epäkelpo %qs:n soveltaminen vaillinaiseen tyyppiin %qT "
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 msgid "reflect_function failed"
 msgstr "odotettiin luokan nimeä"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr ""
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 msgid "unexpected value of value member"
 msgstr "odotettiin luokan nimeä"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 msgid "reflection represents non-integral or bool type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 msgid "invalid argument to can_substitute"
 msgstr "%qs-attribuutin virheellinen argumentti"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 msgid "type is not object or reference type"
 msgstr "# Ei kohde:"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 #, fuzzy
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "muunnos tyyppiin %qT tyypistä %qT saattaa muuttaa sen arvoa"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 msgid "name is not a valid identifier"
 msgstr "universaali merkki %.*s ei ole kelvollinen tunniste"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 msgid "neither name nor bit_width specified"
 msgstr "kohdistusta ei voi määritellä %q+D:lle"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "kohdistusta ei voi määritellä %q+D:lle"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 msgid "bit_width 0 with specified name"
 msgstr "virheellinen saraketarkennin: %s"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+msgid "name unspecified and type is const"
+msgstr "kohdistusta ei voi määritellä %q+D:lle"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+msgid "name unspecified and type is volatile"
+msgstr "kohdistusta ei voi määritellä %q+D:lle"
+
+#: cp/reflect.cc:6038
 #, fuzzy
 msgid "alignment is not power of two"
 msgstr "dwarfin versio %d ei ole tuettu"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "right rotate count is negative"
 msgid "alignment is negative"
 msgstr "oikealle kierron laskuri on negatiivinen"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 msgid "alignment is smaller than alignment_of"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+msgid "reflection does not have non-array object type"
+msgstr "%qE:lla ei ole luokkatyyppiä"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+msgid "current scope does not represent a function"
+msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qE"
 msgid "incomplete parent class"
 msgstr "luokan %qE vaillinainen toteutus"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qE is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qE ei ole luokka eikä nimiavaruus"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 msgid "not a complete class type"
 msgstr "paluutyyppi on vaillinainen tyyppi"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 msgid "value cannot be extracted"
 msgstr "%qT ei ole malli"
@@ -22982,56 +23030,56 @@ msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT"
 msgid "source type is not polymorphic"
 msgstr "lähde ei ole osoitin"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "ehdokkaat ovat:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "unaariselle miinus-operaatiolle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "unaariselle plus-operaatiolle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "bittikomplementille annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "abs-funktiolle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "konjugaatiolle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 msgid "in argument to unary !"
 msgstr "unaariselle huutomerkille annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 #, fuzzy
 msgid "no pre-increment operator for type"
 msgstr "lisäykselle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 #, fuzzy
 msgid "no post-increment operator for type"
 msgstr "lisäykselle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 #, fuzzy
 msgid "no pre-decrement operator for type"
 msgstr "vähennykselle annettu väärä tyyppiargumentti"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 #, fuzzy
 msgid "no post-decrement operator for type"
 msgstr "vähennykselle annettu väärä tyyppiargumentti"
@@ -23050,67 +23098,67 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "Lohkonimiö ei ole sopiva IF-lauseelle kohdassa %C"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, fuzzy, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "liian vähän (%d) argumentteja funktiolle ”%s”"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, fuzzy, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, fuzzy, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 msgid "NULL() is not interoperable"
 msgstr "%qD ei ole muuttuja"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 msgid "BOZ literal constant"
 msgstr "virheellinen rotate-käsky"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 msgid "Expression is polymorphic"
 msgstr "Ennenaikainen säännöllisen lausekkeen loppu"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 msgid "Expression is a noninteroperable derived type"
 msgstr "nimettömällä kentällä on vaillinainen tyyppi"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 msgid "Procedure unexpected as argument"
 msgstr "%qs attribuuttia ei huomioida"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 msgid "Type shall have a character length of 1"
 msgstr "Syntaksivirhe merkkipituusspesifikaatiossa kohdassa %C"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "tyypit eivät ole ihan yhteensopivia"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 msgid "Assumed-size arrays are not interoperable"
 msgstr "Tyhjä taulukkomuodostin kohdassa %C ei ole sallittu"
@@ -23191,7 +23239,7 @@ msgstr "Poistettu ominaisuus:"
 msgid "Unsigned:"
 msgstr "<nimetön-etumerkillinen:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 msgid "array assignment"
 msgstr "virheellinen taulukkosijoitus"
@@ -23201,17 +23249,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, fuzzy, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, fuzzy, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
@@ -23419,11 +23467,11 @@ msgstr "lohkolaite"
 msgid "implied END DO"
 msgstr "syötteen loppu"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "sijoitus"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 #, fuzzy
 msgid "pointer assignment"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
@@ -23442,149 +23490,149 @@ msgstr ""
 "                  muuten yksinkertaisia\n"
 "  never, simple   tee aina yksinkertaisia varmuuskopioita\n"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 #, fuzzy
 msgid "elemental procedure"
 msgstr "RPC: Proseduuri ei ole käytettävissä"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 msgid "allocatable argument"
 msgstr "Virheellinen argumentti"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 msgid "asynchronous argument"
 msgstr "ei argumentteja"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "valinnainen argumentti"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "osoitinargumentti"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "kohdeargumentti"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "arvoargumentti"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 msgid "volatile argument"
 msgstr "ylimääräinen %<volatile%>"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 msgid "assumed-shape argument"
 msgstr "oletetaan palauttavan %<id%> ja hyväksyvän"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 msgid "assumed-rank argument"
 msgstr "oletetaan palauttavan %<id%> ja hyväksyvän"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 msgid "coarray argument"
 msgstr "Virheellinen argumentti"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 msgid "parametrized derived type argument"
 msgstr "sijoitus kirjoitussuojattuun viitteeseen %qD"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 msgid "polymorphic argument"
 msgstr "Virheellinen argumentti"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 #, fuzzy
 msgid "NO_ARG_CHECK attribute"
 msgstr "liian pitkä riviargumentti"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 msgid "assumed-type argument"
 msgstr "unaariselle miinus-operaatiolle annettu väärä tyyppiargumentti"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 #, fuzzy
 msgid "array result"
 msgstr "MD5-tulos on:\n"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 #, fuzzy
 msgid "pointer or allocatable result"
 msgstr "tulosta ei voi kirjoittaa: %s"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 #, fuzzy
 msgid "result with non-constant character length"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 #, fuzzy
 msgid "bind(c) procedure"
 msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Silmukkamuuttuja"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 msgid "iterator variable"
 msgstr "Syntaksivirhe iteraattorissa kohdassa %C"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 #, fuzzy
 msgid "Start expression in DO loop"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 msgid "End expression in DO loop"
 msgstr "Ennenaikainen säännöllisen lausekkeen loppu"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 #, fuzzy
 msgid "Step expression in DO loop"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 #, fuzzy
 msgid "DEALLOCATE object"
 msgstr "EI OBJEKTIA\n"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 #, fuzzy
 msgid "ALLOCATE object"
 msgstr "EI OBJEKTIA\n"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 #, fuzzy
 msgid "STAT variable"
 msgstr "tiedoston tilan lukeminen epäonnistui"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 #, fuzzy
 msgid "ERRMSG variable"
 msgstr "%qD ei ole muuttuja"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 #, fuzzy
 msgid "item in READ"
 msgstr "Soita numero"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 #, fuzzy
 msgid "ACQUIRED_LOCK variable"
 msgstr "uutta arkistoa ei voi lukita"
@@ -23594,31 +23642,31 @@ msgstr "uutta arkistoa ei voi lukita"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Odotettiin PARAMETER-symbolia kompleksivakiossa kohdassa %C"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, fuzzy, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, fuzzy, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, fuzzy, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 #, fuzzy
 msgid "Assignment of scalar to unallocated array"
 msgstr "virheellinen taulukkosijoitus"
@@ -23683,27 +23731,27 @@ msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, fuzzy, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "liian vähän (%d) argumentteja funktiolle ”%s”"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, fuzzy, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "liian vähän (%d) argumentteja funktiolle ”%s”"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, fuzzy, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "liian vähän (%d) argumentteja funktiolle ”%s”"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23806,7 +23854,7 @@ msgid "expected boolean type"
 msgstr "odotettiin totuusarvotyyppiä"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "odotettiin kokonaislukua"
@@ -23877,7 +23925,7 @@ msgstr "liian vähän argumentteja"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "liian monta argumenttia"
@@ -24325,7 +24373,7 @@ msgstr "profilointituki VxWorksille"
 msgid "target OS does not support unaligned accesses"
 msgstr "kohdemuoto ei tue äärettömyyttä"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "Avainsana %s on tuntematon tai sillä ei vielä ole toteutusta"
@@ -24568,13 +24616,13 @@ msgstr "tuntematon komentorivivalitsin %qs"
 msgid "Global declarative %s for %s"
 msgstr "%q+#D:n esittely"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24739,12 +24787,12 @@ msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "tuntematon konetila %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "tls_model-argumentti ei ole merkkijono"
@@ -25176,8 +25224,8 @@ msgstr "%qE-attribuutti on ristiriidassa attribuutin %s kanssa"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "%q+D:lla on edellinen esittely täällä"
@@ -25194,7 +25242,7 @@ msgstr "%qE-attribuuttia ei huomioida %qE:lle"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%qs-attribuuttidirektiivi jätetty huomiotta"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "attribuutille %qE annettu väärä määrä argumentteja"
@@ -25204,7 +25252,7 @@ msgstr "attribuutille %qE annettu väärä määrä argumentteja"
 msgid "expected %i or more, found %i"
 msgstr "odotettu vähintään %i, löytyi %i"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %i or more, found %i"
 msgid "expected %i, found %i"
@@ -25288,12 +25336,12 @@ msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25409,134 +25457,134 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 msgid "corresponding source location"
 msgstr "Säädä dynaamisen linkittäjän ajonaikaiset sidonnat."
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, fuzzy, gcc-internal-format
 msgid "location of the second call"
 msgstr "%qD:lle ei ole edellistä esittelyä"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of functions"
 msgid "location is after end of function"
 msgstr "luodaan funktioiden taulukko"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "Odottamaton TAG."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "profiilitiedostoa %s ei voi avata"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "tiedoston ”%s” otsaketta ei voi lukea"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "tiedoston ”%s” otsaketta ei voi lukea"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "tiedoston ”%s” otsaketta ei voi lukea"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "tiedoston ”%s” otsaketta ei voi lukea"
@@ -25546,7 +25594,7 @@ msgstr "tiedoston ”%s” otsaketta ei voi lukea"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "siirros vakiomerkkijonon rajojen ulkopuolelle"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qE esitelty täällä"
@@ -25649,7 +25697,7 @@ msgstr "%qs odottaa vakioargumenttia"
 msgid "illegal argument 0 to %qs"
 msgstr "virheellinen argumentti 0 %qs:lle"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -25724,12 +25772,12 @@ msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 msgid "cannot tail-call: %s"
 msgstr "lähdetiedostoa %s ei löydy"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "funktiokutsulla on aggregaattiarvo"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "blocks-argumentti on liian suuri, maksimi on %llu"
@@ -26373,342 +26421,342 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "polku puuttuu %qs:n jälkeen"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, fuzzy, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, fuzzy, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "virheellinen sisäinen makro ”%s”"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "virheellinen sisäinen makro ”%s”"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "UNIT-numeron lauseessa kohdassa %L täytyy olla epänegatiivinen"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "%s: kenttä ”%s” ei saa olla määritelty"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "virheellinen sisäinen makro ”%s”"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr "virheellinen sisäinen makro ”%s”"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "%<return%> arvon kanssa voidin palauttavassa funktiossa"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr "funktio voi olla ehdokas %<%s%>-attribuutille"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "Väärä taikaluku --- RESERVED_13"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, fuzzy, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "parametri %q+D esitelty %<inline%>:ksi"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "Väärä taikaluku --- RESERVED_13"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "Väärä taikaluku --- RESERVED_13"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "Väärä taikaluku --- RESERVED_13"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "ei-muuttujan %qD esittely %<for%>-silmukan alkuesittelyssä"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "ei-muuttujan %qD esittely %<for%>-silmukan alkuesittelyssä"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "ei-muuttujan %qD esittely %<for%>-silmukan alkuesittelyssä"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "ei-muuttujan %qD esittely %<for%>-silmukan alkuesittelyssä"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, fuzzy, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "bittikentän %qs leveys on negatiivinen"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, fuzzy, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "Ei ole tuettu"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, fuzzy, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "Stmt-sisäkkäistysvirhe."
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, fuzzy, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "tyhjä esittely"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "lauseella ei ole vaikutusta"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, fuzzy, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "symtab_node::verify epäonnistui"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "%s: osaa ”%.*s” ei tunneta"
@@ -27475,17 +27523,17 @@ msgstr "paikallisten objektien kokonaiskoko on liian suuri"
 msgid "impossible constraint in %<asm%>"
 msgstr "virheellinen ”asm”: "
 
-#: function.cc:4285
+#: function.cc:4292
 #, fuzzy, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "Varoita muuttujista, joita ”longjmp” tai ”vfork” saattaa muuttaa."
 
-#: function.cc:4306
+#: function.cc:4313
 #, fuzzy, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "Varoita muuttujista, joita ”longjmp” tai ”vfork” saattaa muuttaa."
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "funktio palauttaa aggregaatin"
@@ -28161,7 +28209,7 @@ msgstr "raja %3$E, jonka %1$G%2$qD määrittelee, on sama kuin lähteen pituus"
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "joustava taulukkojäsen ei ole structin lopussa"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -28201,7 +28249,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 msgid "%qD defined here"
 msgstr "nimiö %qD määritelty täällä"
@@ -28221,24 +28269,24 @@ msgstr "null-osoittimen käyttö"
 msgid "function may return address of local variable"
 msgstr "funktio palauttaa osoitteen paikalliseen muuttujaan"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "funktio palauttaa osoitteen paikalliseen muuttujaan"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -29131,7 +29179,7 @@ msgstr "%<%.*s%>-direktiivi kirjoittaa jopa %wu tavua %wu tavun kokoiseen aluees
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 msgid "returned from %qD"
 msgstr "käyttämätön muuttuja %q+D"
@@ -29203,210 +29251,210 @@ msgstr "kutsussa muistinvarausfunktioon %qD, joka on esitelty täällä"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "Tuntematon arkkitehtuuri ”%s”"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "valid arguments are: %s"
 msgid "valid models are %e"
 msgstr "kelvolliset argumentit ovat: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, fuzzy, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, fuzzy, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "epäkelpo %<restrict%>-avainsanan käyttö"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, fuzzy, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "epäkelpo %<restrict%>-avainsanan käyttö"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "%qE-attribuutti soveltuu vain muuttujiin ja funktioihin"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "Funktion %s argumentti kohdassa %L on negatiivinen"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "muuttuja %qD esitelty %<inline%>:ksi"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "epäkelpo alkiotyyppi attribuutille %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "Virheellinen vähimmäisargumenttimäärä (%d) funktiolle %s"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "epäkelpo alkiotyyppi attribuutille %qs"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, fuzzy, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr "tiedostoa %s ei voi avata"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 msgid "assigned here"
 msgstr "union määritelty täällä"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "kohdistusta ei voi määritellä %q+D:lle"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %qD"
 msgid "pointer used after %qD"
 msgstr "käyttämätön parametri %qD"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 msgid "call to %qD here"
 msgstr "%qD esiteltiin täällä"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "epäkelpo osoitintila %qs"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "%qD ei ole %qD:n jäsen"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "epäkelpo osoitintila %qs"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD esitelty täällä"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "%s: tuntematon osan nimi ”%.*s”"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "alunperin määritelty täällä"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "%qD on tavallisesti ei-staattinen funktio"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "%qD on tavallisesti ei-staattinen funktio"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "call to %qD"
 msgstr "%J%qD esitelty turhaan uudestaan"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "palautettu osoite paikalliseen muuttujaan %q+D"
@@ -30213,346 +30261,346 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, fuzzy, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "edellinen määrittely täällä"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, fuzzy, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, fuzzy, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "edellinen määrittely täällä"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, fuzzy, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, fuzzy, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "typeid:tä ei voi käyttää -fno-rtti-valitsimen kanssa"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, fuzzy, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, fuzzy, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, fuzzy, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "TAPA"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, fuzzy, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, fuzzy, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "TAPA"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, fuzzy, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "edellinen määrittely täällä"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, fuzzy, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "edellinen määrittely täällä"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "erilainen tyyppi määritelty toisessa käännösyksikössä"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, fuzzy, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "Käyttö: %s [VALITSIN]... NIMI TYYPPI [MAJOR MINOR]\n"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "lueteltu tyyppi määritelty täällä"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "taulukkotyypeillä on eri rajat"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, fuzzy, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "ehtolausekkeessa on osoitin/kokonaislukutyyppiristiriita"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "?:-lausekkeen operandeilla on eri tyypit, %qT ja %qT"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, fuzzy, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "edellinen määrittely täällä"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, fuzzy, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, fuzzy, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, fuzzy, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, fuzzy, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, fuzzy, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, fuzzy, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, fuzzy, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, fuzzy, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, fuzzy, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, fuzzy, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, fuzzy, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, fuzzy, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, fuzzy, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, fuzzy, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "%q+#D määritelty aiemmin täällä"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "edellinen määrittely täällä"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, fuzzy, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, fuzzy, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 msgid "mismatching definition"
 msgstr "puuttuva määrittely"
@@ -30572,7 +30620,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "virheellinen muunnos gimple-kutsussa"
@@ -30806,12 +30854,12 @@ msgstr "Kumoamistoimintojen enimmäismäärä"
 msgid "unable to find a register to spill"
 msgstr "Tiedostoa ”%s” ei löytynyt."
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, fuzzy, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "virheellinen lvalue asm-tulosteessa %d"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "Kumoamistoimintojen enimmäismäärä"
@@ -31182,7 +31230,7 @@ msgstr "argumenttien määrä ei vastaa prototyyppiä"
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "argumenttien määrä ei vastaa prototyyppiä"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -32563,22 +32611,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr "virheellinen lvalue asm-tulosteessa %d"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -33516,107 +33564,107 @@ msgstr "Käyttö: %s <transaktiotiedosto> <tiedostojärjestelmä>\n"
 msgid "ignoring loop annotation"
 msgstr "continue-lause silmukan ulkopuolella"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "pyydetty muuntoa ei-skalaarityypiksi"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "taulukon %qE koko ei ole kokonaislukutyyppiä"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, fuzzy, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "virheellinen %%r-arvo"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "%qD:n virheellinen käyttö"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr ""
@@ -33630,63 +33678,63 @@ msgstr ""
 "                  muuten yksinkertaisia\n"
 "  never, simple   tee aina yksinkertaisia varmuuskopioita\n"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "käytetty tietuetyypin arvoa, vaikka vaaditaan skalaari"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "virheellinen lvalue asm-tulosteessa %d"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, fuzzy, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, fuzzy, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "epäkelpo tallennusluokka funktiolle %qs"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, fuzzy, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr "%<noreturn%>-funktio palaa"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -33697,602 +33745,602 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "ehdotetaan sulkeita vertailun ympärille %<|%>:n operandissa"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, fuzzy, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "epäkelpo totuusarvolauseke"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "epäkelpo vektorityyppi attribuutille %qE"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "Varoita eri enum-tyyppien vertailusta"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "Virheellinen liukulukuoperaatio"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "virheelliset tyypit nop-muunnokselle"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "virheelliset tyypit nop-muunnokselle"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "virheellisiä tyyppejä muunnoksessa kokonaisluvuksi"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, fuzzy, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "virheellisiä tyyppejä muunnoksessa liukuluvuksi"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "virheellisiä tyyppejä muunnoksessa liukuluvuksi"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "virheellisiä tyyppejä muunnoksessa kokonaisluvuksi"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "virheellinen argumentti %s %s:lle"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "virheellinen argumentti %s %s:lle"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "Virheellinen liukulukuoperaatio"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "epäkelpo osoitintila %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "ehtolausekkeessa on tyyppiristiriita"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "Virheellinen liukulukuoperaatio"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "Taulukkotyyppi      : %s\n"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "virheellinen vastaanottajatyyppi %qs"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "virheellinen vastaanottajatyyppi %qs"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "taulukon %qE koko ei ole kokonaislukutyyppiä"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "virheellinen vastaanottajatyyppi %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "Ei ole hakemisto"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "virheellinen argumentti %s %s:lle"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "Ei välitetä lausenimiöstä tyhjässä lauseessa kohdassa %L"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "Ei välitetä lausenimiöstä tyhjässä lauseessa kohdassa %L"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "virheellinen %%r-arvo"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "argumentti %qd ei ole vakio"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, fuzzy, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, fuzzy, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-voidin"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "enum-muunnos palautuksessa on virheellistä C++-kielessä"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "goto-kohde ei ole nimiö eikä osoitin"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "ei-kokonaislukutyyppi switch-lausekkeessa"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "Ensimmäinen/seuraava ketju rikki"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "ehtolausekkeessa on tyyppiristiriita"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "nimike yhdyslauseen lopussa"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "nimike yhdyslauseen lopussa"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "parametrien nimet (ilman tyyppejä) funktion esittelyssä"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, fuzzy, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "muotomerkkijonolla on epäkelpo operandinumero"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "virheellinen versionumero ”%s”"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "virheellinen muunnos gimple-kutsussa"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "MD5-tulos on:\n"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "puuttuva ”]”"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "Virheellinen argumentti"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "verify_gimple epäonnistui"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "funktio %qE esitelty implisiittisesti"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, fuzzy, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) on asetettu väärään peruslohkoon"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, fuzzy, gcc-internal-format
 msgid "PHI node with location"
 msgstr "symtab_node::verify epäonnistui"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 "Vihje: %s\n"
 "\n"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) on asetettu väärään peruslohkoon"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple epäonnistui"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "alustimen lopussa on ylimääräinen lohko"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "alustimen lopussa on ylimääräinen lohko"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE:a ei ole alustettu"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr "verify_flow_info: Väärä lohkolukumäärä %i %i"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "Nimiö ”%s” kohdassa %C ei täsmää IF nimiön ”%s” kanssa"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "%2$qD:n parametrilla %1$P on vaillinainen tyyppi %3$qT"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "vuonohjauskäsky peruslohkon sisällä"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr "vuonohjauskäsky peruslohkon sisällä"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "väärä määrä argumentteja funktiolle %<va_start%>"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "väärä määrä argumentteja funktiolle %<va_start%>"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "useita default-nimikkeitä samassa switch-lauseessa"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "ylimääräisiä tyyppimääreitä muotoiluargumentissa (argumentti %d)"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "”I”-lippu"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%>-funktio palaa"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "ei-void-tyyppisen funktion loppu saavutettu"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "%qD:n paluuarvoa ei huomioida, esitelty attribuutilla warn_unused_result"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "attribuutilla warn_unused_result esitellyn funktion paluuarvoa ei huomioida"
@@ -34472,12 +34520,12 @@ msgstr "kohdemuoto ei tue äärettömyyttä"
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "kohdemuoto ei tue äärettömyyttä"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "epäkelpo alkiotyyppi attribuutille %qs"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
@@ -34990,7 +35038,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -35415,29 +35463,29 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, fuzzy, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "%qE-attribuuttia ei huomioida"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "%qD:lle ei ole edellistä esittelyä"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q+D:n data-alue on ristiriidassa edellisen esittelyn kanssa"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 msgid "%qD conflicts for version %qB"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "%q+D:n data-alue on ristiriidassa edellisen esittelyn kanssa"
@@ -35512,7 +35560,7 @@ msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 msgid "no initializers are allowed in section %qs"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, fuzzy, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "kohdistusta ei voi määritellä %q+D:lle"
@@ -35660,7 +35708,7 @@ msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "weakref ei ole tuettu tässä konfiguraatiossa"
@@ -35705,53 +35753,53 @@ msgstr "pinon ylivuoto"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "muodostimen virheellinen käyttö mallina"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "muodostimen virheellinen käyttö mallina"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
@@ -35766,12 +35814,12 @@ msgstr "%qE-attribuutti soveltuu vain muuttujiin ja funktioihin"
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "%qE-attribuutti soveltuu vain muuttujiin ja funktioihin"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
@@ -35981,12 +36029,12 @@ msgstr "luetelluille tyypeille ei voi käyttää tilaa %qs"
 msgid "mode %qs applied to inappropriate type"
 msgstr "tilaa %qs sovellettu sopimattomaan tyyppiin"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, fuzzy, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "pakattu attribuutti on tarpeeton %q+D:lle"
@@ -35996,18 +36044,18 @@ msgstr "pakattu attribuutti on tarpeeton %q+D:lle"
 msgid "section attribute argument not a string constant"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "osoitealueattribuuttia ei voi määritellä paikallisille muuttujille"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "on ristiriidassa %q+#D:n edellisen esittelyn kanssa"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi"
@@ -36094,7 +36142,7 @@ msgstr "tunniste %qE on ristiriidassa C++:n varatun sanan kanssa"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "muuttuja %qD esitelty %<inline%>:ksi"
@@ -36140,12 +36188,12 @@ msgstr "%qE-attribuutti pätee vain muuttujiin"
 msgid "%qE attribute is only applicable on functions"
 msgstr "%qE-attribuutti pätee vain funktioihin"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "%qE-attribuutti pätee vain funktioihin"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "%qE-attribuutti pätee vain funktioihin"
@@ -36155,12 +36203,12 @@ msgstr "%qE-attribuutti pätee vain funktioihin"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin"
@@ -36251,23 +36299,23 @@ msgstr "%qE-attribuuttia ei huomioida koska %qT on jo määritelty"
 msgid "visibility argument not a string"
 msgstr "näkyvyysargumentti ei ole merkkijono"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "%qE-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD esitelty uudelleen eri näkyvyydellä"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD esiteltiin tyyppinä %qs, mikä edellyttää oletusnäkyvyyttä"
@@ -36284,7 +36332,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "%qE-attribuutti pätee vain funktioihin"
@@ -36355,7 +36403,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "%qE-attribuuttia ei huomioida %qT-tyypin palauttavalle funktiolle"
@@ -36430,7 +36478,7 @@ msgstr "%qD ei ole %qD:n jäsen"
 msgid "%qE argument is not a function"
 msgstr "%qE esitelty funktion palauttavana funktiona"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "odotettiin merkkijonoa ilmaisun %<#pragma message%> jälkeen"
@@ -36496,7 +36544,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "%qE-attribuuttia ei huomioida ei-luokkatyypeille"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
@@ -36659,15 +36707,15 @@ msgid "requested position is less than zero"
 msgstr "haluttu sijainti on pienempi kuin nolla"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "säiekohtaista muistia ei tueta tälle kohteelle"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
@@ -36935,7 +36983,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "ehdotetaan sulkeita totuusarvona käytetyn sijoituksen ympärille"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "epäkelpo %<restrict%>-avainsanan käyttö"
@@ -37106,8 +37154,8 @@ msgstr "ei tarpeeksi muuttuja-argumentteja lopetusalkion mahduttamiseksi"
 msgid "missing sentinel in function call"
 msgstr "lopetusalkio puuttuu funktiokutsusta"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, fuzzy, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "%s ei ole liitospiste tai virheellinen valitsin"
@@ -38134,7 +38182,7 @@ msgstr "virheellinen loppuliite ”%.*s” liukulukuvakiolla"
 msgid "traditional C rejects string constant concatenation"
 msgstr "perinteinen C ei salli merkkijonovakioiden katenointia"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -38189,7 +38237,7 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu"
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
@@ -38204,17 +38252,17 @@ msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 msgid "%qE is not initialized"
 msgstr "%qE:a ei ole alustettu"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, fuzzy, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "’(’ puuttuu predikaatin jäljestä"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "Muotoillun tulosteen hallinta:"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "puuttuva kasvatuslauseke"
@@ -38224,7 +38272,7 @@ msgstr "puuttuva kasvatuslauseke"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "virheellinen kasvatuslauseke"
@@ -38321,18 +38369,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD ei ole funktioargumentti"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "bittikentän %qs leveys on nolla"
@@ -38342,8 +38390,8 @@ msgstr "bittikentän %qs leveys on nolla"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "bittikentän %qs leveys on nolla"
@@ -38861,7 +38909,7 @@ msgstr "virheelinen sijainti ilmaisulle %<#pragma %s%>, jätetään huomiotta"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "väärinmuodostettu %<#pragma %s%>, jätetään huomiotta"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "roskaa %<#pragma %s%>:n lopussa"
@@ -38934,8 +38982,8 @@ msgstr "%<#pragma%> ei ole sallittu täällä"
 msgid "wrong type argument to %s"
 msgstr "abs-funktiolle annettu väärä tyyppiargumentti"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -39425,17 +39473,17 @@ msgstr "funktion %qD vähennys"
 msgid "function %qD used as %<asm%> output"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "kirjoitussuojatun sijainnin %qE sijoitus"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "kirjoitussuojatun sijainnin %qE kasvatus"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "kirjoitussuojatun sijainnin %qE vähennys"
@@ -39703,7 +39751,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "sijoitus hylkää kohdeosoitintyypin määreitä"
 msgstr[1] "sijoitus hylkää kohdeosoitintyypin määreitä"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -40641,7 +40689,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -41312,7 +41360,7 @@ msgstr "argumentin %d/%qE välitys erilaisesta Objective-C-tyypistä"
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "kaksinkertainen <%s>:n määrittely"
@@ -41361,7 +41409,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "tyypillä %qT ei ole tunnettua kokoa"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "%qE-attribuuttia ei huomioida koska %qT on jo määritelty"
@@ -41413,7 +41461,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -41507,19 +41555,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec-argumentti välitetty funktiolle, jolla ei ole prototyyppiä"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41565,212 +41613,212 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr ""
 "Käyttö: %s [MERKKIJONO]...\n"
 "  tai:  %s VALITSIN\n"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "virheellinen lauseke kohdemuuttujana"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "virheellinen %%h-arvo"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 "Käyttö: %s [MERKKIJONO]...\n"
 "  tai:  %s VALITSIN\n"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "tuntematon valitsin -%s"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "Funktio %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, fuzzy, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "Älä varoita Microsoft-laajennosten käytöstä"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "Älä varoita Microsoft-laajennosten käytöstä"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, fuzzy, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "epäkelpo argumentti funktiolle %<__builtin_frame_address%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, fuzzy, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr "-Wformat-y2k jätetty huomiotta ilman valitsinta -Wformat"
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "Virheellinen vähimmäisargumenttimäärä (%d) funktiolle %s"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "valitsin -mcpu=%s on ristiriidassa valitsimen -march=%s kanssa"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "%s ei tue %%n$-operandinumeromuotoilua"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%qE on vanhentunut"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr "koodimalli %s ei tue PIC-tilaa"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "koodimalli %s ei tue PIC-tilaa"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, fuzzy, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "%s:n perästä puuttuu operandi"
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, fuzzy, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "%s:n perästä puuttuu operandi"
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "%s:n perästä puuttuu operandi"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "Väärin muotoiltu kohdekohtainen muuttujamäärittely"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "%J%qD sallii vain nolla tai kaksi argumenttia"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "%s ei tue muotoilua %<%%%s%c%> %s"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "kohde ”%s” ei täsmää kohdehahmon kanssa"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41778,200 +41826,200 @@ msgstr "kohde ”%s” ei täsmää kohdehahmon kanssa"
 msgid "attribute %<target%> argument not a string"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "kohde ”%s” ei täsmää kohdehahmon kanssa"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "Väärin muotoiltu kohdekohtainen muuttujamäärittely"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "%s:n perästä puuttuu operandi"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, fuzzy, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "Varoita ylikuormitetuista virtuaalifunktioiden nimistä"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+#D aiemmin esitelty täällä"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, fuzzy, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "operandinumero on arvoalueen ulkopuolella muotoilussa"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "tuntematon värimoodi"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "%<operator delete%>:n on palautettava tyyppi %qT"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, fuzzy, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "%<operator delete%>:n on palautettava tyyppi %qT"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä"
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "nimiö %qD määritelty täällä"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "funktion %2$qE argumentti %1$d annetaan eri levyisenä prototyypin takia"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "%s: kentän ”%s” arvon on oltava välillä %d...%d"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "funktion %2$qE argumentti %1$d annetaan eri levyisenä prototyypin takia"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "funktion %2$qE argumentti %1$d annetaan eri levyisenä prototyypin takia"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "funktion %2$qE argumentti %1$d annetaan eri levyisenä prototyypin takia"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "%qE-attribuuttia ei huomioida"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 #, fuzzy
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "%qE-attribuuttia ei huomioida"
@@ -42160,12 +42208,12 @@ msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -42298,22 +42346,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, fuzzy, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "taulukon indeksin tyyppi on %<char%>"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "Funktio %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "virheellinen lvalue asm-tulosteessa %d"
@@ -42853,12 +42901,12 @@ msgstr "%<-fpie%> ei ole tuettu"
 msgid "%<-fPIE%> is not supported"
 msgstr "%<-fPIE%> ei ole tuettu"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "valitsimet %s ja %s ovat toisensa poissulkevat"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
@@ -42868,7 +42916,7 @@ msgstr "%qD:lla ei voi olla oletusargumentteja"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
@@ -43197,7 +43245,7 @@ msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "virheellinen sisäinen makro ”%s”"
@@ -43515,7 +43563,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -43683,172 +43731,172 @@ msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 msgid "parameter to builtin not valid: %s"
 msgstr "SISÄÄNRAKENNETTU CD %s\n"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "keskeytyskäsittelijät eivät voi olla MIPS16-funktioita"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr "<%s> ja <%s> ovat virheellisiä nimiä välille"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "argumentin 2 on oltava 5-bittinen etumerkitön literaali"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "virheellinen salasana"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "virheellinen salasana"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "argumentin 2 on oltava 5-bittinen etumerkitön literaali"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "case-nimiö ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, fuzzy, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "<%s> ja <%s> ovat virheellisiä nimiä välille"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, fuzzy, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "<%s> ja <%s> ovat virheellisiä nimiä välille"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%>-funktion toinen argumentti on epäkelpo; käytetään nollaa"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid arguments"
 msgid "invalid third argument"
 msgstr "virheelliset argumentit"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%>-funktion kolmas argumentti on epäkelpo; käytetään nollaa"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%>-funktion kolmas argumentti on epäkelpo; käytetään nollaa"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "%<__builtin_longjmp%>-fuktion toisen argumentin pitää olla 1"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "argumentin <%s>:lle on oltava yksittäinen merkki"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "puhdistusargumentti ei ole tunniste"
@@ -44245,8 +44293,8 @@ msgstr "”%s” ei ole kelvollinen esikääntäjän valitsin"
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
@@ -44488,7 +44536,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr "muodostimen virheellinen käyttö mallina"
@@ -44513,12 +44561,12 @@ msgstr "muodostimen virheellinen käyttö mallina"
 msgid "x87 register return with x87 disabled"
 msgstr "muodostimen virheellinen käyttö mallina"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -44528,128 +44576,128 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "”%s”-liitännäinen on yhteensopiva."
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "ISO C kieltää sisäkkäiset funktiot"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "Rinnakkaiset työt (-j) eivät ole tuettuja tällä alustalla."
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "ISO C kieltää sisäkkäiset funktiot"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "ISO C kieltää sisäkkäiset funktiot"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "ISO C kieltää sisäkkäiset funktiot"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "ISO C90 ei tue joustavia taulukon jäseniä"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "epäkelpo osoitintila %qs"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "epäkelpo osoitintila %qs"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "epäkelpo osoitintila %qs"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, fuzzy, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr "fr30_print_operand: tuntematon koodi"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "fr30_print_operand: tuntematon koodi"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, fuzzy, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "fr30_print_operand: tuntematon koodi"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, fuzzy, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "valitsin -mmultiple ei ole tuettu little-endian-järjestelmissä"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "Tuntematon arkkitehtuuri ”%s”"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
@@ -44702,7 +44750,7 @@ msgstr "gp_offset (%ld) tai end_offset (%ld) on pienempi kuin nolla"
 msgid "argument %qd is not a constant"
 msgstr "argumentti %qd ei ole vakio"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -44713,7 +44761,7 @@ msgstr "PRINT_OPERAND_ADDRESS, null-osoitin"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "Tuntematon tiheys: ”%c”"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -44867,48 +44915,48 @@ msgstr "kohde ”%s” ei täsmää kohdehahmon kanssa"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "kohde ”%s” ei täsmää kohdehahmon kanssa"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, fuzzy, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, fuzzy, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "versioattribuutti ei ole merkkijono"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr "Käytä bittikenttäkäskyjä"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "säiekohtaista muistia ei tueta tälle kohteelle"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not supported on this target"
 msgid "%qs is not supported in target attribute"
@@ -45665,7 +45713,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 msgid "bad builtin code"
 msgstr "<sisäänrakennettu>"
@@ -45889,82 +45937,82 @@ msgstr "%s: ei voida avata COFF-tiedostona"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, fuzzy, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "%s %qs"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "%J%qD:n esittely varjostaa parametria"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "kohdistuksen pitää olla kahden potenssi, ei %d"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "weakref ei ole tuettu tässä konfiguraatiossa"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "weakref ei ole tuettu tässä konfiguraatiossa"
@@ -46197,326 +46245,326 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "Virheellinen vähimmäisargumenttimäärä (%d) funktiolle %s"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "tyypillä %qT ei ole tunnettua kokoa"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "tyypillä %qT ei ole tunnettua kokoa"
 
 # XXX
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, fuzzy, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "tiedostoa %s ei voi avata"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "määrittelemättömän tyypin %<%s %E%> epäkelpo käyttö"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "%2$qD:n parametrilla %1$P on vaillinainen tyyppi %3$qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "tunnistamaton osoite"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "päättämätön kutsu funktioon ”%s”: puuttuva ”%c”"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "tuntematon cc_attr-arvo"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, fuzzy, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "Älä varoita Microsoft-laajennosten käytöstä"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec-argumentti välitetty funktiolle, jolla ei ole prototyyppiä"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "Käytä 64-bittistä ABIa"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "Käytä 64-bittistä ABIa"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "Käytä 64-bittistä ABIa"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "Käytä 64-bittistä ABIa"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "Käytä 64-bittistä ABIa"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, fuzzy, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "Älä varoita Microsoft-laajennosten käytöstä"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "näkyvyysargumentti ei ole merkkijono"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "%qE-attribuutti tarvitsee kokonaislukuvakioargumentin"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, fuzzy, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "Älä varoita Microsoft-laajennosten käytöstä"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "kohdemuoto ei tue äärettömyyttä"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "koodimalli %s ei tue PIC-tilaa"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 ei tue kompleksityyppejä"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, fuzzy, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "-mvsx ja -mpaired ovat yhteensopimattomat"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "  uid = %d, gid = %d, oikeudet = 0%o.\n"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "luokkanimeä ei ole annettu %qs:n kanssa"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "Funktio %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "virheellinen aikakatkaisuarvo: %s"
@@ -47515,22 +47563,22 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr "profilointituki CR16:lle"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "taulukon koko on liian suuri"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, fuzzy, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "%qE-attribuutti soveltuu vain muuttujiin ja funktioihin"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle"
@@ -47751,32 +47799,32 @@ msgstr "%qD ei ole määritelty funktion näkyvyysalueen ulkopuolella"
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%qD määritelty mutta käyttämätön"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, fuzzy, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "Estä kaikkien laitteistoliukulukukäskyjen käyttö"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "weakref ei ole tuettu tässä konfiguraatiossa"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, fuzzy, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "kohdemuoto ei tue äärettömyyttä"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47863,7 +47911,7 @@ msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja
 msgid "%qs attribute only applies to variadic functions"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47947,8 +47995,8 @@ msgstr "Ei ole hakemisto"
 msgid "could not get size of source file"
 msgstr "Tiedoston ”%s” palauttaminen epäonnistui."
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "tyhjää arvoa ei jätetä huomioimatta, vaikka kuuluisi"
@@ -48430,7 +48478,7 @@ msgstr "switch hyppää muuttuja-alustuksen yli"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE määritelty vääränlaisena tunnisteena"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
@@ -48588,7 +48636,7 @@ msgstr "ISO C90 ei tue parametritaulukkoesittelyissä avainsanaa %<static%> tai
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 ei tue syntaksia %<[*]%> taulukkoesittelijöissä"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -48599,7 +48647,7 @@ msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 msgid "%q+D is usually a function"
 msgstr "%q+D on yleensä funktio"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "%qD:lle ei ole edellistä esittelyä"
@@ -48675,7 +48723,7 @@ msgstr "ei voi laittaa volatile-kenttäistä objektia rekisteriin"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "alustamaton vakio %qD on virheellinen C++-kielessä"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, fuzzy, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%qE nimiavaruudessa %qE ei nimeä tyyppiä"
@@ -48879,7 +48927,7 @@ msgstr "tallennusluokka annettu parametrille %qE"
 msgid "storage class specified for unnamed parameter"
 msgstr "tallennusluokka annettu nimettömälle parametrille"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "tallennusluokka annettu typenamelle"
@@ -49052,7 +49100,7 @@ msgstr "tyyppinimi esitelty taulukon palauttavan funktiona"
 msgid "function definition has qualified void return type"
 msgstr "funktion määrittely oikeuttaa tyhjän paluutyypin"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "tyyppimääritteet jätetään huomiotta funktion paluutyypissä"
@@ -49179,7 +49227,7 @@ msgstr "ISO C kieltää const- ja volatile-funktiotyypit"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "muuttuja tai kenttä %qE esitelty voidiksi"
@@ -49394,7 +49442,7 @@ msgstr "tyypin määritteleminen tyyppimuunnoksessa on virheellistä C++-kieless
 msgid "%qT defined in underspecified object initializer"
 msgstr "%qs määritelty tietueen kentälle %qE"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "esittely ei esittele mitään"
@@ -49459,7 +49507,7 @@ msgstr "structilla ei ole nimettyjä jäseniä"
 msgid "struct has no members"
 msgstr "structilla ei ole jäseniä"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -49528,7 +49576,7 @@ msgstr "%<enum %E%>:n uudelleenmäärittely"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr "annettu tila on liian pieni luetelluille arvoille"
@@ -49586,7 +49634,7 @@ msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C rajoittaa luetellun tyypin arvot %<int%>-tyypin arvoalueelle"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline"
@@ -49736,12 +49784,12 @@ msgstr "argumentti %qD ei vastaa sisäistä prototyyppiä"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "argumentti %qD ei sovi prototyyppiin"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-voidin"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "parametri %qD on alustettu"
@@ -49824,7 +49872,7 @@ msgstr "%qE:a käytetään alustamattomana tässä funktiossa"
 msgid "two or more data types in declaration specifiers"
 msgstr "yli yksi tietotyyppi esittelymääritteissä"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> on liian pitkä GCC:lle"
@@ -49932,7 +49980,7 @@ msgstr "ISO C90 ei tue kompleksityyppejä"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C ei tue saturoituvia tyyppejä"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "kohteen int-tyyppi on kapeampi kuin kohteen char-tyyppi"
@@ -50091,12 +50139,12 @@ msgstr "kohdistuksen %q+D:lle pitää olla vähintään %d"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -50157,37 +50205,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%s ei tue muotoilua %<%%%c%> %s"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "negatiivisen arvon siirto vasemmalle"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "vasemmalle siirron lukumäärä on negatiivinen"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "vasemmalle siirron lukumäärä >= tyypin leveys"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "oikealle siirron lukumäärä >= tyypin leveys"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "vasemmalle siirron lukumäärä >= tyypin leveys"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "oikealle siirron lukumäärä >= tyypin leveys"
@@ -50207,7 +50255,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr "toinen täsmäävyys on täällä"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 msgid "expected end of line"
 msgstr "odotettiin %<(%> tai rivin loppu"
@@ -50217,7 +50265,7 @@ msgstr "odotettiin %<(%> tai rivin loppu"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C kieltää tyhjät käännösyksiköt"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -50264,8 +50312,8 @@ msgid "unknown type name %qE"
 msgstr "%qE ei nimeä tyyppiä"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, fuzzy, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "useita tallennusluokkia esittelymääritteissä"
@@ -50300,7 +50348,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
@@ -50315,12 +50363,12 @@ msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 msgid "unexpected attribute"
 msgstr "Odottamattomat argumentit"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "pakattu attribuutti on tarpeeton %q+D:lle"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "pakattu attribuutti on tarpeeton %q+D:lle"
@@ -50363,7 +50411,7 @@ msgstr "%<auto%> tiedostoalueen tyhjässä esittelyssä"
 msgid "%qs may only be used with a single declarator"
 msgstr "tallennusluokan voi antaa vain objekteille ja funktioille"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "odotettiin %<,%> tai %<;%>"
@@ -50398,7 +50446,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "odotettiin merkkijonoliteraalia"
@@ -50428,7 +50476,7 @@ msgstr "ei-vakio ehto staattiselle väitteelle"
 msgid "static assertion failed: %E"
 msgstr "staattinen väite epäonnistui: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "staattinen väite epäonnistui"
@@ -50482,8 +50530,8 @@ msgstr "luetelluille tyypeille ei voi käyttää tilaa %qs"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "odotettu tunniste"
@@ -50514,12 +50562,12 @@ msgstr "rekursiivinen tyyppi %qT määrittelemätön"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "%q+D:n data-alue on ristiriidassa edellisen esittelyn kanssa"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "luetellun tyypin luettelon lopussa on pilkku"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50602,22 +50650,22 @@ msgstr "useita tallennusluokkia esittelymääritteissä"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "odotettiin luokan nimeä"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja"
@@ -50627,7 +50675,7 @@ msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 ei tue syntaksia %<[*]%> taulukkoesittelijöissä"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -50659,17 +50707,17 @@ msgstr "ISO C90 kieltää aliobjektin määrittämisen alustukseen"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "määrätyn alustajan käyttö ilman %<=%>-merkkiä on vanhentunut"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, fuzzy, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, fuzzy, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
@@ -50679,44 +50727,44 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu"
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, fuzzy, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "tunnistamaton osoite"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja"
@@ -50747,7 +50795,7 @@ msgstr "ISO C90 kieltää esittelyjen ja koodin sekoittamisen"
 msgid "expected %<}%> before %<else%>"
 msgstr "#else #else:n jälkeen"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> ilman edeltävää %<if%>:iä"
@@ -50762,7 +50810,7 @@ msgstr "Lohkonimiö ei ole sopiva IF-lauseelle kohdassa %C"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, fuzzy, gcc-internal-format
 msgid "expected statement"
 msgstr "%s-lausetta odotettiin kohdassa %L"
@@ -50797,27 +50845,27 @@ msgstr "ISO C90 ei tue tyyppiä %<long long%>"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 msgid "expected declaration"
 msgstr "odotettiin iteraatioesittelyä tai -alustusta"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "ehdotetaan aaltosulkeita tyhjän lohkon ympärille %<if%>-lauseessa"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "ehdotetaan aaltosulkeita tyhjän lohkon ympärille %<else%>-lauseessa"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "ehdotetaan aaltosulkeita epäselvän %<else%>:n välttämiseksi"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -50837,12 +50885,12 @@ msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -50857,8 +50905,8 @@ msgstr "lopetusalkio puuttuu funktiokutsusta"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "cv-määreen kaksoiskappale"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr "nähty ensimmäisen kerran tässä"
@@ -50880,12 +50928,12 @@ msgstr "ISO C kieltää ?:-lausekkeen ilman keskimmäistä termiä"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "%Jviimeksi käytetty täällä"
@@ -51062,7 +51110,7 @@ msgstr "ISO C ei tue kompleksikokonaiskulutyyppejä"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "odotettiin lauseketta"
@@ -51079,13 +51127,13 @@ msgstr "lohkot lausekkeiden sisällä sallitaan vain funktion sisällä"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C kieltää lohkot lausekkeiden sisällä"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "%<va_start%>-funktion toinen parametri ei ole viimeinen nimetty argumentti"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -51231,7 +51279,7 @@ msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
@@ -51272,7 +51320,7 @@ msgstr "ylivuoto vakiolausekkeessa"
 msgid "rotate count is negative"
 msgstr "vasemmalle kierron laskuri on negatiivinen"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -51384,7 +51432,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -51424,12 +51472,12 @@ msgstr "Odotettiin toista ulottuvuutta taulukkoesittelyssä kohdassa %C"
 msgid "no type or storage class may be specified here,"
 msgstr "tallennusluokka annettu %qs:lle"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "<tuntematon>"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 msgid "missing property attribute"
 msgstr "puuttuva Code-attribuutti"
@@ -51439,57 +51487,57 @@ msgstr "puuttuva Code-attribuutti"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "<tuntematon>"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "<tuntematon>"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "toistuva %<@%> Objective-C-merkkijonon edellä"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, fuzzy, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "kuori on annettava polkuineen"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
@@ -51499,12 +51547,12 @@ msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "Odotettiin =-merkkiä PARAMETER-lauseessa kohdassa %C"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "roskaa ilmaisun %<#pragma GCC pch_preprocess%> lopussa"
@@ -51514,11 +51562,11 @@ msgstr "roskaa ilmaisun %<#pragma GCC pch_preprocess%> lopussa"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "%s: liian monta arvoa"
@@ -51533,58 +51581,58 @@ msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
 msgid "%qD is not a variable"
 msgstr "%qD ei ole muuttuja"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD ei ole muuttuja"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, fuzzy, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "%qs määrittää %<auto%>:n tiedostoalue-esittelyssä"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "odotettiin lauseketta"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "käytetty %<__thread%> ennen %<extern%>:a"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -51607,22 +51655,22 @@ msgstr "%<num_threads%>-arvon on oltava positiivinen"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "UNIT-numeron lauseessa kohdassa %L täytyy olla epänegatiivinen"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "odotettiin %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> tai %<max%>"
@@ -51632,100 +51680,100 @@ msgstr "odotettiin %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<m
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, fuzzy, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "%s: liian monta argumenttia\n"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument"
 msgstr "%qs attribuuttia ei huomioida"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, fuzzy, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, fuzzy, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "sekä %<long%> että %<void%> esittelymääritteissä"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "%qE määritelty vääränlaisena tunnisteena"
@@ -51735,39 +51783,39 @@ msgstr "%qE määritelty vääränlaisena tunnisteena"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, fuzzy, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "odotettiin %<operator%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "kaksois-%qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
@@ -51782,22 +51830,22 @@ msgstr "tallennusluokka annettu typenamelle"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "ristiriitaiset tyyppimääreet %q+D:lle"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "ristiriitaiset tyyppimääreet %q+D:lle"
@@ -51807,7 +51855,7 @@ msgstr "ristiriitaiset tyyppimääreet %q+D:lle"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51822,316 +51870,316 @@ msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "%s ei tue pituusmäärettä %qs %s"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "%qE määritelty vääränlaisena tunnisteena"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "%qE määritelty vääränlaisena tunnisteena"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "odotettiin %<operator%>"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, fuzzy, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "UNIT-numeron lauseessa kohdassa %L täytyy olla epänegatiivinen"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "illegal comma"
 msgstr "virheellinen operandi "
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, fuzzy, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 msgid "invalid map kind"
 msgstr "%qE määritelty vääränlaisena tunnisteena"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, fuzzy, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "virheellinen const_double-operandi"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, fuzzy, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr "odotettiin merkkijonoliteraalia"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "odotettu tunniste"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "Odotettiin nimetöntä rajapintaa kohdassa %C"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicated %<fr%> preference selector"
 msgstr "kaksinkertainen %<if%>-ehto"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "odotettiin merkkijonoliteraalia"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "cv-määreen kaksoiskappale"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "cv-määreen kaksoiskappale"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "kaksinkertainen %<if%>-ehto"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "odotettiin %<,%> tai %<;%>"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "Funktio %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "käytetty sekä %<__thread%> että %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, fuzzy, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "muuttuja tai kenttä %qs esitelty tyhjäksi"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "%<extern%>-muuttujan %qD esittely %<for%>-silmukan alkuesittelyssä"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, fuzzy, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "odotettiin merkkijonoa ilmaisun %<#pragma message%> jälkeen"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -52146,7 +52194,7 @@ msgstr "%qE on esittelemättä"
 msgid "expected function name"
 msgstr "odotettiin luokan nimeä"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
@@ -52156,22 +52204,22 @@ msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
@@ -52196,7 +52244,7 @@ msgstr ""
 msgid "modified here"
 msgstr "union määritelty täällä"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
@@ -52231,111 +52279,111 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "%s: liian monta arvoa"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "%s: liian monta arvoa"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "%qs määritelty parametrille %qE"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "roskaa ilmaisun %<#pragma pack%> lopussa"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "odotettiin %<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "roskaa ilmaisun %<#pragma pack%> lopussa"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "roskaa ilmaisun %<#pragma pack%> lopussa"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, fuzzy, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "roskaa ilmaisun %<#pragma pack%> lopussa"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
@@ -52345,27 +52393,27 @@ msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "käytetty %<__thread%> ennen %<extern%>:a"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, fuzzy, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
@@ -52375,32 +52423,32 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu"
 msgid "expected %<(%> or end of line"
 msgstr "odotettiin %<(%> tai rivin loppu"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "odotettiin merkkijonoa ilmaisun %<#pragma message%> jälkeen"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 msgid "for statement expected"
 msgstr "%s-lausetta odotettiin kohdassa %L"
@@ -52408,68 +52456,68 @@ msgstr "%s-lausetta odotettiin kohdassa %L"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 msgid "loop nest expected"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "odotettiin iteraatioesittelyä tai -alustusta"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "liian vähän argumentteja"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, fuzzy, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
@@ -52479,7 +52527,7 @@ msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 msgid "expected a function name"
 msgstr "odotettiin luokan nimeä"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 msgid "expected target-function call"
 msgstr "odotettiin luokan nimeä"
@@ -52490,47 +52538,47 @@ msgid "%<#pragma omp dispatch%> must be followed by a function call with optiona
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
 # XXXXXXX
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
@@ -52545,57 +52593,57 @@ msgstr "%Jvanhanmallinen funktiomäärittely"
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "Tuntematon -mmacosx-version-min-arvo %qs"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "%s ei tue muotoilua %<%%%c%> %s"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "tallennusluokan voi antaa vain olioille ja funktioille"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "odotettiin merkkijonoliteraalia"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "-pipe ei ole tuettu"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "%s-lausetta odotettiin kohdassa %L"
@@ -52605,27 +52653,27 @@ msgstr "%s-lausetta odotettiin kohdassa %L"
 msgid "variant %qD is not a function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "%s: Annettu useampi kuin yksi -d -valitsin\n"
@@ -52635,7 +52683,7 @@ msgstr "%s: Annettu useampi kuin yksi -d -valitsin\n"
 msgid "%qD is not of pointer type"
 msgstr "%qD ei ole muuttuja"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
@@ -52645,18 +52693,18 @@ msgstr "odotettiin %<none%> tai %<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "Funktio %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
 # XXXXXXX
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "  siirtyy catch-lohkoon"
@@ -52676,12 +52724,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "annettu yhteensopimatonta osoitintyyppiä oleva %d. argumentti funktiolle %qE"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "-I- annettu kahdesti"
@@ -52691,7 +52739,7 @@ msgstr "-I- annettu kahdesti"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "valitsimet -l ja -s eivät ole yhteensopivia"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "valitsimet -l ja -s eivät ole yhteensopivia"
@@ -52701,7 +52749,7 @@ msgstr "valitsimet -l ja -s eivät ole yhteensopivia"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
@@ -52717,85 +52765,85 @@ msgstr "%Jvanhanmallinen funktiomäärittely"
 msgid "no declaration of base function %qs"
 msgstr "funktio %qE esitelty implisiittisesti"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "funktion määrittely ei esittele parametrejä"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, fuzzy, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "  siirtyy catch-lohkoon"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "odotettiin %<none%> tai %<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "Kaksoiskappale-%s-attribuutti määritelty kohdassa %L"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "tallennusluokka annettu typenamelle"
@@ -52820,12 +52868,12 @@ msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q+#D aiemmin esitelty täällä"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 msgid "unexpected clause"
 msgstr "odotettiin %<class%>"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "puuttuva ”]”"
@@ -52885,32 +52933,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "%qs määrittää %<auto%>:n tiedostoalue-esittelyssä"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, fuzzy, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
@@ -52925,160 +52973,160 @@ msgstr "käytetään muuttuvapituista taulukkoa"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, fuzzy, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr "valitsin %qs ei ole enää tuettu"
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, fuzzy, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr "valitsin %qs ei ole enää tuettu"
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 msgid "expected directive name"
 msgstr "odotettiin luokan nimeä"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "odotettiin %<,%>, %<;%> tai %<}%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 msgid "unknown directive name"
 msgstr "%s: tuntematon osan nimi ”%.*s”"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, fuzzy, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%J%qD esitelty avoimeksi kutsumisen jälkeen"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "automaattimuuttuja %qE ei voi olla %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "parametrilla %u in vaillinainen tyyppi"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "odotettiin %<,%> tai %<;%>"
@@ -53088,7 +53136,7 @@ msgstr "odotettiin %<,%> tai %<;%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "Käyttö: %s <transaktiotiedosto> <tiedostojärjestelmä>\n"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "odotettiin %<,%> tai %<;%>"
@@ -53103,7 +53151,7 @@ msgstr "          %s"
 msgid "%qD has an incomplete type %qT"
 msgstr "%2$qD:n parametrilla %1$P on vaillinainen tyyppi %3$qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "void-lausekkeen epäkelpo käyttö"
@@ -53134,173 +53182,173 @@ msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "funktiotyypit eivät aidosti yhteensopivia ISO C:n mukaan"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, fuzzy, gcc-internal-format
 #| msgid "pointers to arrays with different qualifiers are incompatible in ISO C"
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "osoittimet erimääritteisiin taulukoihin ovat epäyhteensopivia ISO C:ssä"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "tyypit eivät ole ihan yhteensopivia"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "tyypit eivät ole ihan yhteensopivia"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "funktion paluuarvojen tyypit eivät ole yhteensopivia %<volatile%>:n takia"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, fuzzy, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "tyypin määritteleminen tyyppimuunnoksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%Jinvalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "%Jepäkelpo joustavan taulukkojäsenen sisältävän tietueen käyttö"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, fuzzy, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "pyydetty jäsentä %qE jostakin, joka ei ole tietue eikä unioni"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, fuzzy, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "pyydetty jäsentä %qE jostakin, joka ei ole tietue eikä unioni"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, fuzzy, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qD ei ole nimiavaruuden nimi"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, fuzzy, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qD ei ole nimiavaruuden nimi"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "pyydetty jäsentä %qE jostakin, joka ei ole tietue eikä unioni"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "taulukon indeksi ei ole kokonaisluku"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "indeksoitu arvo on osoitin funktioon"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "taulukon indeksi ei ole kokonaisluku"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C kieltää %<register%>-taulukon indeksoinnin"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, fuzzy, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C kieltää %<register%>-taulukon indeksoinnin"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD esitelty viitteenä, mutta alustamatta"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "enum-muunnos alustuksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, fuzzy, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "lueteltu tyyppi määritelty täällä"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "kutsuttu objekti %qE ei ole funktio"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
@@ -53308,1882 +53356,1882 @@ msgstr "funktiokutsu epäsopivan tyypin läpi"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "keskeytysfunktiolla on oltava void-paluutyyppi"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "muodollisen parametrin %d tyyppi on vaillinainen"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan kokonaislukuna eikä liukulukuna prototyypin takia"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan kokonaislukuna eikä kompleksisena prototyypin takia"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan kompleksisena eikä liukulukuna prototyypin takia"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan liukulukuna eikä kokonaislukuna prototyypin takia"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan kompleksisena eikä kokonaislukuna prototyypin takia"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan liukulukuna eikä kompleksisena prototyypin takia"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan tyyppinä %<float%> eikä %<double%> prototyypin takia"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan liukulukuna eikä kokonaislukuna prototyypin takia"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan eri levyisenä prototyypin takia"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan etumerkittömänä prototyypin takia"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "funktion %2$qE argumentti %1$d annetaan etumerkillisenä prototyypin takia"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to method %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "liikaa argumentteja metodille %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "liian monta argumenttia funktiolle %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "liian monta argumenttia funktiolle %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "muuttuja %qD esitelty %<inline%>:ksi"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "liian vähän argumentteja funktiolle %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "liian vähän argumentteja funktiolle %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "liian vähän argumentteja funktiolle %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "vertailu merkkijonoliteraalin kanssa aiheuttaa määrittelemätöntä toimintaa"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "osoittimen ja kokonaisluvun välinen vertailu"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "oliko tarkoitus käyttää loogista negaatiota?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "nolla nollaosoitinvakiona"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "vähennyslaskussa käytetty %<void *%>-tyyppistä osoitinta"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "vähennyslaskussa käytetty osoitinta funktioon"
 
 # XXX
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "funktio-osoitinta käytetty laskutoimituksessa"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> totuusarvolausekkeelle"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "oliko tarkoitus käyttää loogista negaatiota?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C ei tue %<~%>-merkkiä kompleksikonjugaateissa"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "abs-funktiolle annettu väärä tyyppiargumentti"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "unaariselle huutomerkille annettu väärä tyyppiargumentti"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "luetellun arvon kasvattaminen on virhe C++:ssa"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "luetellun arvon vähentäminen on virhe C++:ssa"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "odotettiin lauseketta"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "odotettiin lauseketta"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C ei tue kompleksityyppien %<++%>- ja %<--%>-operaatioita"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "lisäykselle annettu väärä tyyppiargumentti"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "vähennykselle annettu väärä tyyppiargumentti"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "odotettiin lauseketta"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "bittikentän %qD osoitetta ei voi ottaa"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "sisäkkäisessä funktiossa käytetty globaalia rekisterimuuttujaa %qD"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "halutaan globaalin rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "ehtolausekkeessa ei-lvalue-taulukko"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "tyypin määritteleminen tyyppimuunnoksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, fuzzy, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT"
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C kieltää ehtolausekkeet, joissa on vain yksi tyhjä puoli"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C kieltää ehtolausekkeet %<void *%>-tyypin ja funktio-osoittimen välillä"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "ehtolausekkeessa on osoitintyyppiristiriita"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "odotettiin lauseketta"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "odotettiin lauseketta"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "ehtolausekkeessa on osoitin/kokonaislukutyyppiristiriita"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "ehtolausekkeessa on tyyppiristiriita"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "%qD:n paluuarvoa ei huomioida, esitelty attribuutilla warn_unused_result"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "%qD:n paluuarvoa ei huomioida, esitelty attribuutilla warn_unused_result"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "%qD:n paluuarvoa ei huomioida, esitelty attribuutilla warn_unused_result"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "%qD:n paluuarvoa ei huomioida, esitelty attribuutilla warn_unused_result"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 msgid "cast adds %q#v qualifier to function type"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "osoitinkohdetyypin määreitä häviää tyyppimuunnoksessa"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "tyyppimuunnos määrittää taulukkotyypin"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "tyyppimuunnos määrittää funktiotyypin"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C kieltää tyyppimuuntamasta ei-skalaaria samaksi tyypiksi"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "tarpeeton tyyppimuunnos tyyppiin %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C kieltää tyyppimuunnokset unionityyppeihin"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "unioniin kuulumattoman tyypin muunnos unionityypiksi"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "kohdetyypin vaatima kohdistus kasvaa tyyppimuunnoksessa"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "tyyppimuunnos %qT-tyyppisestä funktiokutsusta yhteensopimattomaan tyyppiin %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "tyyppimuunnos erikokoisesta kokonaisluvusta osoittimeksi"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C kieltää funktio-osoittimen muuntamisen objektiosoitintyypiksi"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C kieltää objektiosoittimen muuntamisen funktio-osoitintyypiksi"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "muunnos funktiotyypistä %qT epäyhteensopivaan funktiotyyppiin %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "tyypin määritteleminen tyyppimuunnoksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "virheellinen taulukkosijoitus"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "taulukko alustetaan suluilla ympäröidystä merkkijonovakiosta"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid " declared here"
 msgid "%e declared here"
 msgstr " esitelty täällä"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, fuzzy, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "enum-muunnos alustuksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "enum-muunnos palautuksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "edellinen %q+#T:n määrittely"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "argumentin %d antaminen funktiolle %qE tekee kokonaisluvusta osoittimen ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "sijoitus hylkää kohdeosoitintyypin määreitä"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "alustus hylkää kohdeosoitintyypin määreitä"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "sijoitus hylkää kohdeosoitintyypin määreitä"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "%d. argumentti funktiolle %qE hylkää kohdeosoitintyypin %qv-määritteen"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "sijoitus hylkää kohdeosoitintyypin %qv-määritteen"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "alustus hylkää kohdeosoitintyypin määreitä"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "palautus hylkää kohdeosoitintyypin %qv-määritteen"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C kieltää argumenttien muuntamisen unionityypiksi"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "implisiittinen muunnos tyypistä %qT tyyppiin %qT ei ole sallittu C++:ssa"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "annettu yhteensopimatonta osoitintyyppiä oleva %d. argumentti funktiolle %qE"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, fuzzy, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "alustus yhteensopimattomasta osoitintyypistä"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, fuzzy, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "funktiokutsun argumentti voi olla ehdokas muotoiluattribuutille"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, fuzzy, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, fuzzy, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, fuzzy, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "annettu yhteensopimatonta osoitintyyppiä oleva %d. argumentti funktiolle %qE"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "alustus yhteensopimattomasta osoitintyypistä"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C kieltää funktio-osoittimen ja %<void *%>-tyypin väliset sijoitukset"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C kieltää funktio-osoittimen ja %<void *%>-tyypin väliset sijoitukset"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C kieltää funktio-osoittimen ja %<void *%>-tyypin väliset alustukset"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C kieltää funktio-osoittimen ja %<void *%>-tyypin väliset palautukset"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "annettu yhteensopimatonta osoitintyyppiä oleva %d. argumentti funktiolle %qE"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "sijoitus yhteensopimattomasta osoitintyypistä"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "alustus yhteensopimattomasta osoitintyypistä"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "alustus yhteensopimattomasta osoitintyypistä"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "argumentin %d antaminen funktiolle %qE tekee kokonaisluvusta osoittimen ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "sijoituksessa tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "alustuksessa tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "argumentin %d antaminen funktiolle %qE tekee kokonaisluvusta osoittimen ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "argumentin %d antaminen funktiolle %qE tekee kokonaisluvusta osoittimen ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "sijoitus tekee osoittimesta kokonaisluvun ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "alustus tekee osoittimesta kokonaisluvun ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "argumentin %d antaminen funktiolle %qE tekee kokonaisluvusta osoittimen ilman tyyppimuunnosta"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "yhteensopimattomat tyypit sijoituksessa tyyppiin %qT tyypistä %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "yhteensopimattomat tyypit alustettaessa tyyppiä %qT käyttäen tyyppiä %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "yhteensopimattomat tyypit alustettaessa tyyppiä %qT käyttäen tyyppiä %qT"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "perinteinen C ei hyväksy automaattista koostealustusta"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "joustavan taulukkojäsenen alustus"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, fuzzy, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "alustus yhteensopimattomasta osoitintyypistä"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "merkkitaulukon alustusmerkkijono on liian pitkä"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "merkkitaulukon alustusmerkkijono on liian pitkä"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "sopimattomasta tyypistä koostuva taulukko alustetaan merkkijonovakiosta"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, fuzzy, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "ehtolausekkeessa ei-lvalue-taulukko"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "epäkelpo alustin"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "alustusalkio ei ole vakio"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "taulukko alustetaan muuttuvasta taulukkolausekkeesta"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "alustinalkio ei ole vakiolauseke"
 
 # Tämä esiintynee esim. const char* → char* -muunnoksessa.
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "muunnos tyypistä %qT tyyppiin %qT ei säilytä tyyppimääreitä"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "alustusalkiota ei pystytä laskemaan latausajankohtana"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "läpinäkymättömiä vektorityyppejä ei voida alustaa"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "alustimen lopussa on ylimääräinen lohko"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "joustavan taulukkojäsenen alustaminen sisäkkäisessä asiayhteydessä"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "alustimen ympäriltä puuttuu aaltosulkeet"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "puuttuva alustin jäsenelle %qD"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "skalaarialustimessa ylimääräisiä alkioita"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "taulukkoindeksi ei-taulukkoalustimessa"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, fuzzy, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "ylimääräisiä alkioita union-alustimessa"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "ei-vakio taulukkoindeksi alustimessa"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "taulukkoindeksi alustimessa ylittää taulukon rajat"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "tyhjä indeksiväli alustimessa"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "taulukkoindeksiväli alustimessa ylittää taulukon rajat"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "alustettu kenttä ylikirjoitettu"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, fuzzy, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "alustettu kenttä ylikirjoitettu"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "enum-muunnos alustuksessa on virheellistä C++-kielessä"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "ylimääräisiä alkioita union-alustimessa"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "ylimääräisiä alkioita struct-alustimessa"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, fuzzy, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "Varoita mahdollisesti puuttuvista aaltosuluista alustimissa"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "joustavan taulukkojäsenen ei-staattinen alustus"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "ylimääräisiä alkioita union-alustimessa"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "perinteinen C ei hyväksy unionien alustusta"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "ylimääräisiä alkioita taulukkoalustimessa"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "ylimääräisiä alkioita vektorialustimessa"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "ylimääräisiä alkioita skalaarialustimessa"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in output operand outside of a function"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr "virheellinen lvalue asm-tulosteessa %d"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<-%> modifier used inside of a function"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in input operand outside of a function"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD ei ole määritelty funktion näkyvyysalueen ulkopuolella"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C90 kieltää yhdysliteraalit"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "annettu yhteensopimatonta osoitintyyppiä oleva %d. argumentti funktiolle %qE"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "%<noreturn%>-esitellyllä funktiolla on %<return%>-lause"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> ilman arvoa ei-voidin palauttavassa funktiossa"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> arvon kanssa voidin palauttavassa funktiossa"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C kieltää %<return%>:in lausekkeen kanssa voidin palauttavassa funktiossa"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "function returns address of label"
 msgstr "funktio palauttaa osoitteen paikalliseen muuttujaan"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "funktio palauttaa osoitteen paikalliseen muuttujaan"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, fuzzy, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "yhteensopivuusvalitsin (jätetään huomiotta)"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "%<long%>-tyyppistä switch-lauseketta ei muunneta %<int%>-tyyppiin ISO C:ssä"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "case-nimiö ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, fuzzy, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, fuzzy, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "%qs-attribuutin virheellinen argumentti"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, fuzzy, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue-lause silmukan ulkopuolella"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "lauseella ei ole vaikutusta"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, fuzzy, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "nimettömällä kentällä on vaillinainen tyyppi"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "Varoita eri enum-tyyppien vertailusta"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "Varoita eri enum-tyyppien vertailusta"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, fuzzy, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "%qD esitelty extern-avainsanalla sisäkkäin"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "liukulukujen vertailu operaattoreilla == ja != on epävarmaa"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C kieltää %<void *%>:n ja funktio-osoittimen vertailun"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, fuzzy, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "erilaisten Objective-C-tyyppien vertailusta puuttuu tyyppimuunnos"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "osoittimen ja kokonaisluvun välinen vertailu"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "täydellisen ja vaillinaisen osoittimen vertailu"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C kieltää funktio-osoittimien suuruusvertailun"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "käytetty osoittimeksi muuntumatonta taulukkoa paikassa, jossa vaaditaan skalaari"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "käytetty tietuetyypin arvoa, vaikka vaaditaan skalaari"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "käytetty unionityypin arvoa, vaikka vaaditaan skalaari"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "käytetty unionityypin arvoa, vaikka vaaditaan skalaari"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "odotettiin %<operator%>"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qs määritelty parametrille %qE"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "bittikentän %qs leveys on nolla"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, fuzzy, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, fuzzy, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, fuzzy, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, fuzzy, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, fuzzy, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, fuzzy, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, fuzzy, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, fuzzy, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "parametrin %qD tyyppi on vaillinainen"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "iteraattorin askellus ei-kokonaislukutyypillä"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr "parametrin %qD tyyppi on vaillinainen"
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, fuzzy, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "säiekohtaista muistia ei tueta tälle kohteelle"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "säiekohtaista muistia ei tueta tälle kohteelle"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, fuzzy, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "ISO C++ kieltää nollan kokoisen taulukon %qD"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "tyyppimuunnos määrittää funktiotyypin"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "bittikentän %qs leveys on nolla"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "bittikentän %qs leveys on nolla"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, fuzzy, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "tyypillä %qE on virtuaalisia jäsenfunktioita"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "tyypillä %qE on käyttäjän määrittelemä muodostin"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, fuzzy, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, fuzzy, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "automaattimuuttuja %qE ei voi olla %<threadprivate%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, fuzzy, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, fuzzy, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qs määritelty parametrille %qE"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "automaattimuuttuja %qE ei voi olla %<threadprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "automaattimuuttuja %qE ei voi olla %<threadprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "”%s” ei ole kelvollinen makron nimi, sillä se on C++:n operaattori"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, fuzzy, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, fuzzy, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, fuzzy, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "kiintopistevakiot ovat GCC-laajennos"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "lähde ei ole osoitin"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, fuzzy, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "%s: liian monta arvoa"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, fuzzy, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "__COUNTER__ lavennettu direktiivin sisällä valitsimella -fdirectives-only"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD:n on otettava tasan yksi argumentti"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, fuzzy, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qs määritelty parametrille %qE"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, fuzzy, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, fuzzy, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, fuzzy, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, fuzzy, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, fuzzy, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, fuzzy, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, fuzzy, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "%<va_arg%>-funktion ensimmäinen argumentti ei ole tyyppiä %<va_list%>"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "%<va_arg%>-funktion ensimmäinen argumentti ei ole tyyppiä %<va_list%>"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "%<va_arg%>-funktion ensimmäinen argumentti ei ole tyyppiä %<va_list%>"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -55452,253 +55500,248 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "%qD tulee alustaa jäsenten alustuslistassa"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s: virheellinen tiedoston nimi: %s\n"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr "epäkelpo lvalue asm-lauseessa"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr "epäkelpo lvalue asm-lauseessa"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "tls_model-argumentti ei ole merkkijono"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT ei ole luokka-, struct- eikä unionityyppi"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55707,72 +55750,82 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "tyhjä esittely"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "%qE ei nimeä tyyppiä"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%s ei tue muotoilua %<%%%c%> %s"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55782,13 +55835,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "liikaa syötetiedostoja"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "tiedoston ”%s” otsaketta ei voi lukea"
@@ -55804,64 +55857,64 @@ msgstr "%s-signaali päätti %s-ohjelman"
 msgid "%s exited with status %d"
 msgstr "ld:n paluuarvo oli %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s%qs%s is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s%qs%s on virheellinen"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: regcomp: %s"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "vääränmuotoinen COLLECT_GCC_OPTIONS"
@@ -56312,7 +56365,7 @@ msgstr "%<operator new%>:n on palautettava tyyppi %qT"
 msgid "%q#D is private within this context"
 msgstr "tässä yhteydessä"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 msgid "declared private here"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
@@ -56322,7 +56375,7 @@ msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 msgid "%q#D is protected within this context"
 msgstr "tässä yhteydessä"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 msgid "declared protected here"
 msgstr "%qD esiteltiin täällä"
@@ -56671,7 +56724,7 @@ msgstr "Kopiomuodostin %qs"
 
 # XXX
 # %s on "initialization", jota EI VOI suomentaa tällä hetkellä.
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 msgid "cannot convert %qH to %qI"
 msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP"
@@ -56691,7 +56744,7 @@ msgstr "päättämätön kutsu funktioon ”%s”: puuttuva ”%c”"
 msgid "call to non-function %qD"
 msgstr "%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -57300,7 +57353,7 @@ msgstr "joustava taulukkojäsen muuten tyhjässä structissa"
 msgid "next member %q#D declared here"
 msgstr "%q+#D aiemmin esitelty täällä"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "%q#T uudelleenmääritelty"
@@ -57310,7 +57363,7 @@ msgstr "%q#T uudelleenmääritelty"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -57441,7 +57494,7 @@ msgstr "epäkelpo tallennusluokka funktiolle %qs"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
@@ -57492,7 +57545,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -57528,842 +57581,842 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qD:lla ei saa olla vaihtuvaa määrää argumentteja"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "nimike %qD esitelty muttei määritelty"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "nimike %qD esitelty muttei määritelty"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr "%s ei tue muotoilua %<%%%c%> %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr "#pragma message: %s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "liikaa argumentteja metodille %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, fuzzy, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr "vertailu ”etumerkitön lauseke < 0” on aina epätosi"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "lopetusalkio puuttuu funktiokutsusta"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "alunperin määritelty täällä"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "komennon ”%s” ajaminen epäonnistui: %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "esittely ei esittele mitään"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr "puuttuva operandi"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, fuzzy, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "valitsimia -client_name ja -dynamiclib ei voi käyttää yhdessä"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr "varaus suoritettu täällä"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, fuzzy, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "valitsimia -client_name ja -dynamiclib ei voi käyttää yhdessä"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "%q+D:lla on edellinen esittely täällä"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD käytössä ilman esittelyä ennen sen määrittelyä"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, fuzzy, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "protokollalla %qE on kehäriippuvuus"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "oikealle siirron lukumäärä on negatiivinen"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, fuzzy, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "taulukon tyypillä on vaillinainen alkiotyyppi"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "jäsen %qD on alustamaton viittaus"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%qs ei ole tuettu tällä kohteella"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "jäsen %qD on alustamaton viittaus"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 msgid "%qT object created here"
 msgstr "esitelty täällä"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q+D esitelty täällä"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr "varattu täällä"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD käytössä ilman prototyyppiä ennen sen määrittelyä"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "parametriksi ei voida esitellä %<constexpr%>:ksi"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "alustinalkio ei ole vakiolauseke"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "alustinalkio ei ole vakiolauseke"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "%qD:n virheellinen käyttö"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "nimike %qD esitelty muttei määritelty"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, fuzzy, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr "%qD:n poistettu määrittely"
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, fuzzy, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "poistettu funktio %q+D"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "epäkelpo tallennusluokka funktiolle %qs"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr "fr30_print_operand: tunnistamaton %%b-koodi"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr "continue-lause silmukan ulkopuolella"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "hajottimen %qE osoitteen ottaminen"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "virheellinen static_cast-muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, fuzzy, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr "virheellinen %%s-arvo"
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, fuzzy, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "tyypillä %qE on virtuaalisia jäsenfunktioita"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "tallennusluokka %<thread_local%> virheellinen funktiolle %qs"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "ei-staattinen datajäsen %qE esitelty %<constexpr%>:ksi"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "Jako nollalla kohdassa %L"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "liukulukuvakio esikääntäjän lausekkeessa"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "taulukon alustus ei-vakiolla"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "Odottamaton %s-lause kohdassa %C"
@@ -58503,375 +58556,376 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially destructible"
 msgstr "  %q+T:n hajotin on epätriviaali"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "esittely ei esittele mitään"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an abstract class"
 msgstr "%q#T ei ole luokka"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an aggregate"
 msgstr "%qT ei ole malli"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not an array"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T ei ole luokka"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a const type"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "tyypillä %qE on käyttäjän määrittelemä muodostin"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not destructible, because"
 msgstr "%q+T ei ole literaali, koska:"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an empty class"
 msgstr "%q#T ei ole luokka"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT ei ole malli"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a final class"
 msgstr "%q#T ei ole luokka"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT ei ole malli"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not invocable, because"
 msgstr "%q+T ei ole literaali, koska:"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qD ei ole %qD:n jäsen"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a literal type"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%q+T ei ole literaali, koska:"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%q+T ei ole literaali, koska:"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a POD type"
 msgstr "%qD ei ole tyyppi"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "lähde ei ole osoitin"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT ei ole nimiavaruus"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "%qT ei ole nimiavaruus"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "%qT ei ole malli"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a trivial type"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially copyable"
 msgstr "%q+T ei ole literaali, koska:"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially destructible, because"
 msgstr "%q+T ei ole literaali, koska:"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "Ei ole hakemisto"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "joustava taulukkojäsen unionissa"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "%qT ei ole malli"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "argumentti %qd ei ole vakio"
+#| msgid "%qT is not a class type"
+msgid "%qT is not a structural type"
+msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "%qE:a saatetaan käyttää alustamattomana tässä funktiossa"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "%q+D esitelty ystävänä"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "        %qD"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 msgid "invalid constraints"
 msgstr "virheellinen rotate-käsky"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, fuzzy, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr "keskeytysfunktiolla on oltava void-paluutyyppi"
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "vertailu ”etumerkitön lauseke < 0” on aina epätosi"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "%qD ei ole %qD:n jäsen"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -58901,50 +58955,50 @@ msgstr "asm-esittely jätetty huomiotta, koska se on ristiriidassa edellisen nim
 msgid "previous declaration with fewer contracts here"
 msgstr "%q#D:n esittely C-kielen linkityksellä"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "parameter declared here"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "%q+#D:n esittely"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "first declared here"
 msgstr " esitelty täällä"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -59016,7 +59070,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "paluutyyppi %q#T on vaillinainen"
@@ -59089,89 +59143,89 @@ msgstr "objektityyppi %qT ei täsmää hajottimen nimen ~%qT kanssa"
 msgid "awaitable type %qT is not a structure"
 msgstr "objektityyppi %qT ei täsmää hajottimen nimen ~%qT kanssa"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs ei ole tuettu tällä kohteella"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "%<noreturn%>-esitellyllä funktiolla on %<return%>-lause"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %qD"
 msgid "no suspend point info for %qD"
 msgstr "%qD:lle ei ole edellistä prototyyppiä"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "%qE:n kaksoiskappale"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "osoittimet eivät ole sallittuja case-arvoja"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "ISO C kieltää sisäkkäiset funktiot"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -59197,68 +59251,73 @@ msgstr "%qD ei ole mallifunktio"
 msgid "%qs used outside of constant expressions"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "odotettiin iteraatioesittelyä tai -alustusta"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "hajottimen %qE osoitteen ottaminen"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%qD:n osoite tulee aina olemaan %<true%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "hajotin ei voi olla %<constexpr%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "%qs-attribuutin virheellinen argumentti"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD ei ole tyyppi"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qE:lla ei ole luokkatyyppiä"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -59304,7 +59363,7 @@ msgstr "virheellinen %qT-tyyppisen ei-const-viittauksen alustus %qT-tyyppisestä
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "muunnos tyypistä %qT tyyppiin %qT ei säilytä tyyppimääreitä"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, fuzzy, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "oliko tarkoitus käyttää loogista negaatiota?"
@@ -59694,7 +59753,7 @@ msgstr "edellisestä esittelystä %q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "luetellun tyypin jäsenen %q+D uudelleenesittely"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "edellinen esittely %q+D"
@@ -59915,12 +59974,12 @@ msgstr "oletusargumentti annettu %2$q#D:n parametrille %1$d"
 msgid "previous specification in %q#D here"
 msgstr "%q+D:n edellinen esittely oli täällä"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared here without exporting"
@@ -60126,7 +60185,7 @@ msgstr "  ohittaa %q+#D:n alustuksen"
 msgid "  enters %<template for%> statement"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
@@ -60173,547 +60232,547 @@ msgstr "%<typename %T::%D%> nimeää %q#T:n, joka ei ole tyyppi"
 msgid "template parameters do not match template %qD"
 msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "dwarfin versio %d ei ole tuettu"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
 # semi-fuzzy
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "ei-staattista datajäsentä %q+D käytetty virheellisesti"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr "anonyymillä structilla ei voi olla funktiojäseniä"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, fuzzy, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "ei argumentteja"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, fuzzy, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "ei argumentteja"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, fuzzy, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "ei argumentteja"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, fuzzy, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "%q+#T:n attribuutin on oltava %qs-avainsanan perässä"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "useita tyyppejä yhdessä esittelyssä"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "C++:n sisäinen tietotyyppi %qT määritelty uudelleen"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "tallennusluokan voi antaa vain objekteille ja funktioille"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "tyypin nimi puuttuu typedef-esittelystä"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ kieltää nimettömät structit"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "määreet voidaan määrittää vain olioille ja funktioille"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "määreet voidaan määrittää vain olioille ja funktioille"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, fuzzy, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "tallennusluokan voi antaa vain olioille ja funktioille"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "määreet voidaan määrittää vain olioille ja funktioille"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "tallennusluokan voi antaa vain olioille ja funktioille"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "määreet voidaan määrittää vain olioille ja funktioille"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "määreet voidaan määrittää vain olioille ja funktioille"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "tallennusluokan voi antaa vain olioille ja funktioille"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "määreet voidaan määrittää vain olioille ja funktioille"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "tyypin nimi puuttuu typedef-esittelystä"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%Hprototyypin esittely"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "attribuuttia ei huomioida"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, fuzzy, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "%qE-attribuuttia ei huomioida %qT-tyyppiselle kentälle"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD on alustettu (käytä __typeof__ sen sijaan)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "parametrilla %q+D on vain etukäteisesittely"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, fuzzy, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "funktion %q+D määrittely on merkitty dllimport-tyyppiseksi"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "malliesittelylle %q+D"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, fuzzy, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "jäsenen %q+D kaksoiskappale"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "muuttujalla %q#D on alustin, mutta vaillinainen tyyppi"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "taulukon %q#D alkiot ovat vaillinaista tyyppiä"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, fuzzy, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "parametrin %qD tyyppi on vaillinainen"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD esitelty viitteenä, mutta alustamatta"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, fuzzy, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, fuzzy, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, fuzzy, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "dwarfin versio %d ei ole tuettu"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "alustin ei pysty päättelemään taulukon %q+D kokoa"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "%qD-taulukon koko puuttuu"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "nollan kokoinen taulukko %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "%qD:n koko muistissa ei ole tunnettu"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "%qD:n koko muistissa ei ole vakio"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "  voit kiertää tämän poistamalla alustimen"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "alustamaton const %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, fuzzy, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, fuzzy, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "virheellinen alustin taulukon jäsenelle %q#D"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, fuzzy, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "ei-staattisella datajäsenellä %qD on Java-luokkatyyppi"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD:n esittely %qT:n jäsenenä"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "virheellinen alustin taulukon jäsenelle %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "liikaa alustimia %qT:lle"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, fuzzy, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, fuzzy, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "alustimen ympäriltä puuttuu aaltosulkeet"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "taulukon %q#D alkiot ovat vaillinaista tyyppiä"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "muuttuvakokoinen yhdysliteraali"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D on vaillinaista tyyppiä"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "skalaariobjekti %qD vaatii yhden alkion alustimeensa"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "C++98:ssa %qD on alustettava muodostimessa, ei käyttäen %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "taulukko %qD alustettu sulkujen sisällä olevalla merkkijonoliteraalilla %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, fuzzy, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "virheellinen alustin taulukon jäsenelle %q#D"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, fuzzy, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "  ohittaa %q+#D:n alustuksen"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, fuzzy, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "halutaan rekisterimuuttujan %qD osoite"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "%qD esitelty viitteenä, mutta ei ole alustettu"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "annettu yhteensopimatonta osoitintyyppiä oleva %d. argumentti funktiolle %qE"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "liian vähän argumentteja muodostimelle %q#D"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "hajottimen %qE osoitteen ottaminen"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "sijoitus (ei alustus) esittelyssä"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "%<register%>-tallennusluokkamääritteen käyttö"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "%q#D:n esittelyllä ei ole alustimia"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "jäsentä %q+D käytetty virheellisesti staattisessa jäsenfunktiossa"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -60721,1878 +60780,1888 @@ msgstr "paluutyyppi %q#T on vaillinainen"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, fuzzy, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "%q+D:n edellinen esittely"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%qE-attribuutti soveltuu vain muuttujiin ja funktioihin"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "funktio %q#D alustetaan kuin muuttuja"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "Pyydettyä osoitetta ei voi asettaa"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "lambda declared here"
 msgstr " esitelty täällä"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "%s[%s] Virhe 0x%x%s"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "virheellinen tyyppimuunnos funktiotyyppiin %qT"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 kieltää muuttuvakokoisen taulukon %qE"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "paluutyyppi on vaillinainen tyyppi"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr "puuttuva alustin jäsenelle %qD"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "%qs määritelty tietueen kentälle"
 msgstr[1] "%qs määritelty tietueen kentälle"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] "%qs määritelty tietueen kentälle"
 msgstr[1] "%qs määritelty tietueen kentälle"
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, fuzzy, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr "Java-luokalla %qT ei voi olla implisiittistä epätriviaalia hajotinta"
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, fuzzy, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "Java-luokalla %qT ei voi olla implisiittistä epätriviaalia hajotinta"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "alustin ei pysty päättelemään taulukon %q+D kokoa"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "%qD-taulukon koko puuttuu"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "nollan kokoinen taulukko %qD"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, fuzzy, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "Java-luokalla %qT ei voi olla hajotinta"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, fuzzy, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "Java-luokalla %qT ei voi olla hajotinta"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "funktio %qD esitelty virtuaaliseksi unionissa"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "parametri %qD esitelty void-tyyppisenä"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "parametri %q+D esitelty %<inline%>:ksi"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "parametri %qD esitelty void-tyyppisenä"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "parametri %qD esitelty void-tyyppisenä"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "funktio %qD esitelty virtuaaliseksi unionissa"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "parametri %q+D esitelty %<inline%>:ksi"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D esitelty ystävänä"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "nimike %qD esitelty muttei määritelty"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "%qD ei ole luokka eikä nimiavaruus"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "nimetyt paluuarvot eivät ole enää tuettuja"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, fuzzy, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "%<inline%> tyhjässä esittelyssä"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "%qD ei ole malli"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, fuzzy, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "parametriksi ei voida esitellä %<constexpr%>:ksi"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "  esitelty täällä"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "malli C-linkityksellä"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "virheellinen IACC-argumentti"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, fuzzy, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "virheellinen loppuliite ”%.*s” kokonaislukuvakiolla"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, fuzzy, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "virheellinen loppuliite ”%.*s” kokonaislukuvakiolla"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "paluutyyppi on oletuksena %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, fuzzy, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "funktion määrittely esitelty %<auto%>:ksi"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "%q+D:n edellinen määrittely oli täällä"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q+D:n edellinen määrittely oli täällä"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, fuzzy, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "%Jparametri %qD esitelty %<inline%>:ksi"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "automaattimuuttuja %qE ei voi olla %<threadprivate%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "nimetyt paluuarvot eivät ole enää tuettuja"
 
 # semi-fuzzy
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "ei-staattista datajäsentä %q+D käytetty virheellisesti"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, fuzzy, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ kieltää jäsenen %qD alustuksen"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "taulukon %qD koolla on epäkokonaislukutyyppi %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "taulukon koolla on epäkokonaislukutyyppi %qT"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ kieltää nollan kokoisen taulukon %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ kieltää nollan kokoisen taulukon"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ kieltää muuttuvakokoisen taulukon %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ kieltää muuttuvakokoisen taulukon"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, fuzzy, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "taulukon koon ylivuoto"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "NULLin muunnos epäosoitintyypiksi %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "%qD:n esittely void-taulukkona"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "luodaan void-taulukko"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "%qD:n esittely funktioiden taulukkona"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "luodaan funktioiden taulukko"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "%qD:n esittely viitteiden taulukkona"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "luodaan viitteiden taulukko"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "%qD:n esittely funktiojäsenten taulukkona"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "luodaan funktiojäsenten taulukkoa"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "moniulotteisell taulukolla on oltava rajat kaikkiin suuntiin paitsi ensimmäiseen"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "moniulotteisell taulukolla on oltava rajat kaikkiin suuntiin paitsi ensimmäiseen"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, fuzzy, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "virheellinen hajottimen %qD käyttö tyyppinä"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "Tyhjä taulukkomuodostin kohdassa %C ei ole sallittu"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, fuzzy, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "virheellinen hajottimen %qD käyttö tyyppinä"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, fuzzy, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "paluutyyppi %q#T on vaillinainen"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "virheellinen hajottimen %qD käyttö tyyppinä"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "useita tallennusluokkia esittelymääritteissä"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "nimetön muuttuja tai kenttä esitelty voidiksi"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "muuttuja tai kenttä esitelty voidiksi"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "funktiokutsu epäsopivan tyypin läpi"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "hajottimet eivät voi olla cv-määriteltyjä"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 msgid "%e and %e specified together"
 msgstr "sekä %<signed%> että %<unsigned%> määritelty %qs:lle"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "Virheellinen käyttäjänimi ”%s” funktiossa %s, rivillä %d. Keskeytys."
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "määrittelemättömän tyypin %<%s %s%> epäkelpo käyttö"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "Virheellinen käyttäjänimi ”%s” funktiossa %s, rivillä %d. Keskeytys."
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%qT ei ole luokka eikä nimiavaruus"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "funktion määrittely ei esittele parametrejä"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "%qD:n esittely ei-funktiona"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%Hprototyypin esittely"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, fuzzy, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "yli yksi tietotyyppi esittelymääritteissä"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C ei tue pelkkää %<complex%>-tyyppiä merkityksellä %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ kieltää muuttujan %qs esittelyn ilman tyyppiä"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "kohteen int-tyyppi on kapeampi kuin kohteen char-tyyppi"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qE:a käytetään alustamattomana tässä funktiossa"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qE ei ole typedef eikä sisäinen tyyppi"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qE ei ole typedef eikä sisäinen tyyppi"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qE ei ole typedef eikä sisäinen tyyppi"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, fuzzy, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "epäkelpo osoitintila %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "jäsentä %qD ei voida esitellä sekä virtuaaliseksi että staattiseksi"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "jäsentä %qD ei voida esitellä sekä virtuaaliseksi että staattiseksi"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, fuzzy, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "tallennusluokka annettu malliparametrille %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "parametriksi ei voida esitellä %<constexpr%>:ksi"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> luokan esittelyn ulkopuolella"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "virheellinen funktioesittely"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "useita tallennusluokkia %qs:n esittelyssä"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "tallennusluokka annettu %qs:lle"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, fuzzy, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "%<auto%> tiedostoalueen tyhjässä esittelyssä"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "funktioalue %qs implisiittisesti auto ja esitelty %<__thread%>:ksi"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, fuzzy, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "tarpeettomat sulkeet %qs:n esittelyssä"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses"
 msgstr "Odotettiin oikeaa sulkumerkkiä lausekkeessa kohdassa %C"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, fuzzy, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "%qs-nimikkeen kaksoisesittely"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, fuzzy, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "paluutyyppi on vaillinainen tyyppi"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, fuzzy, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "%qs-nimikkeen kaksoisesittely"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "%qs-nimikkeen kaksoisesittely"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "muodostimen virheellinen käyttö mallina"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "tyyppimääreet jätetään huomiotta funktion paluutyypissä"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, fuzzy, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "%qs-nimikkeen kaksoisesittely"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "%qs-nimikkeen kaksoisesittely"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "%qD:n paluuarvon tyyppi ei ole %<int%>"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs esitelty taulukon palauttavan funktiona"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<noreturn%>-funktio palauttaa ei-void-arvon"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "muodostin ei voi olla staattinen jäsenfunktio"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "hajottimet eivät voi olla cv-määriteltyjä"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "muodostimet eivät voi olla cv-määriteltyjä"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "hajottimet eivät voi olla cv-määriteltyjä"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "hajottimet eivät voi olla cv-määriteltyjä"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "muodostimia ei voi esitellä virtuaalisiksi"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, fuzzy, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "tyypillä %qE on virtuaalisia jäsenfunktioita"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, fuzzy, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "mallit eivät voi olla virtuaalisia"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "hajottimilla ei voi olla parametreja"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, fuzzy, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, fuzzy, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "ylimääräinen kvalifiointi %<%T::%> jäsenelle %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, fuzzy, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, fuzzy, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<virtual%> luokan esittelyn ulkopuolella"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%> tyhjässä esittelyssä"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "vain muodostimen esittely voi olla %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, fuzzy, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, fuzzy, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, fuzzy, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "jäsentä %qD ei voida esitellä sekä virtuaaliseksi että staattiseksi"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "%Jparametri %qD esitelty %<inline%>:ksi"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "funktion määrittely esitelty %<auto%>:ksi"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr "<typedef-virhe>"
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, fuzzy, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "kentällä %q+#D on sama nimi kuin luokalla"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, fuzzy, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "strftime-muotoilut eivät voi muotoilla argumentteja"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, fuzzy, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, fuzzy, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "virheelliset määreet ei-jäsenfunktion tyypissä"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr "<typedef-virhe>"
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, fuzzy, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "%q+D esitelty staattisena, edellinen esittely ei-staattinen"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "virheellinen %qT-tyyppisen viittauksen alustus %qT-tyyppisestä lausekkeesta"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, fuzzy, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "%qD ei ole funktiomalli"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "parametri esitelty %<auto%>:ksi"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "parametri esitelty %<auto%>:ksi"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "mallinimen %qE virheellinen käyttö ilman argumenttiluetteloa"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "ei-staattinen datajäsen %qE esitelty %<constexpr%>:ksi"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ kieltää nollan kokoisen taulukon %qD"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 ei tue joustavia taulukon jäseniä"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "%qD:n virheellinen käyttö"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "virheellinen funktioesittely"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "funktio %qD esitelty virtuaaliseksi unionissa"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "jäsentä %qD ei voida esitellä sekä virtuaaliseksi että staattiseksi"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "%qD esitelty staattisesti sisäkkäin"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "%qD:n esittely %qT:n jäsenenä"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "hajotin ei voi olla %<constexpr%>"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "%qD esitelty staattisesti sisäkkäin"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "Kopiomuodostin %qs"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "tiedostoa %s ei voi avata"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "%2$qD:n parametrilla %1$P on vaillinainen tyyppi %3$qT"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "nimellä %qT on vaillinainen tyyppi"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "%<inline%> tyhjässä esittelyssä"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, fuzzy, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "%qE-attribuuttia ei huomioida %qT-tyyppiselle kentälle"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "ei-staattinen datajäsen %qE esitelty %<constexpr%>:ksi"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "ei-staattinen datajäsen %qE esitelty %<constexpr%>:ksi"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "tallennusluokka %<auto%> virheellinen funktiolle %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "tallennusluokka %<register%> virheellinen funktiolle %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "tallennusluokka %<__thread%> virheellinen funktiolle %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "tallennusluokka %<__thread%> virheellinen funktiolle %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "kohdistusta ei voi määritellä %q+D:lle"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, fuzzy, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "%qE esitelty funktion palauttavana funktiona"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, fuzzy, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "jäsentä %qD ei voida esitellä sekä virtuaaliseksi että staattiseksi"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, fuzzy, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "%qD käytössä ilman esittelyä ennen sen määrittelyä"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "parametriksi ei voida esitellä %<constexpr%>:ksi"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs alustettu ja esitelty %<extern%>-avainsanalla"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs on sekä %<extern%> että alustin"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "Varoita implisiittisistä funktioesittelyistä"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "virheellinen parametrityyppi %qT"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "parametri %qD virheellisesti esitelty metodityyppi"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "virheellinen tyyppimuunnos funktiotyyppiin %qT"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "virheellinen tyyppimuunnos funktiotyyppiin %qT"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "virheellinen muodostin; tarkoitit todennäköisesti %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%q+D esitelty ystävänä"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, fuzzy, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, fuzzy, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ kieltää ?:-operaattorin ylikuormituksen"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD:lla ei saa olla vaihtuvaa määrää argumentteja"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "%qD:n on otettava joko nolla tai yksi argumenttia"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "%qD:n on otettava joko yksi tai kaksi argumenttia"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "%qD:n on otettava tasan kaksi argumenttia"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "%qD:n on otettava tasan yksi argumentti"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "%qD:n on otettava tasan kaksi argumenttia"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "muunnnos void-tyypiksi ei koskaan käytä tyyppimuunnosoperaattoria"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "muunnnos void-tyypiksi ei koskaan käytä tyyppimuunnosoperaattoria"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "muunnnos void-tyypiksi ei koskaan käytä tyyppimuunnosoperaattoria"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "muunnnos void-tyypiksi ei koskaan käytä tyyppimuunnosoperaattoria"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "muunnnos void-tyypiksi ei koskaan käytä tyyppimuunnosoperaattoria"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, fuzzy, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "vertailu ”etumerkitön lauseke >= 0” on aina tosi"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, fuzzy, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "<paluuarvo> "
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "<paluuarvo> "
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, fuzzy, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "<paluuarvo> "
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, fuzzy, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, fuzzy, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "tiedostonimi puuttuu %qs:n jälkeen"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%q+D:lla on edellinen esittely täällä"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, fuzzy, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "lueteltu tyyppi määritelty täällä"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%q+D:lla on edellinen esittely täällä"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, fuzzy, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "lueteltu tyyppi määritelty täällä"
@@ -62604,101 +62673,101 @@ msgstr "lueteltu tyyppi määritelty täällä"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, fuzzy, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "jäsennysvirhe malliargumenttien luettelossa"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "%qD-viittaus on moniselitteinen"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "function template %qD redeclared as a class template"
 msgid "class template %qD redeclared as non-template"
 msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD:llä on sama nimi kuin luokalla, jossa se on esitelty"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT ei ole malli"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, fuzzy, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "on ristiriidassa %q+#D:n edellisen esittelyn kanssa"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "C++:n sisäinen tietotyyppi %qT määritelty uudelleen"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, fuzzy, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "useita kenttiä unionissa %qT alustettu"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT määritelty monella suoralla kannoalla"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT määritelty suoralla virtuaalisella kannalla"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, fuzzy, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "%qT ei ole luokka-, struct- eikä unionityyppi"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "rekursiivinen tyyppi %qT määrittelemätön"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, fuzzy, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "edellinen määrittely täällä"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, fuzzy, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, fuzzy, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "cppchar_t:n on oltava etumerkitön tyyppi"
@@ -62707,87 +62776,93 @@ msgstr "cppchar_t:n on oltava etumerkitön tyyppi"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, fuzzy, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "ylivuoto luetellun tyypin arvoissa"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, fuzzy, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "edellinen %q+#T:n määrittely"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "paluutyyppi %q#T on vaillinainen"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, fuzzy, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator delete%>:n on palautettava tyyppi %qT"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "return-lause ilman arvoa funktiossa, jonka paluutyyppi on %qT"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "funktion paluuarvojen tyypit eivät ole yhteensopivia %<volatile%>:n takia"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-voidin"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, fuzzy, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD on jo määritelty"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 msgid "using %qs"
 msgstr "          %s"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D:a käytetty ennen esittelyä"
+
+#: cp/decl.cc:21341
 #, fuzzy, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "%q+D:n oletustyyppi on %<int%>"
@@ -63222,353 +63297,353 @@ msgstr "%q+D:n virheellinen uudelleenesittely"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    avattu lähteestä %qs, %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "Muodostin %qs"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "Muodostin %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In static member function %qD"
 msgstr "Staattinen jäsenfunktio %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In copy constructor %qs"
 msgid "In copy constructor %qD"
 msgstr "Kopiomuodostin %qs"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In constructor %qs"
 msgid "In constructor %qD"
 msgstr "Muodostin %qs"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In destructor %qs"
 msgid "In destructor %qD"
 msgstr "Hajotin %qs"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "Lambda-funktio"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "Staattinen jäsenfunktio %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "Jäsenfunktio %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "Funktio %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "but %qE is a type"
 msgstr "%qE ei ole tyyppi"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "struct määritelty täällä"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "parametri %q+D määritelty uudelleen"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "joustava taulukkojäsen unionissa"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD ei ole funktiomalli"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "  odotettiin luokkamallia, saatiin %qE"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable template"
 msgid "but %qE is a variable template"
 msgstr "%qD ei ole muuttujamalli"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD on nimiavaruus"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "%qD ei ole nimiavaruuden nimi"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s %qs"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "kutsuttu täältä"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 #, fuzzy
 msgid "recursively required by substitution of %qS\n"
 msgstr "tyhjän dynaamisen merkkijonon osan korvaus"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 #, fuzzy
 msgid "required by substitution of %qS\n"
 msgstr "tyhjän dynaamisen merkkijonon osan korvaus"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "kutsuttu täältä"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, fuzzy, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "kutsuttu täältä"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 msgid "required from here\n"
 msgstr "kutsuttu täältä"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "tyhjän dynaamisen merkkijonon osan korvaus"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "tyhjän dynaamisen merkkijonon osan korvaus"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "Vaaditaan todennus.\n"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "in requirements "
 msgstr "%qs määritelty parametrille %qE"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 msgid "(no argument)"
 msgstr "ei argumentteja"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr "[...]"
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, fuzzy, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, fuzzy, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "palautettu viittaus paikalliseen muuttujaan %q+D"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD:n esittely %qT:n jäsenenä"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD ei ole %qD:n jäsen"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%E%> on esittelemättä"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%E%> on esittelemättä"
@@ -63790,7 +63865,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "%qE:a ei ole alustettu"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, fuzzy, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
@@ -63906,7 +63981,7 @@ msgstr "perustyypin %qT kaksoiskappale virheellinen"
 msgid "type %qT is not a direct base of %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -64098,43 +64173,43 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, fuzzy, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "muotoilu %s päättyy %%:iin"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, fuzzy, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "taulukon %qE koko on negatiivinen"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "paluutyyppi on vaillinainen tyyppi"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, fuzzy, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "%qE:lla ei ole luokkatyyppiä"
@@ -64169,82 +64244,90 @@ msgstr "%2$qD:n parametrilla %1$P on vaillinainen tyyppi %3$qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "virheellinen funktioesittely"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, fuzzy, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr "%qE on vanhentunut"
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr "lisää eksplisiittinen %<this%>- tai %<*this%>-kaappaus"
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "Lambda-funktio"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "virheellinen #pragma %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "valitsin %qs ei ole enää tuettu"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr ""
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, fuzzy, gcc-internal-format
 msgid "%qD not defined"
 msgstr "nimiö %qD määritelty täällä"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD on esittelemättä tällä näkyvyysalueella"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD on esittelemättä tällä näkyvyysalueella"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, fuzzy, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(G++ hyväksyy koodin %<-fpermissive%>-valitsimella)"
@@ -64254,64 +64337,57 @@ msgstr "(G++ hyväksyy koodin %<-fpermissive%>-valitsimella)"
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, fuzzy, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "typedef %qD on alustettu (käytä __typeof__ sen sijaan)"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "kolmoismerkki ??%c muunnettu merkiksi %c"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -64698,7 +64774,7 @@ msgstr "luetellun tyypin jäsenen %q+D uudelleenesittely"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "ristiriitainen esittely %q#D"
@@ -64713,427 +64789,427 @@ msgstr "ristiriitainen esittely %q#D"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "useita tallennusluokkia esittelymääritteissä"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "esittelyssä %q+D"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 msgid "existing default declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "oletusargumentti annettu %2$q#D:n parametrille %1$d"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "%qD esitelty extern-avainsanalla sisäkkäin"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "puuttuva määrittely"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "%qD esitelty extern-avainsanalla sisäkkäin"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "luetellun tyypin jäsenen %q+D uudelleenesittely"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE ei ole tyyppiä %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "%qD esitelty uudelleen eri näkyvyydellä"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, fuzzy, gcc-internal-format
 msgid "recursive lazy load"
 msgstr "    Rekursiiviset jäsenet:\n"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, fuzzy, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr "%q+D:n edellinen esittely oli täällä"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, fuzzy, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "%s%qs%s ei ole sallittu"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "%q+D:n edellinen määrittely oli täällä"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "Ei voida poistaa moduulitiedostoa ”%s”: %s"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "  --version                Näytä kääntäjän versiotiedot\n"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2-versio %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 msgid "module %qs found"
 msgstr "Ei löydy"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "kohdemuoto ei tue äärettömyyttä"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "%s: ei voida avata PCH-tiedostoa: %m\n"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "%s: ei voida avata PCH-tiedostoa: %m\n"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "%q+D:n osoitealue on ristiriidassa edellisen esittelyn kanssa"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "%q+D:n osoitealue on ristiriidassa edellisen esittelyn kanssa"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "nimiavaruuden %qD esittely on ristiriidassa"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "nimiavaruuden %qD esittely on ristiriidassa"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, fuzzy, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "esitelty täällä"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, fuzzy, gcc-internal-format
 msgid "import declared in global module"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "malliesittelylle %q+D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "%q#D:n esittely C-kielen linkityksellä"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "esitelty aiemmin täällä"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "esitelty aiemmin täällä"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "luetellun tyypin jäsenen %q+D uudelleenesittely"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "          %s"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, fuzzy, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "tuntematon valitsin -%s"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "ylimääräinen puolipiste metodin määrittelyssä"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "module declared here"
@@ -65146,109 +65222,109 @@ msgstr " esitelty täällä"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 msgid "module already declared"
 msgstr "%qs alustettu ja esitelty %<extern%>-avainsanalla"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 #| msgid "In module imported at"
 msgid "module already imported"
 msgstr "Moduulissa, joka tuotu kohdassa"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 #| msgid "In module imported at"
 msgid "module %qs imported here"
 msgstr "Moduulissa, joka tuotu kohdassa"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "Tuntematon tiheys: ”%c”"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "virheellinen esikääntäjän direktiivi #%s"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "virheellinen --param-arvo %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "virheellinen --param-arvo %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "virhe kirjoitettaessa i-solmua"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "%qD esiteltiin täällä"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "%s: ei voida avata PCH-tiedostoa: %m\n"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "tls_model-argumentti ei ole merkkijono"
@@ -65263,7 +65339,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
@@ -65308,262 +65384,273 @@ msgstr "%q+D:n esittely varjostaa sisäänrakennetun funktion"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "%qD:n esittely %qT:n jäsenenä"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %qD but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "friend-esittely %qD paikallisessa luokassa ilman edeltävää esittelyä"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, fuzzy, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q+D esitelty täällä"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q+D esitelty täällä"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> nimeää muodostimen, ei tyyppiä"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, fuzzy, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qE ei ole luokka, nimiavaruus eikä lueteltu tyyppi"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, fuzzy, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr "oliko tarkoitus käyttää loogista negaatiota?"
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "ristiriitainen esittely %q#D"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> nimeää muodostimen, ei tyyppiä"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "%qD ei ole luokka eikä nimiavaruus"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, fuzzy, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "%qD:n esittely viitteiden taulukkona"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, fuzzy, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "%q+D esitelty ystävänä"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%qs-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "%<fast_interrupt%>-attribuuttidirektiivi jätetty huomiotta"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "ehdotettu vaihtoehto:"
 msgstr[1] "ehdotetut vaihtoehdot:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "  %qE"
 msgstr "%qE on vanhentunut"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<this%> ei ole käytettävissä staattisissa jäsenfunktioissa"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr "määriteltiin myöhemmin tässä"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "funktion %q+D määrittely on merkitty dllimport-tyyppiseksi"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "valitsin %qs ei ole enää tuettu"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, fuzzy, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "%<namespace%>-määrittely ei ole sallittu täällä"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "luetellun tyypin jäsenen %q+D uudelleenesittely"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD esitelty ei-parametrina"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "odotettiin %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "edellinen määrittely täällä"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -65593,7 +65680,7 @@ msgstr "tunniste %qE on ristiriidassa C++:n varatun sanan kanssa"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
@@ -65638,7 +65725,7 @@ msgstr "%<::%E%> on esittelemättä"
 msgid "request for member %qE in non-class type %qT"
 msgstr "pyyntö jäsenen %qs käsittelyyn jossain, joka ei ole tietue tai unioni"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> on esittelemättä"
@@ -65708,7 +65795,7 @@ msgstr "(mahdollisesti %qT:n määrittelyn perästä puuttuu puolipiste)"
 msgid "%qE is not a class template"
 msgstr "  odotettiin luokkamallia, saatiin %qE"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE ei ole malli"
@@ -66019,1698 +66106,1708 @@ msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "odotettiin luokan nimeä"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD ei ole funktiomalli"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qE ei ole luokka, nimiavaruus eikä lueteltu tyyppi"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "säiekohtaista muistia ei tueta tälle kohteelle"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ kieltää lohkot lausekkeiden sisällä"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "odotettiin lauseketta"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "paikallinen muuttuja %qD ei voi esiintyä tässä yhteydessä"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "paikallinen muuttuja %qD ei voi esiintyä tässä yhteydessä"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression"
 msgstr "odotettiin lauseketta"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, fuzzy, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "%qT ei ole luokka tai nimiavaruus"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "parametri esitelty %<auto%>:ksi"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, fuzzy, gcc-internal-format
 msgid "remove the %qs"
 msgstr "Odotettiin oikeaa sulkumerkkiä lausekkeessa kohdassa %C"
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "%<~%T%>:n esittely %qT:n jäsenenä"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, fuzzy, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, fuzzy, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "ID"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD ei ole malli"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, fuzzy, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, fuzzy, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "kutsussa muistinvarausfunktioon %qD, joka on esitelty täällä"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ kieltää yhdysliteraalit"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "%qD:n virheellinen käyttö"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> ei ole luokan jäsen"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, fuzzy, gcc-internal-format
 msgid "non-scalar type"
 msgstr "pyydetty muuntoa ei-skalaarityypiksi"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "taulukon %qE koko ei ole kokonaislukutyyppiä"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, fuzzy, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "taulukkoindeksi ei-taulukkoalustimessa"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, fuzzy, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "taulukkoindeksi ei-taulukkoalustimessa"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, fuzzy, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "vanhanmallisen tyyppimuunnoksen käyttö"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "suosittellaan sulkumerkkejä %<>>%>-lausekkeen ympärille"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, fuzzy, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, fuzzy, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "Odotettiin argumenttiluetteloa kohdassa %C"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, fuzzy, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "versioviitetaulukolle ei voi varata muistia"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, fuzzy, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, fuzzy, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "poistettu funktio %q+D"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr "%s: Liian monta argumenttia\n"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%qE declared here"
+msgid "%q#E declared here"
+msgstr "%qE esitelty täällä"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, fuzzy, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "nimike yhdyslauseen lopussa"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%E%> names the constructor, not the type"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%> nimeää muodostimen, ei tyyppiä"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-voidin"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 msgid "condition declares an array"
 msgstr "taulukon palauttava funktio"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 msgid "condition declares a function"
 msgstr "kenttä %qE esitelty funktiona"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 msgid "expected initializer"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "muuttujalla %qD on funktiotyyppi"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "%Jparametrin %qD tyyppi on vaillinainen"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, fuzzy, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "odotettiin iteraatioesittelyä tai -alustusta"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "hajotin ei voi olla %<constexpr%>"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ kieltää lasketut goto-käskyt"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 msgid "expected module-partition"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 msgid "expected module-name"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "kaksoiskappale-rajapintaesittely luokalle %qE"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 msgid "scope opened here"
 msgstr "union määritelty täällä"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 msgid "private module fragment"
 msgstr "ylimääräinen %<volatile%>"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "ylimääräinen %<;%> luokansisäisen funktiomäärittelyn perässä"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "parametri esitelty %<auto%>:ksi"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "attribuuttia ei huomioida"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "funktio %qE esitelty implisiittisesti"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "kaksoiskappale-rajapintaesittely luokalle %qE"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> ei ole lohkon alussa"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, fuzzy, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, fuzzy, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "tyhjä indeksiväli alustimessa"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, fuzzy, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "tyhjä indeksiväli alustimessa"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "odotettiin iteraatioesittelyä tai -alustusta"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "odotettiin iteraatioesittelyä tai -alustusta"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "puuttuva alustin jäsenelle %qD"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "Proseduurilla ”%s” kohdassa %C on eksplisiittinen rajapinta ja sillä ei saa olla attribuutteja, jotka on esitelty kohdassa %L"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, fuzzy, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "Tuntematon (tyyppi = %d, bitit = %d)\n"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> saa uuden merkityksen C++11:ssä; poista se"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "%qD invalid in lambda"
 msgid "%qD invalid in condition"
 msgstr "%qD ei kelpaa lambdassa"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD ei kelpaa lambdassa"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "virheellinen muunnostarkennin jälkiliitteessä: %c"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "luokkamäärittelyä ei voi esitellä ystäväksi"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "mallit eivät voi olla virtuaalisia"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "%s: virheellinen kenttämääritys %s"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "epäkelpo %<restrict%>-avainsanan käyttö"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "ei voi laajentaa alustinta jäsenelle %<%D%>"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "%q+D esitelty staattisena, edellinen esittely ei-staattinen"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, fuzzy, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, fuzzy, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, fuzzy, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "leveä merkkijonovakio %<asm%>-lauseessa"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 msgid "expected operator"
 msgstr "odotettiin %<operator%>"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, fuzzy, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "Avainsana %s on tuntematon tai sillä ei vielä ole toteutusta"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "Avainsana %s on tuntematon tai sillä ei vielä ole toteutusta"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "PROCEDURE-lauseen kohdassa %C on oltava geneerisessä rajapinnassa"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "virheellinen parametrityyppi %qT"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "hajottimet eivät voi olla cv-määriteltyjä"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "mallinimen %qE virheellinen käyttö ilman argumenttiluetteloa"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "strftime-muotoilut eivät voi muotoilla argumentteja"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "strftime-muotoilut eivät voi muotoilla argumentteja"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 msgid "expected template-id"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, fuzzy, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "jäsennysvirhe malliargumenttien luettelossa"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(G++ hyväksyy koodin -fpermissive-valitsimella)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "jäsennysvirhe malliargumenttien luettelossa"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 msgid "expected template-name"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, fuzzy, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, fuzzy, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "ENUM-määrittelylause odotettiin ennen kohdetta %C"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 msgid "expected template-argument"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "muuttuja %qD esitelty %<inline%>:ksi"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "muuttuja %qD esitelty %<inline%>:ksi"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, fuzzy, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "malli C-linkityksellä"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 msgid "expected type specifier"
 msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 msgid "expected type-name"
 msgstr "Odotettu nimi"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "%qE ei nimeä tyyppiä"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 msgid "concept defined here"
 msgstr "union määritelty täällä"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "%qD:n virheellinen käyttö"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "odotettiin merkkijonoa ilmaisun %<#pragma message%> jälkeen"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, fuzzy, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr "%qD ei ole %qD:n jäsen"
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "esittely %qD ei esittele mitään"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD ei ole malli"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "%<namespace%>-määrittely ei ole sallittu täällä"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "%J%qD:n edellinen esittely oli täällä"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "esittely %qD ei esittele mitään"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, fuzzy, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "ylimääräinen %<;%>"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ kieltää enumin lisäyksen"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD ei ole nimiavaruuden nimi"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD ei ole nimiavaruuden nimi"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "odotettiin %<namespace%>"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "odotettiin %<namespace%>"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, fuzzy, gcc-internal-format
 msgid "namespace name required"
 msgstr "%qD on nimiavaruus"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "%<namespace%>-määrittely ei ole sallittu täällä"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "%<namespace%>-määrittely ei ole sallittu täällä"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "siirryttiin %qD-nimiavaruuteen"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<namespace%>-määrittely ei ole sallittu täällä"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, fuzzy, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "paluutyyppi %q#T on vaillinainen"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "%q+D:lla on edellinen esittely täällä"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "Odotettiin nimetöntä rajapintaa kohdassa %C"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "cv-määreen kaksoiskappale"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "tyyppimääritteet jätetään huomiotta funktion paluutyypissä"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT ei ole nimiavaruus"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "poistettu funktio %q+D"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "parametrien nimet (ilman tyyppejä) funktion esittelyssä"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "taulukkoindeksi ei-taulukkoalustimessa"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "parametrien nimet (ilman tyyppejä) funktion esittelyssä"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "funktio %qD esitelty uudelleen muuttujana"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "sisäkkäisessä funktiossa käytetty globaalia rekisterimuuttujaa %qD"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr "Tyhjä taulukkomuodostin kohdassa %C ei ole sallittu"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "tunniste %qE on ristiriidassa C++:n varatun sanan kanssa"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "virheellinen funktioesittely"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "%qD-viittaus on moniselitteinen"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "Ristiriita funktioargumentin attribuuteissa kohdassa %C"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "#pragma GCC option ei ole sallittu funktioiden sisällä"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "#pragma GCC option ei ole sallittu funktioiden sisällä"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "#pragma GCC option ei ole sallittu funktioiden sisällä"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "%<namespace%>-määrittely ei ole sallittu täällä"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, fuzzy, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "Ristiriita funktioargumentin attribuuteissa kohdassa %C"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, fuzzy, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "Varoita kun kaikki muodostimet ja hajottimet ovat yksityisiä"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "epäkelpo alustin"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, fuzzy, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "taulukkoindeksi ei-taulukkoalustimessa"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "%Jsisäänrakennettu funktio %qD esitelty ei-funktiona"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, fuzzy, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> ei ole tyyppi"
@@ -67719,275 +67816,275 @@ msgstr "%<%T::%E%> ei ole tyyppi"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 msgid "invalid declarator"
 msgstr "Varoita implisiittisistä funktioesittelyistä"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "muodostimen virheellinen käyttö mallina"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "id="
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 msgid "expected declarator"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD on nimiavaruus"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "odotettiin %<operator%>"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "cv-määreen kaksoiskappale"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "ristiriitaiset tyyppimääreet %q+D:lle"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, fuzzy, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "-m64 vaatii PowerPC64-suorittimen"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "Kaksoiskappale pääsy-tarkenne kohdassa %C"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "täsmäämättömät argumentit"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "virheellinen parametrityyppi %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, fuzzy, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr "%qE on vanhentunut"
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "odotettiin %<,%> tai %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "Odotettiin toista ulottuvuutta taulukkoesittelyssä kohdassa %C"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, fuzzy, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "%<operator new%>:n ensimmäisellä parametrilla ei voi olla oletusargumenttia"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "%<operator new%>:n ensimmäisellä parametrilla ei voi olla oletusargumenttia"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "%<operator new%>:n ensimmäisellä parametrilla ei voi olla oletusargumenttia"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "%<operator new%>:n ensimmäisellä parametrilla ei voi olla oletusargumenttia"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C90 ei tue joustavia taulukkojäseniä"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, fuzzy, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella"
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 msgid "expected class-name"
 msgstr "odotettiin luokan nimeä"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "Kaksoiskappale pääsy-tarkenne kohdassa %C"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, fuzzy, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, fuzzy, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "virheellinen luokan nimi %qD:n esittelyssä"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "virheellinen luokan nimi %qD:n esittelyssä"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "%<inline%> tyhjässä esittelyssä"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, fuzzy, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "%qs alustettu ja esitelty %<extern%>-avainsanalla"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, fuzzy, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "%s: ei voida avata PCH-tiedostoa: %m\n"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "edellinen %q+#T:n määrittely"
@@ -67995,272 +68092,272 @@ msgstr "edellinen %q+#T:n määrittely"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 msgid "expected class-key"
 msgstr "odotettiin %<class%>"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "tallennusluokka annettu typenamelle"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "ystäväesittely ei nimeä luokkaa tai funktiota"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr "ISO C++ sallii bittikenttien määritteet vain ennen %<:%>-merkkiä"
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "bittikentällä %qD on ei-kokonaislukutyyppi %qT"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "pure-tarkenne funktiomäärittelyssä"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "ylimääräinen %<,%> jäsenesittelyn lopussa"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "ylimääräinen %<,%> jäsenesittelyn lopussa"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, fuzzy, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "epäkelpo osoitintila %qs"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, fuzzy, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "skalaarialustimen ympärillä on aaltosulkeet"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "varoitus: lähdetiedosto %s annettu useammin kuin kerran"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, fuzzy, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "varoitus: lähdetiedosto %s annettu useammin kuin kerran"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, fuzzy, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "ISO C++17 ei salli dynaamisia poikkeusmäärittelyitä"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "dynaamiset poikkeusmäärittelyt ovat vanhentuneita C++11:ssä"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> tyhjässä esittelyssä"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "%qE-attribuutti on ristiriidassa attribuutin %s kanssa"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "vakio tai tunniste odotettu"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "ENUM-määrittelylause odotettiin ennen kohdetta %C"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "ei-tyhjä attribuutti ilman argumentteja ei-prototyypissä"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "odotettiin lauseketta"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "Muodostin %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "%qE-attribuuttia ei huomioida %qE:lle"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "virheellinen %<%T::%E%>:n esittely"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, fuzzy, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "%J%qD:n edellinen esittely oli täällä"
@@ -68269,434 +68366,434 @@ msgstr "%J%qD:n edellinen esittely oli täällä"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, fuzzy, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "%J%qD:n edellinen esittely oli täällä"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "nimetyt paluuarvot eivät ole enää tuettuja"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "malliesittelylle %q+D"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "malli C-linkityksellä"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "    Ei ilmaistuja epäjäseniä\n"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "malliesittelylle %q+D"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "esittely ei esittele mitään"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "mallinimen %qE virheellinen käyttö ilman argumenttiluetteloa"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, fuzzy, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "mallinimen %qE virheellinen käyttö ilman argumenttiluetteloa"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "mallinimen %qE virheellinen käyttö ilman argumenttiluetteloa"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "%<sizeof...%>-argumentti on ympäröitävä sulkeilla"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "virheellinen hajottimen %qD käyttö tyyppinä"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "Tuntematon (tyyppi = %d, bitit = %d)\n"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, fuzzy, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "käytetty %<__thread%> ennen %<extern%>:a"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%qE ei ole typedef eikä sisäinen tyyppi"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "sekä %<_Sat%> että %<char%> esittelymääritteissä"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "ylimääräinen %<const%>"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "kaksois-%qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "odotettiin %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "odotettiin %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "odotettiin %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "odotettiin %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "odotettiin %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "odotettiin %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "odotettiin %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "odotettiin %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "odotettiin %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "odotettiin %<namespace%>"
 
 # XXXXXXX
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "odotettiin %<=%>, %<,%>, %<;%>, %<asm%> tai %<__attribute__%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "”)” oli odotus"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, fuzzy, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "  siirtyy catch-lohkoon"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "<throw-lauseke>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, fuzzy, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "nimiö "
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, fuzzy, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "Taso 2 ei ole synkronoitu"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, fuzzy, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "<throw-lauseke>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "odotettiin %<,%> tai %<;%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "odotettiin %<(%> tai rivin loppu"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "”)” oli odotus"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, fuzzy, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "”)” oli odotus"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "”)” oli odotus"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "”)” oli odotus"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "odotettiin %<:%> tai %<...%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "”)” oli odotus"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, fuzzy, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "%qs määritelty parametrille %qE"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q+#D aiemmin esitelty täällä"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qD esitelty uudelleen eri näkyvyydellä"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "odotettiin %<class%>"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "nimiö %qD määritelty täällä"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "esitelty täällä"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD esitelty uudelleen eri näkyvyydellä"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "C++98:ssa %<template%> (selventimenä) on sallittu vain malleissa"
 
 # XXX
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, fuzzy, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, fuzzy, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "käytetty %<__thread%> ennen %<extern%>:a"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "useita tallennuspaikkoja esittelymääritteissä"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, fuzzy, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "%qE ei ole Objective-C-luokkanimi eikä -alias"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "Odotettiin toista ulottuvuutta taulukkoesittelyssä kohdassa %C"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "ylimääräinen %qs Objective-C++-metodien välissä"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, fuzzy, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "%qs-attribuuttia ei huomioida %qs:lle"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 msgid "invalid type for property"
 msgstr "virheellinen vastaanottajatyyppi %qs"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "<tuntematon>"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "odotettiin tunnistetta tai %<(%>"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
@@ -68705,173 +68802,173 @@ msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "valitsin %qs ei ole enää tuettu"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, fuzzy, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, fuzzy, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "# Ei kohde:"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "epäkelpo alustin"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, fuzzy, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, fuzzy, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr "edellinen esittely"
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, fuzzy, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely"
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "edellinen esittely"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "%qs määrittää %<auto%>:n tiedostoalue-esittelyssä"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-voidin"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, fuzzy, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr "_Peru"
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, fuzzy, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "Käyttö: %s <transaktiotiedosto> <tiedostojärjestelmä>\n"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, fuzzy, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "%Jvanhanmallinen funktiomäärittely"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "tuntematon #pragma GCC coprocessor %E"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "moduulienvälisiä optimointeja ei ole toteutettu C++:lle"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, fuzzy, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "mallit eivät voi olla virtuaalisia"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -69347,497 +69444,503 @@ msgstr "muodostimen virheellinen käyttö mallina"
 msgid "redeclaration of %qD with different constraints"
 msgstr "%q+D:n virheellinen uudelleenesittely"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "storage class specified for template parameter %qs"
+msgid "local class in lambda in template parameter list"
+msgstr "tallennusluokka annettu malliparametrille %qs"
+
+#: cp/pt.cc:6461
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT ei ole malli"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, fuzzy, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "%qs:n esittelyssä tyyppi on oletuksena %<int%>"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "%J%qD:n edellinen esittely oli täällä"
 msgstr[1] "%J%qD:n edellinen esittely oli täällä"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "%J%qD:n edellinen esittely oli täällä"
 msgstr[1] "%J%qD:n edellinen esittely oli täällä"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, fuzzy, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "malliesittelylle %q+D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, fuzzy, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "%q+D esitelty uudelleen erityyppisenä symbolina"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "redeclared here"
 msgstr "esitelty täällä"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "%q+D:n virheellinen uudelleenesittely"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "varjostunut esittely on täällä"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "%q+D:n virheellinen uudelleenesittely"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, fuzzy, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "%qD:n esittely %qT:n jäsenenä"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "%Juseita parametreja nimellä %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, fuzzy, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "valitsimet -l ja -s eivät ole yhteensopivia"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  täsmäämättömät tyypit %qT ja %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "strftime-muotoilut eivät voi muotoilla argumentteja"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "%qE-attribuuttia ei huomioida %qE:lle"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, fuzzy, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, fuzzy, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  ehdokas odottaa %d argumenttia, %d annettu"
 msgstr[1] "  ehdokas odottaa %d argumenttia, %d annettu"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  ehdokas odottaa %d argumenttia, %d annettu"
 msgstr[1] "  ehdokas odottaa %d argumenttia, %d annettu"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "%qE:ta ei voi muuntaa tyypistä %qT tyyppiin %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, fuzzy, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "virheellinen hajottimen %qD käyttö tyyppinä"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, fuzzy, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  odotettiin %qT-tyyppistä vakiota, saatiin %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  odotettiin luokkamallia, saatiin %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  odotettiin tyyppiä, saatiin %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  odotettiin tyyppiä, saatiin %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  odotettiin tyyppiä, saatiin %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  odotettiin tyyppiä, saatiin %qE"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "%qE:ta ei voi muuntaa tyypistä %qT tyyppiin %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "muodostimen virheellinen käyttö mallina"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "attribuutille %qs annettu väärä määrä argumentteja"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "attribuutille %qs annettu väärä määrä argumentteja"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 msgid "provided for %qD"
 msgstr "nimellä %qD"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT"
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "malliesittelylle %q+D"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, fuzzy, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "malliesittelylle %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "%qT ei ole malli"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "first specified here"
 msgid "first error appeared here"
 msgstr "määritelty ensimmäisen kerran tässä"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "joustava taulukkojäsen unionissa"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE ei ole esittelyn alussa"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, fuzzy, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "  täsmäämättömät tyypit %qT ja %qT"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, fuzzy, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "  täsmäämättömät tyypit %qT ja %qT"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "%q+D määritelty uudelleen"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr "  täsmäämättömät tyypit %qT ja %qT"
@@ -69855,123 +69958,123 @@ msgstr "  täsmäämättömät tyypit %qT ja %qT"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "muuttujalla %qD on funktiotyyppi"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "virheellinen parametrityyppi %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "esittelyssä %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "taulukon palauttava funktio"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "funktion palauttava funktio"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "lueteltu tyyppi määritelty täällä"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, fuzzy, gcc-internal-format
 msgid "forming reference to void"
 msgstr "tyhjää arvoa ei jätetä huomioimatta, vaikka kuuluisi"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "NULLin muunnos epäosoitintyypiksi %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "tyyppitäsmäämättömyys taulukkoviitteessä"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "NULLin muunnos epäosoitintyypiksi %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, fuzzy, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "luodaan void-taulukko"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "taulukolla %q+D oletetaan olevan yksi alkio"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT ei ole luokka-, struct- eikä unionityyppi"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT ei ole luokka-, struct- eikä unionityyppi"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, fuzzy, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "muodostimen virheellinen käyttö mallina"
@@ -69979,133 +70082,133 @@ msgstr "muodostimen virheellinen käyttö mallina"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "%q+D:n edellinen esittely oli täällä"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "objektityyppi %qT ei täsmää hajottimen nimen ~%qT kanssa"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "alustinalkio ei ole vakiolauseke"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "void-lausekkeen epäkelpo käyttö"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, fuzzy, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "Käytä rekistereitä argumenttien välittämiseen"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, fuzzy, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, fuzzy, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "käytä #includea sen sijaan"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "käytä #includea sen sijaan"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qE attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "attribuutille %qE annettu väärä määrä argumentteja"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT ei ole luokka eikä nimiavaruus"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD ei ole luokka eikä nimiavaruus"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "käytetään virheellistä kenttää %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT on/käyttää anonyymiä tyyppiä"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, fuzzy, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, fuzzy, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, fuzzy, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "ohjelman alustusta yritettäessä"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "malliesittelylle %q+D"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 msgid "%s %#qS"
 msgstr ""
@@ -70113,77 +70216,77 @@ msgstr ""
 "%s, %s, %s, %s,\n"
 "%s, %s ja %s.\n"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, fuzzy, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "jäsenen %q+D kaksoiskappale"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ kieltää metodiosoittimen käytön vähennyslaskussa"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, fuzzy, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ kieltää metodiosoittimen käytön vähennyslaskussa"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "jäsenen %q+D kaksoiskappale"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "%q+D:n edellinen esittely oli täällä"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "%Jvanhanmallinen funktiomäärittely"
@@ -70195,520 +70298,576 @@ msgstr "%Jvanhanmallinen funktiomäärittely"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "käyttämätön muuttuja %q+D"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "staattinen tai tyyppimääreitä ei-parametrisessa taulukkoesittelijässä"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "%qT ei ole luokka eikä nimiavaruus"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "malliesittelylle %q+D"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, fuzzy, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "funktion %q+D määrittely on merkitty dllimport-tyyppiseksi"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "%qD ei ole mallifunktio"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "attribuutti %qs pätee vain funktiotyyppeihin"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "käytä #includea sen sijaan"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "liian paljon argumentteja funktiolle %qs"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "Tiedostoa ”%s” on jo tarkasteltu.\n"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "liian paljon argumentteja funktiolle %qs"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "ei voi emuloida %qs"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "%qE:n muunnos tyypistä %qT tyyppiin %qT ei ole yksiselitteinen"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, fuzzy, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "%qD ei ole %qD:n jäsen"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "alustusalkio ei ole vakio"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "alustusalkio ei ole vakio"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "alustusalkio ei ole vakio"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%E%> is not a class or namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<::%E%> ei ole luokka eikä nimiavaruus"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, fuzzy, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "komennon ”%s” ajaminen epäonnistui: %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "odotettiin %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "komennon ”%s” ajaminen epäonnistui: %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  odotettiin tyyppiä, saatiin %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "käytetty sekä %<__thread%> että %qs"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "odotettiin %<template%>"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, fuzzy, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "puhdistusargumentti ei ole funktio"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "bittikentän %qD osoitetta ei voi ottaa"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "lueteltu tyyppi määritelty täällä"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "Virheellinen argumentti"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<decltype%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "odotettiin %<decltype%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "%qs attribuuttia ei huomioida"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "vektoriylivuoto lausekkeessa"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "vektoriylivuoto lausekkeessa"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "alustinalkio ei ole vakiolauseke"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "parametriksi ei voida esitellä %<constexpr%>:ksi"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "sisäinen funktio %q+D esitelty ei-funktiona"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "odotettiin totuusarvolauseketta"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "%<[*]%> ei ole esittelyssä"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "Varoita kun kaikki muodostimet ja hajottimet ovat yksityisiä"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "%qD ei ole nimiavaruuden nimi"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "virheellinen tyyppimuunnos funktiotyyppiin %qT"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr "luokkanimeä ei ole annettu %qs:n kanssa"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "poistettu funktio %q+D"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about uses of a comma operator within a subscripting expression."
 msgid "cannot use a data member specification in a splice expression"
 msgstr "Varoita pilkuoperaattorin käytöstä alaindeksilausekkeessa."
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD ei ole funktiomalli"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -71040,590 +71199,590 @@ msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 msgid "invalid base-class specification"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "jäsentä %q+D käytetty virheellisesti staattisessa jäsenfunktiossa"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "        %qD"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, fuzzy, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "oletusargumentti määritelty lambda-parametrille"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "poistettu funktio %q+D"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, fuzzy, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "poistettu funktio %q+D"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "poistettu funktio %q+D"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments"
 msgstr "täsmäämättömät argumentit"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, fuzzy, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "  odotettiin luokkamallia, saatiin %qT"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "%qD:n esittely ei-jäsenenä"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, fuzzy, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "%qE ei ole tyyppi"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "taulukon koolla on epäkokonaislukutyyppi %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "Funktion %s argumentti kohdassa %L on negatiivinen"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "tarpeeton tyyppimääre tyhjässä esittelyssä"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "ei-triviaalisti-kopioitavan tyyppisiä %q#T-olioita ei voi vastaanottaa %<...%>:n kautta"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "Muodostin %qs"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "tyypillä %qE on käyttäjän määrittelemä muodostin"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %d"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "ISO C kieltää nollan kokoisen taulukon %qE"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "tyypillä %qE on virtuaalisia jäsenfunktioita"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr "tyypillä %qE on käyttäjän määrittelemä muodostin"
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "edellinen esittely"
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, fuzzy, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "%<num_threads%>-arvon on oltava positiivinen"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, fuzzy, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, fuzzy, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, fuzzy, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, fuzzy, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "”%s” ei ole kelvollinen makron nimi, sillä se on C++:n operaattori"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length traits arrays are not supported"
 msgstr "käytetään muuttuvapituista taulukkoa"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "muuttuja %qD esitelty uudelleen funktiona"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "%qE ei ole malli"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, fuzzy, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr "%qE ei ole malli"
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "%s:n arvon on oltava kokonaisluku"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%Jparametrin %qD tyyppi on vaillinainen"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, fuzzy, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %s"
 msgid "static assertion failed: %.*s"
 msgstr "staattinen väite epäonnistui: %s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "ei-vakio ehto staattiselle väitteelle"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT ei ole luokkatyyppi"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "%qT ei ole malli"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "%s: kenttä ”%s” ei saa olla tyhjä"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "  odotettiin luokkamallia, saatiin %qE"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "%<__builtin_prefetch%>-funktion toisen argumentin pitää olla vakio"
@@ -71631,350 +71790,350 @@ msgstr "%<__builtin_prefetch%>-funktion toisen argumentin pitää olla vakio"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "hajotin ei voi olla staattinen jäsenfunktio"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, fuzzy, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "osoitealueattribuuttia ei voi määritellä paikallisille muuttujille"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr " esitelty täällä"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, fuzzy, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "%qT ei ole malli"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "perustyypin %qT kaksoiskappale virheellinen"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "%s:ei ole gcov-datatiedosto\n"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "nimellä %qT on vaillinainen tyyppi"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 msgid "%qD is not public"
 msgstr "        %qD"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD ei ole muuttuja"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qD ei ole tyyppi"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "%qE-attribuutti pätee vain funktiotyyppeihin"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "%qE-attribuutti pätee vain funktiotyyppeihin"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "osoitealueattribuuttia ei voi määritellä paikallisille muuttujille"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "%qE-attribuutti pätee vain funktioihin"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "virheellinen funktioesittely"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%>-avainsanaa sovellettu bittikenttään"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %qD but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "%qs:n esittely taulukollisena tyhjiä alkioita"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "näkyvyysargumentti ei ole merkkijono"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "näkyvyysargumentti ei ole merkkijono"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "universaali merkki %.*s ei ole kelvollinen tunniste"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "universaali merkki %.*s ei ole kelvollinen tunniste"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "%J%qE-attribuutti soveltuu vain funktioihin"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about semicolon after in-class function definition."
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "Varoita puolipisteestä luokansisäisen funktiomäärittelyn perässä."
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "%qE-attribuutti pätee vain muuttujiin"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "tallennusluokka annettu parametrille %qs"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 msgid "annotation on void parameter"
 msgstr "parametri %q+D määritelty uudelleen"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "funktio ei palauta merkkijonotyyppiä"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "verifiointi epäonnistui kohdassa PC=%d: %s"
@@ -72176,817 +72335,822 @@ msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> ei ole luokan jäsen"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "%qD:n esittely %qT:n jäsenenä"
+
+#: cp/typeck.cc:3781
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "funktiomalli %qD esitelty uudelleen luokkamallina"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "joustavan taulukkojäsenen sisältävän tietueen epäkelpo käyttö"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "joustavan taulukkojäsenen sisältävän tietueen epäkelpo käyttö"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "epäkelpo %<restrict%>-avainsanan käyttö"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, fuzzy, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "taulukon indeksi on taulukkorajojen yläpuolella"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, fuzzy, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "ISO C kieltää %<register%>-taulukon indeksoinnin"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, fuzzy, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "%qE esittelemättä (ensimmäinen käyttökerta tässä funktiossa)"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 msgid "no default version in scope"
 msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ kieltää %<::main%>-funktion kutsumisen ohjelmasta"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "%qE:a saatetaan käyttää alustamattomana tässä funktiossa"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE:a saatetaan käyttää alustamattomana tässä funktiossa"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD:a käytetään alustamattomana tässä funktiossa"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "funktio-osoitinta käytetty laskutoimituksessa"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "liikaa argumentteja muodostimelle %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "liian vähän argumentteja muodostimelle %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "liikaa argumentteja jäsenfunktiolle %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "liian vähän argumentteja jäsenfunktiolle %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "liikaa argumentteja funktiolle %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "liian vähän argumentteja funktiolle %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "liikaa argumentteja metodille %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "liian vähän argumentteja funktiolle %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "liikaa argumentteja funktiolle"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "liian vähän argumentteja funktiolle"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "%2$qD:n parametrilla %1$P on vaillinainen tyyppi %3$qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the compiler can assume that the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "kääntäjä voi olettaa, että %qD:n osoite ei koskaan ole NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "kääntäjä voi olettaa, että %qD:n osoite ei koskaan ole NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä muunnoksesta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä muunnoksesta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä vertailusta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä vertailusta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä vertailusta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä vertailusta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä vertailusta puuttuu tyyppimuunnos"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, fuzzy, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "liian paljon argumentteja funktiolle %qs"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL-arvon käyttö laskutoimituksessa"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ kieltää osoittimen ja kokonaisluvun vertailun"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "ei-liukulukuargumentti kutsussa funktiolle %qE"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, fuzzy, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "virheellinen parametrityyppi %qT"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ kieltää %<void *%>-tyyppisen osoittimen käytön vähennyslaskussa"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ kieltää funktio-osoittimen käytön vähennyslaskussa"
 
 # semi-fuzzy; onko metodi tässä luokan jäsenfunktio ja yllä muu funktio?
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ kieltää metodiosoittimen käytön vähennyslaskussa"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, fuzzy, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "muodostimen %qE osoitteen ottaminen"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "hajottimen %qE osoitteen ottaminen"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "virheellinen ei-staattisen jäsenfunktion käyttö"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, fuzzy, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "id="
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, fuzzy, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "keskeytyskäsittelijät eivät voi olla MIPS16-funktioita"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "väliaikaismuuttujan osoitteen ottaminen"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ kieltää %<::main%>-funktion osoitteen ottamisen"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, fuzzy, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "NULLin muunnos epäosoitintyypiksi %qT"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "yritys ottaa bittikentän osoite"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "odotettiin lauseketta"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, fuzzy, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr "oliko tarkoitus käyttää loogista negaatiota?"
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ kieltää enumin lisäyksen"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ kieltää enumin vähentämisen"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ kieltää %qT-tyyppisen osoittimen kasvattamisen"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ kieltää %qT-tyyppisen osoittimen vähentämisen"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "ei voi ottaa %<this%>:in osoitetta, joka on rvalue-lauseke"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, fuzzy, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "halutaan globaalin rekisterimuuttujan %qD osoite"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "virheellinen alustin taulukon jäsenelle %q#D"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "esittely ei esittele mitään"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, fuzzy, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "%qE ei nimeä tyyppiä"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "tyyppimuunnos tyypistä %qT tyyppiin %qT hylkää määreet"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "static_cast-muunnos tyypistä %qT tyyppiin %qT hylkää määreet"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "reinterpret_cast-muunnos tyypistä %qT tyyppiin %qT hylkää määreet"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "tarpeeton tyyppimuunnos tyyppiin %qT"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "tyyppimääreet jätetään huomiotta funktion paluutyypissä"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "virheellinen static_cast-muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "nimellä %qT on vaillinainen tyyppi"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 msgid "converting from %qH to %qI"
 msgstr "muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "virheellinen static_cast-muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 msgid "cast from %qH to %qI loses precision"
 msgstr "muunnoksessa tyypistä %qT tyyppiin %qT menetetään tarkkuutta"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 #, fuzzy
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr "ei voi muuntaa tyyppiä %qT tyypiksi %qT"
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "muunnos epäyhteensopivien jäsenosoitintyyppien %qH ja %qI välillä"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "muunnos tyypistä %qT tyyppiin %qT kasvattaa kohdetyypin vaadittua kohdistusta"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "tyyppimuunnos funktio-osoittimen ja olio-osoittimen välillä on ehdollisesti tuettu"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "virheellinen const_cast tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "virheellinen const_cast tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ kieltää tyyppimuunnoksen taulukkotyyppiin %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "virheellinen tyyppimuunnos funktiotyyppiin %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "%qE:ta ei voi muuntaa tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, fuzzy, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "%q#T ei ole luokka eikä nimiavaruus"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "ei-vakio taulukon indeksi alustimessa"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "taulukkoa käytetty alustimena"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "virheellinen taulukkosijoitus"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, fuzzy, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "Jäsenfunktio %qs"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, fuzzy, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "Jäsenfunktio %qs"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, fuzzy, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "Jäsenfunktio %qs"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP"
 
 # XXX
 # %s on "initialization", jota EI VOI suomentaa tällä hetkellä.
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP"
 
 # XXX
 # %s on "initialization", jota EI VOI suomentaa tällä hetkellä.
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP"
 
 # XXX
 # %s on "initialization", jota EI VOI suomentaa tällä hetkellä.
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 msgid "cannot convert %qH to %qI in return"
 msgstr "ei voi muuntaa tyyppiä %qT tyypiksi %qT"
 
 # XXX
 # %s on "initialization", jota EI VOI suomentaa tällä hetkellä.
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "ei voi muuntaa tyyppiä %qT tyypiksi %qT"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "funktiokutsun argumentti voi olla ehdokas muotoiluattribuutille"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "  alustettaessa funktion %2$qD argumenttia %1$P"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, fuzzy, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "tyhjää arvoa ei jätetä huomioimatta, vaikka kuuluisi"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "tyhjää arvoa ei jätetä huomioimatta, vaikka kuuluisi"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "palautettu viittaus paikalliseen muuttujaan %q+D"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "nimiö %qD määritelty täällä"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "palautettu osoite paikalliseen muuttujaan %q+D"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr "poista %<std::move%>-kutsu"
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "%s: liian monta arvoa"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "%s: liian monta arvoa"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "arvon palautus hajottimesta"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "arvon palautus muodostimesta"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "return-lause ilman arvoa funktiossa, jonka paluutyyppi on %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 msgid "returning initializer list"
 msgstr "taulukon palauttava funktio"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, fuzzy, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "uusia tyyppejä ei voi määritellä paluutyypissä"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, fuzzy, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "return-lause ilman arvoa funktiossa, jonka paluutyyppi on %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> ei saa palauttaa NULLia ellei esittely ole %<throw()%> (tai -fcheck-new ole voimassa)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "epäkelpo vektorityyppi attribuutille %qs"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "virheellinen %%s-arvo"
@@ -73393,17 +73557,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "<tuntematon>"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%J%qD esitelty avoimeksi kutsumisen jälkeen"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -73429,44 +73593,44 @@ msgstr "puuttuva alustin jäsenelle %qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "%qD:n osoite ei tule koskaan olemaan NULL"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "luokalla %q#T on datajäseninä osoittimia"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 msgid "nested function missing body"
 msgstr "vähennyslaskussa käytetty osoitinta funktioon"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "tyhjää arvoa ei jätetä huomioimatta, vaikka kuuluisi"
@@ -73551,34 +73715,34 @@ msgstr "Virheellinen vähimmäisargumenttimäärä (%d) funktiolle %s"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "Virheellinen vähimmäisargumenttimäärä (%d) funktiolle %s"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "ei voida luoda esikäännettyä otsikkoa %s: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "avataan tulostetiedosto %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "ei voida luoda esikäännettyä otsikkoa %s: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "avataan riippuvuustiedosto %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -73677,7 +73841,7 @@ msgstr "tls_model-argumentti ei ole merkkijono"
 msgid "%qs is not an associative array"
 msgstr "lueteltu tyyppi määritelty täällä"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -73693,23 +73857,23 @@ msgstr "%qD on tavallisesti ei-staattinen funktio"
 msgid "%qs is not a field, but a %qs"
 msgstr "Funktio %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "kutsuttu täältä"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "ylivuoto vakiolausekkeessa"
@@ -73800,17 +73964,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella"
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<dynamic_cast%> ei ole sallittu valitsimen -fno-rtti kanssa"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -74136,8 +74300,8 @@ msgstr "Taulukkoviitteellä kohdassa %C ei voi olla yli %d ulottuvuutta"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74414,7 +74578,7 @@ msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava vakio"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "epäkelpo osoitintila %qs"
@@ -74490,7 +74654,7 @@ msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdass
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava INTEGER tai PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava vakio"
@@ -74630,7 +74794,7 @@ msgstr "ylivuoto vakiolausekkeessa"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "kääntäjänsisäisen ”%3$s”-funktion argumenttien ”%1$s” ja ”%2$s” kohdassa %4$L on oltava samaa tyyppiä"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
@@ -74645,7 +74809,7 @@ msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
@@ -74786,8 +74950,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "puhdistusargumentti ei ole tunniste"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74886,9 +75050,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
@@ -74903,12 +75067,12 @@ msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdass
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava tasoa %d tai sen on oltava skalaari"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava numeerinen tai LOGICAL"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "Kääntäjänsisäisen ”%s”-funktion argumenttityyppien kohdassa %L on täsmättävä (%s/%s)"
@@ -75003,619 +75167,619 @@ msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdass
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Puuttuva argumentti kohteelle ”%s” kohdassa %C"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”a%1$d” kohdassa %3$L on oltava %4$s(%5$d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "kääntäjänsisäisen ”%s”-funktion ”al” kohdassa %L on oltava INTEGER, REAL tai CHARACTER"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "kääntäjänsisäisen ”%s”-funktion ”al” kohdassa %L on oltava INTEGER, REAL tai CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion ”%1$s”-argumentin kohdassa %3$L on oltava tasoa 1 tai 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava INTEGER tai REAL"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava joko REAL tai INTEGER"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava saman tyyppinen ja kaltainen kuin ”%4$s”"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava valemuuttuja"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava OPTIONAL-valemuuttuja"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ”ei saa olla ”%4$s”:n aliobjekti"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "Tämänhetkisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "kääntäjänsisäisen ”reshape”-funktion argumentti ”shape” kohdassa %L ei saa olla vakiokokoinen taulukko"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on tyhjä"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentilla ”%1$s” kohdassa %3$L on negatiivinen alkio (%4$d)"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentilla ”%1$s” kohdassa %3$L on negatiivinen alkio (%4$d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on väärä määrä alkioita (%4$d/%5$d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on lukualueen ulkopuolinen ulottuvuus (%4$d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on virheellinen ulottuvuuksia permutaatio (ulottuvuus ”%4$d” kahteen kertaan)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava laajennettavaa tyyppiä"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "kääntäjänsisäisen ”shape”-funktion argumentti ”source” kohdassa %L ei saa olla oletetun kokoinen taulukko"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "kääntäjänsisäisen ”shape”-funktion argumentti ”source” kohdassa %L ei saa olla oletetun kokoinen taulukko"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "Tämänhetkisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Odottamatonta roskaa muodollisessa argumenttiluettelossa kohdassa %C"
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr "Odottamatonta roskaa muodollisessa argumenttiluettelossa kohdassa %C"
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "Tämänhetkisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Odottamatonta roskaa muodollisessa argumenttiluettelossa kohdassa %C"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "%<return%> arvon kanssa voidin palauttavassa funktiossa"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "Tämänhetkisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "Tämänhetkisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$d tasoa"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei ole kelvollinen ulottuvuusindeksi"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava oletusreaaliluku"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "kääntäjänsisäisen ”TRANSFER”-funktion argumentti ”MOLD” kohdassa %L ei saa olla %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "kääntäjänsisäisen ”TRANSFER”-funktion argumentti ”MOLD” kohdassa %L ei saa olla %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "kääntäjänsisäisen ”TRANSFER”-funktion argumentti ”MOLD” kohdassa %L ei saa olla %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava samaa tasoa kuin ”%4$s” tai sen on oltava skalaari"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "kääntäjänsisäisen ”%3$s”-funktion argumenttien ”%1$s” ja ”%2$s” kohdassa %4$L on oltava muodoltaan identtisiä."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” koko kohdassa %3$L on liian pieni (%4$i/%5$i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, fuzzy, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr "Sarakkeiden määrä   : %d\n"
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "Sarakkeiden määrä   : %d\n"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$d:n kaltainen"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava INTEGER tai LOGICAL"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -75681,12 +75845,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "alustusmerkkijono typistetty, jotta se täsmäisi muuttujaan kohdassa %L"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
@@ -75738,2059 +75902,2059 @@ msgstr ""
 " EPÄONNISTUI\n"
 "\n"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Virheellinen alustin %s Data-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Symbolin ”%s” täytyy olla PARAMETER DATA-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Virheellinen alustin %s Data-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Virheellinen alustin %s Data-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "vanhanmallinen funktiomäärittely"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "skalaarialustimessa ylimääräisiä alkioita"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Odotettiin vaihtoehtoista paluunimiötä kohdassa %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "Odotettiin skalaarialustuslauseketta kohdassa %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "ylimääräisiä alkioita taulukkoalustimessa"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "ylimääräisiä alkioita taulukkoalustimessa"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Syntaksivirhe argumenttiluettelossa kohdassa %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Kaksoiskappale %s-spesifikaatio kohdassa %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "virheellinen parametrityyppi %qT"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Syntaksivirhe merkkipituusspesifikaatiossa kohdassa %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Syntaksivirhe merkkipituusspesifikaatiossa kohdassa %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Proseduurilla ”%s” kohdassa %C on eksplisiittinen rajapinta ja sillä ei saa olla attribuutteja, jotka on esitelty kohdassa %L"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "tyhjä esittely"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "Muuttujan alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, fuzzy, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, fuzzy, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "Odotettiin PARAMETER-symbolia kompleksivakiossa kohdassa %C"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "CHARACTER-lauseke kohdassa %L on typistetty (%d/%d)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "%s: paniikki: Virheellinen ”l_value” %d\n"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "PARAMETER kohdassa %L on ilman alustinta"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Alkio %s-taulukkomuodostimessa kohdassa %L on %s"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "Alkio %s-taulukkomuodostimessa kohdassa %L on %s"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "”%s” kohdassa %L on jo alustettu kohdassa %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "parametrilla %P on vaillinainen tyyppi %qT"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "%qD esitelty extern-avainsanalla sisäkkäin"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava vakio"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "NULL()-alustus kohdassa %C on moniselitteinen"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "NULL()-alustus kohdassa %C on moniselitteinen"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Alustus kohdassa %C ei ole osoitinmuuttuja"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "NULL()-alustus kohdassa %C on moniselitteinen"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, fuzzy, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "Odottamaton %s-lause INTERFACE-lohkossa kohdassa %C"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "Jäsenfunktio %qs"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%qD:lla ei voi olla oletusargumentteja"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Virheellinen merkki nimessä kohdassa %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla osoitinarvoinen"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Alkio %s-taulukkomuodostimessa kohdassa %L on %s"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Tyhjällä ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Kaksoiskappalemuotospesifikaatio kohdassa %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "funktiota %<main%> ei voi määrittää avoimeksi"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "vanhanmallinen funktiomäärittely"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "virheellinen %qT-tyyppisen viittauksen alustus %qT-tyyppisestä lausekkeesta"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Alustus kohdassa %C ei ole osoitinmuuttuja"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Alustus kohdassa %C ei ole osoitinmuuttuja"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Alustus kohdassa %C ei ole osoitinmuuttuja"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Odotettiin alustuslauseketta kohdassa %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Muuttujan alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn"
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn"
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Vanhantyylinen esittely %s*%d ei ole tuettu kohdassa %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Ei-vakio tyyppiesittely %s*%d kohdassa %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Puuttuva oikea sulje kohdassa %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Odotettiin alustuslauseketta kohdassa %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Odotettiin skalaarialustuslauseketta kohdassa %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Vanhantyylinen esittely %s*%d ei ole tuettu kohdassa %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Puuttuva oikea sulje kohdassa %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Vanhantyylinen esittely %s*%d ei ole tuettu kohdassa %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Syntaksivirhe CHARACTER-esittelyssä kohdassa %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, fuzzy, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "Jäsenfunktio %qs"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Odotettiin nimetöntä rajapintaa kohdassa %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "%<operator new%>:n ensimmäisellä parametrilla ei voi olla oletusargumenttia"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, fuzzy, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "sijoitus kirjoitussuojattuun viitteeseen %qD"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "oletetaan palauttavan %<id%> ja hyväksyvän"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "tyypin määritteleminen tyyppimuunnoksessa on virheellistä C++-kielessä"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Monimerkityksellinen symboli TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Tyhjä IMPLICIT-lause kohdassa %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "Tyhjä IMPLICIT-lause kohdassa %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "loppumerkki %c puuttuu"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Tyhjä IMPLICIT-lause kohdassa %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Tyhjä IMPLICIT-lause kohdassa %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr "virtuaalinen ei-luokkafunktio %qs"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Puuttuva ulottuvuusspesifikaatio kohdassa %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Puuttuva ulottuvuusspesifikaatio kohdassa %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Kaksoiskappele %s attribuutti kohdassa %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, fuzzy, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr "Jäsenfunktio %qs"
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%s-attribuutti kohdassa %L ei ole sallittu moduulin spesifikaatio-osan ulkopuolella"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "Odotettiin sitomisattribuuttia kohdassa %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "yhtenäistä dataa"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "Kaksoiskappale POINTER-attribuutti kohdassa %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "Kaksoiskappale VALUE-attribuutti määritelty kohdassa %L"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "Syntaksivirhe VOLATILE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Useita tunnisteita tarjottu yhdellä NAME= tarkenteella kohdassa %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, fuzzy, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, fuzzy, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä ALLOCATABLE- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla merkkijono"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Virheellinen alustin %s Data-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Virheellinen alustin %s Data-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Puuttuva symboli"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "Tyhjä IMPLICIT-lause kohdassa %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Syntaksivirhe data-esittelyssä kohdassa %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Syntaksivirhe data-esittelyssä kohdassa %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "PROCEDURE-lauseen kohdassa %C on oltava geneerisessä rajapinnassa"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "sijoituksen vasemman operandin on oltava lvalue"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "Odotettiin vaihtoehtoista paluunimiötä kohdassa %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "sijoituksen vasemman operandin on oltava lvalue"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Odotettiin toista ulottuvuutta taulukkoesittelyssä kohdassa %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Odottamatonta roskaa muodollisessa argumenttiluettelossa kohdassa %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Kaksoiskappalesymboli ”%s” muodollisessa argumenttiluettelossa paikassa %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "RESULT-muuttujan paikassa %C on oltava erilainen kuin funktionimen"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Odottamatonta roskaa funktioesittelyn jälkeen kohdassa %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "Kaksoiskappale POINTER-attribuutti kohdassa %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Valeproseduurilla ”%s” kohdassa %C ei voi olla geneeristä rajapintaa"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Odotettiin erityistä sitomisnimeä kohdassa %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Odotettiin tyyppiriippuvaista proseduuria tai proseduurin osoitinkomponenttia kohdassa %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Syntaksivirhe proseduuriosoitinkomponentissa kohdassa %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE-lauseen kohdassa %C on oltava geneerisessä rajapinnassa"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Odotetiin muodollista argumenttiluetteloa funktiomäärittelyssä kohdassa %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, fuzzy, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Odottamaton CASE-lause kohdassa %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Puuttuva oikea sulje kohdassa %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "virheellinen muunnostarkennin jälkiliitteessä: %c"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Syntaksivirhe CASE-spesifikaatiossa kohdassa %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Puuttuva muotonimiö kohdassa %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Sitomisnimeä ei ole sallittu BIND(C):ssä kohdassa %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "Sitomisnimeä ei ole sallittu BIND(C):ssä kohdassa %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "Sitomisnimeä ei ole sallittu BIND(C):ssä kohdassa %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Odottamaton END-lause kohdassa %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Odotettiin ”%s”-lohkonimeä %s-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Odotettiin päättävää nimeä kohdassa %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Odotettiin lauseketta %s-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "tyhjä esittely"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "tyhjä esittely"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Odottamaton merkki muuttujaluettelossa kohdassa %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "Odotettiin merkkiä ”,” kohdassa %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Odotettiin muuttujanimeä kohdassa %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Cray-osoittimen kohdassa %C on oltava kokonaisluku"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Cray-osoittimella kohdassa %C on %d-tavun tarkkuus; muistiosoitteet vaativat %d tavua"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Odotettiin merkkiä ”,” kohdassa %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "ei voi muuntaa osoitintyypiksi"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Kaksoiskappalemuotospesifikaatio kohdassa %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Odotettiin ”)” kohdassa %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "Odottamaton END-lause kohdassa %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "Odottamaton %s-lause INTERFACE-lohkossa kohdassa %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "Odottamaton %s-lause INTERFACE-lohkossa kohdassa %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "Odottamaton %s-lause kohdassa %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "Syntaksivirhe PROTECTED-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Syntaksivirhe PROTECTED-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Odotettiin muuttujanimeä kohdassa %C PARAMETER-lauseessa"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Odotettiin =-merkkiä PARAMETER-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Odotettiin lauseketta kohdassa %C PARAMETER-lauseessa"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Alustetaan jo alustettu muuttuja kohdassa %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Odottamattomia merkkejä PARAMETER-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, fuzzy, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr "Jäsenfunktio %qs"
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Syntaksivirhe VOLATILE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "Odottamaton %s-lause INTERFACE-lohkossa kohdassa %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "Syntaksivirhe VALUE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Syntaksivirhe VALUE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "Syntaksivirhe VOLATILE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Syntaksivirhe VOLATILE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Odottamaton %s-lause kohdassa %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Syntaksivirhe VALUE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "PROCEDURE-lauseen kohdassa %C on oltava geneerisessä rajapinnassa"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "SAVE-attribuuttia kohdassa %L ei voida määritellä PURE-proseduurissa"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Monimerkityksellinen symboli TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "abstrakti metodi ei-abstraktissa luokassa"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "%s: Tulostetiedoston %s sulkeminen epäonnistui\n"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, fuzzy, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "Jäsenfunktio %qs"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Odottamatonta roskaa funktioesittelyn jälkeen kohdassa %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Ulkoisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Ulkoisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei saa olla OPTIONAL"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Syntaksivirhe CHARACTER-esittelyssä kohdassa %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Enumeraattori ylittää C-kokonaislukutyypin kohdassa %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "ENUM-määrittelylause odotettiin ennen kohdetta %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Syntaksivirhe ENUMERATOR-määrittelyssä kohdassa %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Kaksoiskappale pääsy-tarkenne kohdassa %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Kaksoiskappale POINTER-attribuutti kohdassa %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Kaksoiskappale pääsy-tarkenne kohdassa %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "Kaksoiskappale %s-nimiöspesifikaatio kohdassa %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Odotettiin sitomisattribuuttia kohdassa %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "Odotettiin tyyppiriippuvaista proseduuria tai proseduurin osoitinkomponenttia kohdassa %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Odotettiin nimetöntä rajapintaa kohdassa %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "Odotettiin merkkiä ”,” kohdassa %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Syntaksivirhe CASE-spesifikaatiossa kohdassa %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Odotettiin sitomisnimeä kohteessa %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, fuzzy, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "Syntaksivirhe CASE-spesifikaatiossa kohdassa %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Odotettiin sitomisnimeä kohteessa %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, fuzzy, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "Odotettiin merkkiä ”,” kohdassa %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Odotettiin geneeristä nimeä tai operaattorimäärittelijää kohdassa %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Odotettiin geneeristä nimeä tai operaattorimäärittelijää kohdassa %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "Odotettiin merkkiä ”,” kohdassa %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr "Tämä pikanäppäin on jo käytössä toiminnolle %s"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "%qD on jo määritelty"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected module procedure name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "Syntaksivirhe VALUE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Odotettiin erityistä sitomisnimeä kohdassa %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Roskaa CALL-lauseen jälkeen kohdassa %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "Syntaksivirhe VALUE-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "Tyhjä taulukkomuodostin kohdassa %C ei ole sallittu"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "Odotettiin merkkiä ”,” kohdassa %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Tuntematon attribuutti !GCC$ ATTRIBUTES-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Syntaksivirhe !GCC$ ATTRIBUTES-lauseessa kohdassa %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Syntaksivirhe iteraattorissa kohdassa %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Syntaksivirhe iteraattorissa kohdassa %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Syntaksivirhe iteraattorissa kohdassa %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "Syntaksivirhe iteraattorissa kohdassa %C"
@@ -77934,408 +78098,408 @@ msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 msgid "IM part_ref at %C"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Odotettiin PARAMETER-symbolia kompleksivakiossa kohdassa %C"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Sijoitusoperaattorirajapinta kohdassa %L ei saa määritellä uudelleen INTRINSIC-tyyppisijoitusta"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "ei-vakio alustuslauseke kohdassa %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Syntaksivirhe IF-lausekkeessa kohdassa %C"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Odotettiin oikeaa sulkumerkkiä lausekkeessa kohdassa %C"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Syntaksivirhe merkkipituusspesifikaatiossa kohdassa %C"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "%J%qD käytössä ilman prototyyppiä ennen määrittelyänsä"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "%s-lause ei ole sallittu PURE-proseduurissa kohdassa %C"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei saa olla OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "virheellinen %%L-arvo"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Iteraattoriaskel kohdassa %L ei voi olla nolla"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Yhteensopimattomat tyypit DATA-lauseessa kohdassa %L; yritettiin muuntaa tyyppi %s tyypiksi %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Käskyfunktio ”%s” on virheellinen proseduuriosoitinsijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Käskyfunktio ”%s” on virheellinen proseduuriosoitinsijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Sisäinen proseduuri ”%s” on virheellinen proseduuriosoittimessa kohdassa %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Eri tyypit osoitinsijoituksessa kohdassa %L; yritettiin tyypin %s sijoitusta tyyppiin %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
@@ -78343,197 +78507,197 @@ msgstr "muuttuvakokoista objektia ei voi alustaa"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Sisäinen proseduuri ”%s” on virheellinen proseduuriosoittimessa kohdassa %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Sisäinen proseduuri ”%s” on virheellinen proseduuriosoittimessa kohdassa %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "vektoriylivuoto lausekkeessa"
@@ -78554,7 +78718,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -78615,42 +78779,42 @@ msgstr "ylivuoto vakiolausekkeessa"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr "continue-lause silmukan ulkopuolella"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "tyyppien %qT ja %qT välinen vertailu"
@@ -78775,12 +78939,12 @@ msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
@@ -79206,307 +79370,312 @@ msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, fuzzy, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, fuzzy, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "muuttuvakokoista objektia ei voi alustaa"
+
+#: fortran/interface.cc:4181
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, fuzzy, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "  eikä %<operator=(const %T&)%>"
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, fuzzy, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, fuzzy, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, fuzzy, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, fuzzy, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, fuzzy, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "Odotettiin tyyppiriippuvaista proseduuria tai proseduurin osoitinkomponenttia kohdassa %C"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "ei voi emuloida %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, fuzzy, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "rekursiivinen tyyppi %qT määrittelemätön"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "ei voi kirjoittaa tiedostoon %s: %m"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, fuzzy, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei saa olla OPTIONAL"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "tyhjä esittely"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
@@ -79695,7 +79864,7 @@ msgstr "Muunnos tyypistä %s tyyppiin %s kohdassa %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
@@ -80241,7 +80410,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
@@ -80412,12 +80581,12 @@ msgstr "Kokonaisluvun ylivuoto"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -80922,7 +81091,7 @@ msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
@@ -81436,92 +81605,92 @@ msgstr "tyhjä esittely"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "%qD on jo määritelty"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Syntaksivirhe PROTECTED-lauseessa kohdassa %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Syntaksivirhe PROTECTED-lauseessa kohdassa %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Odottamaton CASE-lause kohdassa %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Syntaksivirhe CASE-spesifikaatiossa kohdassa %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Odottamaton TYPE IS -lause kohdassa %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Syntaksivirhe TYPE IS -spesifikaatiossa kohdassa %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Syntaksvirhe CLASS IS -spesifikaatiossa kohdassa %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "Odottamaton END-lause kohdassa %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "Syntaksivirhe CASE-spesifikaatiossa kohdassa %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "Odottamaton %s-lause WHERE-lohkossa kohdassa %C"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "Nimiö ”%s” kohdassa %C ei täsmää IF nimiön ”%s” kanssa"
@@ -82519,7 +82688,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "decltypen argumentin on oltava lauseke"
@@ -82554,12 +82723,12 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu"
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Odottamatonta roskaa ELSE IF -lauseen jälkeen kohdassa %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr "tyhjä esittely"
@@ -83040,7 +83209,7 @@ msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
@@ -83060,7 +83229,7 @@ msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, fuzzy, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
@@ -83090,17 +83259,17 @@ msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "Objekti ”%s” ei ole muuttuja kohdassa %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "Objekti ”%s” ei ole muuttuja kohdassa %L"
@@ -83220,8 +83389,8 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu"
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "decltypen argumentin on oltava lauseke"
@@ -83301,7 +83470,7 @@ msgstr "muuttuvakokoista objektia ei voi alustaa"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
@@ -83324,7 +83493,7 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu"
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
@@ -83364,7 +83533,7 @@ msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -83677,600 +83846,610 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, fuzzy, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, fuzzy, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, fuzzy, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "indeksoitu arvo ei ole taulukko eikä osoitin"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, fuzzy, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, fuzzy, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, fuzzy, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "ei-vakio alustuslauseke kohdassa %L"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "%<void%> vain parametrina ei ole oikeutettu"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Odotettiin skalaarialustuslauseketta kohdassa %C"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "kääntäjänsisäisten ”!$OMP ATOMIC”-argumenttien on oltava skaalaareja kohdassa %L"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "kääntäjänsisäiset ”!$OMP ATOMIC”-argumentit paitsi yksi eivät saa viitata kohteeseen ”%s” kohdassa %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, fuzzy, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "kääntäjänsisäiset ”!$OMP ATOMIC”-argumentit paitsi yksi eivät saa viitata kohteeseen ”%s” kohdassa %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "kääntäjänsisäisen ”!$OMP ATOMIC”-sijoituksen on oltava MIN, MAX, IAND, IOR tai IEOR kohdassa %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "kääntäjänsisäiset ”!$OMP ATOMIC”-argumentit paitsi yksi eivät saa viitata kohteeseen ”%s” kohdassa %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "kääntäjänsisäisellä ”!$OMP ATOMIC”-sijoituksella IAND, IOR tai IEOR täytyy olla kaksi argumenttia kohdassa %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "kääntäjänsisäisen ”!$OMP ATOMIC”-sijoituksen on oltava MIN, MAX, IAND, IOR tai IEOR kohdassa %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, fuzzy, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "kääntäjänsisäiset ”!$OMP ATOMIC”-argumentit paitsi yksi eivät saa viitata kohteeseen ”%s” kohdassa %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "kääntäjänsisäisten ”!$OMP ATOMIC”-argumenttien on oltava skaalaareja kohdassa %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, fuzzy, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Ensimmäisen tai viimeisen kääntäjänsisäisen ”!$OMP ATOMIC”-argumentin on oltava ”%s” kohdassa %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "”!$OMP ATOMIC”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Odottamatonta roskaa ELSE IF -lauseen jälkeen kohdassa %C"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "”!$OMP DO”-iteraatiomuuttuja ei saa olla THREADPRIVATE kohdassa %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "”!$OMP DO”-iteraatiomuuttuja ei saa olla THREADPRIVATE kohdassa %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "”!$OMP DO”-iteraatiomuuttuja on läsnä muussa lauseessa kuin PRIVATE tai LASTPRIVATE kohdassa %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "”!$OMP DO”-iteraatiomuuttuja on läsnä muussa lauseessa kuin PRIVATE tai LASTPRIVATE kohdassa %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "”!$OMP DO”-iteraatiomuuttuja ei saa olla THREADPRIVATE kohdassa %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "epäkelvot operandit binääriselle %s-operaatiolle"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "virheellinen tyyppi iterointimuuttujalle %qE"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "mahdollisia ikisilmukoita ei voi optimoida"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "liian vähän argumentteja"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "liian vähän argumentteja"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "odotettiin kokonaislukulauseketta"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "”!$OMP DO”-iteraatiomuuttuja ei saa olla THREADPRIVATE kohdassa %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "liian vähän argumentteja"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "liian vähän argumentteja"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "mahdollisia ikisilmukoita ei voi optimoida"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "ei-vakio alustuslauseke kohdassa %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, fuzzy, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, fuzzy, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Syntaksivirhe !GCC$ ATTRIBUTES-lauseessa kohdassa %C"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, fuzzy, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Syntaksivirhe !GCC$ ATTRIBUTES-lauseessa kohdassa %C"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, fuzzy, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected an initialization expression at %C"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Odotettiin alustuslauseketta kohdassa %C"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Odotettiin toista ulottuvuutta taulukkoesittelyssä kohdassa %C"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr "Odotettiin PARAMETER-symbolia kompleksivakiossa kohdassa %C"
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -84936,62 +85115,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Odottamaton %s-lause CONTAINS-lohkossa kohdassa %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "SAVE-attribuuttia kohdassa %L ei voida määritellä PURE-proseduurissa"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Odottamaton %s-lause BLOCK DATA -lohkossa kohdassa %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Odottamaton %s-lause MODULE-lohkossa kohdassa %C"
@@ -84999,7 +85178,7 @@ msgstr "Odottamaton %s-lause MODULE-lohkossa kohdassa %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -85460,1082 +85639,1082 @@ msgstr "epäkelpo lvalue asm-lauseessa"
 msgid "%qs at %C is not a variable"
 msgstr "Odotettiin muuttujanimeä kohdassa %C"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "epäkelpo %qs:n soveltaminen tyhjään tyyppiin"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "ABSTRACT-tyyppiä ”%s” käytetty kohdassa %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROCEDURE-lauseen kohdassa %C on oltava geneerisessä rajapinnassa"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Valeproseduurilla ”%s” kohdassa %C ei voi olla geneeristä rajapintaa"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "%s-lause ei ole sallittu PURE-proseduurissa kohdassa %C"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla skalaari"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla skalaari"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Nimi ”%s” kohdassa %C on proseduurin nimi"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr "Odottamaton %s-lause INTERFACE-lohkossa kohdassa %C"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, fuzzy, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, fuzzy, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "Unequal character lengths (%ld/%ld) in %s at %L"
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Erisuuret merkkipituudet (%ld/%ld) merkkijonossa %s kohdassa %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, fuzzy, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "liikaa argumentteja funktiolle %s %q+#D"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Nimiö %d kohdassa %L on määritelty, mutta ei käytetty"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Monimerkityksellinen symboli TYPE-määrittelyssä kohdassa %C"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ABSTRACT-tyyppiä ”%s” käytetty kohdassa %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Odotetiin muodollista argumenttiluetteloa funktiomäärittelyssä kohdassa %C"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "funktion paluuarvon tyyppi ei voi olla funktio"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "Funktiota ”%s” kohdassa %L ei voida kutsua rekursiivisesti, koska se ei ole RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Funktiota ”%s” kohdassa %L ei voida kutsua rekursiivisesti, koska se ei ole RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "%qE on vanhentunut"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "Funktiota ”%s” kohdassa %L ei voida kutsua rekursiivisesti, koska se ei ole RECURSIVE"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Funktiota ”%s” kohdassa %L ei voida kutsua rekursiivisesti, koska se ei ole RECURSIVE"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "liian paljon argumentteja funktiolle %qs"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "%qE on vanhentunut"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "attribuutit fastcall ja cdecl eivät ole yhteensopivia"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, fuzzy, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla osoitinarvoinen"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "vertailu ”etumerkitön lauseke >= 0” on aina tosi"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, fuzzy, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "osoitealueattribuuttia ei voi määritellä paikallisille muuttujille"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr "%s: paniikki: Virheellinen ”l_value” %d\n"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr "%s: paniikki: Virheellinen ”l_value” %d\n"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "käytetty sekä %<__thread%> että %qs"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "tuntematon binäärioperaattori"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "tuntematon binäärioperaattori"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "pilkkuoperaattori #if:in operandissa"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, fuzzy, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Arvo sallitun välin ulkopuolella."
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Iteraattoriaskel kohdassa %L ei voi olla nolla"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "luodaan viitteiden taulukko"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "ehtolausekkeessa on tyyppiristiriita"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Arvo sallitun välin ulkopuolella."
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "taulukkoindeksi ei-taulukkoalustimessa"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Virheellinen taulukkoviitemuoto kohdassa %C"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "luodaan viitteiden taulukko"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "taulukon indeksi on taulukkorajojen yläpuolella"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
@@ -86544,12 +86723,12 @@ msgstr "muuttuvakokoista objektia ei voi alustaa"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
@@ -86558,416 +86737,416 @@ msgstr "muuttuvakokoista objektia ei voi alustaa"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "luodaan viitteiden taulukko"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%qE on vanhentunut"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "Taulukkoviite rajojen ulkopuolella"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "<tyyppivirhe>"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, fuzzy, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, fuzzy, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, fuzzy, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Odotettiin muuttujanimeä kohdassa %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "SAVE-attribuuttia kohdassa %L ei voida määritellä PURE-proseduurissa"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "Objekti ”%s” ei ole muuttuja kohdassa %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "osoittimet eivät ole sallittuja case-arvoja"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "Odotettiin ”%s”-lohkonimeä %s-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "muuttuja %qD asetettu mutta käyttämätön"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "Iteraattoriaskel kohdassa %L ei voi olla nolla"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "tulosta ei voi kirjoittaa: %s"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Syntaksivirhe IF-lausekkeessa kohdassa %C"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "Jäsenfunktio %qs"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE"
@@ -86976,314 +87155,314 @@ msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABL
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "CASE-nimiö kohdassa %L menee CASE-nimiön päälle kohdassa %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %d-kaltainen"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Tämä pikanäppäin on jo käytössä toiminnolle %s"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "”%s” ei ole kelvollinen makron nimi, sillä se on C++:n operaattori"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "CASE-nimiö kohdassa %L menee CASE-nimiön päälle kohdassa %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Syntaksivirhe PROTECTED-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Varsinainen argumentti kohteelle ”%s” ei voi olla oletetunkokoinen taulukko kohdassa %L"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Haarautuminen kohdassa %L voi aiheuttaa ikisilmukan"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
@@ -87291,214 +87470,214 @@ msgstr "break-lause silmukan tai switch-rakenteen ulkopuolella"
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Odottamaton %s-lause WHERE-lohkossa kohdassa %C"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Sijoitus FORALL-indeksimuuttujaan kohdassa %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "Lohkonimiö ei ole sopiva IF-lauseelle kohdassa %C"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Odotettiin muuttujanimeä kohdassa %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, fuzzy, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "CHARACTER-lauseke kohdassa %L on typistetty (%d/%d)"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, fuzzy, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "UNIT-numeron CLOSE-lauseessa kohdassa %L täytyy olla epänegatiivinen"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "UNIT-numeron CLOSE-lauseessa kohdassa %L täytyy olla epänegatiivinen"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Odotettiin alustuslauseketta CASE-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "UNIT-numeron CLOSE-lauseessa kohdassa %L täytyy olla epänegatiivinen"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "virheellinen %%L-arvo"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, fuzzy, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "decltypen argumentin on oltava lauseke"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Käyttämätön parameteri ”%s” esitelty kohdassa %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
@@ -87506,119 +87685,119 @@ msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "Merkkijonon pituus kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, fuzzy, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, fuzzy, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava valemuuttuja"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Varattavalla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Ulkoisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Tyhjällä ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr ""
@@ -87626,939 +87805,939 @@ msgstr ""
 "  tai:  %s -l [SIGNAALI]...\n"
 "  tai:  %s -t [SIGNAALI]...\n"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Ulkoisella objektilla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "ELEMENTAL-funktiolla ”%s” kohdassa %L täytyy olla skalaaritulos"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "funktiokutsun argumentti voi olla ehdokas muotoiluattribuutille"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla taulukkoarvoinen"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla osoitinarvoinen"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla puhdas"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla rekursiivinen"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Valeproseduurilla ”%s” kohdassa %C ei voi olla geneeristä rajapintaa"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, fuzzy, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, fuzzy, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "SAVE-attribuuttia kohdassa %L ei voida määritellä PURE-proseduurissa"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "PROCEDURE-attribuutti on ristiriidassa INTENT-attribuutin kanssa kohteessa ”%s” kohdassa %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "PROCEDURE-attribuutti on ristiriidassa RESULT-attribuutin kanssa kohteessa ”%s” kohdassa %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "EXTERNAL-attribuutti on ristiriidassa FUNCTION-attribuutin kanssa kohteessa ”%s” kohdassa %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "%qD:n on otettava tasan yksi argumentti"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, fuzzy, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "%J%qD:lle ei ole aiempaa esittelyä"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, fuzzy, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla perittyä tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla perittyä tyyppiä ”%s”"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, fuzzy, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla perittyä tyyppiä ”%s”"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla skalaari"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Ristiriita funktioargumentin attribuuteissa kohdassa %C"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, fuzzy, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, fuzzy, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn"
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, fuzzy, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr "%s: Tulostetiedoston %s sulkeminen epäonnistui\n"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Tyhjä taulukkomuodostin kohdassa %C ei ole sallittu"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "funktiota %<__builtin_next_arg%> kutsuttu ilman argumenttia"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "PROCEDURE-attribuutti on ristiriidassa INTENT-attribuutin kanssa kohteessa ”%s” kohdassa %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "yhteensopimattomat tyypit sijoituksessa"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "ei-vakio alustuslauseke kohdassa %L"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "SAVE-attribuuttia kohdassa %L ei voida määritellä PURE-proseduurissa"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava valemuuttuja"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Sijoitus FORALL-indeksimuuttujaan kohdassa %L"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, fuzzy, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, fuzzy, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä ALLOCATABLE- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä ALLOCATABLE- että BIND(C)-attribuutit"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "epäkelpo %qs:n soveltaminen tyhjään tyyppiin"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, fuzzy, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Muuttujan alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "Muuttujan alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "Muuttujan alustus kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Tuntematon argumenttiluettelofunktio kohdassa %L"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Varattavalla ”%s” kohdassa %L ei voi olla alustinta"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, fuzzy, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "%s-lausetta odotettiin kohdassa %L"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, fuzzy, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "Proseduurilla ”%s” kohdassa %C on eksplisiittinen rajapinta ja sillä ei saa olla attribuutteja, jotka on esitelty kohdassa %L"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "tyhjä esittely"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Nimiö %d kohdassa %L on määritelty, mutta ei käytetty"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Nimiö %d kohdassa %L on määritelty, mutta sitä ei voida käyttää"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Ei voi sijoitaa nimettyyn vakioon kohdassa %C"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, fuzzy, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "%J%qD on tavallisesti ei-staattinen funktio"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Syntaksivirhe merkkipituusspesifikaatiossa kohdassa %C"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "epäkelpo %qs:n soveltaminen tyhjään tyyppiin"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla merkkijono"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$s"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$s"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L"
@@ -88578,97 +88757,97 @@ msgstr "jätetään puuttuva hakemisto ”%s” huomiotta\n"
 msgid "%qs is not a directory"
 msgstr "Ei ole hakemisto"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Lohkonimiö ei ole sopiva IF-lauseelle kohdassa %C"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Odottamaton %s-lause MODULE-lohkossa kohdassa %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Virheellinen merkki BOZ-vakiossa kohdassa %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "monimerkkinen sarkain %s"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "Virheellinen merkki nimessä kohdassa %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, fuzzy, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "Vastaava sulku löytyi riviltä: %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "monimerkkinen sarkain %s"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "syötetiedosto %qs on sama kuin tulostiedosto"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "”override”-toimintaohje"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "Ei voi avata varmistustiedostoa %s"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "syötetiedoston avaaminen ei onnistu: %s"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "syötetiedoston avaaminen ei onnistu: %s"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "input file %qs is the same as output file"
 msgid "Included file %qs is not a regular file"
@@ -88834,218 +89013,218 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, fuzzy, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Funktion %s argumentti kohdassa %L on lukualueen [0,127] ulkopuolella"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, fuzzy, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr "Käytä bittikenttäkäskyjä"
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Funktion %s argumentti kohdassa %L on negatiivinen"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "Arvo sallitun välin ulkopuolella."
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, fuzzy, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, fuzzy, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "%qs ei ole kelpo tulostetiedosto"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, fuzzy, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Haarautuminen kohdassa %L voi aiheuttaa ikisilmukan"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Kokonaisluku liian suuri kohdassa %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "tulosta ei voi kirjoittaa: %s"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$d tasoa"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, fuzzy, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "ylivuoto vakiolausekkeessa"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Funktion %s argumentti kohdassa %L on negatiivinen"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "Virheellinen proseduuriargumentti kohdassa %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -89384,74 +89563,74 @@ msgstr "Odotettiin päättävää nimeä kohdassa %C"
 msgid "Labeled DO statement at %L"
 msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "tyhjä esittely"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Perityllä tyypillä ”%s” BIND(C):llä ei saa olla CONTAINS-lohkoa kohdassa %C"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "tyhjä esittely"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "Symbolia ”%s” käytetään ennen kuin sille määritellään tyyppi kohdassa %L"
@@ -89481,29 +89660,34 @@ msgstr "Odotettiin argumenttiluetteloa kohdassa %C"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Odotettiin argumenttiluetteloa kohdassa %C"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Luodaan väliaikainen komentotiedosto %s\n"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke"
@@ -89605,113 +89789,113 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr "ei-vakio alustuslauseke kohdassa %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%s:n kohdassa %L täytyy olla INTEGER"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, fuzzy, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "instanssimuuttuja %qE on esitelty yksityisenä"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, fuzzy, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "Käyttämätön muuttuja ”%s” esitelty kohdassa %L"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Käyttämätön muuttuja ”%s” esitelty kohdassa %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Liikaa argumentteja funktiolle %s kohdassa %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "%Jmuuttuja %qD esitelty %<inline%>:ksi"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Käyttämätön muuttuja ”%s” esitelty kohdassa %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Käyttämätön parameteri ”%s” esitelty kohdassa %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "%Jparametri %qD esitelty %<inline%>:ksi"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Valitettavasti et ole root\n"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa"
@@ -89741,12 +89925,12 @@ msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 msgid "Unknown intrinsic op"
 msgstr "last-op"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Tuntematon argumenttiluettelofunktio kohdassa %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -89762,12 +89946,12 @@ msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei ole kelvollinen ulottuvuusindeksi"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "kirjoitussuojatun muuttujan %qs sijoitus"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio"
@@ -89792,183 +89976,183 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr "vektoriylivuoto lausekkeessa"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 msgid "optional class parameter"
 msgstr "valinnainen argumentti"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "odotettiin lauseketta"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 msgid "unhandled expression"
 msgstr "odotettiin lauseketta"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 msgid "Used here"
 msgstr "union määritelty täällä"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, fuzzy, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "lauseella ei ole vaikutusta"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "puhdistusargumentti ei ole tunniste"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "(%qs:n alustuksen lähistöllä)"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "muuttuvakokoista objektia ei voi alustaa"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "%qs esitelty funktion palauttavana funktiona"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "valitsimet -l ja -s eivät ole yhteensopivia"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "Odotettiin argumenttiluetteloa kohdassa %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla skalaari"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "%s: Annettu useampi kuin yksi -d -valitsin\n"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "-pipe ei ole tuettu"
@@ -90310,7 +90494,7 @@ msgstr "close: %s"
 msgid "two or more sections for %s"
 msgstr "yli yksi tietotyyppi esittelymääritteissä"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -90647,32 +90831,32 @@ msgstr "taulukkoa käytetty alustimena"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "haluttu sijainti ei ole kokonaislukuvakio"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "pyydetty kohdistus ei ole kahden potenssi"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "pyydetty kohdistus on liian suuri"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -93833,10 +94017,6 @@ msgstr ""
 #~ msgid "DISTANCE= argument to THIS_IMAGE at %L"
 #~ msgstr "Funktion %s argumentti kohdassa %L on negatiivinen"
 
-#, fuzzy, gcc-internal-format
-#~ msgid "gfc_array_size failed"
-#~ msgstr "vektoriylivuoto lausekkeessa"
-
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #~ msgid "Component with KIND attribute at %C must be default integer kind (%d)"
 #~ msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER"
@@ -94849,10 +95029,6 @@ msgstr ""
 #~ msgid "looser throw specifier for %q+#F"
 #~ msgstr "kohdistusta ei voi määritellä %q+D:lle"
 
-#, fuzzy
-#~ msgid "cannot call function %qD"
-#~ msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota"
-
 #, fuzzy
 #~ msgid "left rotate count >= width of type"
 #~ msgstr "vasemmalle siirron lukumäärä >= tyypin leveys"
@@ -96192,6 +96368,10 @@ msgstr ""
 #~ msgid "expected integer expression before ')'"
 #~ msgstr "odotettiin kokonaislukulauseketta"
 
+#, fuzzy
+#~ msgid "%qD is not a constant"
+#~ msgstr "argumentti %qd ei ole vakio"
+
 #, fuzzy
 #~| msgid "%<num_threads%> value must be positive"
 #~ msgid "%<num_gangs%> value must be positive"
@@ -96578,9 +96758,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "ei-staattinen metodi %q+D korvaa staattisen metodin"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D:a käytetty ennen esittelyä"
-
 #, fuzzy
 #~ msgid "invokestatic on abstract method"
 #~ msgstr "abstrakti metodi ei-abstraktissa luokassa"
@@ -96671,10 +96848,6 @@ msgstr ""
 #~ msgid "%qs and floating point or vector arguments"
 #~ msgstr "%J%qD sallii vain nolla tai kaksi argumenttia"
 
-#, fuzzy
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton"
-
 #, fuzzy
 #~ msgid "unrecognizable argument of option -foffload-abi"
 #~ msgstr "tuntematon komentorivivalitsin ”%s”"
--- a/src/gcc/po/fr.po
+++ b/src/gcc/po/fr.po
@@ -97,10 +97,10 @@
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: gcc-16.1-b20260329\n"
+"Project-Id-Version: gcc-16.1.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
-"PO-Revision-Date: 2026-03-30 19:48+0200\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
+"PO-Revision-Date: 2026-04-30 20:27+0200\n"
 "Last-Translator: Frédéric Marchal <fmarchal@perso.be>\n"
 "Language-Team: French <traduc@traduc.org>\n"
 "Language: fr\n"
@@ -1343,12 +1343,12 @@ msgstr "Alias :"
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Versions PTX ISA connues (à utiliser avec l'option -mptx=) :"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "Spécifier la version de la version PTX ISA à utiliser."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr "Initialiser les registres ptx."
@@ -2167,13 +2167,13 @@ msgstr "Activer les conversions par défaut entre __float128 et long double."
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "Utiliser la méthode donnée pour protéger la pile."
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2622,7 +2622,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Supposer que le processeur cible est configuré comme gros-boutiste."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Supposer que le processeur cible est configuré comme petit-boutiste."
@@ -2697,7 +2697,7 @@ msgstr "Utiliser du code plus petit mais plus lent pour le prologue et l'épilog
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr "Convertir les adresses BASE + GRAND_OFFSET en NOUVELLE_BASE + PETIT_OFFSET pour autoriser plus d'accès mémoire à être générés comme instructions compressées. Cible actuellement les chargements/stockages d'entiers 32 bits."
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2734,7 +2734,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr "Activer la vérification CSR pour le CSR dépendant de ISA et le CSR en lecture seule. Le CSR dépendant de ISA est uniquement valide quand l'ISA spécifique est définiie. Le CSR en lecture seule ne peut pas être écrit par les instructions CSR."
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Omettre le pointeur de trame dans les fonctions feuilles."
@@ -2844,7 +2844,7 @@ msgstr "-param=vsetvl-strategy=<chaîne>\tDéfini le niveau d'optimisation de la
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr "-param=riscv-two-source-permutes Activer les permutations avec deux vecteurs source."
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr "Débrayer le modèle de coût scalaire de telle sorte que la vectorisation est toujours profitable."
@@ -2890,7 +2890,7 @@ msgstr "-msve-vector-bits=<nombre>\tFixe le type de bits pour un registre vector
 msgid "The possible TLS dialects:"
 msgstr "Les dialectes TLS possibles:"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5153,7 +5153,7 @@ msgstr "Supporter les fonctions internes RAOINT et la génération de code."
 msgid "Enable conservative small loop unrolling."
 msgstr "Activer le dépliage conservatif de petites boucles"
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr "Limiter le nombre de fois qu'une boucle peut être dépliée par l'auto vectoriseur. "
@@ -5511,7 +5511,7 @@ msgstr "Lors de l'édition de liens pour des cibles gros-boutistes, générer un
 msgid "Cost to assume for a branch insn."
 msgstr "Coût supposé pour une insn de branchement."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr "Utiliser les fonctionnalités de protection de branchement."
@@ -5817,212 +5817,217 @@ msgstr "Correctif pour l'erratum numéro 835769 de l'ARM Cortex-A53."
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr "Correctif pour l'erratum numéro 843419 de l'ARM Cortex-A53."
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr "Activer le rétrécissement des écritures 64 bits des registres généraux à 32 bits quand les 32 bits supérieurs du registre sont inutilisés."
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "Le registre utilisé pour accéder au pointeur du thread :"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Spécifier le registre du pointeur du thread."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "Ne pas supposer que les accès non alignés sont traités par le système."
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Spécifier la taille en bits des décalages TLS immédiats. Les valeurs valides sont 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "Utiliser les fonctionnalités de l'architecture ARCH."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "Utiliser les fonctionnalité et l'optimisation pour le CPU."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr "Optimiser pour le CPU."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Générer du code conforme à l'ABI spécifiée."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr "-fdump-tuning-model=<filename> Vidanger le modèle de réglage actuel dans un fichier JSON."
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr "-muser-provided-CPU=<json-tuning-file> Réglages du CPU spécifique à l'utilisateur"
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr "-moverride=<chaîne>\tUniquement pour les utilisateurs avertis ! Outrepasser les paramètres d'optimisation du processeur."
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "ABI AArch64 connues (à utiliser avec l'option -mabi=):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr "Chargements littéraux relatifs au PC."
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr "Sélectionner la portée pour la signature de l'adresse de retour."
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Portées supportées pour la signature de l'adresse de retour du AArch64 (à utiliser avec l'option -msign-return-address=):"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Activer l'approximation de l'inverse de la racine carrée.  Activer cette option réduit la précision des résultats de l'inverse de la racine carrée à 16 bits en simple précision et 32 bits en double précision."
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr "Activer l'approximation de la racine carrée.  Activer cette option réduit la précision des résultats de la racine carrée à 16 bits en simple précision et 32 bits en double précision. Si activée, elle implique -mlow-precision-recip-sqrt."
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Activer l'approximation de la division.  Activer cette option réduit la précision des résultats de la division à 16 bits en simple précision et 32 bits en double précision."
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr "Spécifier quand activer une étape d'allocation de registres précoce.  Les possibilités sont : toutes les fonctions, les fonctions qui ont accès aux instructions multi-registres avec pas et aucune fonction."
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "Les longueurs de vecteurs SVE possibles:"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "-msve-vector-bits=<nombre>\tFixe le nombre de bits dans le registre vectoriel SVE."
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Forcer une stratégie de sélection ISA pour l'auto vectorisation. Pour une meilleure performance, il est fortement recommandé d'utiliser -mcpu ou -mtune. Ce paramètre ne devrait être utilisé que pour explorer du code."
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr "Activer la vidange verbeuse du modèle de coût dans les fichiers de vidange de débogage."
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr "Générer du code pour détecter quand le processeur pourrait spéculer incorrectement."
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr "Activer la copie de la passe de fusion de paires load/store de AArch64 qui s'exécute avant l'allocation de registres."
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr "Activer la copie de la passe de fusion de paires load/store de AArch64 qui s'exécute après l'allocation de registres."
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Utiliser le registre système spécifié sur la ligne de commande comme registre de protection de la pile. Cette option est à utiliser avec fstack-protector-strong et n'est pas destinée au code utilisateur."
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Utiliser un immédiat depuis un décalage comme registre de protection de la pile, sp_el0. Cette option est à utiliser avec fstack-protector-strong et n'est pas destinée au code utilisateur."
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Générer des appels locaux vers des opérations atomiques hors ligne."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr "Lors de la vectorisation, prend en compte plusieurs approches différentes et utilise le modèle de coût pour choisir la moins onéreuse."
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr "Le nombre d'itérations Newton pour calculer la réciproque du type float. La précision de la division est proportionnelle à ce paramètre quand l'approximation de la division est activée. La valeur par défaut est 1."
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr "Le nombre d'itérations Newton pour calculer la réciproque du type double. La précision de la division est proportionnelle à ce paramètre quand l'approximation de la division est activée. La valeur par défaut est 2."
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr "Un ancien alias pour -mautovec-preference.  Si -mautovec-preference et --param=aarch64-autovec-preference sont tous les deux passés, la valeur de --param sera utilisée."
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr "Taille de memcpy constante en octets au delà de laquelle commencer à utiliser une séquence MOPS."
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr "Taille de memmove constante en octets au delà de laquelle commencer à utiliser une séquence MOPS."
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr "Taille de memset constante en octets au delà de laquelle commencer à utiliser une séquence MOPS."
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr "--param=aarch64-ldp-policy=[default|always|never|aligned] Politique fine pour charger les paires."
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr "--param=aarch64-stp-policy=[default|always|never|aligned] Politique fine pour stocker les paires."
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr "Limite sur le nombre de vérifications de synonymes réalisées en tentant de former un ldp/stp"
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr "Paramètre pour contrôler quelles opportunités d'écriture nous essayons de gérer dans l'étape de fusion des paires load/store.  Une valeur de zéro désactive la gestion des écritures.  Un signifie qu'on essaie de former des paires impliquant un ou plusieurs accès d'écriture individuels existants, si possible.  Une valeur de deux signifie qu'on essaie aussi de former des écritures opportunistes en comprimant les mises à jours destructrices à la fin du registre de base utilisé par une paire."
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr "Paramètre pour contrôler le seuil en nombre de granules au delà duquel une boucle explicite pour étiqueter un bloc mémoire est émise."
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, no-c-format
 msgid "This option is deprecated."
 msgstr "Cette option est obsolète."
@@ -11346,8 +11351,8 @@ msgstr "Activer la vectorisation sur les instructions en virgule flottante."
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
-msgstr "Le multiplicateur d'échelle, sous forme de pourcentage, à appliquer aux coûts de toutes les boucles scalaires en réalisant l'analyse de profitabilité de la vectorisation. La valeur par défaut est 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
+msgstr "Activer la vectorisation des boucles qui pourraient ne pas être profitable selon le modèle de coût mais qui réalise quand même l'évaluation de coût entre les modes de vecteurs."
 
 #: params.opt:1304
 #, no-c-format
@@ -18264,77 +18269,77 @@ msgstr "Être conforme à l'édition du langage D 2024."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Être conforme à la dernière édition du langage D 202Y (expérimental)."
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr "un argument copié par l'appelé est stocké dans la trame de la fonction courante"
 
-#: calls.cc:1537
+#: calls.cc:1533
 msgid "argument must be passed by copying"
 msgstr "l'argument doit être passé par copie"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr "la description machine n'a pas un modèle d'instruction sibcall_epilogue"
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr "l'appelé retourne une structure"
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr "la cible n'est pas capable d'optimiser l'appel sous forme d'appel frère"
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr "l'appelé retourne deux fois"
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr "l'appelé ne retourne pas"
 
-#: calls.cc:2595
+#: calls.cc:2596
 msgid "volatile function type"
 msgstr "type de fonction volatile"
 
-#: calls.cc:2614
+#: calls.cc:2615
 msgid "nested function"
 msgstr "fonction imbriquée"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr "l'appelé exige plus d'emplacements de pile que l'appelant"
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr "nombre d'arguments dépilés est inconsistant"
 
-#: calls.cc:2646
+#: calls.cc:2647
 msgid "frontend does not support sibling call"
 msgstr "l'interface ne supporte pas l'appel frère"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr "autres raisons"
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr "à l'intérieur d'un autre appel"
 
-#: calls.cc:3085
+#: calls.cc:3086
 msgid "variable size arguments"
 msgstr "arguments de taille variable"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr "argument de longueur de chaîne cachée passé sur la pile"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr "l'appelant et l'appelé ne sont pas d'accord sur la manière de promouvoir la valeur de retour de la fonction"
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr "échec de la production de l'appel de fin"
 
@@ -18454,12 +18459,12 @@ msgstr "l'opérande « %%l » n'est pas une étiquette"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "constante flottante mal utilisée"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19759,11 +19764,11 @@ msgstr "littéral JSON"
 msgid "this is the insn:"
 msgstr "ceci est la insn :"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 msgid "unable to reload address in "
 msgstr "impossible de recharger l'adresse dans "
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "incapable de générer des recharges pour:"
 
@@ -19982,7 +19987,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "heuristiques %s%sGGC: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonyme>"
@@ -20360,20 +20365,20 @@ msgstr "opérande non supporté pour le code « %c »"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "opérande invalide pour « %%%c »"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "constante vecteur invalide"
@@ -20418,71 +20423,71 @@ msgstr "préfixe d'opérande invalide « %%%c »"
 msgid "invalid address mode"
 msgstr "mode d'adresse invalide"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "conversion invalide depuis le type %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "conversion invalide vers le type %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "opération de pré-incrémentation non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "opération de pré-décrémentation non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "opération de post incrémentation non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "opération de post décrémentation non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr "opération de négation non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr "opération plus non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr "opération moins non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr "opération multiplication non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr "opération division non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr "opération décalage non permise sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr "seules les opérations == et !- sont permises sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr "opération d'indice non supportée sur svbool_t"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "opération non permise sur le type %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "impossible de combiner les vecteurs GNU et SVE dans l'opération binaire"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20499,13 +20504,13 @@ msgid "invalid %%r value"
 msgstr "valeur %%r invalide"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "valeur %%R invalide"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "valeur %%N invalide"
@@ -20520,7 +20525,7 @@ msgstr "valeur %%P invalide"
 msgid "invalid %%h value"
 msgstr "valeur %%h invalide"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "valeur %%L invalide"
@@ -20535,7 +20540,7 @@ msgstr "valeur %%m invalide"
 msgid "invalid %%M value"
 msgstr "valeur %%M invalide"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "valeur %%U invalide"
@@ -20867,7 +20872,7 @@ msgstr "opérande non supporté"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21112,126 +21117,126 @@ msgstr "constante en virgule flottante invalide"
 msgid "Expected register or constant integer."
 msgstr "Registre ou constante entière attendus."
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "UNSPEC invalide comme opérande"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "utilisation invalide du registre « %s »"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "utilisation invalide de la sortie du fanion asm"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "taille d'opérande invalide pour le code d'opérande « 0 »"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "taille d'opérande invalide pour le code d'opérande « z »"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "type opérande invalide utilisé avec le code d'opérande « %c »"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "taille d'opérande invalide pour le code d'opérande « %c »"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "l'opérande n'est pas du code de condition, code d'opérande « Y » invalide"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "l'opérande n'est pas du code de condition, code d'opérande « D » invalide"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "l'opérande n'est pas du code de condition, code d'opérande « %c » invalide"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "l'opérande n'est pas une référence mémoire avec décalage, code d'opérande « H » invalide"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "l'opérande n'est pas un entier, code d'opérande « K » invalide"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "l'opérande n'est pas un entier spécifique, code d'opérande « r » invalide"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "l'opérande n'est pas un entier, code d'opérande « R » invalide"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "l'opérande n'est pas un entier spécifique, code d'opérande « R » invalide"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "l'opérande n'est pas une référence mémoire, code d'opérande « v » invalide"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "opérande invalide pour « %c »"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "contrainte invalide pour l'opérande"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr "immédiat vecteur invalide"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "mode insn inconnu"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "conversion invalide depuis le type %<__bf16%> sans option %<-msse2%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "conversion invalide depuis le type %<_Float16%> sans option %<-msse2%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "conversion invalide vers le type %<__bf16%> sans option %<-msse2%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "conversion invalide vers le type %<_Float16%> sans option %<-msse2%>"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr "opération non permise sur le type %<__bf16%> sans option %<-msse2%>"
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr "opération non permise sur le type %<_Float16%> sans option %<-msse2%>"
 
@@ -21310,9 +21315,9 @@ msgstr "« %%%c » n'est pas un préfixe d'opérande valide"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "utilisation invalide de « %%%c »"
@@ -21377,7 +21382,7 @@ msgid "insn contains an invalid address !"
 msgstr "insn contient une adresse invalide !"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "adresse invalide"
 
@@ -21452,7 +21457,7 @@ msgstr "réadressage invalide"
 msgid "invalid %%H value"
 msgstr "valeur %%H invalide"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "valeur %%d invalide"
@@ -21502,32 +21507,32 @@ msgstr "adresse constante non supportée :"
 msgid "unsupported memory expression:"
 msgstr "expression mémoire non supportée :"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, c-format
 msgid "invalid vector operand"
 msgstr "opérande vectoriel invalide"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr "le modificateur « N » requiert un opérande registre"
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, c-format
 msgid "invalid register number for 'N' modifier"
 msgstr "numéro de registre invalide pour le modificateur « N »"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr "le modificateur « H » requiert un opérande registre"
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr "le modificateur « H » est uniquement pour des registres entiers"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr "le modificateur « H » ne peut pas être appliqué à R31"
@@ -21584,7 +21589,7 @@ msgstr "Mauvais déplacement sur 128 bits"
 msgid "invalid %%A value"
 msgstr "valeur %%A invalide"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "valeur %%D invalide"
@@ -21624,7 +21629,7 @@ msgstr "valeur %%J invalide"
 msgid "invalid %%k value"
 msgstr "valeur %%k invalide"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "valeur %%K invalide"
@@ -21654,17 +21659,17 @@ msgstr "valeur %%T invalide"
 msgid "invalid %%u value"
 msgstr "valeur %%u invalide"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "valeur %%v invalide"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "valeur %%V invalide"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "valeur %%x invalide"
@@ -21873,27 +21878,27 @@ msgstr "opérande %%s invalide"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "la constante en virgule flottante n'est pas un opérande immédiat valide"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "l'opérande « B » n'est pas une constante"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "l'opérande « B » a plusieurs bits activés"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "l'opérande « o » n'est pas une constante"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, c-format
 msgid "'h' operand is not SImode register"
 msgstr "l'opérande « h » n'est pas un registre SImode"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: code inconnu"
@@ -21949,24 +21954,24 @@ msgstr "adresse d'opérande illégale (4)"
 msgid "Unable to load DLL."
 msgstr "Impossible de charger la DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "mauvais test"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "masque invalide"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "valeur %%t/%%b invalide"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "pas de registre dans l'adresse"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "le décalage d'adresse n'est pas une constante"
 
@@ -21998,7 +22003,7 @@ msgstr "{erroné}"
 msgid "aka"
 msgstr "alias"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anonyme})"
 
@@ -22023,8 +22028,8 @@ msgstr "({anonyme})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "%<;%> attendu"
@@ -22052,7 +22057,7 @@ msgstr "%<:%> ou %<)%> attendu"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "%<)%> attendu"
@@ -22060,7 +22065,7 @@ msgstr "%<)%> attendu"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "%<]%> attendu"
@@ -22080,13 +22085,13 @@ msgstr "%<;%>, %<,%> ou %<)%> attendu"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "%<(%> attendu"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "%<[%> attendu"
@@ -22095,7 +22100,7 @@ msgstr "%<[%> attendu"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22112,13 +22117,13 @@ msgstr "%<{%> attendu"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "%<:%> attendu"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "%<while%> attendu"
@@ -22128,7 +22133,7 @@ msgstr "%<while%> attendu"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "%<,%> attendu"
@@ -22138,18 +22143,18 @@ msgid "expected %<.%>"
 msgstr "%<.%> attendu"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "%<@end%> attendu"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "%<>%> attendu"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "%<,%> ou %<)%> attendu"
@@ -22159,45 +22164,45 @@ msgstr "%<,%> ou %<)%> attendu"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "%<=%> attendu"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "%<)%> ou %<,%> attendu"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "%<}%> attendu"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "%<else%> attendu"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "%<#pragma omp section%> ou %<}%> attendu"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr "<message inconnu durant la compilation>"
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anonyme)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "%<<%> attendu"
@@ -22222,7 +22227,7 @@ msgstr "candidat %i :"
 msgid "  after user-defined conversion:"
 msgstr "  après la conversion définie par l'utilisateur :"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "le candidat est :"
@@ -22322,7 +22327,7 @@ msgstr "<erreur de paramètre du patron>"
 msgid "<statement>"
 msgstr "<déclaration>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<inconnu>"
@@ -22349,252 +22354,288 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<erreur d'expression>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<opérateur inconnu>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "Au niveau global:"
 
-#: cp/reflect.cc:565
-msgid "array element not a constant integer"
-msgstr "l'élément du tableau n'est pas une constante entière"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr "reflect_constant_array a échoué"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr "reflect_constant a échoué"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+msgid "array element not a constant integer"
+msgstr "l'élément du tableau n'est pas une constante entière"
+
+#: cp/reflect.cc:1117
 msgid "reflection does not represent a type"
 msgstr "la réflexion ne représente pas un type"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 msgid "reflection does not have template arguments"
 msgstr "la réflexion n'a pas d'arguments de patron"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 msgid "reflection does not represent a function or function type"
 msgstr "la réflexion ne représente pas une fonction ou un pointeur de fonction"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr "la réflexion ne représente pas une fonction opérateur ou un patron de fonction opérateur"
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 msgid "operators argument is not a valid operator"
 msgstr "l'argument des opérateurs n'est pas un opérateur valide"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 msgid "reflection does not have a type"
 msgstr "la réflexion n'a pas de type"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr "la réflexion ne représente pas un objet avec une durée de stockage statique ou une référence à un tel objet"
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr "la réflexion ne représente pas une annotation ou un argument valable à une expression de tranche"
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr "la réflexion ne représente pas une entité avec un parent"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr "la réflexion ne représente pas un paramètre de la fonction courante"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "la réflexion ne représente pas une fonction ou un type de fonction avec un type de retour"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr "la réflexion d'une relation de base directe virtuelle avec une classe dérivée abstraite"
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr "la réflexion est inappropriée pour offset_of"
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr "décalage non constant pour offset_of"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr "la réflexion n'est pas appropriée pour size_of"
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr "réflexion avec un type incomplet dans size_of"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 msgid "reflection not suitable for alignment_of"
 msgstr "réflexion inappropriée pour alignment_of"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 msgid "alignment_of on function type"
 msgstr "alignment_of sur un type de fonction"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr "réflexion avec un type incomplet dans alignment_of"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr "la réflexion est inappropriée pour bit_size_of"
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "réflexion avec un type incomplet dans bit_size_of"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr "réflexion avec has_identifier false"
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr "identifier_of pas représentable dans un encodage littéral ordinaire"
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr "u8identifier_of pas représentable en UTF-8"
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
-msgstr "la réflexion ne représente pas un type, un synonyme de type, une variable, une fonction, un espace de noms, un énumérateur, une relation de classe de base directe ou un membre de données non statique"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr "display_string_of pas représentable dans un encodage littéral ordinaire"
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr "u8display_string_of pas représentable en UTF-8"
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr "la réflexion ne représente pas un type, un synonyme de type, une variable, une fonction, un paramètre de fonction, un espace de noms, un énumérateur, une relation de classe de base directe ou un membre de données non statique"
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr "la réflexion ne représente pas un type complet ou un synonyme de type"
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr "reflect_object a échoué"
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr "reflect_function a échoué"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr "membre de valeur manquant"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr "valeur de membre de valeur inattendue"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr "membre de type manquant"
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr "la réflexion ne représente pas un type d'énumération complet"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "la réflexion ne représente pas un type d'énumération énumérable"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr "la réflexion représente un type non intégral ou booléen"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 msgid "reflection does not represent a template"
 msgstr "la réflexion ne représente pas un patron"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 msgid "invalid argument to can_substitute"
 msgstr "argument invalide à can_substitute"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr "can_substitute a retourné faux"
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 msgid "type is not object or reference type"
 msgstr "le type n'est pas un objet ou un type de référence"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr "la conversion depuis un encodage littéral ordinaire vers un jeu de caractères source a échouée"
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "la conversion depuis l'encodage UTF-8 vers le jeu de caractères source a échouée"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 msgid "name is not a valid identifier"
 msgstr "le nom n'est pas un identificateur valable"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr "le nom est un mot-clé"
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr "le nom est un trait interne"
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr "ni le nom ni bit_width sont spécifiés"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr "annotations spécifiées sans non et non vides"
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "bit_width spécifié avec un type non intégral ou non énumérable"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 msgid "both alignment and bit_width specified"
 msgstr "l'alignement et bit_width sont spécifiés tous les deux"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr "bit_width spécifié avec no_unique_address vrai"
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr "bit_width 0 avec le nom spécifié"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr "bit_width est négatif"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr "le nom n'est pas spécifié et le type est const"
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr "le nom n'est pas spécifié et le type est volatile"
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr "l'alignement n'est pas une puissance de deux"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr "l'alignement est négatif"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr "l'alignement est plus petit que alignment_of"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+msgid "reflection does not have non-array object type"
+msgstr "la réflexion n'a pas de type objet non-tableau"
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr "la portée actuelle ne représente pas une fonction"
+
+#: cp/reflect.cc:6526
+msgid "current scope does not represent a class nor a member function"
+msgstr "la portée actuelle ne représente pas une classe ou une fonction membre"
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr "classe parent incomplète"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr "n'est ni un type de classe complet ni un espace de noms"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 msgid "not a complete class type"
 msgstr "pas un type de classe complet"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr "type de fermeture"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 msgid "value cannot be extracted"
 msgstr "la valeur ne peut pas être extraite"
 
@@ -22638,52 +22679,52 @@ msgstr "la conversion supprime l'attribut « const »"
 msgid "source type is not polymorphic"
 msgstr "le type source n'est pas polymorphique"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "les candidats sont :"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "type d'argument erroné pour le moins unaire"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "type d'argument erroné pour le plus unaire"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "type d'argument erroné pour le complément de bit"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "type d'argument erroné pour abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "type d'argument erroné pour la conjugaison"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "dans l'argument d'un unaire !"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "pas d'opérateur de pré-incrémentation pour le type"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "pas d'opérateur de post-incrémentation pour le type"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "pas d'opérateur de pré-décrémentation pour le type"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "pas d'opérateur de post-décrémentation pour le type"
 
@@ -22699,59 +22740,59 @@ msgstr " [consultez %<-fallow-invalid-boz%>]"
 msgid "BOZ constant truncated at %L"
 msgstr "constante BOZ tronquée à %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "arguments « a%d » et « a%d » pour l'intrinsèque « %s »"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "arguments « %s » et « %s » pour l'intrinsèque %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "arguments « %s » et « %s » pour l'intrinsèque « %s »"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr "NULL() n'est pas interopérable"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 msgid "BOZ literal constant"
 msgstr "constante littérale BOZ"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr "L'expression est polymorphique"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr "L'expression est un type dérivé non-interopérable"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 msgid "Procedure unexpected as argument"
 msgstr "Procédure inattendue comme argument"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr "Extension pour utiliser un LOGICAL qui n'est pas du type C_Bool"
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr "Extension pour utiliser un CHARACTER qui n'est pas du type C_CHAR"
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr "Le type doit avoir une longueur de caractère de 1"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr "Les co-tableaux ne sont pas interopérables"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr "Le tableau de taille tacite ne sont pas interopérables"
 
@@ -22833,7 +22874,7 @@ msgstr "Fonctionnalité supprimée :"
 msgid "Unsigned:"
 msgstr "Non signé :"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "affectation de tableau"
 
@@ -22842,17 +22883,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr "La variable d'index %qs est redéfinie à %L dans la procédure %qs appelée depuis l'intérieur d'une boucle DO à %L"
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr "Extent incorrect dans l'argument B de l'intrinsèque MATMUL dans la dimension 1: est %ld, devrait être %ld"
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "Désaccord de la limite du tableau pour la dimension 1 du tableau (%ld/%ld)"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "Désaccord de la limite du tableau pour la dimension 2 du tableau (%ld/%ld)"
@@ -23028,11 +23069,11 @@ msgstr "bloc IF"
 msgid "implied END DO"
 msgstr "END DO implicite"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "affectation"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "affectation de pointeur"
 
@@ -23040,125 +23081,125 @@ msgstr "affectation de pointeur"
 msgid "simple IF"
 msgstr "IF simple"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "procédure élémentaire"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "argument qui peut être alloué"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "argument asynchrone"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "argument optionnel"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "argument pointeur"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "argument cible"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "argument valeur"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "argument volatile"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "argument de forme tacite (assumed-shape)"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "argument de rang tacite (assumed-rank)"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "argument co-tableau"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "argument de type dérivé paramétrisé"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "argument polymorphique"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "attribut NO_ARG_CHECK "
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "argument de type tacite (assumed-type)"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "résultat tableau"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "résultat pointeur ou allouable"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr "résultat avec une longueur de caractères non constante"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "procédure bind(c)"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Variable de boucle"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "variable d'itérateur"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Expression de départ dans la boucle DO"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "Expression de fin dans la boucle DO"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Expression de pas dans la boucle DO"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "objet DEALLOCATE"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "objet ALLOCATE"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "variable STAT"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "variable ERRMSG"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "élément dans READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "variable ACQUIRED_LOCK"
 
@@ -23167,31 +23208,31 @@ msgstr "variable ACQUIRED_LOCK"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Longueurs de CHARACTER différentes (%ld/%ld) dans le constructeur de tableau"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "Débordement d'entier en calculant la quantité de mémoire à allouer"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr "La valeur du paramètre PDT LEN « %s » n'est pas en accord avec celle dans la déclaration fictive"
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "La longueur réelle de la chaîne ne correspond pas à celle déclarée pour l'argument fictif « %s » (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "La longueur réelle de la chaîne est plus courte que celle déclarée pour l'argument fictif « %s » (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "La cible du remappage de rang est trop petite (%ld < %ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Assignation d'un scalaire à un tableau non alloué"
 
@@ -23254,27 +23295,27 @@ msgstr "L'argument NCOPIES de l'intrinsèque REPEAT est négatif (sa valeur est
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "L'argument NCOPIES de l'intrinsèque REPEAT est trop grand"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "Argument FROMPOS (%ld) hors limite 0:%d dans l'intrinsèque MVBITS"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "Argument LEN (%ld) hors limite 0:%d dans l'intrinsèque MVBITS"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "Argument TOPOS (%ld) hors limite 0:%d dans l'intrinsèque MVBITS"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) dans l'intrinsèque MVBITS"
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) dans l'intrinsèque MVBITS"
@@ -23371,7 +23412,7 @@ msgid "expected boolean type"
 msgstr "type booléen attendu"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "entier attendu"
@@ -23434,7 +23475,7 @@ msgstr "pas assez d'arguments"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "trop d'arguments"
@@ -23829,7 +23870,7 @@ msgstr "support du profilage pour VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "le système d'exploitation cible ne supporte pas les accès non alignés"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "le profilage n'a pas encore été implémenté sur cette architecture"
@@ -24072,13 +24113,13 @@ msgstr "exception %qs"
 msgid "Global declarative %s for %s"
 msgstr "Déclarative globale %s pour %s"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr "%s:%d: %<symbol_type_t%> %d invalide"
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr "SET identifier-11 TO LOCALE"
@@ -24239,12 +24280,12 @@ msgstr "%qs est obsolète; utilisez -fstack-check."
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs est déprécié; utilisez -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "préférence autovec %qs inconnue"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "politique LDP/STP %qs inconnue"
@@ -24670,8 +24711,8 @@ msgstr "l'attribut %qE est ignoré car il est en conflit avec l'attribut %qs"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "déclaration précédente ici"
@@ -24688,7 +24729,7 @@ msgstr "directive d'attribut %qE ignorée"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "directive d'attribut de portée %<%E::%E%> ignorée"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "nombre erroné d'arguments spécifié pour l'attribut %qE"
@@ -24698,7 +24739,7 @@ msgstr "nombre erroné d'arguments spécifié pour l'attribut %qE"
 msgid "expected %i or more, found %i"
 msgstr "%i ou plus attendu, %i trouvé"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "%i attendu, %i trouvé"
@@ -24781,12 +24822,12 @@ msgstr "les attributs de type sont ignorés après que le type ait déjà été
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -24902,133 +24943,133 @@ msgstr "le profil automatique contient l'index de nom de symbole %d invalide"
 msgid "auto-profile contains invalid filename index %d"
 msgstr "le profil automatique contient l'index de nom de fichier %d invalide"
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr "le profil automatique de %q+F contient la fonction en ligne avec le nom de symbole %s au lieu du nom de symbole %s"
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr "appel correspondant"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr "décompte d'information dupliqué dans le profil automatique de %q+F à l'emplacement relatif %i, et discriminateur %i"
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr "emplacement source correspondant"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr "site d'appel dupliqué dans le profil automatique %q+F à l'emplacement relatif %i, discriminateur %i"
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr "les cibles d'appel et l'information du site d'appel en ligne sont présentes toutes les deux dans le profil automatique de la fonction %q+F à l'emplacement relatif %i, discriminateur %i"
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr "le profil automatique de %q+F semble contenir le discriminateur perdu %i pour l'appel de %s à l'emplacement relatif %i"
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr "le profil automatique de %q+F contient plusieurs cibles pour un appel direct avec l'emplacement relatif %i, discriminateur %i"
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr "la fonction contient deux appels du même emplacement relatif +%i, discriminateur %i, cela conduit à un profil automatique perdu"
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr "emplacement du premier appel"
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr "emplacement du deuxième appel"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr "le profil automatique de %q+F contient des cibles d'appel indirect qui ne sont pas associées avec une instruction d'appel indirect"
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr "décompte %<PRIu64> avec l'emplacement relatif +%i, discriminateur %i"
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr "le profil automatiquement de %q+F contient des instructions supplémentaires"
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, gcc-internal-format
 msgid "location is after end of function"
 msgstr "l'emplacement est après la fin de la fonction"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr "le profil automatique de %q+F contient des sites d'appel supplémentaires"
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr "appel de %s avec un décompte total %<PRId64>, emplacement relatif +%i, discriminateur %i"
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "TAG inattendu."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr "le profil automatique contient l'instance de fonction dupliquée %s"
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "n'a pu ouvrir le fichier profil %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr "le nombre magique du profil AutoFDO ne correspond pas"
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "la version %u du profil AutoFDO ne correspond pas à %u"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "impossible de lire l'information résumée de %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "impossible de lire la table des chaînes depuis %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "impossible de lire le profil de la fonction depuis %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "impossible de lire le profil du module depuis %s"
@@ -25038,7 +25079,7 @@ msgstr "impossible de lire le profil du module depuis %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "le décalage %qwi est hors des limites de la chaîne constante"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qE déclaré ici"
@@ -25141,7 +25182,7 @@ msgstr "argument non constant 0 pour %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "argument 0 invalide pour %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr "le troisième argument des fonctions internes %<crc%> doit être une constante"
@@ -25215,12 +25256,12 @@ msgstr "le dernier argument de %qD n'est pas une constante entière entre 0 et 3
 msgid "cannot tail-call: %s"
 msgstr "impossible d'appeler en fin de fonction (tail-call): %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "l'appel de fonction a une valeur d'agrégat"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "passage d'un argument trop grand sur la pile"
@@ -25864,342 +25905,342 @@ msgstr "les blocs de base n'ont pas été disposés consécutivement"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "le nombre d'annotations des bb dans la chaîne des insn (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "le nombre d'arêtes de l'appelant est invalide"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr "appel indirect manquant dans la séquence d'appel spéculative"
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr "l'appel indirect dans la séquence d'appel spéculative n'a pas le fanion spéculatif"
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr "les arrêtes spéculatives ne sont pas adjacentes"
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr "l'appel direct à %s dans la séquence d'appel spéculative n'a pas de fanion spéculatif"
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr "l'appel direct à %s dans une séquence d'appel spéculative a speculative_id %i hors limites"
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr "appel direct dupliqué pour %s dans la séquence d'appel spéculative avec speculative_id %i"
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr "le hachage de l'instruction d'appel ne pointe pas vers la première arrête directe de la séquence d'appel spéculative"
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr "référence %s dupliquée dans la séquence d'appel spéculative avec speculative_id %i"
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "appel direct manquant pour la spéculation %i"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "référence manquante pour la spéculation %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr "le nombre de cibles spéculatives %i est en désaccord avec num_speculative_call_targets %i"
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "champ aux défini pour l'arête %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr "décompte cgraph invalide"
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "clone en ligne dans la même liste du groupe comdat"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "le nombre de clones en ligne n'est pas compatible"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "tp_first_run doit être non négatif"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "les symboles locaux doivent être définis"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "clone en ligne visible depuis l'extérieur"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "clone en ligne avec l'adresse prise"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "le clone en ligne est forcé à sortir"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr "le clone en ligne est référencé par l'assembleur"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr "calls_comdat_local est défini en dehors d'un groupe comdat"
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr "fanion calls_comdat_local invalide"
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "l'attribut malloc devrait être utilisé pour une fonction qui retourne un pointeur"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr "interposition sémantique incohérente"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "champ aux défini pour une arête indirecte depuis %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "le décompte d'arêtes n'est pas compatible avec le décompte de fonction"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "le décompte d'arêtes n'est pas compatible avec le décompte de fonction en ligne"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "Une arête indirecte depuis %s n'est pas marquée comme indirecte ou a un indirect_info associé, l'instruction correspondante est: "
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr "l'arête a, à la fois, call_stmt et lto_stmt_uid définis"
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr "la fonction locale comdat est appelée par %s en dehors de son comdat"
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "le pointeur inlined_to est faux"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "appelants en ligne multiples"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "pointeur inlined_to défini pour des appelants pas en ligne"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "le décompte des arêtes de l'appelant ne correspond pas au décompte du BB"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "le décompte des appels indirects ne correspond pas au décompte du BB"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr "la référence a, à la fois, stmt et lto_stmt_uid définis"
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "le pointeur inlined_to est défini mais aucun prédécesseur trouvé"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "le pointeur inlined_to fait référence à lui même"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "le cgraph_node a un mauvais clone_of"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "le cgraph_node a une mauvaise liste de clones"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "le cgraph_node est dans la liste des clones mais il n'est pas un clone"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "le cgraph_node a un mauvais pointeur prev_clone"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "la liste doublement liée des clones est corrompue"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "L'alias a des arêtes d'appel"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "L'alias a une référence qui n'est pas un alias"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "L'alias a plus d'une référence alias"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "L'alias analysé n'a pas de référence"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "Pas d'arête hors du nœud du fragment"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "Plus d'une arête sortante hors du nœud du fragment"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "Le fragment n'est pas supposé avoir un contenu"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "call_stmt partagé:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "l'arête pointe vers la mauvaise déclaration:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "une arête indirecte avec un appelé inconnu correspondant à un call_stmt avec une déclaration connue:"
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "arête callgraph manquante pour l'appel stmt:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "référence à une instruction morte"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr "l'arête non-callback a callback_id défini"
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr "l'arête a, à la fois, callback et has_callback défini"
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr "l'arrête de la callback %s->%s n'a pas de callback-carrying"
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr "l'arête de la callback %s->%s n'a pas le bon nombre d'arêtes de callback, au plus %d attendu, %d obtenu"
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr "l'arête transportant la callback pointe vers __builtin_unreachable mais l'arête de sa callback %s -> %s ne le fait pas"
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "l'arête %s->%s n'a pas de call_stmt correspondant"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "une arête indirecte depuis %s n'a pas de call_stmt correspondant"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr "origine manquante pour un nœud dans une liste imbriquée"
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "l'origine pointe vers un parent différent"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node a échoué"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "%s: la section %s.%d est manquante"
@@ -26966,17 +27007,17 @@ msgstr "la taille totale des objets locaux dépasse le maximum %wu"
 msgid "impossible constraint in %<asm%>"
 msgstr "contrainte impossible dans %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "la variable %q+D pourrait être écrasée par %<longjmp%> ou %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "l'argument %q+D pourrait être écrasé par %<longjmp%> ou %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "la fonction retourne un agrégat"
@@ -27647,7 +27688,7 @@ msgstr "la limite spécifiée par %qD (%E) est égale la longueur de la destinat
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "le membre tableau flexible %qD n'a pas de bits de remplissage bien définis pour %qs"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr "la gestion du champ de bits PDP11 est non supportée dans %qs"
@@ -27687,7 +27728,7 @@ msgstr "%qD a plus de %u blocs, le maximum demandé pour %<-fharden-control-flow
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr "une référence à l'étiquette %qD est définie à l'intérieure de l'expression d'attribut %<assume%> depuis l'extérieur de l'attribut"
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr "%qD défini ici"
@@ -27707,24 +27748,24 @@ msgstr "déréférencement d'un pointeur null"
 msgid "function may return address of local variable"
 msgstr "la fonction peut retourner l'adresse d'une variable locale"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "la fonction retourne l'adresse d'une variable locale"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -28614,7 +28655,7 @@ msgstr "attend entre %E et %E octets dans une région de taille %E"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr "%qD appelé sur le pointeur %qE avec l'offset%s non nul"
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr "retourné depuis %qD"
@@ -28684,204 +28725,204 @@ msgstr "dans un appel à la fonction d'allocation %qD déclarée ici"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "spécificateur d'architecture inconnu dans le modèle mémoire %wi pour %qD"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "modèle mémoire %qs invalide pour %qD"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "modèle mémoire %wi invalide pour %qD"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr "les modèles valables sont %e"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "modèle mémoire d'échec %qs invalide pour %qD"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "les modèles d'échec valables sont %qs, %qs, %qs, %qs"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "le modèle mémoire en cas d'échec %qs ne peut pas être plus fort que le modèle mémoire en cas de succès %qs pour %D"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "le modèle mémoire en cas d'échec %wi ne peut pas être plus fort que le modèle mémoire en cas de succès %wi pour %D"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "l'argument lié %i a la valeur %s qui est négative pour l'argument %i d'un tableau de longueur variable de type %s"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "l'argument %i a la valeur %s qui est négative"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr "l'argument %i est nul mais la valeur de l'argument de taille %i correspondant est %s"
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "fait référence à l'argument %u de type %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "dans un appel à la fonction %qD déclarée avec l'attribut %qs"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "dans un appel avec le type %qT et l'attribut %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "dans un appel à la fonction %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "dans un appel avec le type %qT"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr "%qD appelé sur l'objet %qD non alloué"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr "%qD appelé sur un pointeur vers un objet %qE non alloué"
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr "assigné ici"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD appelé sur un pointeur retourné depuis une fonction d'allocation inappropriée"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr "%qD appelé sur un pointeur vers un objet non alloué"
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "le pointeur %qE peut être utilisé après %qD"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "le pointeur %qE est utilisé après %qD"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr "le pointeur peut être utilisé après %qD"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "le pointeur est utilisé après %qD"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, gcc-internal-format
 msgid "call to %qD here"
 msgstr "appel à %qD ici"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr "le pointeur ballant %qE vers %qD est peut-être utilisé ici"
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr "utilisation du pointeur ballant %qE vers %qD"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "le pointeur ballant vers %qD est peut-être utilisé"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr "utilisation d'un pointeur ballant vers %qD"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD déclaré ici"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr "le pointeur ballant %qE vers un temporaire non nommé est peut-être utilisé"
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr "utilisation du pointeur ballant %qE vers un temporaire non nommé"
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr "le pointeur ballant vers un temporaire non nommé est peut-être utilisé"
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "utilisation d'un pointeur ballant vers un temporaire non nommé"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "le temporaire non nommé est défini ici"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "%qD appelé sur un pointeur %qE passé à la fonction d'allocation %qD inappropriée"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "%qD appelé sur un pointeur passé à la fonction de réallocation %qD inappropriée"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr "appel à %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "stockage de l'adresse de la variable locale %qD dans %qE"
@@ -29688,346 +29729,346 @@ msgstr "le jeton %u a %<y-location == %llu%>"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "utilisation invalide de l'attribut %<fallthrough%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "la table virtuelle de type %qD enfreint la règle de la définition unique"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "une variable avec le même nom assembleur que la table virtuelle est définie dans une autre unité de traduction"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "la table virtuelle de type %qD contient des informations RTTI"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr "mais elle est remplacée par une autre qui n'en a pas dans une autre unité de traduction"
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "RTTI ne fonctionnera pas sur ce type"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "le type en conflit défini dans une autre unité de traduction a une table virtuelle d'une taille différente"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "le type en conflit défini dans une autre unité de traduction avec des informations RTTI différentes"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "le type en conflit défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "contient la méthode virtuelle additionnelle %qD"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "le type en conflit défini dans une autre unité de traduction a une table virtuelle avec plus d'entrées"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "méthode virtuelle %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr "aurait dû correspondre à la méthode virtuelle %qD mais ce n'est pas le cas"
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "le type en conflit défini dans une autre unité de traduction a une table virtuelle avec un contenu différent"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "le type %qT (typedef de %qT) enfreint la règle de la définition unique du C++"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "le type %qT enfreint la règle de la définition unique du C++"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "un type différent est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr "la première différence des définitions correspondantes est le champ %qD"
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr "la première différence des définitions correspondantes est la méthode %qD"
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "le type %qT défini dans l'espace de noms anonyme ne peut pas correspondre au type %qT de l'autre côté de la frontière de l'unité de traduction"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "le type %qT défini dans l'espace de noms anonyme ne peut pas correspondre au type de même nom de l'autre côté de la frontière de l'unité de traduction"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "le type incomplet défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "le nom du type %qs devrait correspondre au nom du type %qs"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "le type incompatible est défini ici"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "les types tableaux ont des limites différentes"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "désaccord dans le type de la valeur retournée"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "désaccord dans le type du pointeur implicite « this »"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "désaccord de type dans le paramètre %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "les types ont des nombres de paramètres différents"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "le type %qT enfreint lui-même la règle de la définition unique du C++"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "le type %qT devrait correspondre au type %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "un type avec une précision différente est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "un type vectoriel avec un nombre différent d'éléments est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "un type avec une plage signée différente est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "il est défini comme un pointeur dans des espaces d'adresses différents dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "il est défini comme un pointeur vers un type différent dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "un tableau d'une taille différente est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "a une valeur de retour différente dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "a des paramètres différents dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "un type défini dans une autre unité de traduction n'est pas polymorphique"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "un type défini dans une autre unité de traduction est polymorphique"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "un type avec des pointeurs de tables virtuelles différents est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "un type avec une base différente est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "un champ avec un nom différent est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "un champ avec le même nom mais un type différent est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "les champs ont un agencement différent dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr "un champ est un champ de bits alors que l'autre ne l'est pas"
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "un type avec un nombre de champs différent est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "un type avec une taille différente est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr "un type doit être construit alors que l'autre ne le doit pas"
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "désaccord dans la disposition de la mémoire"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "la base supplémentaire est définie ici"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] "La déclaration du type %qD comme étant final permettrait la dévirtualisation de %i appel"
 msgstr[1] "La déclaration du type %qD comme étant final permettrait la dévirtualisation de %i appels"
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "La déclaration du type %qD comme étant final permettrait la dévirtualisation de %i appel exécuté %lli fois"
 msgstr[1] "La déclaration du type %qD comme étant final permettrait la dévirtualisation de %i appels exécutés %lli fois"
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] "La déclaration du destructeur virtuel de %qD comme étant final permettrait la dévirtualisation de %i appel"
 msgstr[1] "La déclaration du destructeur virtuel de %qD comme étant final permettrait la dévirtualisation de %i appels"
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] "La déclaration de la méthode %qD comme étant finale permettrait la dévirtualisation de %i appel"
 msgstr[1] "La déclaration de la méthode %qD comme étant finale permettrait la dévirtualisation de %i appels"
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "La déclaration du destructeur virtuel de %qD comme étant final permettrait la dévirtualisation de %i appel exécuté %lli fois"
 msgstr[1] "La déclaration du destructeur virtuel de %qD comme étant final permettrait la dévirtualisation de %i appels exécutés %lli fois"
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "La déclaration de la méthode %qD comme étant finale permettrait la dévirtualisation de %i appel exécuté %lli fois"
 msgstr[1] "La déclaration de la méthode %qD comme étant finale permettrait la dévirtualisation de %i appels exécutés %lli fois"
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "le type %qs enfreint la règle de la définition unique du C++"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "un « enum » avec un nombre de valeurs différents est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "un « enum » avec des noms de valeurs différents est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "un « enum » avec des valeurs différentes est défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "le nom %qs diffère du nom %qs défini dans une autre unité de traduction"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "le nom %qs est défini comme ayant %u bits alors qu'une autre unité de traduction le défini avec %u bits"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "le nom %qs est défini à %wd alors qu'une autre unité de traduction le défini à %wd"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "le nom %qs est défini à une valeur différente dans une autre unité de traduction"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr "définition non concordante"
@@ -30047,7 +30088,7 @@ msgstr "le résumé en ligne ipa est manquant dans le fichier d'entrée"
 msgid "IPA modref summary is missing in input file"
 msgstr "le résumé de modref IPA est manquant dans le fichier d'entrée"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "fonction de saut invalide dans un flux LTO"
@@ -30277,12 +30318,12 @@ msgstr "le nombre maximum d'étapes d'affectations LRA est atteint (%d)"
 msgid "unable to find a register to spill"
 msgstr "impossible de trouver un registre à déverser"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "contraintes d'opérande inconsistantes dans un %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "le nombre maximum d'insns de rechargement générées par insn est atteint (%d)"
@@ -30649,7 +30690,7 @@ msgstr "la clause %qs avec le modificateur %<sink%> attend une itération lexica
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "la clause %qs avec le modificateur %<sink%> fait référence à une itération qui n'est jamais dans l'espace d'itération"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr "pas de boucle OpenMP non rectangulaire invalide ; %<(%E - %E) * %E%> n'est pas un multiple de la boucle %d avec le pas %qE"
@@ -32037,22 +32078,22 @@ msgstr "les registres explicitement utilisés doivent être groupés en haut de
 msgid "output operand %d must use %<&%> constraint"
 msgstr "l'opérande de sortie %d doit utiliser la contrainte %<&%>"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "%qs: [%u] %<next_regno%> erroné pour une chaîne vide (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "%qs: boucle dans la chaîne %<next_regno%> (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "%qs: [%u] %<oldest_regno%> erroné (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr "%qs: [%u] registre non vide dans la chaîne (%s %u %i)"
@@ -32991,167 +33032,167 @@ msgstr "transaction extérieure dans une fonction %<transaction_safe%>"
 msgid "ignoring loop annotation"
 msgstr "ignore l'annotation de boucle"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "la constante n'a pas été recalculée quand %<ADDR_EXPR%> a changé"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "les effets de bords n'ont pas été recalculés quand %<ADDR_EXPR%> a changé"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "l'adresse est prise mais le bit %<TREE_ADDRESSABLE%> n'est pas défini"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "%qs non scalaire"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "position ou opérande de taille invalide pour %qs"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr "la précision du type résultant intégral ne correspond pas à la taille du champ de %qs"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "la taille du mode du résultat non intégral ne correspond pas à la taille du champ de %qs"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "%qs dans un opérande non-mode-precision"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "la position plus la taille dépasse la taille de l'objet référencé dans %qs"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "désaccord de type dans la référence %qs"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "conversion d'un %qs dans le membre de gauche de %qs"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "conversion d'un registre vers une taille différente dans %qs"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr "%qs pas au plus haut niveau"
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "opérande invalide pour %qs"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "désaccord de type dans %qs"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "opérande de décalage %qs invalide"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "opérande d'adresse invalide dans %qs"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "opérande de décalage invalide dans %qs"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "clique invalide dans %qs"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr "%qs dans IL gimple"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr "%qs en tant que base où un non-registre est requis"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "expression invalide pour la l-valeur min"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "l'appel gimple a deux cibles"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "l'appel gimple n'a pas de cible"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "fonction invalide dans l'appel gimple"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "non fonction dans un appel gimple"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "type const pure invalide pour la fonction"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "membre de gauche invalide dans un appel gimple"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr "membre de gauche dans un appel %<noreturn%>"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "conversion invalide dans un appel gimple"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "chaîne statique invalide dans un appel gimple"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "chaîne statique avec une fonction qui n'en utilise pas"
@@ -33162,597 +33203,597 @@ msgstr "chaîne statique avec une fonction qui n'en utilise pas"
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "appel %<__builtin_unreachable%> ou %<__builtin_trap%> avec des arguments"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr "les appels %<DEFERRED_INIT%> devraient avoir la même taille constante pour le premier argument et le terme de gauche"
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "argument invalide dans un appel gimple"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "opérandes invalides dans une comparaison gimple"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "types d'opérandes de comparaison non concordants"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "opération ou type non supporté pour une comparaison vectorielle retournant un booléen"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "opérandes non vectoriels dans une comparaison vectorielle"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "type invalide comme résultat d'une comparaison vectorielle"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "type foireux pour le résultat d'une comparaison"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "non registre comme membre de gauche d'une opération unaire"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "opérande invalide dans l'opération unaire"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "types vectoriels invalides dans une conversion nop"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "types invalides dans une conversion nop"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "types invalides dans une conversion d'espace d'adresse"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "types invalides dans une conversion en virgule fixe"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "types invalides dans une conversion vers une virgule flottante"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "types invalides dans une conversion vers un entier"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "désaccord de type dans l'expression %qs"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "types invalides pour %qs"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr "%qs devrait provenir d'un scalaire vers un vecteur similaire"
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "type invalide pour %qs"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "conversion non triviale dans une opération unaire"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "non registre comme membre de gauche d'une opération binaire"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "opérandes invalides dans l'opération binaire"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "opérandes non vectoriels invalides pour %qs"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "opérandes (pointeurs) %qs invalides"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "types vectoriels attendus dans %qs"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "désaccord de type dans une expression binaire"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "non registre comme membre de gauche dans une opération ternaire"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "opérandes invalides dans l'opération ternaire"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr "le premier argument d'un %qs doit être d'un type vectoriel booléen du même nombre d'éléments que le résultat"
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "types vectoriels attendus dans %qs"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "des vecteurs avec un nombre d'éléments différents ont été trouvés dans %qs"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "type de masque invalide dans %qs"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "combinaison de types pas permise dans %qs"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "position ou taille invalide dans %qs"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "%qs dans un opérande non-mode-precision"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "insertion hors limites dans %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%qs pas à la frontière d'un élément"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "conversion non triviale dans %qs"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "membre de gauche (%qs) invalide pour l'affectation : %qs"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "membre de gauche de %qs dans une instruction écrasée"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "membre de gauche de %qs dans une instruction d'assignation"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "opérande invalide dans %qs"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "argument de taille %qs invalide dans le chargement"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "membre de droite invalide pour un stockage mémoire gimple : %qs"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr "non registre comme membre de gauche dans un constructeur vectoriel"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "type incorrect pour les éléments d'un vecteur %qs"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "nombre incorrect pour les éléments d'un vecteur %qs"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "type incorrect pour les éléments d'un vecteur CONSTRUCTOR"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr "vecteur %qs avec un index d'élément non nul"
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "l'élément d'un vecteur %qs n'est pas une valeur GIMPLE"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "non vecteur %qs avec des éléments"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "le stockage non temporel lhs ne peut pas être un registre gimple"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "opérande invalide dans l'instruction de retour"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "conversion invalide dans une instruction de retour"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "la destination du « goto » n'est ni une étiquette ni un pointeur"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "opérande invalide pour l'instruction « switch »"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "instruction « switch » avec un type non entier"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "étiquette invalide pour le « case » par défaut dans l'instruction « switch »"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "%<CASE_CHAIN%> invalide"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "étiquette invalide pour un « case » dans l'instruction « switch »"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "plage du « case » invalide dans l'instruction « switch »"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "désaccord dans la précision du type dans l'instruction « switch »"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "désaccord de type pour l'étiquette du « case » dans l'instruction « switch »"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "les « case » ne sont pas triés dans l'instruction « switch »"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "le contexte de l%'étiquette n'est pas la déclaration de la fonction actuelle"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "entrée incorrecte dans %<label_to_block_map%>"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "configuration incorrecte pour le numéro de la zone d'atterrissage des exceptions (landing pad)"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "code de comparaison invalide dans la condition gimple"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "étiquettes invalides dans la condition gimple"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr "une condition gimple cond ne peut pas lever une exception"
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "résultat %<PHI%> invalide"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "définition %<PHI%> manquante"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "argument %<PHI%> invalide"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "types incompatibles dans l'argument %<PHI%> %u"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "%<verify_gimple%> a échoué"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "instruction sans effet dans la table EH"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr "le bloc des références vers les emplacements n'est pas dans l'arbre des blocs"
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "déclaration locale depuis une fonction différente"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) est défini avec un mauvais bloc de base"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr "nœud PHI avec emplacement"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "partage incorrect des nœuds de l'arbre"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "PHI virtuel avec des emplacements d'arguments"
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) est défini avec un mauvais bloc de base"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "l'instruction est marquée comme produisant une exception mais elle ne le fait pas"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "une instruction est marquée comme produisant une exception au milieu du bloc"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple a échoué"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK a un nœud dans le langage intermédiaire (IL) qui lui est associé"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK a un nœud dans le langage intermédiaire (IL) qui lui est associé"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "fallthru pour sortir du bloc de base %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr "décompte du bloc d'entrée pas initialisé"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr "décompte du bloc de sortie par initialisé"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr "la probabilité de l'arête depuis le bloc d'entrée n'est pas initialisée"
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "le décompte du bloc de sortie n'est pas compatible avec le décompte du bloc d'entrée"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr "le compte de bb %d n'est pas initialisé"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr "la probabilité de l'arête %d->%d n'est pas initialisée"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "le décompte du bloc de base %d n'est pas compatible avec le décompte du bloc d'entrée"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr "l'étiquette non locale %qD n'est pas la première dans la séquences des étiquettes dans le bb %d"
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr "l'étiquette « EH landing pad » %qD n'est pas la première dans la séquence des étiquettes dans le bb %d"
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "l'étiquette %qD du bloc ne correspond pas dans le bb %d"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "l'étiquette %qD a un contexte incorrect dans le bb %d"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "contrôle de flux au milieu du bloc de base %d"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr "étiquette %qD au milieu du bloc de base %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr "l'appel returns_twice n'est pas le dernier dans le bloc de base %d"
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr "l'appel returns_twice n'est pas le premier dans le bloc de base %d"
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "arête fallthru après une instruction de contrôle dans le bb %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "arête vrai/faux après un non GIMPLE_COND dans le bb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "mauvais fanions d'une arête sortante à la fin du bb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "« goto » explicite à la fin du bb %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "l'arête de retour ne pointe pas vers la sortie dans le bb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "« case » par défaut rencontré mais pas au début du vecteur des « case »"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "étiquettes « case » pas triées: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "arête sortante supplémentaire %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "arête manquante %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "une fonction avec %<noreturn%> retourne une valeur"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "le contrôle a atteint la fin d'une fonction non « void »"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "la valeur retournée par %qD est ignorée alors qu'elle est déclarée avec l'attribut %<warn_unused_result%>"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "la valeur retournée est ignorée pour une fonction déclarée avec l'attribut %<warn_unused_result%>"
@@ -33934,12 +33975,12 @@ msgstr "la cible ne supporte pas complètement la mise à jour atomique du profi
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "la cible ne supporte pas la mise à jour atomique du profilage, le mode simple est sélectionné"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "attribut de spec fn « %s » invalide"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "attribut de spec fn « %s » invalide arg %i"
@@ -34448,7 +34489,7 @@ msgstr "la condition vectorielle sera développée à la pièce"
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "l'opération de brassage vectoriel sera développée à la pièce"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr "la vectorisation n'a pas eu lieu pour une boucle simd"
@@ -34868,29 +34909,29 @@ msgstr "%<TYPE_CACHED_VALUES_P%> est défini alors qu'il ne le devrait pas"
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "%<TYPE_METHOD_BASETYPE%> n'est pas la variante principale"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "attribut %<target%> manquant pour %qD avec plusieurs versions"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "déclaration précédente de %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%qD entre en conflit avec une déclaration %<target_clone%> qui le chevauche"
 
 # ce message apparaît juste après le %q#D ci-dessus
-#: tree.cc:15804
+#: tree.cc:15824
 msgid "%qD conflicts for version %qB"
 msgstr "%qD est en conflit pour la version %qB"
 
-#: tree.cc:15817
+#: tree.cc:15837
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "%qD entre en conflit avec une déclaration précédente pour la version %qB"
 
@@ -34965,7 +35006,7 @@ msgstr "seuls les initialiseurs à zéro sont autorisés dans la section %qs"
 msgid "no initializers are allowed in section %qs"
 msgstr "aucun initialiseur n'est autorisé dans la section %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "le nom du registre n'est pas spécifié pour %q+D"
@@ -35110,7 +35151,7 @@ msgstr "le symbole %qs %q+D pointe vers lui-même en fin de compte"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "le symbole %qs %q+D doit avoir une classe de liaison statique"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "les définitions d'alias ne sont pas supportées dans cette configuration"
@@ -35155,54 +35196,54 @@ msgstr "disposition de pile compacte"
 msgid "cannot tail-call: return value must be a call"
 msgstr "impossible d'appeler à la fin : la valeur de retour doit être un appel"
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "l'argument de l'attribut %qE est invalide"
 
 # Il semble que la syntaxe habituelle pour modifier l'ordre des paramètres n'est pas supportée, d'où la construction bizarre.
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "l'attribut %qE à son argument %i qui est invalide"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "l'argument de l'attribut %qE a le type %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "l'attribut %qE a son argument %i qui est de type %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "l'argument de l'attribut %qE avec la valeur %qE n'est pas une constante entière"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "l'attribut %qE a son argument %i avec a la valeur %qE qui n'est pas une constante entière"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "l'argument de l'attribut %qE avec la valeur %qE ne fait pas référence à un paramètre de fonction"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "l'attribut %qE a son argument %i avec la valeur %qE qui ne fait pas référence à un paramètre de fonction"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "l'argument de l'attribut %qE a la valeur %qE qui excède le nombre de paramètres %u de la fonction"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "l'attribut %qE a son argument %i dont la valeur %qE excède le nombre de paramètres %u de la fonction"
@@ -35217,12 +35258,12 @@ msgstr "l'attribut de l'argument %qE avec la valeur %qE ne fait pas référence
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "l'attribut %qE qui a l'argument %i avec la valeur %qE ne fait pas référence à une liste d'arguments variable"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "l'argument de l'attribut %qE avec la valeur %qE fait référence au type de paramètre %qT"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "l'attribut %qE qui a l'argument %i avec la valeur %qE fait référence au type de paramètre %qT"
@@ -35430,12 +35471,12 @@ msgstr "impossible d'utiliser le mode %qs pour des types énumérés"
 msgid "mode %qs applied to inappropriate type"
 msgstr "mode %qs appliqué à un type inapproprié"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "les attributs de sections ne sont pas supportés pour cette cible"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "l'attribut de section n'est pas permis pour %q+D"
@@ -35445,18 +35486,18 @@ msgstr "l'attribut de section n'est pas permis pour %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "l'argument de l'attribut de section n'est pas une constante de type chaîne de caractères"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "l'attribut de section ne peut pas être spécifié pour des variables locales"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "la section de %q+D est en conflit avec la déclaration précédente"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "la section de %q+D ne peut pas être contournée"
@@ -35541,7 +35582,7 @@ msgstr "l'argument %<counted_by%> n'est pas un identificateur"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "l'attribut %<counted_by%> %qE est en conflit avec la déclaration précédente %qE"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "la fonction « inline » %q+D est déclarée faible"
@@ -35587,12 +35628,12 @@ msgstr "l'attribut %qE est ignoré car il est défini sur une variable non initi
 msgid "%qE attribute is only applicable on functions"
 msgstr "l'attribut %qE s'applique uniquement aux fonctions"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "l'attribut %<symver%> ne s'applique qu'aux fonctions et aux variables"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "l'attribut %<symver%> s'applique uniquement aux symboles"
@@ -35602,12 +35643,12 @@ msgstr "l'attribut %<symver%> s'applique uniquement aux symboles"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "l'argument de l'attribut %<symver%> n'est pas une constante de chaîne de caractères"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr "l'argument d'attribut symver doit avoir le format %<name@nodename%>"
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr "l'argument de l'attribut %<symver%> %qs doit contenir un ou deux %<@%>"
@@ -35698,23 +35739,23 @@ msgstr "l'attribut %qE est ignoré car %qT est déjà défini"
 msgid "visibility argument not a string"
 msgstr "l'argument de visibilité n'est pas une chaîne"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "l'attribut %qE est ignoré sur les types"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "l'argument de l'attribut %qE doit être %qs, %qs, %qs ou %qs"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD est redéclaré avec une visibilité différente"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD a été déclaré %qs ce qui implique la visibilité par défaut"
@@ -35731,7 +35772,7 @@ msgstr "l'argument %qE doit être %qs, %qs, %qs ou %qs"
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "l'attribut %qE ne s'applique qu'à des fonctions"
@@ -35802,7 +35843,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "l'argument 1 de l'attribut %qE doit prendre un type pointer comme premier argument ; avoir %qT"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "l'attribut %qE est ignoré sur une fonction retournant %qT"
@@ -35877,7 +35918,7 @@ msgstr "%qD n'est pas compatible avec %qD"
 msgid "%qE argument is not a function"
 msgstr "l'argument de %qE n'est pas une fonction"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "le message déprécié n'est pas une chaîne"
@@ -35943,7 +35984,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "l'attribut %qE est ignoré sur les non enum"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "l'attribut %qE requiert une chaîne comme argument"
@@ -36105,15 +36146,15 @@ msgid "requested position is less than zero"
 msgstr "la position demandée est plus petite que zéro"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "chaîne vide dans l'attribut %<target%>"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "l'argument de l'attribut %qE n'est pas une constante de chaîne de caractères"
@@ -36379,7 +36420,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "parenthèses suggérées autour de l'affectation utilisée comme valeur dans une condition"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "usage de %<restrict%> invalide"
@@ -36551,8 +36592,8 @@ msgstr "pas assez d'arguments variables pour insérer une sentinelle"
 msgid "missing sentinel in function call"
 msgstr "sentinelle manquante dans l'appel à la fonction"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "mauvaise option %qs pour l'attribut %<optimize%>"
@@ -37562,7 +37603,7 @@ msgstr "concaténation non standard de chaînes littérales non supportée"
 msgid "traditional C rejects string constant concatenation"
 msgstr "le C traditionnel rejette la concaténation de chaînes constantes"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr "%<#pragma omp critical%> avec la clause %<hint%> requiert un nom sauf quand %<omp_sync_hint_none%> est utilisé"
@@ -37617,7 +37658,7 @@ msgstr "type de dépendance %<depobj%> spécifié dans la clause %<depend%> d'un
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "le modificateur %<iterator%> ne peut pas être spécifié sur une construction %<depobj%>"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "type invalide pour la variable d'itération %qE"
@@ -37632,17 +37673,17 @@ msgstr "variable d'itération %<_Atomic%> %qE"
 msgid "%qE is not initialized"
 msgstr "%qE n'est pas initialisé"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "prédicat de contrôle manquant"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "prédicat de contrôle invalide"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "expression d'incrémentation manquante"
@@ -37652,7 +37693,7 @@ msgstr "expression d'incrémentation manquante"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr "l'incrément n'est pas la constante 1 ou -1 pour la condition %<!=%>"
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "expression d'incrémentation invalide"
@@ -37747,18 +37788,18 @@ msgstr "modificateur de réduction %<task%> invalide sur une construction pas co
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr "clause %<inscan%> %<reduction%> sur une construction autre que %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr "%qD spécifié dans la clause %<allocate%> mais pas dans dans la clause de privatisation explicite"
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD n'est pas un argument de fonction"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "champ de bits %qE dans la clause %qs"
@@ -37768,8 +37809,8 @@ msgstr "champ de bits %qE dans la clause %qs"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE n'a pas un type pour lequel une correspondance peut être établie (mappable type) dans la clause %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%> %qE dans la clause %qs"
@@ -38284,7 +38325,7 @@ msgstr "emplacement invalide pour %<pragma %s%>, ignoré"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "%<#pragma %s%> mal composé, ignoré"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "rebut à la fin de %<#pragma %s%>"
@@ -38356,8 +38397,8 @@ msgstr "fanions de vidange pas gérés ici"
 msgid "wrong type argument to %s"
 msgstr "argument de type erroné pour %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -38843,17 +38884,17 @@ msgstr "décrémentation de la fonction %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "la fonction %qD est utilisée comme sortie %<asm%>"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "affectation de l'emplacement %qE en lecture seule"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "incrémentation de l'emplacement %qE en lecture seule"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "décrémentation de l'emplacement %qE en lecture seule"
@@ -39119,7 +39160,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "passage de l'argument %i aux alias qualifiés avec %qs avec l'argument %Z"
 msgstr[1] "passage de l'argument %i aux alias qualifiés avec %qs avec les arguments %Z"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr "cette condition a des branches identiques"
@@ -40056,7 +40097,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "la fonction ACLE %qD requiert l'extension ISA %qs"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "vous pouvez activer %qs en utilisant l'option %<-march%> sur la ligne de commande ou en utilisant l'attribut ou le pragma %<target%>"
@@ -40685,7 +40726,7 @@ msgstr "passage de %qT à l'argument %d de %qE mais sa forme %qT n'accepte pas d
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "définition dupliquée de %qs"
@@ -40731,7 +40772,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "le type SVE %qT n'a pas un alignement défini"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "les variables de type %qT ne peuvent pas avoir une durée de stockage limitée au thread"
@@ -40782,7 +40823,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "le type SVE %qT n'est pas autorisé dans la clause %<map%>"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr "impossible de faire référence aux types d'objet %qT dans la région %<target%>"
@@ -40875,19 +40916,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "le type SVE %qT ne peut pas être passé en argument à une fonction sans prototype"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr "le passage de paramètre pour l'argument de type %qT a changé dans GCC 13.1"
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr "le passage de paramètre pour l'argument de type %qT a changé dans GCC 14.1"
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -40933,208 +40974,208 @@ msgstr "appel à une fonction qui partage un état autre que %qs depuis une fonc
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr "utilisez %<__arm_preserves(\"za\")%> si l'appelé préserve ZA"
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr "fanion inconnu passé à %<-moverride=%s%> (%s)"
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr "chaîne %qs mal formée"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "format invalide pour %<sve_width%>"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "valeur invalide pour %<sve_width%>: %d"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "chaîne d'ajustement manquante dans l'option (%s)"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "option d'ajustement inconnue (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr "%<-mstack-protector-guard=global%> et %<-mstack-protector-guard-offset=%qs%> incompatibles"
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr "%<-mstack-protector-guard-offset%> et %<-mstack-protector-guard-reg%> doivent être utilisés tous les deux avec %<-mstack-protector-guard=sysreg%>"
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr "spécifie un registre système avec une chaîne de courte longueur"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs n'est pas un décalage valide dans %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr "%<-fsanitize=shadow-call-stack%> requiert %<-ffixed-x18%>"
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "%<-fsanitize=shadow-call-stack%> est en conflit avec l'utilisation du registre x18 par le système d'exploitation cible"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "%<-fsanitize=memtag-stack%> requière l'extension ISA %qs"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "les fonctions de streaming requièrent l'extension ISA %qs"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "les fonctions avec un état SME requièrent l'extension ISA %qs"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr "seules les valeurs 12 (4 ko) et 16 (64 ko) sont supportées pour la taille de garde. La valeur %d donnée (%llu ko) est hors limites"
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr "la taille %<%d%> de la sécurité anti-collision de la pile doit être égale à l'intervalle de sondage %<%d%>"
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "argument invalide donné à %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr "%qs doit être seul pour %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "argument %qs invalide pour %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "l'option %<-mcpu=%s%> est en conflit avec l'option %<-march=%s%> et résulte dans l'ajout des options %qs"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "l'assembleur ne supporte pas %<-mabi=ilp32%>"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%<-mabi=ilp32%> est obsolète"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr "la signature de l'adresse de retour n'est supportée qu'avec %<-mabi=lp64%>"
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr "modèle de code %qs avec %<-f%s%>"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "le modèle de code %qs n'est pas supporté en mode ilp32"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "les fonctions avec l'état %qs requièrent l'extension ISA %qs"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "nom manquant dans le pragma ou l'attribut %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "nom %qs invalide dans le pragma ou l'attribut %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "modificateur de fonctionnalité %s invalide avec la valeur %qs dans le pragma ou l'attribut %<target()%>"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "nom manquant dans le pragma ou l'attribut %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "nom %qs invalide dans le pragma ou l'attribut %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "modificateur de fonctionnalité %qs invalide avec la valeur %qs dans le pragma ou l'attribut %<target()%>"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "nom %qs invalide dans le pragma ou l'attribut %<target(\"tune=\")%>"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "valeur manquante dans le pragma ou l'attribut %<target()%>"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "le pragma ou l'attribut %<target()%> est mal composé"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "le pragma ou l'attribut %<target(\"%s\")%> n'accepte pas d'argument"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "le pragma ou l'attribut %<target(\"%s\")%> n'autorise pas de forme négative"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "le pragma ou l'attribut %<target(\"%s=%s\")%> n'est pas valide"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41142,194 +41183,194 @@ msgstr "le pragma ou l'attribut %<target(\"%s=%s\")%> n'est pas valide"
 msgid "attribute %<target%> argument not a string"
 msgstr "l'argument %<target%> de l'attribut n'est pas une chaîne"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr "l'extension arch %qs devraient être préfixée par %<+%>"
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "le pragma ou l'attribut %<target(\"%s\")%> n'est pas valide"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "le pragma ou l'attribut %<target(\"%s\")%> est mal composé"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "l'attribut %<target_version%> a plusieurs valeurs"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "l'argument %<target_version%> de l'attribut n'est pas une chaîne"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "valeur manquante dans l'attribut %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "modificateur de fonctionnalité %qs invalide de la valeur %qs dans l'attribut %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "modificateur de fonctionnalité %qs dupliqué avec la valeur %qs dans l'attribut %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "des versions multiples de fonctions virtuelles ne sont pas supportées"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "les versions multiples requièrent %<ifunc%> qui n'est pas supporté sur cette cible"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr "%q+D a une valeur de priorité multi-versions de fonction incohérente"
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+D précédemment déclaré ici avec la valeur de priorité %d"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr "le passage de paramètre pour l'argument de type %qT avec des membres %<[[no_unique_address]]%> a changé dans %{GCC 10.1%}"
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr "le passage par paramètre pour l'argument de type %qT quand C++17 est activé a changé pour correspondre à C++14 %{dans GCC 10.1%}"
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr "le passage de paramètre pour l'argument de type %qT a changé dans %{GCC 12.1}%"
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "avenue %wd hors des limites %wd - %wd"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "simdlen %wd non supportée"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "GCC ne supporte actuellement pas le type de retour %qT pour simd"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "type de retour %qT non supporté pour simd"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "GCC ne supporte actuellement pas un argument de type %qT pour simd"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "type d'argument %qT non supporté pour simd"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "GCC ne supporte actuellement pas simdlen %wd pour le type %qT"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "GCC ne supporte actuellement pas un simdclone avec simdlens %wd et %wd pour ces types."
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "impossible d'appliquer l'attribut %qs à %q+D après que la fonction ait été définie"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "%q+D défini ici"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr "goto non locaux dans les fonctions avec l'état SME"
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr "interception des exceptions sans appel dans des fonctions avec l'état SME"
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "l'argument %d de %qE doit être une expression constante entière"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "passage de %wd à l'argument %d de %qE qui attend la valeur %wd"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "passage de %wd à l'argument %d de %qE qui attend une valeur dans la plage [%wd, %wd]"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "passage de %wd à l'argument %d de %qE qui attend soit %wd ou %wd"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "passage de %wd à l'argument %d de %qE qui attend %wd, %wd, %wd ou %wd"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "passage de %wd à l'argument %d de %qE qui attend une valeur %qT valable"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "une chaîne vide n'est pas valide pour une version de %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "modificateur de fonctionnalité %qs invalide dans la version %qB pour l'attribut %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "modificateur de fonctionnalité %qs dupliqué dans la version %qB pour l'attribut %<target_clone%>"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "fonctionnalité %qs invalide dans la version %qB pour l'attribut %<target_clones%>"
 
@@ -41517,12 +41558,12 @@ msgstr "l'argument de l'attribut %qE n'est pas « ilink » ni « firq »"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41655,22 +41696,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "l'argument de l'attribut %qE est ignoré"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "l'attribut %qE ne s'applique qu'aux variables"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "les alternatives ne sont pas autorisées dans la sortie du fanion %<asm%>"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "sortie du fanion %<asm%> %qs inconnue"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "type invalide pour la sortie du fanion %<asm%>"
@@ -42203,12 +42244,12 @@ msgstr "%<-fpie%> n'est pas supporté"
 msgid "%<-fPIE%> is not supported"
 msgstr "%<-fPIE%> n'est pas supporté"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "les attributs de fonction %qs et %qs sont mutuellement exclusifs"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "la fonction avec l'attribut %qs ne peut pas avoir d'argument"
@@ -42218,7 +42259,7 @@ msgstr "la fonction avec l'attribut %qs ne peut pas avoir d'argument"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr "la méthode %qs a un argument %<this%> implicite"
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "la fonction avec l'attribut %qs ne peut pas retourner une valeur"
@@ -42548,7 +42589,7 @@ msgstr "appel indirect dans une fonction, ceci n'est pas supporté par eBPF"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "argument invalide pour la fonction interne"
@@ -42864,7 +42905,7 @@ msgstr "utilisation de %<vector_length (64)%>, %d est ignoré"
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr "utilisation de %<vector_length (64)%>, le paramètre à l'exécution est ignoré"
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr "utilisation de %<num_workers (%d)%>, %d est ignoré"
@@ -43030,168 +43071,168 @@ msgstr "le paramètre à une fonction interne doit être une chaîne sous forme
 msgid "parameter to builtin not valid: %s"
 msgstr "le paramètre à la fonction interne n'est pas valable: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "une routine de service d%'interruption ne peut pas être appelée directement"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 2 bits"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "le cinquième argument doit être une valeur immédiate sur 8 bits"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "le troisième argument doit être une valeur immédiate sur 8 bits"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 1 bit"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 3 bits"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 4 bits"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 1 bit"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr "« %s » a besoin de l'option isa %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 5 bits"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "l'avant dernier argument doit être une valeur immédiate sur 8 bits"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 8 bits"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "le troisième argument doit être une constante de comparaison"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "mode de comparaison incorrect"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "opérande d'arrondi incorrect"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "l'argument immédiat doit être une valeur immédiate sur 4 bits"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "l'argument immédiat doit être une valeur immédiate sur 5 bits"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "l'argument immédiat doit être une valeur immédiate sur 8 bits"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "le quatrième argument doit être de type enum %qs"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "le sélecteur doit être une constante entière dans la plage [0, %wi]"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE a besoin d'une option isa inconnue"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE a besoin de l'option isa %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "les deuxième, troisième et quatrième arguments doivent être des constantes"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "le deuxième argument de %<__builtin_ia32_prefetch%> est invalide; utilisation de zéro"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, gcc-internal-format
 msgid "invalid third argument"
 msgstr "troisième argument invalide"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr "le préchargement des instructions est appliqué en mode 64 bits avec l'adressage relatif à RIP et l'option %<-mprefetchi%> ; il ne fait rien autrement"
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "le quatrième argument de %<__builtin_ia32_prefetch%> est invalide ; utilisation de zéro"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "le troisième argument de %<__builtin_ia32_prefetch%> est invalide ; utilisation de zéro"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "le deuxième argument doit être une constante"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "le dernier argument doit être une valeur immédiate sur 32 bits"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "le dernier argument doit être une valeur immédiate"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "le dernier argument doit être une échelle 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "l'argument de l'intrinsèque %<xabort%> doit être une valeur immédiate sur 8 bits"
@@ -43586,8 +43627,8 @@ msgstr "%qs n'est pas un registre de base valable dans %<-mstack-protector-guard
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr "%<-fcf-protection=full%> n'est pas activé par %<-fhardened%> car il a été spécifié sur la ligne de commande"
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%<-fcf-protection%> n'est pas compatible avec cette cible"
@@ -43829,7 +43870,7 @@ msgstr "l'ABI pour passer une structure possédant un membre %<complex float%> a
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "l'ABI pour passer des structures C avec des champs de bits de largeur zéro a changé dans GCC %{12.1%}"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr "retour d'un registre SSE alors que SSE2 est désactivé"
@@ -43854,12 +43895,12 @@ msgstr "argument dans un registre SSE alors que SSE est désactivé"
 msgid "x87 register return with x87 disabled"
 msgstr "retour d'un registre x87 alors que x87 est désactivé"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "appel de %qD avec la convention d'appel SSE sans avoir activé SSE/SSE2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr "ceci est un bogue de GCC qui peut être contourné en ajoutant l'attribut utilisé à la fonction appelée"
@@ -43869,128 +43910,128 @@ msgstr "ceci est un bogue de GCC qui peut être contourné en ajoutant l'attribu
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "l'ABI pour passer des paramètres avec un alignement de %d octets a changé dans GCC 4.6"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "%<-mcall-ms2sysv-xlogues%> est incompatible avec %s"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "l'attribut %<ms_hook_prologue%> est incompatible avec %<-mfentry%> pour 32 bits"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr "DRAP (Dynamic Realign Argument Pointer) n'est pas supporté dans une routine de service d'interruption. Ceci peut être contourné en évitant les fonctions avec un retour agrégé."
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "Le réalignement de pile n'est pas supporté avec %<__builtin_eh_return%>"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "les fonctions regparm imbriquées ne sont pas supportées avec %<__builtin_eh_return%>"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%<-fsplit-stack%> ne supporte pas fastcall avec des fonctions imbriquées"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "%<-fsplit-stack%> ne supporte pas deux paramètres registres pour une fonction imbriquée"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "%<-fsplit-stack%> ne supporte pas trois paramètres registres"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "les instructions %<-mtls-dialect=gnu2%> doivent être utilisées avec une fonction qui a l'attribut %<no_caller_saved_registers%>"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "%<-mtls-dialect=gnu2%> doit être utilisé avec une routine de service exception"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "%<-mtls-dialect=gnu2%> doit être utilisé avec une routine de service d'interruption"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr "modificateur %<V%> sur un registre non entier"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "taille non supportée pour un registre entier"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "les registres étendus n'ont pas de moitié haute"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "taille d'opérande non supportée pour un registre étendu"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "opérande non entier utilise avec le code d'opérande %<z%>"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "l'ABI de passage de paramètres pour la classe vide %qT change avec %<-fabi-version=12%> (GCC 8)"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "l'alignement des champs de %<_Atomic %T%> ont changé dans %{GCC 11.1%}"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "pas de registre disponible pour profiler %<-mcmodel=large%s%>"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "le profilage %<-mcmodel=large%> avec PIC n'est pas supporté"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr "%<__bfloat16%> est redéfini du typedef %<short%> en un réel %<__bf16%> depuis GCC 13.1, soyez attentif aux conversions implicites entre %<__bf16%> et %<short%>; un transtypage binaire explicite pourrait être nécessaire ici"
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "modèle mémoire spécifique à l'architecture inconnu"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr "%<HLE_ACQUIRE%> n'est pas utilisé avec le modèle mémoire %<ACQUIRE%> ou un autre plus contraignant"
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr "%<HLE_RELEASE%> n'est pas utilisé avec le modèle mémoire %<RELEASE%> ou un autre plus contraignant"
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "%<-fexcess-precision=16%> n'est pas compatible avec %<-mfpmath=387%>"
@@ -44041,7 +44082,7 @@ msgstr "%<gp_offset%> (%ld) ou %<end_offset%> (%ld) est plus petit que zéro"
 msgid "argument %qd is not a constant"
 msgstr "l'argument %qd n'est pas une constante"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr "%<PRINT_OPERAND_ADDRESS%>, pointeur nul"
@@ -44051,7 +44092,7 @@ msgstr "%<PRINT_OPERAND_ADDRESS%>, pointeur nul"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "%<PRINT_OPERAND%>: Ponctuation %<%c%> inconnue"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr "%<PRINT_OPERAND%> pointeur nul"
@@ -44204,48 +44245,48 @@ msgstr "la valeur de pragma ou l'attribut %<target(\"%s\")%> n'est pas vide"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "l'argument %<target%> de l'attribut %qs est inconnu"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "« default » ne peut pas être défini avec d'autres fonctionnalités dans %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "le caractère avant %<;%> dans l'attribut %qs ne peut pas être vide"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr "la priorité ne peut pas être vide dans l'attribut %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr "le nombre de fonctionnalités ne peut pas dépassé deux dans l'attribut %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr "Définir la valeur de la priorité à %qs est illégal dans l'attribut %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr "dans l'attribut %qs, la deuxième fonctionnalité devrait être « priority=%<num%> » au lieu de %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr "dans l'attribut %qs, vous devez définir une valeur légale pour « arch »"
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "l'attribut %qs n'est pas supporté dans %<target_version%> ou %<target_clones%>"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "%qs n'est pas supporté dans l'attribut cible"
@@ -44998,7 +45039,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr "les fonctions internes du MSP430 ne fonctionnent qu'à l'intérieur des gestionnaires d'interruptions"
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "code interne erroné"
@@ -45221,82 +45262,82 @@ msgstr "impossible d'ouvrir le fichier ptx intermédiaire"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "l'option %s n'est pas supportée avec %<-fopenacc%>"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr "la version PTX (%<-mptx%>) doit être au moins %s pour supporter le %<-misa%> demandé (sm_%s)"
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "%<-march=%> doit être spécifié"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "pas de génération de zone de correctif, nops pas supporté"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr "l'initialisation statique de la variable %q+D dans la mémoire %<.shared%> n'est pas supportée"
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr "ne peut produire des pointeurs non alignés dans l'assembleur ptx"
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr "PTX ne supporte pas les déclarations faibles (uniquement les définitions faibles)"
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "l'attribut %qE requiert un type de retour « void »"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "l'attribut %qE n'est pas permis avec une classe de stockage auto"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "la valeur de la barrière doit être dans [0, 15]"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "l'argument de complément doit être une constante"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr "utilisation de %<vector_length (%d)%> à cause de l'appel à la routine vector-partitionable, %d est ignoré"
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr "utilisation de %<vector_length (%d)%>, le paramètre à l'exécution est ignoré"
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr "utilisation de %<vector_length (%d)%>, %d est ignoré"
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr "variable %qD ajustée pour le niveau de privatisation de OpenACC : %qs"
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "les définitions d'alias faibles ne sont pas supportées dans cette configuration"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "les définitions d'alias sur autre chose qu'une fonction ne sont pas supportées dans cette configuration"
@@ -45525,321 +45566,321 @@ msgstr "le mode %s est attendu pour l'opérande %d de l'insn %s mais le mode %s
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "nombre d'opérandes invalides pour l'insn %s, %d attendus mais %d obtenus.\n"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr "passage de %wd à l'argument %d de %qE qui attend une valeur dans la plage [%wd, %wd] ou %wd"
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "le type RVV %qT n'a pas de taille fixe"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "le type RVV %qT n'a pas un alignement défini"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "arithmétique sur un pointeur vers un type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr "les variables membre ne peuvent pas avoir le type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "les champs ne peuvent pas avoir le type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "les éléments de tableau de peuvent pas avoir le type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "ne peut allouer des objets du type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "impossible de supprimer des objets du type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "ne peut lever ou intercepter une exception sur le type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "capture par copie du type RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "le type RVV %qT n'est pas autorisé dans la clause %<map%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "le type RVV %qT n'est pas autorisé dans la clause %<target%> %<private%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "le type RVV %qT n'est pas autorisé dans la clause %<target%> %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "le type RVV %qT n'est pas autorisé dans les clauses de périphérique %<target%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "la fonction interne %qE requiert l'extension ISA zvfbfmin ou zvfbfwma"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "la fonction interne %qE requiert l'extension ISA zvfhmin ou zvfh"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "la fonction interne %qE requiert l'extension ISA zve32f, zve64f, zve64d ou v"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "la fonction interne %qE requiert l'extension ISA zve64d ou v"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "la fonction interne %qE requiert l'extension ISA zve64x, zve64f, zve64d ou v"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "instruction interne RVV non reconnue"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "la fonction interne %qE requiert l'extension ISA %qs"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "pas d'appel de fonction concordant pour %qE avec des arguments vides"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "processeur %qs inconnu pour %<-mtune%>"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "cette opération requiert l'extension de l'ISA RVV"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "vous pouvez activer RVV en utilisant l'option %<-march%> sur la ligne de commande ou en utilisant l'attribut ou le pragma %<target%>"
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "l'ABI pour des structures aplaties avec un champ de bits d'une taille non nulle a changé dans GCC 10"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "l'ABI pour des unions vides aplaties et les tableaux de longueur zéro a changé dans GCC 16"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "le type RVV %qT ne peut pas être passé en argument à une fonction sans prototype"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "%s %qT requiert l'extension ISA V"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT requiert l'extension ISA zve64x, zve64f, zve64d ou v"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "%s %qT requiert l'extension ISA zvfhmin ou zvfh"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT requiert l'extension ISA zve32f, zve64f, zve64d ou v"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "%s %qT requiert l'extension ISA zve64d ou v"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr "%s %qT requiert la longueur de vecteur minimale %qd mais %qd est fourni"
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "l'attribut de fonction %qs requiert l'extension ISA V"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr "valeur de %<ABI_VLEN%> %d non supportée pour l'attribut %qs ; %<ABI_VLEN%> doit être dans la plage [32, 16384] et doit être une puissance de 2"
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "l'attribut de fonction %qs requiert l'extension ISA vectorielle"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "l'attribut « rnmi » requiert l'extension ISA Smrnmi"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "l'argument de l'attribut %qE n'est pas %<\"supervisor\"%>, %<\"machine\"%> ou %<\"rnmi\"%>"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr "%qs est uniquement supporté quand %<-mrvv-vector-bits=zvl%> est spécifié"
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qs appliqué au type non-RVV %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "%qs requiert une constante entière"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr "talle de vecteur RVV %qd invalide, la taille attendue est %qd sur base du LMUL de type %qs"
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr "%<-mdiv%> requiert %<-march%> pour incorporer l'extension %<M%>"
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "Actuellement, l'implémentation %<V%> requiert l'extension %<M%>"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr "Le GCC RISC-V actuel ne supporte pas un VLEN plus grand que 4096 bits pour l'extension « V »"
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "Le GCC RISC-V actuel ne supporte pas RVV en mode gros boutiste"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "modèle de code %qs avec %qs"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr "l'ABI demandée requiert %<-march%> pour incorporer l'extension %qc"
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr "rv32e requiert l'ABI ilp32e"
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr "rv64e requiert l'ABI lp64e"
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, gcc-internal-format
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "l'ABI ILP32E ne supporte pas l'extension %qc"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr "L'ABI LP64E est marquée comme dépréciée dans GCC"
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr "si vous avez besoin de LP64E, notifiez le projet GCC via %{PR116152%}"
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr "z*inx requiert l'ABI ilp32, ilp32e, lp64 ou lp64e"
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "l'ABI requiert %<-march=rv%d%>"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "%<-mpreferred-stack-boundary=%d%> doit être entre %d et %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr "l'attribut RISC-V ELF %<-mriscv-attribute%> requiert GNU as 2.32 [%<-mriscv-attribute%>]"
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs n'est pas un registre de base valable dans %qs"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs n'est pas un nombre valide dans %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "la fonction %qs ne peut pas avoir un type d'interruption différent"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr "impossible d'allouer le registre vl pour %qs sur cette cible"
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "version %qB invalide pour l'attribut %<target_clones%>"
 
@@ -46836,22 +46877,22 @@ msgstr "les exigences en mémoire pour les variables locales excèdent la capaci
 msgid "%<function_profiler%> support"
 msgstr "support de %<function_profiler%>"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "ne peut utiliser %<va_start%> dans une fonction d'interruption"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "l'instruction « switch » d'une taille de %lu entrées est trop grande"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "l'attribut %<__BELOW100__%> s'applique uniquement aux variables"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "l'attribut %<__BELOW100__%> n'est pas autorisé avec la classe de stockage « auto »"
@@ -47071,32 +47112,32 @@ msgstr "%qs est chargée mais le symbole %qs n'est pas trouvé : %s"
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%qs est défini mais le support des greffons est désactivé"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "registres booléens requis pour l'option de virgule flottante"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "%<-f%s%> n'est pas supporté avec les instructions CONST16"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC est requis mais non supporté avec des instructions CONST16"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "seules les variables non initialisées peuvent être placées dans une section %<.bss%>"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr "constantsynth: dans la méthode %qs, séquence d'instructions invalide, attendu %wd (%wx)"
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr "constantsynth: méthode %qs, désaccord de valeur, attendu %wd (%wx) synthétisé %wd (%wx)"
@@ -47182,7 +47223,7 @@ msgstr "l'attribut %qs requiert des prototypes avec des arguments nommés"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "l'attribut %qs s’applique seulement aux fonctions variadiques"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47263,8 +47304,8 @@ msgstr "le fichier spécifié %s est un répertoire"
 msgid "could not get size of source file"
 msgstr "n'a pu obtenir la taille du fichier source"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "la valeur void n'a pas été ignorée comme elle aurait dû l'être"
@@ -47742,7 +47783,7 @@ msgstr "le « switch » saute dans l'expression d'une instruction"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE est défini comme un mauvais type de balise"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "attribut %qE appliqué à %qD avec un type de retour void"
@@ -47891,7 +47932,7 @@ msgstr "le C90 ISO ne supporte pas %<static%> ou les qualificatifs de types dans
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "le C90 ISO ne supporte pas %<[*]%> dans les déclarateurs de tableau"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "%<omp::%s%> ne peut pas être spécifié dans ce contexte"
@@ -47901,7 +47942,7 @@ msgstr "%<omp::%s%> ne peut pas être spécifié dans ce contexte"
 msgid "%q+D is usually a function"
 msgstr "%q+D est habituellement une fonction"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "aucune déclaration précédente pour %qD"
@@ -47977,7 +48018,7 @@ msgstr "impossible de mettre un objet avec un champ volatile dans un registre"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "%<const %qD%> non initialisé est invalide en C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%q+D dans la directive de déclaration de cible n'a pas de type pour lequel une correspondance peut être établie (mappable type)"
@@ -48177,7 +48218,7 @@ msgstr "classe de stockage spécifiée pour le paramètre %qE"
 msgid "storage class specified for unnamed parameter"
 msgstr "classe de stockage spécifiée pour le paramètre sans nom"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "classe de stockage spécifiée pour un typename"
@@ -48350,7 +48391,7 @@ msgstr "nom de type déclaré comme une fonction retournant un tableau"
 msgid "function definition has qualified void return type"
 msgstr "la définition de la fonction a un type de retour « void » qualifié"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "les qualificatifs de type sont ignorés sur le type retourné par la fonction"
@@ -48477,7 +48518,7 @@ msgstr "le C ISO interdit les fonctions de type volatile ou constante"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "un membre d'une structure ou d'une union ne peut pas avoir de type modifié par une variable"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "variable ou champ %qE déclaré « void »"
@@ -48690,7 +48731,7 @@ msgstr "définir le type dans l'expression %qs est invalide en C++"
 msgid "%qT defined in underspecified object initializer"
 msgstr "%qT est défini dans l'initialiseur de l'objet sous-spécifié"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "la déclaration ne déclare rien du tout"
@@ -48755,7 +48796,7 @@ msgstr "la structure n'a aucun membre nommé"
 msgid "struct has no members"
 msgstr "la structure n'a aucun membre"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "un membre de tableau flexible dans une union est une extension de GCC"
@@ -48820,7 +48861,7 @@ msgstr "redéclaration de %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr "%<enum%> déclaré avec mais défini sans type sous-jacent fixe"
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr "le mode spécifié est trop petit pour les valeurs énumérées"
@@ -48875,7 +48916,7 @@ msgstr "la valeur de l'énumération est en dehors de la plage de %qs"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "le C ISO restreint les valeurs de l'énumérateur à la plage d'un %<int%> avant C23"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "la fonction à mettre en ligne %qD a reçu l'attribut %qs"
@@ -49025,12 +49066,12 @@ msgstr "l'argument %qD ne concorde pas avec le prototype interne"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "l'argument %qD ne concorde pas avec le prototype"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "« return » manquant dans une fonction devant retourner une valeur"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "le paramètre %qD est défini mais pas utilisé"
@@ -49112,7 +49153,7 @@ msgstr "%<auto%> utilisé avec %<constexpr%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "deux types de données ou plus dans le spécificateur de déclaration"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> est trop long pour GCC"
@@ -49216,7 +49257,7 @@ msgstr "le C90 ISO ne supporte pas les types booléens"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "le C ISO ne supporte pas le type %<_Float%d%s%> avant C23"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<_Float%d%s%> n'est pas supporté sur cette cible"
@@ -49373,12 +49414,12 @@ msgstr "l'argument de %<signed _BitInt%> doit être au moins 2"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "le C ISO ne supporte pas %<%s_BitInt(%d)%> avant C23"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr "le combinateur %<#pragma omp declare reduction%> fait référence à la variable %qD qui n'est ni %<omp_out%> ni %<omp_in%>"
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr "l'initialiseur %<#pragma omp declare reduction%> fait référence à la variable %qD qui n'est ni %<omp_priv%> ni %<omp_orig%>"
@@ -49438,37 +49479,37 @@ msgstr "l'instruction %<break%> à l'opérande %qE qui fait référence à %<swi
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs est un mot-clé avec %qs à partir de là"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "décalage vers la gauche d'une valeur négative"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "le compteur de décalages vers la gauche est négatif"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "le compteur de décalages vers la droite est négatif"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "compteur de décalages vers la gauche >= à la largeur du type"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "compteur de décalages vers la droite >= à la largeur du type"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "compteur de décalages vers la gauche >= à la largeur de l'élément du vecteur"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "compteur de décalages vers la droite >= à la largeur de l'élément du vecteur"
@@ -49488,7 +49529,7 @@ msgstr "marqueur de conflit de contrôle de version dans le fichier"
 msgid "to match this %qs"
 msgstr "pour correspondre à ce %qs"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "fin de ligne attendue"
@@ -49498,7 +49539,7 @@ msgstr "fin de ligne attendue"
 msgid "ISO C forbids an empty translation unit"
 msgstr "le C ISO interdit une unité de traduction vide"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49545,8 +49586,8 @@ msgid "unknown type name %qE"
 msgstr "nom de type %qE inconnu"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "spécificateurs de déclaration attendus"
@@ -49581,7 +49622,7 @@ msgstr "attribut %<musttail%> mélangé avec d'autres attributs sur l'instructio
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "%<;%>, identificateur ou %<(%> attendu"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "les attributs de préfixes sont ignorés pour les méthodes"
@@ -49596,12 +49637,12 @@ msgstr "les attributs de préfixes sont ignorés pour les implémentations"
 msgid "unexpected attribute"
 msgstr "attribut inattendu"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "l'attribut %<fallthrough%> n'est pas suivi par %<;%>"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "l'attribut %<assume%> n'est pas suivi par %<;%>"
@@ -49644,7 +49685,7 @@ msgstr "%qs requiert une déclaration de donnée initialisée"
 msgid "%qs may only be used with a single declarator"
 msgstr "%qs peut uniquement être utilisé avec un seul déclarateur"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "%<,%> ou %<;%> attendu"
@@ -49678,7 +49719,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "la fonction %<__GIMPLE%> ne peut pas être une fonction imbriquée"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "chaîne littérale attendue"
@@ -49708,7 +49749,7 @@ msgstr "l'expression dans l'assertion statique n'est pas une constante"
 msgid "static assertion failed: %E"
 msgstr "échec de l'assertion statique: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "l'assertion statique a échoué"
@@ -49762,8 +49803,8 @@ msgstr "impossible d'utiliser le mot-clé %qs comme constante d'une énumératio
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "identificateur attendu"
@@ -49793,12 +49834,12 @@ msgstr "type sous-jacent invalide pour %<enum%>"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "type sous-jacent de %<enum%> incompatible avec la déclaration précédente"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "virgule à la fin de la liste d'énumerateurs"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -49879,22 +49920,22 @@ msgstr "spécificateurs de déclaration ou %<...%> attendu"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "les parenthèses doivent être omises si la liste des arguments de l'attribut est vide"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "nom de directive OpenMP attendu"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "%<directive%> ou %<sequence%> attendu"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "l'attribut %<omp::%E%> requiert un argument"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "l'attribut %qE ne prend pas d'argument"
@@ -49904,7 +49945,7 @@ msgstr "l'attribut %qE ne prend pas d'argument"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "le C ISO ne supporte pas les attributs %<[[]]%> avant C23"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr "un objet de taille variable ne peut pas être initialisé excepté avec un initialiseur vide"
@@ -49934,17 +49975,17 @@ msgstr "le C90 ISO interdit de spécifier des sous-objets à initialiser"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "utilisation obsolète d'une initialisation désignée sans %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "les boucles internes doivent être parfaitement imbriquées dans %<#pragma acc loop%>"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "les boucles internes doivent être parfaitement imbriquées avec la clause %<ordered%>"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr "les boucles internes doivent être parfaitement imbriquées avec la clause %<reduction%> %<inscan%>"
@@ -49954,44 +49995,44 @@ msgstr "les boucles internes doivent être parfaitement imbriquées avec la clau
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr "les boucles internes doivent être parfaitement imbriquées dans %<#pragma omp tile%>"
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr "mélange de directives OpenMP avec des attributs et la syntaxe pragma sur la même instruction"
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr "attribut OpenMP %<omp::decl%> sur une instruction"
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "nom de directive OpenMP inconnue dans l'argument de l'attribut %qs"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr "la construction OpenMP au milieu des attributs %<omp::directive%> requiert que tous les attributs %<omp::directive%> sur la même instruction soient dans le même %<omp::sequence%>"
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr "plusieurs directives OpenMP autonomes au milieu d'attributs %<omp::directive%> doivent toutes être dans le même %<omp::sequence%>"
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr "les directives OpenMP autonomes dans l'attribut %<omp::directive%> peuvent uniquement apparaître dans une instruction vide"
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr "mélange de directives OpenMP avec un attribut et la syntaxe pragma dans la même déclaration"
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "l'attribut %qs ne prend pas d'argument"
@@ -50022,7 +50063,7 @@ msgstr "le C90 ISO interdit les mélanges de déclarations et de code"
 msgid "expected %<}%> before %<else%>"
 msgstr "%<}%> attendu avant %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> sans %<if%> précédent"
@@ -50037,7 +50078,7 @@ msgstr "étiquette à la fin d'une déclaration composée"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "instruction attendue"
@@ -50072,27 +50113,27 @@ msgstr "le C ISO ne supporte pas les déclarations « if » avant C2Y"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "la déclaration dans l'expression contrôlante doit avoir un initiliseur"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "déclaration attendue"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "accolades suggérées autour du corps vide d'une instruction %<if%>"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "accolades suggérées autour du corps vide d'une instruction %<else%>"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "des accolades explicites sont suggérées pour éviter toute ambiguïté sur le %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr "boucle par permise dans le code intervenant dans le corps d'une boucle OpenMP"
@@ -50112,12 +50153,12 @@ msgstr "variables d'itération multiples dans l'énumération rapide"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "variable d'itération invalide dans l'énumération rapide"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr "condition de boucle manquante dans la boucle avec le pragma %<GCC ivdep%>"
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr "condition de boucle manquante dans la boucle avec le pragma %<GCC unroll%>"
@@ -50132,8 +50173,8 @@ msgstr "collection manquante dans l'énumération rapide"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "qualificatif %<asm%> %qE dupliqué"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr "vu pour la première fois ici"
@@ -50155,12 +50196,12 @@ msgstr "le C ISO interdit l'omission du terme central de l'expression %<?:%>"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr "la division %<sizeof (%T) / sizeof (%T)%> ne calcule pas le nombre d'éléments dans le tableau"
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "le premier opérande %<sizeof%> a été déclaré ici"
@@ -50332,7 +50373,7 @@ msgstr "le C90 ISO ne supporte pas l'identificateur prédéfini %<__func__%>"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "expression attendue"
@@ -50347,12 +50388,12 @@ msgstr "un groupe entre accolades à l'intérieur d'une expression n'est permis
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "le C ISO interdit les groupes entre accolades à l'intérieur d'expressions"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "le deuxième paramètre optionnel de %<va_start%> n'est pas le dernier argument nommé"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr "la macro %<va_start%> est utilisée avec des arguments supplémentaires autres que l'identificateur du dernier argument nommé"
@@ -50497,7 +50538,7 @@ msgstr "l'argument de %<__builtin_counted_by_ref%> doit être un tableau ou un p
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "l'argument de %<__builtin_counted_by_ref%> doit être un champ ou une structure"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "mauvais nombre d'arguments pour %<__builtin_shuffle%>"
@@ -50537,7 +50578,7 @@ msgstr "l'argument 1 dans l'appel à la fonction %qs a le type %<char%>"
 msgid "rotate count is negative"
 msgstr "le compteur de rotations est négatif"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr "%<omp_all_memory%> peut uniquement être utilisé dans la clause OpenMP %<depend%>"
@@ -50647,7 +50688,7 @@ msgstr "utilisation de la fonction %qD d'une valeur absolue décimale en virgule
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr "la fonction de valeur absolue %qD reçoit un argument de type %qT mais elle a un paramètre de type %qT qui peut produire une valeur tronquée"
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr "les appels à l'API d'exécution de OpenMP ne sont pas permises dans du code intervenant"
@@ -50687,12 +50728,12 @@ msgstr "une déclaration de méthode objective-c est attendue"
 msgid "no type or storage class may be specified here,"
 msgstr "aucun type ni classe de stockage ne peut être spécifié ici,"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "liste d'attributs de propriété vide"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, gcc-internal-format
 msgid "missing property attribute"
 msgstr "attribut de propriété manquant"
@@ -50702,57 +50743,57 @@ msgstr "attribut de propriété manquant"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "attribut de propriété %<%s%s%> inconnu"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "attribut de propriété inconnu"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "%<=%> attendu après Objective-C %qE"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "nom de sélecteur %qE attendu"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "les noms des méthodes « setter » doivent être terminés par %<:%>"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr "%<#pragma GCC unroll%> requiert une expression d'affectation qui est évaluée en une constante entière non négative plus petite que %u"
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr "du code intervenant ne peut pas contenir des directives OpenMP exécutables"
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma %s%> ne peut être utilisé que dans des instructions composées"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> doit être dans la portée au niveau du fichier"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp scan%> ne peut être utilisé que dans une construction de boucle avec la clause %<inscan%> %<reduction%>"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> ne peut être utilisé que dans une construction %<#pragma omp sections%>"
@@ -50762,12 +50803,12 @@ msgstr "%<#pragma omp section%> ne peut être utilisé que dans une construction
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma %s%> peut uniquement être utilisé dans la portée du fichier"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "instruction « for », « while » ou « do » attendue"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> doit être le premier"
@@ -50777,11 +50818,11 @@ msgstr "%<#pragma GCC pch_preprocess%> doit être le premier"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "trop de clauses %qs"
@@ -50796,58 +50837,58 @@ msgstr "l'expression doit être fondamentale"
 msgid "%qD is not a variable"
 msgstr "%qD n'est pas une variable"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD n'est pas une variable pointeur"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "l'argument « collapse » a besoin d'une expression entière constante positive"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "%<none%> ou %<present%> attendu"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "%<none%>, %<shared%>, %<private%> ou %<firstprivate%> attendu"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "expression logique constante attendue"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "%<data%>, %<update%>, %<enter%> ou %<exit%> attendu"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "%<data%> attendu"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "trop de %<if%> avec le modificateur %qs"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "trop de clauses %<if%>"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "trop de clauses %<if%> sans modificateur"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr "si une clause %<if%> a un modificateur, alors toutes les clauses %<if%> doivent utiliser un modificateur"
@@ -50870,22 +50911,22 @@ msgstr "la valeur de %<num_threads%> doit être positive"
 msgid "%<num_tasks%> value must be positive"
 msgstr "la valeur de %<num_tasks%> doit être positive"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "la valeur de %<grainsize%> doit être positive"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "la valeur de %<priority%> doit être positive ou nulle"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "expression entière constante attendue avec une valeur sync-hint valide"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "%<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> ou %<default%> attendu"
@@ -50895,99 +50936,99 @@ msgstr "%<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> ou %
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "%<scalar%>, %<aggregate%>, %<pointer%> ou %<all%> attendu"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "trop de clauses %<defaultmap%> avec la catégorie %qs"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "trop de clauses %<defaultmap%> avec une catégorie non spécifiée"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "l'expression %qs doit être un entier"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "la valeur de %qs doit être positive"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "trop d'arguments pour %<static%>"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "argument inattendu"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "l'argument %<tile%> a besoin d'une constante entière positive"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "trop de clauses %<self%>"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "%<reproducible%> ou %<unconstrained%%> attendu"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "%<concurrent%> attendu"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "%<team%>, %<parallel%> ou %<thread%> attendu"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "les arguments ordonnés ont besoin d'une expression entière constante positive"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr "l'opérateur %<-%> pour les réductions est déprécié dans OpenMP 5.2"
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "%<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> ou identificateur attendu"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "les deux modificateurs %<monotonic%> et %<nonmonotonic%> sont spécifiés"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "schedule %<runtime%> ne prend pas de paramètre %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "schedule %<auto%> ne prend pas de paramètre %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "la taille du fragment doit être positive"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "type d'ordonnancement invalide"
@@ -50997,38 +51038,38 @@ msgstr "type d'ordonnancement invalide"
 msgid "%<num_teams%> value must be positive"
 msgstr "la valeur de %<num_teams%> doit être positive"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr "la borne inférieure %<num_teams%> %qE est plus grande que la borne supérieure %qE"
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "la valeur de %<thread_limit%> doit être positive"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "l'expression d'alignement %<aligned%> doit être une expression entière constante positive"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "%<allocator%> ou %<align%> attendu"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr "modificateur %qs dupliqué"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr "l'expression d'allocation de la clause %<allocate%> a le type %qT plutôt que %<omp_allocator_handle_t%>"
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "dans la clause %<allocate%>, l'argument du modificateur %<align%> doit être une expression entière constante positive qui est une puissance de deux"
@@ -51043,22 +51084,22 @@ msgstr "%<traits%> ou %<memspace%> attendu"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr "la syntaxe de trait historique %<%s(%s)%> n'est pas permise dans la clause %<uses_allocators%> en utilisant des modificateurs"
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr "la spécifications d'arguments à %<uses_allocators%> où chaque élément a la forme %<allocator(traits)%> est dépréciée depuis OpenMP 5.2"
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr "la clause %<uses_allocators%> n'accepte qu'un seul allocateur lorsque des modificateurs sont utilisés"
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "modificateurs linéaires multiples"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "modificateurs %<step%> multiples"
@@ -51068,7 +51109,7 @@ msgstr "modificateurs %<step%> multiples"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "l'expression du pas de %<linear%> doit être fondamentale"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr "spécifier la liste des éléments comme arguments des modificateurs est déprécié depuis OpenMP 5.2"
@@ -51083,311 +51124,311 @@ msgstr "l'expression %<safelen%> doit être une expression entière constante po
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "l'expression %<simdlen%> doit être une expression entière constante positive"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr "le modificateur %<sink%> avec la clause %<depend%> est déprécié depuis OpenMP 5.2, utilisé avec %<doacross%>"
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr "le modificateur %<source%> avec la clause %<depend%> est déprécié depuis OpenMP 5.2, utilisé avec %<doacross%>"
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "le modificateur %<iterator%> est incompatible avec %qs"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "type de « depend » invalide"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "type de « doacross » invalide"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "modificateur %<fallback%> attendu"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "%<abort%>, %<default_mem%> ou %<null%> attendus comme mode de repli"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "la valeur de %<dyn_groupprivate%> doit être positive ou nulle"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr "virgule illégale"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "trop de modificateurs %<always%>"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "trop de modificateurs %<close%>"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr "trop de modificateurs %<iterator%>"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr "trop de modificateurs %<mapper%>"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr "dans la directive %<declare mapper%>, le paramètre du modificateur %<mapper%> doit être %<default%>"
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr "identificateur ou %<default%> attendu"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "trop de modificateurs %<present%>"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "clause %<map%> avec un modificateur de type map autre que %<always%>, %<close%>, %<iterator%>, %<mapper%> ou %<present%>"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr "modificateurs de clause %<map%> sans virgule de séparation est déprécié depuis OpenMP 5.2"
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "type de « map » invalide"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr "le modificateur de périphérique %<ancestor%> pas précédé de la directive %<requires%> avec la clause %<reverse_offload%>"
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "%<ancestor%> ou %<device_num%> attendu"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "l'expression de la clause %<device%> doit être évaluée à %<1%>"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "type de « dist_schedule » invalide"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr "l'affinité %<master%> est dépréciée depuis OpenMP 5.1, utilisez %<primary%>"
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "type de « proc_bind » invalide"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "%<host%>, %<nohost%> ou %<any%> attendu"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "clause %qs avec un modificateur autre que %<iterator%> ou %<present%>"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "l'argument de %<partial%> a besoin d'une expression entière constante positive"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr "le gestionnaire d'événement de la clause %<detach%> a le type %qT plutôt que %<omp_event_handle_t%>"
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr "le littéral de chaîne de caractères ne peut pas contenir %<\\0%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "identificateur d'exécution étranger %qs inconnu"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "littéral de chaîne ou expression entière constante attendu"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr "identificateur d'exécution étranger %qwd inconnu"
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "sélecteur de préférence %<fr%> ou %<attr%> attendu"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr "sélecteur de préférence %<fr%> dupliquée"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr "le littéral de chaîne %<attr%> doit commencer par %<ompx_%>"
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr "le littéral de chaîne %<attr%> ne peut pas contenir de virgule"
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr "chaîne littérale non vide attendue"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "modificateur %<targetsync%> dupliqué"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "modificateur %<target%> dupliqué"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "modificateur %<prefer_type%> dupliqué"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "%<prefer_type%>, %<target%> ou %<targetsync%> attendu"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr "le modificateur %<target%> ou %<targetsync%> requis est manquant"
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "clause OpenACC attendue"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs n'est pas valide pour %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr "les clauses dans un trait %<simd%> devraient être séparées par des %<,%>"
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs doit être la première clause de %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr "la clause %<to%> avec %<declare target%> est dépréciée depuis OpenMP 5.2, utilisez %<enter%>"
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "clause OpenMP attendue"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "pas de clause valide spécifiée dans %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "section de tableau dans %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "%qD doit être une variable globale dans %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "clause OpenACC invalide au niveau global du fichier"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "utilisation invalide de la variable %<extern%> %qD dans %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "utilisation invalide de la variable %<global%> %qD dans %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "%qD doit être une variable déclarée dans la même portée que %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "variable %qD utilisée plus d'une fois avec %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "%<data%> attendu après %<#pragma acc %s%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma acc %s data%> n'a pas clause de mouvement de données"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr "la construction %<host_data%> requiert la clause %<use_device%>"
@@ -51402,7 +51443,7 @@ msgstr "%qE n'a pas été déclaré"
 msgid "expected function name"
 msgstr "nom de fonction attendu"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD ne fait pas référence à une fonction"
@@ -51412,22 +51453,22 @@ msgstr "%qD ne fait pas référence à une fonction"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma acc routine%> n'est pas immédiatement suivi d'une déclaration ou d'une définition de fonction"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma acc routine%> n'est pas immédiatement suivi d'une seule déclaration ou définition de fonction"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> doit être appliqué avant l'utilisation"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> doit être appliqué avant la définition"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> doit contenir au moins une clause %<device%> ou %<host%> ou %<self%>"
@@ -51452,7 +51493,7 @@ msgstr "la variable %qD utilisée dans la clause %<allocator%> ne peut pas être
 msgid "modified here"
 msgstr "modifié ici"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "l'argument de la clause %<align%> doit être une expression de constante entière positive qui est une puissance de deux"
@@ -51487,110 +51528,110 @@ msgstr "clause %<allocator%> requise pour la variable statique %qD"
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr "la clause %<allocator%> requiert un allocateur prédéfini car %qD est statique"
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "clause %<read%>, %<write%>,  %<update%> ou %<capture%> attendue"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "%<seq_cst%>, %<acquire%> ou %<relaxed%> attendu"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "clause %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> ou %<hint%> attendue"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "trop de clauses atomiques"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "trop de clauses d'ordre de mémoire"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "la clause %qs est incompatible avec les clauses %<read%> ou %<write%>"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "la clause %qs requiert la clause %qs"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic write%> est incompatible avec la clause %<acquire%> fournie implicitement par une directive %<requires%>"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic read%> est incompatible avec la clause %<release%> fournie implicitement par une directive %<requires%>"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp atomic read%> est incompatible avec la clause %<release%>"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp atomic write%> est incompatible avec la clause %<acquire%>"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "la comparaison %<==%> est attendue dans la condition %<if%>"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr "la comparaison %<==%>, %<<%> ou %<>%> est attendue dans la condition %<if%>"
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "forme invalide de %<#pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "%<else%> attendu"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "forme invalide de %<pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "forme invalide de %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "opération invalide pour %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr "la clause %<weak%> requiert une comparaison d'égalité atomique"
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> utilise deux expressions différentes pour la mémoire"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "l'expression %<depobj%> n'est pas une expression l-valeur"
@@ -51600,27 +51641,27 @@ msgstr "l'expression %<depobj%> n'est pas une expression l-valeur"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "l'expression %<destroy%> n'est pas une expression l-valeur"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr "l'expression %<destroy%> %qE devrait être la même que l'argument %<depobj%> %qE"
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "%<in%>, %<out%>, %<inout%>, %<mutexinoutset%> ou %<inoutset%> attendu"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "clause %<depend%>, %<destroy%> ou %<update%> attendue"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "%<seq_cst%>, %<acq_rel%>, %<release%> ou %<acquire%> attendu"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr "liste %<flush%> spécifiée avec une clause d'ordre de mémoire"
@@ -51630,32 +51671,32 @@ msgstr "liste %<flush%> spécifiée avec une clause d'ordre de mémoire"
 msgid "expected %<(%> or end of line"
 msgstr "%<(%> ou fin de ligne attendue"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr "%<[[omp::directive(%s)]]%> doit être le seul attribut spécifié dans une instruction"
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp scan%> avec zéro instruction exécutable précédente"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "%<inclusive%> ou %<exclusive%> attendu"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "%<#pragma omp scan%> attendu"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp scan%> avec zéro instruction exécutable suivante"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "instruction « for » attendue"
@@ -51663,68 +51704,68 @@ msgstr "instruction « for » attendue"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, gcc-internal-format
 msgid "loop nest expected"
 msgstr "imbrication de boucles inattendue"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr "les attributs autres que les directives OpenMP ne sont pas permises avec les imbrications de boucles %<for%>"
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr "la construction %<unroll%> avec la clause %<partial%> génère une seule boucle avec la forme canonique mais %d boucles sont nécessaires"
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr "la boucle générée par la construction %<unroll%> avec la clause %<partial%> n'a pas la forme canonique"
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr "la construction %<tile%> génère %d boucles avec la forme canonique mais %d boucles sont nécessaires"
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr "boucle %<for%> ou construction de transformation de boucle OpenMP attendue"
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "déclaration ou initialisation d'itération attendue"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "pas assez de boucles imbriquées"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "le paramètre de la clause %<ordered%> est plus petit que %<collapse%>"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "la variable d'itération %qD ne devrait pas être « firstprivate »"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr "la construction %<master%> est dépréciée depuis OpenMP 5.1, utilisez %<masked%>"
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp ordered%> avec la clause %qs ne peut être utilisé qu'avec des instructions composées"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "%<for%> attendu après %qs"
@@ -51734,7 +51775,7 @@ msgstr "%<for%> attendu après %qs"
 msgid "expected a function name"
 msgstr "nom de fonction attendu"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, gcc-internal-format
 msgid "expected target-function call"
 msgstr "appel de fonction cible attendu"
@@ -51744,47 +51785,47 @@ msgstr "appel de fonction cible attendu"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma omp dispatch%> doit être suivi d'un appel de fonction avec une assignation optionnelle"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "%<point%> attendu"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target data%> avec un type avec correspondance autre que %<to%>, %<from%>, %<tofrom%> ou %<alloc%> sur un clause %<map%>"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp target data%> doit contenir au moins une clause %<map%>, %<use_device_ptr%> ou %<use_device_addr%>"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp target update%> doit contenir au moins une clause %<from%> ou %<to%>"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target enter data%> avec un type avec correspondance autre que %<to%>, %<tofrom%> ou %<alloc%> sur une clause %<map%>"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target enter data%> doit contenir au moins une clause %<map%>"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp target exit data%> avec un type « map » autre que %<from%>, %<tofrom%>, %<release%> ou %<delete%> sur une clause %<map%>"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target exit data%> doit contenir au moins une clause %<map%>"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target%> avec un type avec correspondance autre que %<to%>, %<from%>, %<tofrom%> ou %<alloc%> sur une clause %<map%>"
@@ -51799,57 +51840,57 @@ msgstr "%<#pragma omp declare %s%> doit être suivi d'une déclaration ou une d
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> doit être suivi d'une déclaration ou une définition de fonction"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "nom de sélecteur de trait attendu"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "sélecteur %qs inconnu pour l'ensemble %qs du sélecteur de contexte"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "le sélecteur %qs n'accepte aucune propriété"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<score%> ne peut pas être spécifié dans les traits dans le trait-selector-set %qs"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "l'argument %<score%> doit être une expression entière constante"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "l'argument %<score%> doit être non négatif"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "identificateur ou chaîne littérale attendus"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "la propriété doit être une expression entière"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "les propriétés pour le sélecteur %<simd%> ne peuvent pas être spécifiées dans %<metadirective%>"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "le sélecteur %<requires%> n'est pas encore supportée"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "nom de l'ensemble du sélecteur de contexte attendu"
@@ -51859,27 +51900,27 @@ msgstr "nom de l'ensemble du sélecteur de contexte attendu"
 msgid "variant %qD is not a function"
 msgstr "la variante %qD n'est pas une fonction"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr "la variante %qD est interne"
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "la variante %qD est la même que la fonction de base"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "clause %<match%>, %<adjust_args%> ou %<append_args%> attendue"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "trop de clauses %<match%>"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "%qD est spécifié plus d'une fois"
@@ -51889,7 +51930,7 @@ msgstr "%qD est spécifié plus d'une fois"
 msgid "%qD is not of pointer type"
 msgstr "%qD n'est pas un type pointeur"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "%<nothing%> ou %<need_device_ptr%> attendu"
@@ -51899,17 +51940,17 @@ msgstr "%<nothing%> ou %<need_device_ptr%> attendu"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%<need_device_addr%> n'est pas valide pour le C"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "%<nothing%> ou %<need_device_ptr%> suivi par %<:%> attendu"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "%<interop%> attendu"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "clause %<match%> attendue"
@@ -51929,12 +51970,12 @@ msgstr "%<append_args%> avec une fonction de base sans prototype n'est pas encor
 msgid "base function %qD declared here"
 msgstr "la fonction de base %qD est déclarée ici"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "l'argument %d de %qD doit être du type %<omp_interop_t%>"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "%<append_args%> spécifié ici"
@@ -51944,7 +51985,7 @@ msgstr "%<append_args%> spécifié ici"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "la variante %qD et la base %qD ont des types incompatibles après l'ajustement de %<append_args%>"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "le variant %qD et la base %qD ont des types incompatibles"
@@ -51954,7 +51995,7 @@ msgstr "le variant %qD et la base %qD ont des types incompatibles"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma omp declare %s%> pas immédiatement suivi d'une déclaration ou une définition de fonction"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma omp declare %s%> pas immédiatement suivi par une seule déclaration ou définition de fonction"
@@ -51969,84 +52010,84 @@ msgstr "%<#pragma omp declare %s%> ne peut pas être utilisé avec plusieurs ver
 msgid "no declaration of base function %qs"
 msgstr "aucune déclaration de la fonction de base %qs"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "la définition de la fonction variante ne correspond pas à la déclaration de %qE"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr "l'utilisation de %<omp declare target%> comme synonyme de %<omp begin declare target%> est déprécié depuis OpenMP 5.2"
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD est spécifié à la fois dans les clauses declare target %<link%> et %qs"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "%qD est spécifié à la fois dans les clauses declare target %<link%> et %<to%> ou des clauses %<enter%>"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr "la directive avec uniquement des clauses %<device_type%> ou %<indirect%>"
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "la clause %<device_type%> doit spécifier « any » lorsqu'elle est utilisée avec une clause %<indirect%>"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "%<match%> attendu"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "%<target%> ou %<variant%> attendu"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "%<declare target%>, %<declare variant%> ou %<assumes%> attendu"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma omp end declare target%> sans %<#pragma omp declare target%> correspondant ou %<#pragma omp begin declare target%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr "%qs dans la syntaxe d'attribut est terminé par %qs dans la syntaxe pragma"
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%qs dans la syntaxe pragma est terminé par %qs dans la syntaxe d'attribut"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma omp end declare variant%> sans %<#pragma omp begin declare variant%> correspondant"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr "%<begin declare variant%> dans la syntaxe d'attribut est terminé par %<end declare variant%> dans la syntaxe pragma"
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr "%<begin declare variant%> dans la syntaxe pragma est terminé par %<end declare variant%> dans la syntaxe d'attribut"
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "%<declare%> ou %<assumes%> attendu"
@@ -52071,12 +52112,12 @@ msgstr "redéclaration de %qs %<#pragma omp declare mapper%> pour le type %qT"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%<#pragma omp declare mapper%> a été précédemment déclaré ici"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, gcc-internal-format
 msgid "unexpected clause"
 msgstr "classe inattendue"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "clause %<map%> manquante"
@@ -52136,32 +52177,32 @@ msgstr "un des arguments de l'appel de l'initialisation devrait être %<&omp_pri
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "%<simd%>, %<reduction%>, %<target%> ou %<variant%> attendu"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "%<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> ou %<seq_cst%> attendu"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr "clause %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> ou %<atomic_default_mem_order%> attendue"
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr "clause %qs utilisée lexicalement après la construction de la première cible ou l'API de déchargement"
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr "plus d'une clause %<atomic_default_mem_order%> dans une même unité de compilation"
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr "clause %<atomic_default_mem_order%> utilisée lexicalement après la première construction %<atomic%> sans clause d'ordre de mémoire"
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr "%<pragma omp requires%> requiert au moins une clause"
@@ -52176,160 +52217,160 @@ msgstr "type %qT de taille nulle dans la clause %<reduction%>"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "type %qT de taille variable dans la clause %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "%<sizes%> attendu"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "l'argument %<sizes%> a besoin d'une constante entière positive"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "clause %<at%>, %<severity%> ou %<message%> attendue"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "%qs ou %qs attendu"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp error%> avec une clause %<at(execution)%> peut uniquement être utilisé dans des instructions composées"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp error%> avec une clause %<at(execution)%> ne peut pas être utilisé dans du code intervenant"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr "%<pragma omp error%> rencontrée : %s"
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr "%<pragma omp error%> rencontrée"
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "au moins une clause de présomption est attendue"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr "nom de directive attendu"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr "nom de directive OpenMP invalide dans l'argument de la clause %qs : déclarative, informationnelle et meta directives non permises"
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr "nom de directive OpenMP inconnue dans l'argument de la clause %qs"
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr "directive %<%s%s%s%s%s%> mentionnée simultanément dans les clauses %<absent%> et %<contains%>"
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr "directive %<%s%s%s%s%s%> mentionnée plusieurs fois dans les clauses %qs"
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "clause de présomption %qs inconnue"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "clause de présomption attendue"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "clause %<when%>, %<otherwise%> ou %<default%> attendue"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr "une clause %<default%> sur les métadirectives est dépréciée depuis OpenMP 5.2, utilisez %<otherwise%>"
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "trop de clauses %<otherwise%> ou %<default%> dans %<metadirective%>"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "la clause %<otherwise%> ou %<default%> doit apparaître en dernier dans %<metadirective%>"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, gcc-internal-format
 msgid "unknown directive name"
 msgstr "nom de directive inconnu"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr "les métadirectives ne peuvent pas être utilisées comme variantes de %<metadirective%>"
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr "les variantes de directives déclaratives d'une %<metadirective%> ne sont pas supportées"
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr "%<omp groupprivate%>"
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE est déclaré %<threadprivate%> après la première utilisation"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "la variable automatique %qE ne peut être %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE a un type incomplet"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%> sans avoir activé le support pour la mémoire transactionnelle"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%> sans avoir activé le support pour la mémoire transactionnelle"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%> sans avoir activé le support pour la mémoire transactionnelle"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> à l'intérieur de %<__transaction_relaxed%>"
@@ -52339,7 +52380,7 @@ msgstr "%<__transaction_cancel%> à l'intérieur de %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "le %<__transaction_cancel%> extérieur n'est pas dans un %<__transaction_atomic%> extérieur ou une fonction %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> pas à l'intérieur de %<__transaction_atomic%>"
@@ -52354,7 +52395,7 @@ msgstr "pas d'accolade fermante"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD a un type incomplet %qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "utilisation invalide de l'expression void"
@@ -52385,167 +52426,167 @@ msgstr "utilisation invalide du typedef incomplet %qT"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT et %qT sont dans des espaces d'adresses nommés disjoints"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "l'attribut %qs peut uniquement être appliqué aux fonctions variadiques"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "types fonctions pas vraiment compatibles en C ISO"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "les opérandes de types décimaux flottants et vectoriels ne peuvent pas être mélangés"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "les opérandes de types décimaux flottants et complexes ne peuvent pas être mélangés"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "les opérandes de types décimaux flottants ne peuvent pas être mélangés avec d'autres flottants"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr "%<_Complex _BitInt(%d)%> non supporté"
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "l'utilisation de pointeurs vers des tableaux ayant des qualificatifs différent est interdite en ISO C avant C23"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "les types ne sont pas vraiment compatibles"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "les types ciblés par les pointeurs sont incompatibles en C++"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "les types retournés par les fonctions ne sont pas compatibles en raison de %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "convertir un tableau de littéraux composés en un pointeur conduit à un pointeur ballant en C++"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "l'attribut %<counted_by%> n'est pas autorisé pour un pointeur vers une structure ou une union avec un membre qui est un tableau flexible"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT n'a pas de membre nommé %qE; vouliez-vous employer %qE ?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT n'a pas de membre nommé %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "accès au membre %qE d'une structure %qE atomique"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "accès au membre %qE d'une union %qE atomique"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qE est un pointeur vers un pointeur ; vouliez-vous le déréférence avant de lui appliquer %<->%> ?"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qE est un pointeur; vouliez-vous utiliser %<->%> ?"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "accès au membre %qE de quelque chose qui n'est ni une structure ni une union"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "déréférencement d'un pointeur %<void *%>"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "la valeur de l'indice n'est ni un tableau ni un pointeur ni un vecteur"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "l'indice du tableau n'est pas un entier"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "la valeur de l'indice est un pointeur vers une fonction"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, gcc-internal-format
 msgid "array subscript is negative"
 msgstr "l'indice du tableau est négatif"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "le C ISO interdit d'accéder aux tableaux %<register%> par un indice avant C2Y"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "le C90 ISO interdit d'accéder à un tableau par un indice si le tableau n'est pas une l-valeur"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD sous-spécifié référencé dans son initialiseur"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "une constante enum définie dans une structure ou une union n'est pas visible en C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "constante enum définie ici"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr "%<sizeof%> sur le tableau %qE en paramètre de fonction retournera la taille de %qT"
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "l'objet appelé %qE n'est pas une fonction ou un pointeur de fonction"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "l'objet %qD appelé n'est pas une fonction ou un pointeur de fonction"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "l'objet appelé n'est pas une fonction ou un pointeur de fonction"
@@ -52553,1852 +52594,1852 @@ msgstr "l'objet appelé n'est pas une fonction ou un pointeur de fonction"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "fonction appelée à travers un type non compatible"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "fonction appelée avec un type de retour void qualifié"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "le type du paramètre formel %d est incomplet"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "passage de l'argument %d de %qE comme entier au lieu de flottant à cause du prototype"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "passage de l'argument %d de %qE comme entier au lieu de complexe à cause du prototype"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "passage de l'argument %d de %qE comme complexe au lieu de flottant à cause du prototype"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "passage de l'argument %d de %qE comme flottant au lieu d'entier à cause du prototype"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "passage de l'argument %d de %qE comme complexe au lieu d'entier à cause du prototype"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "passage de l'argument %d de %qE comme flottant au lieu de complexe à cause du prototype"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "passage de l'argument %d de %qE comme %<float%> au lieu de %<double%> à cause du prototype"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "passage de l'argument %d de %qE comme %qT au lieu de %qT à cause du prototype"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "passage de l'argument %d de %qE avec des largeurs différentes à cause du prototype"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "passage de l'argument %d de %qE comme un non signé à cause du prototype"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "passage de l'argument %d de %qE comme signé à cause du prototype"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "trop d'arguments pour la méthode %qE ; %i attendus, %i obtenus"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "trop d'arguments pour la fonction %qE ; %i attendus, %i obtenus"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "trop d'arguments pour la fonction interne %qE %d attendus"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr "le C23 ISO n'autorise pas que les arguments pour la méthode %qE soient déclarés sans paramètres"
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "le C23 ISO n'autorise pas que les arguments de la fonction %qE soient déclarés sans paramètres"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "conversion implicite de %qT en %qT lors du passage de l'argument à la fonction"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "trop peu d'arguments pour la fonction %qE ; %i attendus au moins, %i obtenus"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "trop peu d'arguments pour la fonction %qE ; %i attendus, %i obtenus"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "trop peu d'arguments pour la fonction interne %qE %u attendus"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "une comparaison avec une chaîne littérale produit un résultat non spécifié"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "comparaison entre un pointeur et la constante caractère zéro"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "vouliez-vous déréférencer le pointeur ?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "zéro comme constante de pointeur nul"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "comparaison entre %qT et %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "pointeur de type %<void *%> utilisé dans une soustraction"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "pointeur vers une fonction utilisé dans une soustraction"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "arithmétique sur un pointeur vers un type incomplet"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "arithmétique sur un pointeur vers un agrégat vide"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> sur une expression booléenne"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "vouliez-vous utiliser le « non » logique ?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "le C ISO ne permet pas d'utiliser %<~%> pour calculer le conjugué d'un complexe"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "type d'argument erroné pour absu"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "type d'argument erroné pour le point d'exclamation unaire"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "incrémenter une valeur énumérée est invalide en C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "décrémenter une valeur énumérée est invalide en C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "incrémentation d'une expression booléenne"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "décrémentation d'une expression booléenne"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "le C ISO ne permet pas %<++%> ni %<--%> sur les types complexes avant C2Y"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "type d'argument erroné pour un incrément"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "type d'argument erroné pour un décrément"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "incrément d'un pointeur vers un type incomplet %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "décrément d'un pointeur vers un type incomplet %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "prise de l'adresse d'une expression de type %<void%>"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "ne peut prendre l'adresse du champ de bits %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "ne peut prendre l'adresse d'un scalaire avec un ordre de stockage inversé"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "adresse demandée pour un tableau avec un ordre de stockage scalaire inversé"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr "adresse d'un littéral composé registre demandée"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "variable globale de registre %qD utilisée dans une fonction imbriquée"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "variable de registre %qD utilisée dans une fonction imbriquée"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "adresse d'une variable registre globale %qD demandée"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "adresse d'une variable registre %qD demandée"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "le tableau n'est pas une l-valeur dans l'expression conditionnelle"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "différents types d'énumérations dans une condition est invalide en C++ : %qT vs %qT"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "conversion implicite depuis %qT vers %qT pour correspondre à d'autres résultats de la condition"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr "l'opérande de %<?:%> change de type signé de %qT à %qT à cause du caractère non signé de l'autre opérande"
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "le C ISO interdit une expression conditionnelle dont un seul côté est « void »"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "pointeurs vers des espaces d'adresses disjoints utilisés dans une expression conditionnelle"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "le pointeur vers le tableau perd le qualificatif dans l'expression conditionnelle"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "le pointeur vers le tableau perd le qualificatif dans l'expression conditionnelle dans le C ISO avant C23"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "le C ISO interdit une expression conditionnelle entre %<void *%> et un pointeur de fonction"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "non concordance de type de pointeurs dans une expression conditionnelle"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "la première expression a le type %qT"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "la seconde expression a le type %qT"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "non concordance entre un pointeur et un entier dans une expression conditionnelle"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "non concordance de type dans une expression conditionnelle"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "la valeur de retour de %qD est ignorée alors qu'elle est déclarée avec l'attribut %<nodiscard%> : %E"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "la valeur de retour de %qD est ignorée alors qu'elle est déclarée avec l'attribut %<nodiscard%>"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "la valeur de retour de type %qT est ignorée alors qu'elle est déclarée avec l'attribut %<nodiscard%> : %E"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "la valeur de retour de type %qT est ignorée alors qu'elle est déclarée avec l'attribut %<nodiscard%>"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "dans l'appel à %qD, déclaré ici"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "l'opérande à gauche de la virgule n'a pas d'effet"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "l'opérande à droite de la virgule n'a pas d'effet"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr "le transtypage ajoute le qualificatif %q#v au type de la fonction"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "le transtypage annule le qualificatif %qv du type ciblé par le pointeur"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "pour être sûrs, tous les pointeurs intermédiaires dans les transtypages de %qT vers %qT doivent être qualifiés avec %<const%>"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "le transtypage spécifie un type de tableau"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "le transtypage spécifie un type de fonction"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "le C ISO interdit le transtypage d'un type non scalaire vers lui-même"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "transtypage inutile vers le type %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "le C ISO interdit le transtypage vers un type union"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "transtypage vers un type union depuis un type absent de l'union"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "transtypage vers un pointeur de l'espace d'adresses %qs depuis un pointeur d'espace d'adresses générique disjoint"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "transtypage vers un pointeur de l'espace d'adresses générique vers un pointeur de l'espace d'adresses %qs disjoint"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "transtypage vers un pointeur de l'espace d'adresses %qs depuis un pointeur de l'espace d'adresses %qs disjoint"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "le transtypage augmente l'alignement requis pour le type ciblé"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "transtypage d'un pointeur vers un entier de taille différente"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "transtypage d'un appel de fonction de type %qT vers le type %qT ne correspondant pas"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "transtypage vers un pointeur depuis un entier de taille différente"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "le C ISO interdit la conversion d'un pointeur de fonction en un type de pointeur vers un objet"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "le C ISO interdit la conversion d'un pointeur vers un objet en un type de pointeur vers une fonction"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "transtypage entre des types de fonction incompatibles de %qT vers %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "définir un type dans un transtypage est invalide en C++"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "affectation vers une expression de type tableau"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "la conversion en enum dans une affectation est invalide en C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(près de l'initialisation de %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "tableau initialisé depuis une constante chaîne entre parenthèses"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 msgid "expected %e but argument is of type %e"
 msgstr "%e attendu mais l'argument est de type %e"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "dans %qD, le type de l'argument %d est %qT quand %qT est attendu dans un appel à une fonction interne déclarée sans prototype"
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "dans %qD, l'argument %d promeut vers %qT quand %qT est attendu dans un appel à une fonction interne déclarée sans prototype"
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "la fonction interne %qD est déclarée ici"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 msgid "%e declared here"
 msgstr "%e déclaré ici"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "la conversion d'un enum lors du passage de l'argument %d de %qE est invalide en C++"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "%qT attendu mais l'argument est de type %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "la conversion d'un enum de %qT vers %qT dans une affectation est invalide en C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "la conversion d'un enum de %qT vers %qT durant l'initialisation est invalide en C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "la conversion d'un enum de %qT vers %qT durant le retour est invalide en C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "conversion implicite de %qT vers %qT"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "passer l'argument %d de %qE ajoute le qualificatif %q#v au pointeur de fonction qui n'avait pas de qualificatif"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "l'affectation ajoute la qualificatif %q#v au pointeur de fonction qui n'avait pas de qualificatif"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "l'initialisation ajoute le qualificatif %q#v au pointeur de fonction qui n'avait pas de qualificatif"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "le retour ajoute le qualificatif %q#v au pointeur de fonction qui n'avait pas de qualificatif"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "passer l'argument %d de %qE abandonne le qualificatif %qv du type pointé"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "l'affectation abandonne le qualificatif %qv du type pointé"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "l'initialisation abandonne le qualificatif %qv du type pointé"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "le retour abandonne le qualificatif %qv du type pointé"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "le C ISO interdit la conversion d'argument en type union"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "la conversion implicite de %qT vers %qT n'est pas permise en C++"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "passage de l'argument %d de %qE depuis un pointeur vers un espace d'adresses non fermé"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "affectation depuis un pointeur vers un espace d'adresses non fermé"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "initialisation depuis un pointeur vers un espace d'adresses non fermé"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "retour depuis un pointeur vers un espace d'adresses non fermé"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "%qT attendu mais le pointeur est de type %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "l'argument %d de %qE pourrait être un candidat pour un attribut de format"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "le membre de gauche de l'affectation pourrait être un candidat pour un attribut de format"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "le membre de gauche de l'initialisation pourrait être un candidat pour un attribut de format"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "le type de retour pourrait être un candidat pour un attribut de format"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "passage de l'argument %d de %qE depuis un ordre de stockage scalaire incompatible"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "affectation à %qT depuis un type pointeur %qT avec un ordre de stockage scalaire incompatible"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "initialisation de %qT depuis un type pointeur %qT avec un ordre de stockage scalaire incompatible"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "retour de %qT depuis un type pointeur avec un ordre de stockage scalaire %qT incompatible"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "le C ISO interdit de passer l'argument %d de %qE entre un pointeur de fonction et %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "le C ISO interdit l'affectation entre un pointeur de fonction et %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "le C ISO interdit l'initialisation entre un pointeur de fonction et %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "le C ISO interdit le retour entre un pointeur de fonction et %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr "un tableau avec un qualificatif sur l'élément n'est pas qualifié avant C23"
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "les cibles pointées dans le passage de l'argument %d de %qE diffèrent dans la plage signée"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "les cibles pointées dans l'affectation de %qT vers %qT diffèrent dans la plage signée"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "les cibles pointées dans l'initialisation de %qT depuis %qT diffèrent dans la plage signée"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "les cibles pointées en retournant %qT depuis une fonction qui retourne le type %qT  diffèrent dans la plage signée"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "passage de l'argument %d de %qE depuis un type pointeur incompatible"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "affectation à %e depuis un pointeur vers %qD avec le type incompatible %e"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "affectation à %e depuis le type pointeur %e qui est incompatible"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "initialisation de %e depuis un pointeur vers %qD avec le type incompatible %e"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "initialisation de %e depuis le type pointeur %e qui est incompatible"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "retour d'un pointeur vers %qD de type %e depuis une fonction avec le type incompatible %e"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "retour de %e depuis une fonction avec le type de retour %e qui est incompatible"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "le passage de l'argument %d de %qE transforme un entier en pointeur sans transtypage"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "l'affectation à %qT depuis %qT transforme un entier en pointeur sans transtypage"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "l'initialisation de %qT depuis %qT transforme un entier en pointeur sans transtypage"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "retourner %qT depuis une fonction avec le type de retour %qT transforme un entier en pointeur sans transtypage"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "le passage de l'argument %d de %qE transforme un pointeur en entier sans transtypage"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "l'affectation à %qT depuis %qT transforme un pointeur en entier sans transtypage"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "l'initialisation de %qT depuis %qT transforme un pointeur en entier sans transtypage"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "retourner %qT depuis une fonction qui retourne le type %qT transforme un pointeur en entier sans transtypage"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "type incompatible pour l'argument %d de %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "types incompatibles dans l'affectation au type %qT depuis le type %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "types incompatibles dans l'initialisation du type %qT en utilisant le type %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "types incompatibles en retournant le type %qT alors que %qT était attendu"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "le C traditionnel rejette l'initialisation automatique d'agrégats"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr "le pointeur d'initialisation de %<constexpr%> n'est pas nul"
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "l'initialiseur de %<constexpr%> n'est pas représentable dans un type d'objet"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "l'initialiseur entier de %<constexpr%> n'est pas une expression entière constante"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "l'initialiseur de %<constexpr%> n'est pas une expression arithmétique constante"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr "l'initialiseur de %<constexpr%> pour un type réel est de type complexe"
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr "l'initialiseur de %<constexpr%> pour un type en virgule flottante binaire est de type décimal"
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "initialisation d'un membre de tableau flexible"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "impossible d'initialiser un tableau de %qT depuis une chaîne de caractères littérale avec un tableau de type %qT"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "la chaîne d'initialisation pour le tableau de %qT est trop longue (%wu caractères dans %wu disponibles)"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "la chaîne d'initialisation pour le tableau de %qT est trop longue pour C++ (%wu caractères dans %wu disponibles)"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr "la chaîne d'initialisation pour le tableau de %qT tronque le NUL de fin mais la destination n'a pas l'attribut %qs (%wu caractères dans %wu disponibles)"
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "tableau d'un type inapproprié initialisé avec une chaîne constante"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "utilisation invalide d'un tableau n'étant pas une l-valeur"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "initialisation invalide"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "un élément de l'initialisation n'est pas une constante"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "tableau initialisé à l'aide d'une expression de tableau non constante"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "un élément de l'initialisation n'est pas une expression constante"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "la conversion depuis %qT vers %qT change la valeur de %qd en %qd"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "un élément de l'initialisation n'est pas évaluable lors du chargement"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "type de vecteur opaque ne peut être initialisé"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "groupe d'accolades superflu à la fin de l'initialisation"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "accolades autour d'une initialisation d'un scalaire"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "initialisation d'un membre de tableau flexible dans un contexte imbriqué"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "accolades manquantes autour de l'initialisation"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "initialisation manquante pour le champ %qD de %qT"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "éléments superflus dans l'initialisation d'un scalaire"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "index de tableau dans l'initialisation de quelque chose n'étant pas un tableau"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "le nom du champ n'est pas dans l'initialisation de l'enregistrement ou de l'union"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "l'index de tableau dans l'initialisation n'est pas un entier"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "l'index de tableau dans l'initialisation n'est pas une expression entière constante"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "index de tableau non constant dans l'initialisation"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "l'index de tableau dépasse les limites du tableau dans l'initialisation"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "plage de l'index vide dans l'initialisation"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "la plage d'index du tableau excède les limites du tableau dans l'initialisation"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "le champ initialisé est écrasé"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "le champ initialisé a des effets de bord écrasés"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "la conversion en enum durant l'initialisation est invalide en C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr "trop d'éléments dans l'initialisation %qT"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "trop d'éléments dans l'initialisation de la structure"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "initialisation par position de champs dans une %<struct%> qui est déclarée avec l'attribut %<designated_init%>"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "initialisation non statique d'un membre de tableau flexible"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "trop d'éléments dans l'initialisation de l'union"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "le C traditionnel rejette l'initialisation des unions"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "trop d'éléments dans l'initialisation du tableau"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "trop d'éléments dans l'initialisation du vecteur"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "trop d'éléments dans l'initialisation d'un scalaire"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr "la contrainte n'autorise pas des registres en dehors d'une fonction"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr "effets de bord dans l'opérande de sortie en dehors d'une fonction"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr "l'opérande de sortie en dehors d'une fonction n'est pas une constante"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "le modificateur %<-%> est utilisé à l'intérieur d'une fonction"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr "l'opérande de contrainte %<:%> n'est pas une adresse d'une fonction ou une variable non automatique"
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr "effets secondaires dans l'opérande d'entrée en dehors d'une fonction"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr "l'opérande d'entrée en dehors d'une fonction n'est pas une constante"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "le C ISO interdit %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "le goto calculé doit être un type pointeur"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "la fonction est déclarée avec %<noreturn%> mais elle utilise l'instruction %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> sans valeur dans une fonction retournant autre chose que void"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> avec une valeur dans une fonction retournant un void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "le C ISO interdit %<return%> avec une expression dans une fonction qui retourne un void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "la fonction retourne l'adresse d'une étiquette"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, gcc-internal-format
 msgid "function returns address of nested function referencing local context"
 msgstr "la fonction retourne l'adresse d'une fonction imbriquée faisant référence au contexte local"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "la quantité du switch n'est pas un entier"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "l'expression %<long%> du « switch » n'est pas convertie en %<int%> avec le C ISO"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "l'étiquette du « case » doit être une expression constante entière"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "étiquette « case » en dehors de tout « switch »"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "étiquette %<default%> en dehors de tout « switch »"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "mot-clé « break » à l'extérieur de toute boucle ou « switch »"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "sortie invalide du bloc structuré OpenMP"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "mot-clé « break » utilisé dans une boucle OpenMP"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "mot-clé « continue » à l'extérieur de toute boucle"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "déclaration sans effet"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "l'instruction de l'expression a un type incomplet"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "la comparaison sera toujours %<false%> car l'opérande pointeur dans %qE ne peut pas être NULL"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "la comparaison sera toujours %<true%> car l'opérande pointeur dans %qE ne peut pas être NULL"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "la comparaison sera toujours %<false%> car l'adresse de %qE ne sera jamais NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "la comparaison sera toujours %<true%> car l'adresse de %qE ne sera jamais NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "comparaison de vecteurs avec des types d'éléments différents"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "comparaison de vecteurs avec des nombres d'éléments différents"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "comparaison entre les types %qT et %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "n'a pu trouver un type entier de la même taille que %qT"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "comparer des nombres flottants à l'aide de %<==%> ou %<!=%> n'est pas sûr"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "comparaison de pointeurs vers des espaces d'adresses disjoints"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "le C ISO interdit la comparaison de %<void *%> avec un pointeur de fonction"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "il manque un transtypage pour comparer des types de pointeurs distincts"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "comparaison entre un pointeur et un entier"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "comparaison de pointeurs complet et incomplet"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "le C ISO interdit les comparaisons ordonnées de pointeurs vers des fonctions"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "comparaison ordonnée d'un pointeur avec un pointeur nul"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "comparaison ordonnée d'un pointeur avec un zéro entier"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "conversion implicite de %qT vers %qT pour correspondre à d'autres opérandes de l'expression binaire"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "le tableau utilisé ne peut pas être converti en pointeur là où un scalaire est requis"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "valeur de type « struct » utilisée là où un scalaire est requis"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "valeur de type « union » utilisée là où un scalaire est requis"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "valeur de type « vector » utilisée là où un scalaire est requis"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancel%> doit spécifier l'une des clauses %<parallel%>, %<for%>, %<sections%> ou %<taskgroup%>"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "modificateur de clause %<cancel%> %<if%> attendus"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancellation point%> doit spécifier l'une des clauses %<parallel%>, %<for%>, %<sections%> ou %<taskgroup%>"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD n'est pas une variable dans la clause %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE n'est pas une variable dans la clause %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%<_Atomic%> %qD dans la clause %qs"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD est une variable « threadprivate » dans la clause %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "la borne inférieure %qE de la section du tableau n'a pas un type entier"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "la longueur %qE de la section du tableau n'a pas un type entier"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "pointeur unique attendu dans la clause %qs"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "section de tableau ayant une longueur nulle dans la clause %qs"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr "l'expression de longueur doit être spécifiée pour un type tableau dont la limite est inconnue"
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "limite inférieure négative dans la section du tableau dans la clause %qs"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "longueur négative dans la section du tableau dans la clause %qs"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "limite inférieure %qE au delà de la taille de la section du tableau dans la clause %qs"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "longueur %qE au delà de la taille de la section du tableau dans la clause %qs"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "limite supérieure %qE au delà de la taille de la section du tableau dans la clause %qs"
 
 # Ce message ne veut absolument rien dire !
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "pour une fonction tableau, l'expression de longueur du paramètre doit être spécifiée"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "l'expression de longueur doit être spécifiée pour un type pointeur"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "la section du tableau n'est pas contigüe dans la clause %qs"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE n'a pas un type pointeur ou tableau"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "l'itérateur %qD n'a pas le type entier ni le type pointeur"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "l'itérateur %qD a le type qualifié par %<_Atomic%>"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "l'itérateur %qD à le type qualifié par « const »"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "pas de l'itérateur avec un type non entier"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr "l'itérateur %qD a un pas de zéro"
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr "le type de l'itérateur %qD fait référence à l'itérateur extérieur %qD"
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr "l'expression de début fait référence à l'itérateur extérieur %qD"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "l'expression de fin fait référence à l'itérateur extérieur %qD"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "l'expression de pas fait référence à l'itérateur extérieur %qD"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "pointeur attendu dans la clause %qs"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "clauses %<inscan%> et non-%<inscan%> %<reduction%> sur la même construction"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "clause %<inscan%> %<reduction%> avec une section de tableau"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD dans la clause %<reduction%> est un tableau de taille nulle"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE dans la clause %<reduction%>"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "type de taille nulle %qT dans la clause %qs"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "type de taille variable %qT dans la clause %qs"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE a un type invalide pour %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "réduction définie par l'utilisateur pas trouvée pour %qE"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "type d'élément de longueur variable dans la table de la clause %<reduction%>"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "la clause %<nowait%> ne doit pas être utilisée avec la clause %<copyprivate%>"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE doit être %<threadprivate%> pour %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr "le modificateur ne devrait pas être spécifié dans la clause %<linear%> sur des constructions %<simd%> ou %<for%> lorsque les modificateurs OpenMP 5.2 ne sont pas utilisés"
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr "clause linéaire appliquée à une variable non entière non pointeur de type %qT"
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr "%<_Atomic%> %qD dans la clause %<linear%>"
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "le pas %qE de la clause %<linear%> n'est ni une constante ni un paramètre"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE n'est pas une variable dans la clause %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses de partage de données"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses de réduction"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE apparaît plus d'une fois dans les clauses de données"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses de données"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD apparaît à la fois dans les clauses « data » et « map »"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE n'est pas une variable dans la clause %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE n'est pas une variable dans la clause %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE n'est pas une variable dans la clause %<aligned%>"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "%qE dans la clause %<aligned%> n'est ni un pointeur ni un tableau"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%<_Atomic%> %qD dans la clause %<aligned%>"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE apparaît plus d'une fois dans les clause %<aligned%>"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE n'est pas une variable dans la clause %<nontemporal%>"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE apparaît plus d'une fois dans les clauses %<nontemporal%>"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE n'est pas une variable dans la clause %<allocate%>"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE apparaît plus d'une fois dans les clause %<allocate%>"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr "l'allocateur %qE doit être du type %<omp_allocator_handle_t%>"
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr "l'allocateur %qE doit être soit une variable ou soit un allocateur prédéfini"
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "les modificateurs ne peuvent pas être utilisés avec l'allocateur défini %qE"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr "le modificateur memspace %qE doit être une constante enum de type %<omp_memspace_handle_t%>"
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr "le tableau de traits %qE doit être défini dans la même portée que la constate dans laquelle la clause apparaît"
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr "le tableau de traits %qE doit être du type %<const omp_alloctrait_t []%>"
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr "le tableau de traits doit être du type %<const omp_alloctrait_t []%>"
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr "le tableau de traits doit être initialisé avec des constantes"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr "clause %<depend%> avec le type de dépendance %<depobj%> sur une section de tableau"
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr "%<omp_all_memory%> utilisé avec le type %<depend%> autre que %<out%> ou %<inout%>"
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE n'est pas une une expression l-valeur ni une section de tableau dans la clause %qs"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr "%qE n'a pas le type %<omp_depend_t%> dans la clause %<depend%> avec le type de dépendance %<depobj%>"
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr "%qE ne devrait pas avoir le type %<omp_depend_t%> dans la clause %<depend%> avec un type de dépendance autre que %<depobj%>"
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "la section du tableau n'a pas un type pour lequel une correspondance peut être établie (mappable type) dans la clause %qs"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "expression map %qE non supportée"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses de mouvement"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses « map »"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD n'a pas un type pour lequel la correspondance peut être établie (mappable type) dans la clause %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE n'est ni une variable ni un nom de fonction dans la clause %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE apparaît plus d'une fois dans la même directive %<declare target%>"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD n'est pas un argument dans la clause %<uniform%>"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE n'est pas un argument dans la clause %<uniform%>"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "la variable %qs n'est pas un pointeur"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "la variable %qs n'est ni un pointeur ni un tableau"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "la clause %<order%> ne doit pas être utilisée avec la clause %<ordered%>"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "trop de clauses %qs dans une construction de tâche"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "la clause %<inbranch%> est incompatible avec %<notinbranch%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses d'action"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD par défaut doit être du type %<omp_interop_t%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "%qD ne doit pas être const"
 
 # le premier %qs est un mot non traduit tel que « private », « shared » ou « threadprivate ».
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE est prédéterminé %qs pour %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "%qE qualifié avec %<const%> peut uniquement apparaître dans les clauses %<shared%> ou %<firstprivate%>"
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr "la valeur de la clause %<simdlen%> est plus grande que la valeur de la clause %<safelen%>"
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr "modificateur d'ordonnancement %<nonmonotonic%> spécifié en même temps que la clause %<ordered%>"
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "clause %qs spécifiée en même temps que la clause %<inscan%> %<reduction%>"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr "le pas de la clause %<linear%> est un paramètre %qD pas spécifié dans la clause %<uniform%>"
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "la clause %<nogroup%> ne doit pas être utilisée avec la clause %<reduction%>"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "la clause %<grainsize%> ne doit pas être utilisée avec la clause %<num_tasks%>"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "la clause %<full%> ne doit pas être utilisée avec la clause %<partial%>"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "la clause %<detach%> ne doit pas être utilisée avec la clause %<mergeable%>"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr "l'identificateur de l'événement d'une clause %<detach%> ne devrait pas être dans une clause qui partage des données"
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr "la clause %<depend%> requiert les clauses d'action avec le type interop %<targetsync%>"
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "la clause %<init%> n'a pas le modificateur %<targetsync%>"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "impossible d'utiliser %<va_arg%> avec un ordre de stockage inversé"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "le deuxième argument de %<va_arg%> est du type incompatible %qT"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "le deuxième argument de %<va_arg%> est un type fonction %qT"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "le deuxième argument de %<va_arg%> est un type tableau %qT"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "le C++ exige un type promu, pas un type enum, dans %<va_arg%>"
@@ -54664,253 +54705,248 @@ msgstr "Nous ne devrions jamais voir un dash-main non égal dans cobol1.c"
 msgid "no such exception: 0x%x"
 msgstr "pas de telle exception : 0x%x"
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr "Cause probable : il a été référencé sans avoir été défini."
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr "Cette chaîne ne devrait pas être aussi longue."
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "%s ne devrait pas être null"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%s: Le type de la variable %s est inconnu pour %s"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s: Champ de type invalide %s :"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr "Pas valide pour l'instruction ACCEPT."
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr "Tentative d'envoyer à un périphérique d'entrée."
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr "Pas valide pour l'instruction DISPLAY."
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr "%<parser_logop()%> a été appelé avec la variable %s à la ligne %d qui n'est pas un FldConditional"
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr "%<parser_relop()%> a été appelé avec la variable %s qui n'est pas un FldConditional"
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr "%<parser_relop()%> a été appelé avec la variable %s qui n'est pas un FldConditional"
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr "%<parser_if()%> a été appelé avec la variable %s qui n'est pas un FldConditional"
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr "le candidat %s a le type %<CVT_type%> %d(%s) non implémenté"
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "code %<setop_t%> %d inconnu"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr "%s:%d: %u dépasse %<MAXIMUM_UNTILS%> de %d, ligne %d"
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr "%s:%d: indices ignorés"
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr "%s: appelé avec NULL *fichier"
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr "%s:%d le mode d'accès du fichier %s est %<file_inaccessible_e%> dans %s"
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr "%<parser_file_open%> appelé avec NULL *fichier"
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr "%<parser_file_open%> pour %s appelé avec NULL %<var_decl_node%>"
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr "EXTEND peut uniquement être utilisé où %s est ACCESS MODE SEQUENTIAL"
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr "%<parser_file_close%> appelé avec NULL *fichier"
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr "%<parser_file_close%> pour %s est appelé avec NULL %<fichier->var_decl_node%>"
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr "%s:%d pour le fichier %s, « where » est zéro dans %s"
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr "%<parser_file_read%> appelé avec NULL *fichier"
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr "%<parser_file_read%> pour %s est appelé avec NULL %<fichier->var_decl_node%>"
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr "%<parser_file_read%> appelé avec NULL *champ"
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr "%<parser_file_read%> pour %s est appelé avec NULL %<champ->var_decl_node%>"
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr "%s:%d le fichier %s est RELATIVE/SEQUENTIAL, mais le %<where >= 0%>"
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr "%s:%d le fichier %s est RELATIVE/RANDOM mais le %<where < 0%>"
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr "%s:%d le fichier %s a « sequentially » à %d dans %s"
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr "%s: pour %s appelé avec NULL %<fichier->var_decl_node%>"
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr "%s: appelé avec NULL *champ"
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr "%s: pour %s appelé avec NULL %<champ->var_decl_node%>"
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr "Le pointeur de fichier ne devrait pas être null"
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr "%s:%d le fichier %s est INDEXED/SEQUENTIAL mais « sequentially » est faux"
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%s: le tri de %s a été demandé mais ce n'est pas une table"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr "%s: erreur de syntaxe : les deux (ou aucun) USING et une procédure d'entrée sont spécifiés"
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr "%s: erreur de syntaxe : les deux (ou aucun) GIVING et une procédure de sortie sont spécifiés"
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr "%s: erreur de syntaxe : les deux (ou aucun) fichiers et une procédure de sortie sont spécifiés"
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr "CALL USING BY CONTENT <temporary> requiert REPOSITORY PROTOTYPES."
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "%s: Qu'est-ce que nous bricolons ici ?"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr "In %<parser_move(%s to %s)%>, le déplacement de FldLiteralN vers %s n'a pas été implémenté"
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr "Dans %<mh_dest_is_float%>(%s to %s), le déplacement de %s vers %s n'a pas été implémenté"
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr "LEVEL 01 (%s) OCCURS a un paramètre data.memsize insuffisant"
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr "%<parser_symbol_add()%> a été appelé avec une %<nouvelle_var%> NULL"
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr "%s: %d %s est une table mais elle a une capacité inopportunément à zéro"
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr "%s: %s est son propre ancêtre"
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr "%s: %d %qs a un ancêtre NULL"
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr "%s(%s) a un %<var_decl_node%> inopportunément non null"
@@ -54919,72 +54955,82 @@ msgstr "%s(%s) a un %<var_decl_node%> inopportunément non null"
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr "%<our_index%> est NULL dans les circonstances anticipées"
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr "%s: %d %s<%s> a une data.capacité inopportunément à zéro"
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr "%<bytes_to_allocate%> est zéro pour %s (numéro de symbole "
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr "Le type donné n'est pas NULL et ce n'est pas sympa"
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "Le type donné n'est pas une déclaration ou un TYPE"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "Type %d inconnu"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr "Tentative d'une affectation de types différents."
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr "Quelqu'un a demandé le champ %s.%s qui n'existe pas"
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%s:%d: Ne peut pas appeler ici avec %s"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr "%s:%d: Ne peut pas appeler ici avec un non-%s"
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr "Vous rigolez"
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr "Vous avez encore oublié de mettre un %<NULL_TREE%> à la fin d'un %<gg_printf()%>"
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr "Vous avez encore oublié de mettre un %<NULL_TREE%> à la fin d'un %<gg_define_function()%>"
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr "%d paramètres ? Vraiment ? Êtes-vous fou ?"
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr "Décompte de contextes résiduels"
@@ -54994,12 +55040,12 @@ msgstr "Décompte de contextes résiduels"
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr "%<parser_op()%> ne sait pas comment évaluer %<%s = %s %c %s%>"
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, gcc-internal-format
 msgid "Too many subscripts"
 msgstr "Trop d'indices"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "impossible de lire la valeur %<float%> depuis %s"
@@ -55014,61 +55060,61 @@ msgstr "%s pid %ld terminé par %s"
 msgid "%s exited with status %d"
 msgstr "%s s'est terminé avec le statut %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr "%s:%d: LblNone « %s » a le parent #%zu"
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr "%s: élément de donnée %s #"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%s: la clé doit être un champ"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s: %s %s a un encodage invalide"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr "%s:%d: impossible d'ajouter « %s »"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s %lu %s %lu"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr "%s: num_octets %lu %s %lu"
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr "%s:%d: type %s, qui l'eût cru ?"
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr "erreur de logique : MOVE %s %s type invalide :"
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr "%s: regcomp: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr "erreur de logique : inœud manquant pour %s"
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "échec de la compilation %s"
@@ -55503,7 +55549,7 @@ msgstr "pas de %<operator %s%> adapté pour %qT"
 msgid "%q#D is private within this context"
 msgstr "%q#D est privé dans ce contexte"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr "déclaré privé ici"
@@ -55513,7 +55559,7 @@ msgstr "déclaré privé ici"
 msgid "%q#D is protected within this context"
 msgstr "%q#D est protégé dans ce contexte"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr "déclaré protégé ici"
@@ -55837,7 +55883,7 @@ msgstr "l'argument %u dans l'appel à la fonction %qE est un pointeur vers un ty
 msgid "constructor delegates to itself"
 msgstr "le constructeur délègue à lui-même"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr "ne peut convertir %qH en %qI"
 
@@ -55856,7 +55902,7 @@ msgstr "pas de fonction concordante pour l'appel à %<%T::%s%E(%A)%#V%>"
 msgid "call to non-function %qD"
 msgstr "appel à la non fonction %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "ne peut appeler le constructeur %<%T::%D%> directement"
@@ -56451,7 +56497,7 @@ msgstr "membre tableau flexible %qD dans %q#T par ailleurs vide est une extensio
 msgid "next member %q#D declared here"
 msgstr "membre %q#D suivant déclaré ici"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "redéfinition de %q#T"
@@ -56461,7 +56507,7 @@ msgstr "redéfinition de %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr "définition de %qT, qui a précédemment échoué à être complété dans un contexte SFINAE"
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr "ici. Utilisez %qs pour un diagnostique à ce point"
@@ -56593,7 +56639,7 @@ msgstr "type invalide pour le paramètre %d de la fonction %<constexpr%> %q+#D"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr "les lambdas ne sont implicitement %<constexpr%> qu'à partir du C++17"
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les destructeurs %<constexpr%> sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
@@ -56644,7 +56690,7 @@ msgstr "%<-fimplicit-constexpr%> affecte uniquement les fonctions %<inline%>"
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%qD n'est pas utilisable comme une fonction %<constexpr%> car:"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr "destruction de %qE en dehors de sa durée de vie"
@@ -56679,839 +56725,839 @@ msgstr "exception %qE non interceptée"
 msgid "uncaught exception of type %qT"
 msgstr "exception de type %qT non interceptée"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "appel à la fonction %qD avec un nombre incorrect d'arguments"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "%qD appelé sans aucune exception interceptée en attente"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "impossible d'allouer l'exception : la taille n'est pas constante"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr "le premier argument de le fonction %qD n'est pas le résultat de %<__cxa_allocate_exception%>"
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "%qD appelé sans exception active interceptée"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr "%qD appelé sans que %<std::%D%> ait été défini"
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr "%qD appelé sans %qs supporté"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr "%qD appelé avec l'argument %qs inattendu"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr "%qD appelé avec le deuxième argument autre que 1 ou -1"
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "nombre d'arguments erroné dans l'appel à %qs"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr "le premier argument de l'appel à %qs devrait être 0, 1, 2, 16, 17 ou 18"
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr "la chaîne de l'étiquette %qs contient le caractère %qc qui n'est pas une lettre, un chiffre ou %<_%>"
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr "message de constexpr : %.*s [%r%.*s%R]"
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr "message de constexpr : %.*s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "l'appel %<constexpr%> déborde au delà de la fin de la fonction"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E n'est pas une expression constante"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "appel à la fonction non %<constexpr%> %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "déréférencement d'un pointeur nul"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "la comparaison se réduit à %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr "%qE est évalué à « faux »"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr "la supposition de l'attribut %<assume%> a échoué"
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "appel à la fonction interne %qE"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "la modification d'un objet constant %qE n'est pas permise dans une expression constante"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "initialement déclaré %<const%> ici"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr "la référence %<dynamic_cast%> a échoué"
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "le type dynamique %qT de son opérande n'a pas une classe de base du type %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "le pointeur vers une table virtuelle est utilisé sans avoir été initialisé"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr "le type statique %qT de son opérande est une classe de base non publique du type dynamique %qT"
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT est une classe de base ambigüe du type dynamique %qT de son opérande"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr "le type dynamique %qT de son opérande n'a pas une classe de base publique %qT non ambigüe"
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "appel à la fonction membre constexpr %qD via un sous-objet de base virtuel"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr "impossible de lever %qT"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "l'expression %qE ne désigne pas une fonction %<constexpr%>"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr "impossible d'allouer le tableau : la taille n'est pas constante"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "désallocation de type tableau sur un objet alloué avec une allocation de type non tableau"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr "l'allocation a été réalisée ici"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "désallocation de type non tableau sur un objet alloué avec une allocation de type tableau"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr "désallocation d'un stockage déjà désalloué"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "désallocation d'un stockage qui n'a pas été précédemment alloué"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD est appelé dans une expression constante avant que sa définition soit complète"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD appelé dans une expression constante"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD utilisé avant sa définition"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "l'appel a une dépendance circulaire"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "la profondeur d'évaluation de la %<constexpr%> dépasse le maximum permis %d (utilisez %<-fconstexpr-depth=%> pour augmenter le maximum)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "la référence vers %qD n'est pas une expression constante"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "le pointeur vers %qD n'est pas une expression constante"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr "l'adresse de la variable constexpr non statique %qD peut différer entre chaque invocation de la fonction englobante ; ajoutez %<static%> pour lui donner une adresse constante"
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "l'opérande de droite de l'expression de décalage %q+E est négatif"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "l'opérande de droite de l'expression de décalage %q+E est plus grand ou égal à la précision %wu de l'opérande de gauche"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "l'opérande de gauche de l'expression de décalage %q+E est négatif"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "l'expression de décalage %q+E déborde"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr "arithmétique impliquant un pointeur nul dans %qE"
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "la valeur %qE de l'indice du tableau est hors des limites du tableau %qD du type %qT"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "l'indice de tableau non nul %qE est utilisé avec le tableau %qD de type %qT dont les limites sont inconnues"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "la valeur %qE de l'indice du tableau est hors des limites du tableau de type %qT"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "l'indice de tableau non nul %qE est utilisé avec un tableau de type %qT dont les limites sont inconnues"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "accès à un élément non initialisé du tableau"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "déréférencement d'un pointeur nul dans %qE"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE n'est pas une expression constante"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "le mutable %qD n'est pas utilisable dans une expression constante"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "accès au membre non initialisé %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "accès au membre %qD au lieu du membre actif %qD dans l'expression constante"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "accès au membre %qD au lieu du membre initialisé %qD dans l'expression constante"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%qs n'est pas une expression constante car %qT est un type union"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%qs n'est pas une expression constante car %qT contient un type union"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qs n'est pas une expression constante car %qT est un type pointeur"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%qs n'est pas une expression constante car %qT contient un type pointeur"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%qs n'est pas une expression constante car %qT est un type référence"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%qs n'est pas une expression constante car %qT contient un type référence"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "%qs n'est pas une expression constante car %qT est un type pointeur vers un membre"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "%qs n'est pas une expression constante car %qT contient un type pointeur vers un membre"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%qs n'est pas une expression constante car %qT est volatile"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qs n'est pas une expression constante car %qT contient un sous-objet volatile"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%qs ne peut pas être évalué de manière constante sur la cible"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr "%qs ne peut pas être évalué de manière constante car le type est trop grand"
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "%qs ne peut pas être évalué de manière constante car l'argument ne sait pas être encodé"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "%qs accès à un octet non initialisé à l'offset %d"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "%qs ne peut pas être évalué de manière constante car l'argument ne sait pas être interprété"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "accès à la valeur de l'objet %qT au travers d'une gl-valeur %qT dans une expression constante"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, gcc-internal-format
 msgid "%qT object created here"
 msgstr "l'objet %qT est créé ici"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D déclaré ici"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "utilisation d'un stockage alloué après sa désallocation dans une expression constante"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr "alloué ici"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr "accès à %qE en dehors de sa durée de vie"
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "le contenu d'un stockage non initialisé n'est pas utilisable dans une expression constante"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "la valeur de %qD n'est pas utilisable dans une expression constante"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD utilisé dans sa propre initialisation"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D n'est pas const"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D est volatile"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD n'a pas été initialisé par une expression constante"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD n'a pas été déclaré %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD n'a pas un type entier ou énuméré"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "modifier un stockage alloué après désallocation n'est pas une expression constante"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "modifie %qE en dehors de sa durée de vie n'est pas une expression constante"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "détruire %qE en dehors de l'évaluation courante n'est pas une expression constante"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "la modification de %qE en dehors de l'évaluation courante n'est pas une expression constante"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "changement du membre actif d'une union de %qD à %qD n'est pas une expression constante avant C++20"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr "%qD ne commence pas implicitement sa durée de vie car %qT n'a pas un constructeur par défaut trivial non supprimé, utilisez plutôt %<std::construct_at%>"
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr "l'initialisation de %qD requiert une expression d'accès à un membre comme opérande de gauche dans l'assignement"
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "changement du membre actif d'une union de %qD à %qD durant l'initialisation"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "le décompte des itérations de la boucle %<constexpr%> dépasse la limite permise %d (utilisez %<-fconstexpr-loop-limit=%> pour augmenter la limite)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "l'assembleur en ligne n'est pas une expression constante"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr "seul de l'assembleur en ligne non évalué est autorisé dans une fonction %<constexpr%> en C++20"
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, gcc-internal-format
 msgid "use of %qD"
 msgstr "utilisation de %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr "sa valeur peut varier entre les versions du compilateur ou avec des fanions %<-mtune%> ou %<-mcpu%> différents"
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr "si son utilisation fait partie d'une ABI publique, changez-le pour utiliser plutôt une variable constante que vous définissez"
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr "la valeur par défaut pour les réglages actuels du processeur est %d octets"
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr "vous pouvez stabiliser cette valeur avec %<--param hardware_destructive_interference_size=%d%> ou désactiver cet avertissement avec %<-Wno-interference-size%>"
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "le destructeur s'est terminé avec une exception"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "la valeur %qE du type %qT n'est pas une expression constante"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "le décompte des opérations d'évaluation de %<constexpr%> dépasse la limite permise %wd (utilisez %<-fconstexpr-ops-limit=%> pour augmenter la limite)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr "le contrôle passe au travers de la définition de %qD avec une durée de stockage limitée au thread"
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "le contrôle passe au travers de la définition de %qD avec une durée de stockage statique"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "temporaire du type %qT non littéral dans une expression constante"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "une exception non interceptée est sortie de la fonction %<noexcept%> %qD"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr "le destructeur s'est terminé avec une exception après avoir initialisé l'objet de l'exception"
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr "le constructeur s'est terminé avec une autre exception en entrant dans le gestionnaire"
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "un %<reinterpret_cast%> n'est pas une expression constante"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "conversion depuis le type pointeur %qT vers le type arithmétique %qT dans une expression constante"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "le transtypage de %qT n'est pas permis dans une expression constante car le type pointé %qT n'est pas similaire à %qT"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "l'objet pointé est déclaré ici"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "le transtypage depuis %qT n'est pas autorisé dans une expression constante avant C++26"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "%qE n'est pas une expression constante tant que la classe %qT est encore incomplète"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%<reinterpret_cast<%T>(%E)%> n'est pas une expression constante"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "l'expression %qE n'est pas une expression constante"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%<goto%> n'est pas une expression constante"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "l'adresse d'un appel à %qs n'est pas une expression constante"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "l'instruction n'est pas une expression constante"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "l'expression %qE du sous-type %s est inattendue"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr "%qE accède à un objet en dehors de sa durée de vie"
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr "la condition du contrat n'est pas constant"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "le prédicat du contrat est faux dans une expression constante"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "%<break%> à l'extérieur d'une boucle ou d'un « switch »"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr "%<continue%> utilisé en dehors d'une boucle"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "%<return%> dans l'expression d'une instruction"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qE n'est pas une expression constante car elle fait référence aux sous-objets mutables de %qT"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qE n'est pas une expression constante car elle fait référence à un objet d'exception alloué avec %<__cxa_allocate_exception%>"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qE n'est pas une expression constante car il fait référence à un résultat de %<operator new%>"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qE n'est pas une expression constante car le stockage alloué n'a pas été désalloué"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr "l'évaluation immédiate retourne l'adresse de la fonction immédiate %qD"
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "l'évaluation constante retourne l'adresse de la fonction immédiate %qD"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr "la référence à l'intérieur d'un objet de type consteval-only n'est pas une expression constante à moins qu'elle ait aussi le type consteval-only"
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr "le pointer à l'intérieur d'un objet de type consteval-only n'est pas une expression constante à moins qu'il ait aussi le type consteval-only"
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qE n'est pas une expression constante car il fait référence à une variable incomplètement initialisée"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qE n'est pas une expression constante car il initialise un %qT plutôt qu'un %qT"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "conversion l-valeur vers r-valeur d'une l-valeur volatile %qE avec le type %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "la capture lambda de %qE n'est pas une expression constante"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr "car il est utilisé comme gl-valeur"
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "%<reinterpret_cast%> d'un entier vers un pointeur"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "prendre l'adresse avec address-of d'un objet %qE qui est local au thread ou a un stockage automatique n'est pas une expression constante"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "expression lambda dans une expression constante avant C++17"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "l'expression new n'est pas une expression constante avant C++20"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "les fonctions virtuelles ne peuvent pas être %<constexpr%> avant C++20"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "l'expression %<typeid%> n'est pas une expression constante car %qE est un type polymorphique"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "transtypage vers le type non entier %qT dans une expression constante"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qD défini %<thread_local%> dans un contexte %<constexpr%>"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%qD défini %<static%> dans un contexte %<constexpr%>"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "la division par zéro n'est pas une expression constante"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%<delete[]%> n'est pas une expression constante"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "aucune des branches de %<if%> est une expression constante"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "initialisation d'un tableau non constant"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "la définition d'une étiquette dans une fonction %<constexpr%> est uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "arbre syntaxique abstrait (AST=Abstract Syntax Tree) de type %s inattendu"
@@ -57643,352 +57689,352 @@ msgstr "aucun opérande de la disjonction est satisfait"
 msgid "the operand %qE is unsatisfied because"
 msgstr "l'opérande %qE n'est pas satisfait car"
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qT n'est pas assignable par copie avec nothrow"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%qT ne sait pas être construit par défaut avec nothrow"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qT ne peut pas être construit par copie avec nothrow"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr "%qT n'est pas trivialement copiable par affectation"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "%qT n'a pas de constructeur par défaut trivialement utilisable"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%qT n'a pas de constructeur par copie trivialement utilisable"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "%qT n'a pas de destructeur trivialement utilisable"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qT n'a pas de représentation objet unique, car"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "%qT n'a pas de destructeur virtuel"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "%qT n'est pas une classe abstraite"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, gcc-internal-format
 msgid "%qT is not an aggregate"
 msgstr "%qT n'est pas un agrégat"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, gcc-internal-format
 msgid "%qT is not an array"
 msgstr "%qT n'est pas un tableau"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qT n'est pas assignable depuis %qT, car"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT n'est pas une base de %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qT n'est pas un tableau borné"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "%qT n'est pas une classe"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "%qT n'est pas un type constant"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "%qT n'a pas de constructeur par défaut utilisable, car"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qT ne peut pas être construit à partir de %qT, car"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "%qT n'est pas destructible, car"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "%qT n'est pas une classe vide"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "%qT n'est pas une énumération"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "%qT n'est pas une classe finale"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "%qT n'est pas une fonction"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT n'est pas un type avec une durée de vie implicite"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "%qT ne peut pas être invoqué, car"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qT ne peut pas être invoqué par %qT, car"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qT n'a pas une disposition compatible avec %qT, car"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "%qT n'est pas un type littéral"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "%qT n'est pas un pointeur vers une fonction membre"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "%qT n'est pas un pointeur vers un objet membre"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "%qT n'est pas un pointeur membre"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qT n'est pas assignable avec nothrow depuis %qT, car"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%qT ne sait pas être construit par défaut avec nothrow, car"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qT ne peut pas être construit avec nothrow à partir de %qT, car"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qT ne peut pas être converti avec nothrow à partir de %qT, car"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qT ne sait pas être détruit avec nothrow, car"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qT ne peut pas être invoqué avec nothrow, car"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qT ne peut pas être invoqué avec nothrow par %qT, car"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "%qT n'est pas un type objet"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT n'est pas une base qui peut être convertie par pointeur en %qT, car"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "%qT n'est pas un type simple (aussi appelé POD : Plain Old Data)"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "%qT n'est pas un pointeur"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "%qT n'est pas un type polymorphique"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "%qT n'est pas une référence"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "%q#T n'est pas le même que %q#T"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "%qT n'est pas une énumération fortement typée"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "%qT n'est pas un type ayant une disposition standard"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "%qT n'est pas un type trivial"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qT n'est pas trivialement assignable depuis %qT, car"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "%qT n'a pas de constructeur par défaut trivialement utilisable, car"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%qT ne peut pas être construit trivialement à partir de %qT, car"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "%qT n'est pas trivialement copiable"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "%qT n'a pas de destructeur trivialement utilisable, car"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "%qT n'est pas un tableau non borné"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "%qT est une union"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT n'est pas une base virtuelle de %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "%qT n'est pas un type volatile"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "%qT n'est pas consteval-only"
+msgid "%qT is not a structural type"
+msgstr "%qT n'est pas un type structuré"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "%qT ne peut pas rendre un rang"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "%qT et %qT ne peuvent pas être triés"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "%qT n'a pas de déstructuré"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr "%qT n'est pas une référence qui se lie à un objet temporaire de type %qT (initialisation directe)"
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr "%qT n'est pas une référence qui se lie à un objet temporaire de type %qT (initialisation par copie)"
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "%qD n'est pas déductible de %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, gcc-internal-format
 msgid "invalid constraints"
 msgstr "contraintes invalides"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr "la contrainte %qE a le type %qT au lieu de %<bool%>"
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "l'expression %qE est évaluée à %<false%>"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "la contrainte n'est pas satisfaite"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr "définissez %qs à au moins %d pour plus de détails"
@@ -58018,47 +58064,47 @@ msgstr "la déclaration a un nombre différent de contrats que précédemment d
 msgid "previous declaration with fewer contracts here"
 msgstr "la déclaration précédente avec moins de contrats est ici"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr "un paramètre de valeur utilisé dans une post-condition doit être const"
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, gcc-internal-format
 msgid "parameter declared here"
 msgstr "paramètre déclaré ici"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr "le paramètre de valeur %qE utilisé dans une post-condition doit être const"
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr "le nom du résultat de la post-condition du contrat cache un paramètre de fonction"
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "la déclaration ajoute des contrats à %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, gcc-internal-format
 msgid "first declared here"
 msgstr "première déclaration ici"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr "le constructeur ne retourne pas de valeur à tester"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr "le destructeur ne retourne pas de valeur à tester"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr "la fonction ne retourne pas de valeur à tester"
@@ -58129,7 +58175,7 @@ msgstr "le type de « promise » %qT pour la coroutine déclare à la fois %<r
 msgid "%<return_void%> declared here"
 msgstr "%<return_void%> déclaré ici"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "pas de membre nommé %qE dans %qT"
@@ -58201,83 +58247,83 @@ msgstr "%qs le type %qT sur lequel une attente est possible n'est pas une struct
 msgid "awaitable type %qT is not a structure"
 msgstr "le type %qT sur lequel une attente est possible n'est pas une structure"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr "%<await_suspend%> doit retourner %<void%>, %<bool%> ou un identifiant de coroutine"
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs ne peut pas être utilisé dans un contexte non évalué"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "la fonction déclarée avec %<noreturn%> a une instruction %<co_return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "l'argument d'alignement de %<__builtin_core_promise%> doit être une constante"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "l'argument de direction de %<__builtin_core_promise%> doit être une constante"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "aucune information du point de suspension pour %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "information dupliquée pour %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr "la supposition est ignorée car elle contient une expression temporisable"
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr "les expressions temporisables ne sont pas permises dans les gestionnaires"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "les tableaux de longueur variable ne sont pas encore supportés dans les coroutines"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr "%qE est fourni par %qT mais il n'est pas utilisable avec la fonction ayant la signature %qD"
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr "%qE est fourni par %qT mais %qE n'est pas marqué avec %<throw()%> ou %<noexcept%>"
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr "%qE est marqué avec %<throw()%> ou %<noexcep%> mais aucun %<get_return_object_on_allocation_failure%> utilisable est fourni par %qT"
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr "%qE est fourni par %qT mais %<std::nothrow%> n'est pas trouvé"
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "%qE est fourni par %qT mais il n'est pas utilisable avec la fonction %qD"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr "aucune conversion viable de %<void%> est fournie par %<get_return_object%> pour retourner le type %qT"
@@ -58302,68 +58348,73 @@ msgstr "%qD a été promu en une fonction immédiate"
 msgid "%qs used outside of constant expressions"
 msgstr "%qs utilisé en dehors d'expressions constantes"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "déclaration %<std::%s%> inattendue"
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "prise de l'adresse d'une fonction immédiate %qD"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "l'appel à la fonction consteval %qE n'est pas une expression constante"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%<throw%> appellera toujours %<terminate%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "en C++11, les destructeurs sont %<noexcept%> par défaut"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr "en C++11, ce %<throw%> appellera %<terminate%> car les destructeurs sont %<noexcept%> par défaut"
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "l'attribut %qE est ignoré après un %qE antérieur"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "comprimer l'expansion de l'attribut %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "utiliser plutôt une expression de repli (fold) dans l'argument de l'attribut"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD n'est pas un type"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qD n'est pas un type de classe"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qD n'a pas le type %<const char *%>"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qD n'a pas un type entier"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr "%<std::source_location::__impl%> ne contient pas uniquement que des membres de données non-statiques %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> et %<_M_column%>"
@@ -58404,7 +58455,7 @@ msgstr "conversion vers le type référencé non const %q#T depuis une r-valeur
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "la conversion depuis %qH vers %qI écarte les qualificatifs"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "le transtypage de %qT vers %qT ne déréférence pas le pointeur"
@@ -58792,7 +58843,7 @@ msgstr "par rapport à la déclaration précédente de %qF"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "la redéclaration de %qD diffère de %qs dans la déclaration précédente"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "déclaration précédente de %qD"
@@ -59013,13 +59064,13 @@ msgstr "argument par défaut donné pour le paramètre %d de %q#D"
 msgid "previous specification in %q#D here"
 msgstr "la spécification précédente dans %q#D est ici"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "export conflictuel pour la déclaration %qD"
 
 # la phrase fait référence à une variable ou une fonction (cf les deux messages ci-dessus) d'où le féminin
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "précédemment déclarée ici sans export"
@@ -59224,7 +59275,7 @@ msgstr "  passe outre l'initialisation de %q#D"
 msgid "  enters %<template for%> statement"
 msgstr "  entre dans l'instruction %<template for%>"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "%qD utilisé sans arguments du patron"
@@ -59269,2418 +59320,2428 @@ msgstr "%<typename %T::%D%> nomme %q#D qui n'est pas un type"
 msgid "template parameters do not match template %qD"
 msgstr "les paramètres du patron ne correspondent pas au patron %qD"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "%<-faligned-new=%d%> n'est pas une puissance de deux"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr "%<--param destructive-interference-size=%d%> est plus petit que %d"
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param destructive-interference-size=%d%> est plus petit que %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr "%<--param constructive-interference-size=%d%> est plus petit que %d"
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param constructive-interference-size=%d%> est plus grand que %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q#D est invalide; une union anonyme ne peut avoir que des membres de données publiques non statiques"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr "cette flexibilité est dépréciée et sera supprimée"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr "struct anonyme avec des classes de base"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "le membre %q+#D avec un constructeur n'est pas permis dans un agrégat anonyme"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "le membre %q+#D avec un destructeur n'est pas permis dans un agrégat anonyme"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "le membre %q+#D avec un opérateur d'affectation par copie n'est pas permis dans un agrégat anonyme"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "attribut ignoré dans la déclaration de %q#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "l'attribut pour %q#T doit suivre le mot-clé %qs"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "types multiples dans une déclaration"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "redéclaration du type interne C++ %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> peut seulement être spécifié pour des déclarations de variables ou de fonctions"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "nom de type manquant dans la déclaration typedef"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "le C++ ISO interdit les structures anonymes"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "%<inline%> peut seulement être spécifié pour des fonctions"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%<virtual%> peut seulement être spécifié pour des fonctions"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> peut seulement être spécifié à l'intérieur d'une classe"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> peut seulement être spécifié pour des constructeurs"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "une classe de stockage peut seulement être spécifiée pour des objets et des fonctions"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%<const%> peut seulement être spécifié pour des objets et des fonctions"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%<volatile%> peut seulement être spécifié pour des objets et des fonctions"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%<__restrict%> peut seulement être spécifié pour des objets et des fonctions"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%<__thread%> peut seulement être spécifié pour des objets et des fonctions"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> a été ignoré dans cette déclaration"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%qs ne peut pas être utilisé pour des déclarations de types"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "attribut ignoré dans l'instanciation explicite de %q#T"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "aucun attribut peut être appliqué à une instanciation explicite"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "attribut ignoré"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "un attribut qui appartient à un spécificateur de type est ignoré"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "les attributs sont ignorés s'ils sont appliqués à la classe de type %qT en dehors de la définition"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "attributs ignorés car ils sont appliqués au type dépendent %qT sans déclaration associée"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD est initialisé (utilisez plutôt %qs)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr "les post-conditions avec des types de noms résultats déduits doivent uniquement apparaître dans les définitions de fonctions"
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "la déclaration de %q#D est %<extern%> et est initialisée"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "la définition de %q#D est marquée %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q+#D n'est pas un membre de donnée statique de %q#T"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "la déclaration du patron non membre de %qD"
 
 # le message ci-dessous est la suite de celui juste ci-dessus
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "ne correspond pas à la déclaration du patron membre ici"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "le C++ ISO ne permet pas que %<%T::%D%> soit défini comme %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "initialisation en double de %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "la déclaration de %q#D en dehors de la classe n'est pas une définition"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr "la déclaration externe avec la portée bloc %q#D ne doit pas être attachée à un module nommé"
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD défini %<thread_local%> dans la fonction %qs est uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD défini %<static%> dans la fonction %qs est uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "la variable %q#D a un initialiseur mais a un type incomplet"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "les éléments du tableau %q#D ont un type incomplet"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "l'agrégat %q#D a un type incomplet et ne peut être défini"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD est déclaré comme référence mais n'est pas initialisé"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "nom utilisé dans une initialisation par désignation dans le style GNU pour un tableau"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "nom %qD utilisé dans une initialisation par désignation dans le style GNU pour un tableau"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "les initialisations par désignation non triviales ne sont pas supportées"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "le champ désigné par l'indicateur C99 %qE n'est pas une expression constante entière"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "l'initialisation n'a pu déterminer la taille de %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "taille de tableau manquante dans %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "tableau %qD de taille zéro"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "la taille de stockage de %qD n'est pas connue"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "la taille de stockage de %qD n'est pas constante"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "désolé: les sémantiques de la variable en ligne %q#D sont erronées (vous obtiendrez de multiples copies)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "désolé: les sémantiques de la fonction statique en ligne %q#D sont erronées (vous obtiendrez de multiples copies)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "vous pouvez contourner cela en enlevant l'initialiseur"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "%<const %D%> non initialisé"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "variable %qD non initialisée dans une fonction %<constexpr%>"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "variable %qD non initialisée dans un contexte %<constexpr%>"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T n'a pas de constructeur par défaut fourni par l'utilisateur"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "le constructeur n'est pas défini par l'utilisateur car le constructeur par défaut est explicitement demandé dans le corps de la classe"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "et le constructeur implicitement défini n'initialise pas %q#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "type %qT invalide pour initialiser un vecteur de type %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "l'initialisation de %qT doit être entre accolades"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%<[%E] =%> utilisé dans une initialisation par désignation dans le style GNU pour la classe %qT"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "la requête pour le membre %qD est ambiguë"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT n'a pas de membre de données non statique nommé %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD n'est pas un membre direct de %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "initialisation invalide pour %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "le champ désigné par l'indicateur C99 %qE est hors de l'initialisation de l'agrégat"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "trop d'éléments d'initialisation pour %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "accolades autour de l'initialiseur scalaire pour le type %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "trop d'accolades autour de l'initialiseur scalaire pour le type %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "accolades manquantes autour de l'initialisation pour %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "la liaison structurée à le type incomplet %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "les éléments du tableau %q#T ont un type incomplet"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "littéral composé de taille variable"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D a un type incomplet"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "l'objet scalaire %qD requiert un élément dans l'initialisation"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "en C++98, %qD doit être initialisé par un constructeur et non par %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "le tableau %qD est initialisé par la chaîne littérale entre parenthèses %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "initialisation invalide pour un membre statique avec constructeur"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "l'initialisation non constante dans la classe est invalide pour le membre statique %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "l'initialisation non constante dans la classe est invalide pour le membre statique pas en ligne %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(une initialisation en dehors de la classe est requise)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "adresse de la variable registre explicite %qD requise"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "la référence %qD est initialisée avec elle-même"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "l'argument %d de %qE doit être un type %<omp_interop_t%>"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "n'a pu trouver la déclaration du variant"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%<declare variant%> sur le constructeur %qD"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "%<declare variant%> sur le destructeur %qD"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "%<declare variant%> sur %qD par défaut"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr "%<declare variant%> sur %qD supprimé"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr "%<declare variant%> sur %qD virtuel"
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "affectation (pas une initialisation) dans la déclaration"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "le C++17 ISO n'autorise pas le spécificateur de classe de stockage %<register%>"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "spécificateur de classe de stockage %<register%> utilisé"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "la déclaration de %q#D n'est pas initialisée"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "l'initialisation pour %<decltype(auto) %D%> a un type fonction (avez-vous oublié les %<()%> ?)"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "le type déduit %qT pour %qD est incomplet"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "%<::main%> ne peut pas être supprimé"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "masque la déclaration précédente du type de %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%<constinit%> peut uniquement être appliqué à une variable avec une durée de stockage statique ou au niveau du thread"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<constinit%> peut être appliqué à une liaison structurée uniquement avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "la fonction %q#D est initialisée comme une variable"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "impossible de décomposer le type de fermeture lambda %qT"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, gcc-internal-format
 msgid "lambda declared here"
 msgstr "lambda déclarée ici"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "impossible de décomposer le type de la classe %qT car il a une structure anonyme comme membre"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr "impossible de décomposer le type de la classe %qT car il a une union anonyme comme membre"
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "impossible de décomposer le membre inaccessible %qD de %qT"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "dans la classe de base de %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr "impossible de décomposer le type de classe %qT: lui et sa classe de base %qT ont des membres de données non statiques"
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr "impossible de décomposer le type de classe %qT: ses classes de base %qT et %qT ont des membres de données non statiques"
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "la liaison structurée fait référence au type incomplet %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "impossible de décomposer un tableau ayant la limite %qT inconnue"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "impossible de décomposer le tableau de longueur variable %qT"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "impossible de décomposer le vecteur de longueur variable %qT"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "%<std::tuple_size<%T>::value%> n'est pas une expression constante entière"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "impossible de décomposer le type union %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "impossible de décomposer le type %qT qui n'est ni une classe ni un tableau"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "la liaison structurée fait référence au type de classe incomplet %qT"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr "initialiseur de tableau pour une déclaration de liaison structurée dans une condition"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "%u nom fourni pour la liaison structurée"
 msgstr[1] "%u noms fournis pour la liaison structurée"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] "seulement %u nom fourni pour la liaison structurée"
 msgstr[1] "seulement %u noms fournis pour la liaison structurée"
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] "alors que %qT se décompose en %wu élément"
 msgstr[1] "alors que %qT se décompose en %wu éléments"
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr "alors que %qT se décompose en %E éléments"
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr "%<std::tuple_element<%wu, %T>::type%> est %<void%>"
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "dans l'initialisation du paquet de liaison structurée %qD"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "dans l'initialisation de la variable de liaison structurée %qD"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "impossible de décomposer le type de classe %qT sans membre de donnée non statique"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr "la variable non locale %qD déclarée %<__thread%> a besoin d'une initialisation dynamique"
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "la variable non locale %qD déclarée %<__thread%> a un destructeur non trivial"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr "%<thread_local%> en C++11 permet l'initialisation et la destruction dynamique"
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "l'initialisation n'a pu déterminer la taille de %qT"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "taille du tableau manquante dans %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "tableau %qT de taille zéro"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "le destructeur pour la classe étrangère %qT ne peut pas être un membre"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "le constructeur pour la classe étrangère %qT ne peut pas être un membre"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD est déclaré comme une variable %<virtual%>"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "les spécificateurs de fonction %<const%> et %<volatile%> sur %qD sont invalides dans la déclaration de variable"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD déclaré comme un paramètre %<virtual%>"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD déclaré comme un paramètre %<inline%>"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "les spécificateurs de fonction %<const%> et %<volatile%> sur %qD sont invalides dans la déclaration de paramètre"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD déclaré comme un type %<virtual%>"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD déclaré comme un type %<inline%>"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "les spécificateurs de fonction %<const%> et %<volatile%> sur %qD sont invalides dans la déclaration de type"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD déclaré comme un champ %<virtual%>"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD déclaré comme un champ %<inline%>"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "les spécificateurs de fonction %<const%> et %<volatile%> sur %qD sont invalides dans la déclaration de champ"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D déclaré comme un ami"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D déclaré avec une spécification d'exception"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "la définition de %qD n'est pas dans l'espace de noms incluant %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "la fonction membre statique %q#D est déclarée avec des qualificatifs de type"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "les concepts de fonctions ne sont plus supportés"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "contraintes sur une fonction sans patron"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "la déclaration amie hors patron et contrainte doit être une définition"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr "le patron de la fonction amie avec des contraintes qui dépendent de paramètres extérieures au patron doit être une définition"
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "définition de la spécialisation explicite %qD dans la déclaration amie"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "utilisation invalide du template-id %qD dans la déclaration du patron primaire"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "les arguments par défaut ne sont pas permis dans la déclaration de la spécialisation du patron ami %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> n'est pas permis dans la déclaration de la spécialisation du patron ami %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "la déclaration amie de %qD spécifie des arguments par défaut et n%'est pas une définition"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "ne peut déclarer %<::main%> comme étant un patron"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "ne peut déclarer %<::main%> comme étant à mettre en ligne"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "ne peut déclarer %<::main%> comme étant %qs"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "ne peut déclarer %<::main%> comme étant static"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "ne peut déclarer %<::main%> avec une spécification de liaison autre que %<extern \"C++\"%>"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "ne peut attacher %<::main%> à un module nommé"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr "utilisez %<extern \"C++\"%> pour l'attacher au module globale"
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "la fonction non membre %qD ne peut pas avoir de qualificatif CV"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "la fonction membre statique %qD ne peut pas avoir de qualificatif CV"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "la fonction membre objet explicite %qD ne peut pas avoir de qualificatif CV"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "la fonction non membre %qD ne peut pas avoir de qualificatif de référence"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "la fonction membre statique %qD ne peut pas avoir de qualificatif de référence"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "la fonction membre objet explicite %qD ne peut pas avoir de qualificatif de référence"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "le paramètre objet explicite est déclaré ici"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "le guide de déduction %qD doit être déclaré dans la même portée que %qT"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "  déclaré ici"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "le guide de déduction %qD doit avoir le même accès que %qT"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "le guide de déduction %qD ne peut pas avoir un corps de fonction"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "opérateur littéral avec une classe de liaison C"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD a une liste d'arguments invalide"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "le suffixe entier %qs est masqué par l'implémentation"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "le suffixe en virgule flottante %qs est masqué par l'implémentation"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "les suffixes d'opérateurs littéraux qui ne sont pas précédés par %<_%> sont réservés pour une standardisation future"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD doit être une fonction non membre"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> doit retourner %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "définition de %qD déclaré implicitement"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "définition de %qD explicitement par défaut"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q#D explicitement par défaut ici"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "pas de fonction membre %q#D déclarée dans la classe %qT"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "ne peut déclarer %<::main%> comme variable globale"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr "un %<main%> nommé vide ne peut pas être déclaré avec la liaison du langage C"
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "une variable qui n'est pas un patron ne peut pas avoir %<concept%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "le concept doit être défini au niveau de l'espace de noms"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "les concepts de variables ne sont plus supportés"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "initialisation intra-classe du membre de donnée statique %q#D d'un type incomplet"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "%<constexpr%> est requis pour l'initialisation intra-classe du membre de donnée statique %q#D d'un type non entier"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "initialisation intra-classe du membre de donnée statique %q#D du type non littéral"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "initialisation intra-classe invalide du membre de donnée statique du type non entier %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "le C++ ISO interdit l'initialisation intra-classe du membre statique non constant %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "le C++ ISO interdit l'initialisation du membre constant %qD du type non entier %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "la taille du tableau %qD a le type non entier %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "la taille du tableau a le type non entier %qT"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "la taille du tableau %qD n'est pas une expression constante de type entier"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "la taille du tableau n'est pas une expression constante entière"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "le C++ ISO interdit le tableau de taille zéro %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "le C++ ISO interdit le tableau de taille zéro"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "le C++ ISO interdit le tableau de taille variable %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "le C++ ISO interdit le tableau de taille variable"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "le tableau de taille variable %qD est utilisé"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "le tableau de taille variable est utilisé"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "débordement dans la dimension du tableau"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD est déclaré comme tableau de type à remplacer dans un patron %qT"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "création d'un tableau de type à remplacer dans un patron %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "déclaration de %qD comme un tableau de « void »"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "création d'un tableau « void »"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "déclaration de %qD comme un tableau de fonctions"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "création d'un tableau de fonctions"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "déclaration de %qD comme un tableau de références"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "création d'un tableau de références"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "déclaration de %qD comme un tableau de fonctions membres"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "création d'un tableau de fonctions membres"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "la déclaration de %qD comme tableau multidimensionnel doit avoir des bornes pour chaque dimension excepté la première"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "le tableau multidimensionnel doit avoir des bornes pour chaque dimension excepté la première"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr "tableau de taille variable de %<auto%>"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "la spécification d'un type retourné pour un constructeur est invalide"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "les qualificatifs ne sont pas permis dans la déclaration d'un constructeur"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "la spécification d'un type retourné pour un destructeur est invalide"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "les qualificatifs ne sont pas permis dans la déclaration d'un destructeur"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "type de retour spécifié pour %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "les qualificatifs ne sont pas permis dans la déclaration de %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "type de retour spécifié pour le guide de déduction"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "les qualificatifs ne sont pas permis dans la déclaration du guide de déduction"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "paramètre de patron %qT, qui est lui-même un patron, dans la déclaration du guide de déduction"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "%<decl-specifier%> dans la déclaration du guide de déduction"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "variable non nommée ou champ déclaré void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "variable ou champ déclaré void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "spécificateur %<inline%> invalide pour la variable %qD déclarée au niveau du bloc"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "les variables « inline » sont uniquement disponibles avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr "nom de type anonyme non compatible avec le C donné pour la liaison par la déclaration %<typedef%>"
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr "le type n'est pas compatible avec le C car il a une classe de base"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr "le type n'est pas compatible avec le C car %qD a un initialiseur membre par défaut"
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "le type n'est pas compatible avec le C car il contient la déclaration %qD"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr "%qT en tant que type plutôt qu'un simple %<decltype(auto)%>"
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "%<decltype(auto)%> ne peut pas être qualifié avec CV"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 msgid "%e and %e specified together"
 msgstr "%e et %e spécifiés ensemble"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "utilisation invalide du nom qualifié %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "utilisation invalide du nom qualifié %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "utilisation invalide du nom qualifié %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%q#T n'est pas une classe ou un espace de noms"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "déclaration de %qE comme non fonction"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "déclaration de %qE comme non membre"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "declarator-id manquant; utilisation du mot réservé %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "la définition de fonction ne déclare aucun paramètre"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "déclaration de %qD comme non fonction"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "déclaration de %qD comme %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "déclaration de %qD comme paramètre"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr "%qs et %qs spécifiés tous les deux"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%qs ne peut pas apparaître dans une déclaration typedef"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr "au plus un seul spécificateur %<constinit%> ou %<constexpr%> peut être utilisé"
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "au moins deux types de données dans la déclaration de %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "le C++ ISO n'accepte pas qu'un simple %<complex%> signifie %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "le C++ ISO interdit la déclaration de %qs sans type"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int%d%> n'est pas supporté par la cible"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "le C++ ISO ne supporte pas %<__int%d%> pour %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qs spécifié avec %qT"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qs spécifié avec le nom typedef %qD"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs spécifié avec %<decltype%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qs spécifié avec %<typeof%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "« complex » invalide pour %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr "liste d'arguments de patron manquante après %qE ; pour la déduction, le type à remplacer doit être suivi d'un simple declarator-id"
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "le membre %qD ne peut pas être déclaré à la fois %<virtual%> et %<static%>"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "le membre %qD peut être déclaré à la fois %<virtual%> et %<constexpr%> uniquement avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "la déclaration typedef est invalide dans la déclaration du paramètre"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "classe de stockage spécifiée pour le paramètre %qs du patron"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "classe de stockage spécifiée pour le paramètre %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "un paramètre ne peut pas être déclaré %qs"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> en dehors de la déclaration de classe"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "la déclaration d'une liaison structurée ne peut pas être %qs"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "les déclarations de liaisons structurées peuvent être %qs uniquement en %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les déclarations de liaisons structurées peuvent être %qs uniquement en %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "la liaison structurée qualifiée avec %<volatile%> est dépréciée"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "une déclaration de liaison structurée ne peut pas avoir le %<auto%> du C++98"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "une déclaration de liaison structurée ne peut pas avoir le type %qT"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr "le type doit être un %<auto%> qualifié avec CV ou une référence à un %<auto%> qualifié avec CV"
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "une déclaration de liaison structurée ne peut pas avoir la contrainte %<auto%> de type %qT"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "classes de stockage multiples dans la déclaration de %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "classe de stockage spécifiée pour %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "fonction imbriquée %qs déclarée %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "la déclaration de %qs hors de toute fonction spécifie %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "%qs dans le champ de la fonction est implicitement déclaré auto et déclaré %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "spécificateurs de classe de stockage invalides dans les déclarations de fonctions amies"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "parenthèses inutiles dans la déclaration de %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr "retirez les parenthèses"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "la fonction membre objet explicite est uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "un type de fonction ne peut pas avoir de paramètre objet explicite"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "un pointeur vers un type de fonction ne peut pas avoir de paramètre d'objet explicite"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "un pointer vers un type de fonction membre ne peut pas avoir de paramètre objet explicite"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr "le type d'un pointeur vers une fonction membre d'objet explicite est un pointeur régulier vers un type de fonction"
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "le type d'une fonction membre d'un objet explicite est un type de fonction régulier"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr "seul le premier paramètre d'une fonction membre peut être déclaré comme un paramètre objet explicite"
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr "le paramètre objet explicite valide est déclaré ici"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "clause « requires » sur le type de retour"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "la fonction %qs utilise le spécificateur de type %<auto%> sans type de retour à la fin"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "le type de retour déduit est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "une fonction virtuelle ne peut pas avoir un type de retour déduit"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "la fonction %qs avec un type de retour à la fin a %qT comme étant son type au lieu d'un simple %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "la fonction %qs avec un type de retour à la fin a %<decltype(auto)%> comme étant son type au lieu d'un simple %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "utilisation invalide de %<decltype(auto)%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "la fonction %qs avec un type de retour à la fin a le spécificateur de type %<auto%> contraint au lieu d'un simple %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "utilisation invalide du type %<auto%> contraint"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "type de classe %qD déduit dans le type de retour de la fonction"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "le guide de déduction pour %qT doit avoir un type de retour à la fin"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr "le type de retour %qT à la fin du guide de déduction n'est pas une spécialisation de %qT"
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "le type de retour à la fin est uniquement disponible avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "la fonction %qs avec le type de retour à la fin n'est pas déclarée avec le spécificateur de type %<auto%>"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "une fonction de conversion ne peut pas avoir de type de retour à la fin"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "le type de retour qualifié avec %<volatile%> est déprécié"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs déclaré comme une fonction retournant une fonction"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs déclaré comme une fonction retournant un tableau"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "le type de retour %<constinit%> pour une fonction n'est pas permis"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "le destructeur ne peut être une fonction membre statique"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "le constructeur ne peut être une fonction membre statique"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "les destructeurs ne peuvent pas être qualifiés avec CV"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "les constructeurs ne peuvent pas être qualifiés avec CV"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "les destructeurs ne peuvent pas être qualifiés comme des références"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "les constructeurs ne peuvent pas être qualifiés comme des références"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "les constructeurs ne peuvent pas être déclarés %<virtual%>"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "les fonctions virtuelles ne peuvent pas être amies"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "la déclaration amie n'est pas dans la définition de la classe"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "ne peut définir la fonction amie %qs dans une définition de classe locale"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr "la définition de la fonction amie %qs ne peut pas avoir son nom qualifié avec %<::%>"
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr "la définition de la fonction amie %qs ne pas avoir son nom qualifié avec %<%D::%>"
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "la fonction non membre ne peut pas avoir de paramètre objet explicite"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "une fonction membre d'objet explicite ne peut pas être %<virtual%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "une fonction membre d'objet explicite ne peut pas être %<static%>"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD ne peut pas être une fonction membre d'un objet explicite"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "destructeurs ne peuvent pas avoir de paramètre"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "ne peut déclarer un pointeur vers %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "ne peut déclarer une référence vers %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "ne peut déclarer un pointeur vers le membre %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "ne peut déclarer une référence vers le type de fonction qualifié %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "ne peut déclarer un pointeur vers le type de fonction qualifié %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "ne peut déclarer une référence vers %q#T qui n'est pas un typedef ou un argument vers un type d'un patron"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "template-id %qD utilisé comme un déclarateur"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "les fonctions membres sont implicitement amies de leur classe"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "qualification %<%T::%> additionnelle sur le membre %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "ne peut définir la fonction membre %<%T::%s%> à l'intérieur de %qT"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "ne peut déclarer la fonction membre %<%T::%s%> à l'intérieur de %qT"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "ne peut déclarer le membre %<%T::%s%> à l'intérieur de %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "le non paramètre %qs ne peut pas être un paquet de paramètres"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "les membres de données ne peuvent pas avoir le type %qT modifié par une variable"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "le paramètre ne peut pas avoir le type %qT modifié par une variable"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<explicit%> en dehors de la déclaration de la classe"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<explicit%> dans une déclaration amie"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "seuls les déclarations de constructeurs et les opérateurs de conversion peuvent être %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "le non membre %qs ne peut pas être déclaré %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "le membre non objet %qs ne peut pas être déclaré %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "la fonction %qs ne peut pas être déclarée %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "%<static%> %qs ne peut pas être déclaré %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "%<const%> %qs ne peut pas être déclaré %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "la référence %qs ne peut pas être déclarée %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "typedef ne peut pas être une définition de fonction"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "typedef ne peut pas être une définition de fonction membre"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<auto%> n'est pas autorisé dans une déclaration de synonyme"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef déclaré %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr "clause « requires » sur un typedef"
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "le nom du typedef ne peut pas être un nom de spécificateur imbriqué"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "le C++ ISO interdit le type imbriqué %qD avec le même nom que la classe englobante"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> spécifié pour la déclaration d'une classe amie"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "les paramètres du patron ne peuvent pas être amis"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "une déclaration amie requiert le mot-clé « class », c-à-d. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "une déclaration amie requiert le mot-clé « class », c-à-d %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "tentative de rendre amie la classe %qT au niveau de la portée globale"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "qualificatifs invalides sur un type de fonction non membre"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr "clause « requires » sur type-id"
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "déclaration abstraite %qT utilisée comme déclaration"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "clause « requires » dans la déclaration du type non fonction %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "ne peut utiliser %<::%> dans la déclaration d'un paramètre"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "ne peut déclarer un paramètre avec %<decltype(auto)%>"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr "liste d'arguments de patron manquante après %qE ; type à remplacer pour le patron non permis dans le paramètre"
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "ou utilisez %<auto%> pour le patron de fonction abrégé"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "le paramètre %<auto%> n'est pas permis dans ce contexte"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "paramètre déclaré %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "utilisation invalide du nom de patron %qE sans liste d'arguments"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "membre de donnée non statique déclaré avec %qT comme type à remplacer"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "le C++ ISO interdit le membre tableau flexible %qs"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "le C++ ISO interdit les tableaux flexibles comme membres"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "utilisation invalide de %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "déclaration de la fonction %qD dans un contexte invalide"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "fonction %qD déclarée %<virtual%> à l'intérieur d'une union"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD ne peut pas être déclaré %<virtual%> puisqu'il est toujours statique"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "nom qualifié attendu dans la déclaration amie du destructeur %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "déclaration de %qD comme membre de %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "un destructeur ne peut pas être %qs"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "nom qualifié attendu dans la déclaration amie pour le constructeur %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "un constructeur ne peut pas être un %<concept%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "un concept ne peut être une fonction membre"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%qD ne peut pas être %qs"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "spécialisation du patron de variable %qD déclaré comme une fonction"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr "le patron de variable a été déclaré ici"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "le champ %qD a le type incomplet %qT"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "le nom %qT a un type incomplet"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE n'est ni une fonction ni une fonction membre; il ne peut pas être déclaré ami"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "le champ sans nom n'est ni une fonction ni une fonction membre; il ne peut pas être déclaré ami"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "l'annotation est appliquée à la déclaration amie non définissante %qD"
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "l'annotation est appliquée au paramètre %qD d'une déclaration amie non définissante"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "un attribut qui appartient à une déclaration amie qui n'est pas une définition est ignorée"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "membre de donnée statique %qE déclaré %qs"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "le membre statique %<constexpr%> %qD doit avoir une initialisation"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "le membre de donnée non statique %qE est déclaré %qs"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "la classe de stockage %<auto%> est invalide pour la fonction %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "la classe de stockage %<register%> est invalide pour la fonction %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "la classe de stockage %<__thread%> est invalide pour la fonction %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "la classe de stockage %<thread_local%> est invalide pour la fonction %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "le spécificateur %<constinit%> est invalide pour la fonction %qs"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "le spécificateur de type « virt-specifier » sur %qs n'est pas permis en dehors d'une définition de classe"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "le spécificateur %<static%> est invalide pour la fonction %qs déclarée en dehors de la portée globale"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "le spécificateur %<inline%> est invalide pour la fonction %qs déclarée en dehors de la portée globale"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "fonction non classe virtuelle %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs défini en dehors d'un contexte de classe"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs déclaré en dehors d'un contexte de classe"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "ne peut déclarer la fonction membre %qD comme ayant une classe de liaison statique"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "ne peut déclarer une fonction statique à l'intérieur d'une autre fonction"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> ne peut pas être utilisé lors de la définition (contrairement à la déclaration) d'un membre de donnée statique"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "membre statique %qD déclaré %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "ne peut explicitement déclarer le membre %q#D comme ayant une classe de liaison externe"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "la déclaration de la variable %<constexpr%> %qD n'est pas une définition"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "une variable ne peut pas être déclarée %<consteval%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs initialisé et déclaré %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs a, à la fois, %<extern%> et une initialisation"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "l'argument par défaut %qE utilise %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "l'argument par défaut %qE utilise la variable locale %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "utilisation invalide du type %qT qualifié CV dans la déclaration du paramètre"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "utilisation invalide du type %<void%> dans la déclaration du paramètre"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "le paramètre qualifié avec %<volatile%> est obsolète"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "le paramètre %qD est incorrectement déclaré comme type de méthode"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "le paramètre %qD inclut un pointeur vers un tableau %qT dont les bornes sont inconnues"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "le paramètre %qD inclut une référence vers un tableau %qT dont les bornes sont inconnues"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "constructeur invalide; vous vouliez probablement utiliser %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD ne peut pas être déclaré dans un espace de noms"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD ne peut pas être déclaré statique"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "%qD doit être une fonction membre non statique"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD doit être une fonction membre"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD peut être une fonction membre statique uniquement avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD doit être soit une fonction membre non statique ou une fonction non membre"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD doit avoir un argument de type classe ou énuméré"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "le C++ ISO interdit la surcharge de %<operator ?:%>"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD ne doit pas avoir un nombre variables d'arguments"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "%qD doit avoir zéro ou un argument"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "%qD doit avoir un ou deux arguments"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "%qD suffixé doit avoir %<int%> comme argument"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "%qD suffixé doit avoir %<int%> comme second argument"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "%qD ne doit avoir aucun argument"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "%qD doit avoir exactement un argument"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "%qD doit avoir exactement deux arguments"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD ne peut avoir d'arguments par défaut"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "la conversion de %qT vers %<void%> n'utilisera jamais un opérateur de conversion de type"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "la conversion de %qT en une référence vers le même type n'utilisera jamais un opérateur de conversion de type"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "la conversion de %qT vers le même type n'utilisera jamais un opérateur de conversion de type"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "la conversion de %qT en une référence vers une classe de base %qT n'utilisera jamais un opérateur de conversion de type"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "la conversion de %qT vers une classe de base %qT n'utilisera jamais un opérateur de conversion de type"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "%qD défini par l'usager évalue toujours les 2 arguments"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "%qD préfixé devrait retourner %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "%qD suffixé devrait retourner %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD devrait retourner par valeur"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "utilisation du paramètre du type de patron %qT après %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "utilisation de la spécialisation du patron d'alias %qT après %qs"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "utilisation du nom de typedef %qD après %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD a une déclaration précédente ici"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT référé en tant que %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%qT a une déclaration précédente ici"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "il est fait référence à %qT comme un enum"
@@ -61692,100 +61753,100 @@ msgstr "il est fait référence à %qT comme un enum"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "argument du patron requis pour %<%s %T%>"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "la référence à %qD est ambiguë"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "le patron de classe %qD est redéclaré comme un non patron"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD a le même nom que la classe dans laquelle il est déclaré"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT n'est pas un patron"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr "vous voulez peut-être ajouter %<%T::%> explicitement"
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "utilisation de l'enum %q#D sans déclaration précédente"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "redéclaration de %qT sous une forme qui n'est pas un patron"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "l'union dérivée %qT est invalide"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT est défini avec des bases directes multiples"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT est défini avec des bases virtuelles directes"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "le type de base %qT n'est pas un « struct » ou une « class »"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "type récursif %qT non défini"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "le type de base dupliqué %qT est invalide"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "non concordance entre un enum simple et un enum fortement typé pour %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "définition précédente ici"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "désaccord dans le type sous-jacent de l'enum %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "types sous-jacents différents dans l'enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "le type sous-jacent %qT de %qT doit être un type entier"
@@ -61794,88 +61855,93 @@ msgstr "le type sous-jacent %qT de %qT doit être un type entier"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "aucun type entier ne peut représenter toutes les valeurs de l'énumération pour %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "les valeurs énumérées de %qD doivent être de type entier ou une énumération simple (donc, pas fortement typée)"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "la valeur de l'énumération pour %qD n'est pas une constante entière"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "la valeur incrémentée de l'énumération est trop grande pour %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "la valeur incrémentée de l'énumération est trop grande pour %<long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "débordement dans les valeurs de l'énumération à %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "la valeur de l'énumération %qE est en dehors de la plage du type sous-jacent %qT"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "définition multiple de %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "le type retourné %q#T est incomplet"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> devrait retourner une référence à %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "« return » manquant dans une fonction retournant %qT"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "seul un type de retour %<auto%> évident peut être déduit en %<void%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr "définition de %qD qui a précédemment échoué à être déduit dans un contexte SFINAE"
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "« return » manquant dans une fonction %<constexpr%> devant retourner une valeur"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD est déjà défini dans la classe %qT"
 
 # le %qs est un nom de région non traduit tel que « parallel », « task », « teams ».
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr "en utilisant %qs"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "%qs est utilisé sans déclaration %qs"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "utilisation de %qD avant la déduction de %<auto%>"
@@ -62305,336 +62371,336 @@ msgstr "utilisation de la fonction %qD avec des contraintes non satisfaites"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "utilisation du paquet de paramètres intégré %qD en dehors d'un patron"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    mis en ligne depuis %qD à %r%s:%d:%d%R"
 
 # FRONT
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    mis en ligne depuis %qD à %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "    mis en ligne depuis %qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "Dans la fonction membre statique %qD"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "Dans le constructeur de copie %qD"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "Dans le constructeur %qD"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "Dans le destructeur %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "Dans la fonction lambda"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "Dans la fonction membre objet explicite %qD"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, gcc-internal-format
 msgid "In member function %qD"
 msgstr "Dans la fonction membre %qD"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr "Dans la fonction %qD"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "mais %qE est un type"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "mais %qE est une expression"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "mais %qE est une liaison structurée"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr "mais %qE est une variable"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "mais %qE est un paramètre"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "mais %qE est une fonction"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "mais %qE est un membre de donnée"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr "mais %qE est un patron de fonction"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "mais %qE est un patron de classe"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "mais %qE est un patron de variable"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr "mais %qE est un espace de noms"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "mais %qE est un énumérateur"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s%s%sDans l'instanciation de %<template for%> à l'itération %E :\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s%s%sDans la substitution de %qS :\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s%s%sDans l'instanciation de %q#D :\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "requis récursivement depuis %<template for%> à l'itération %E\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr "requis depuis %<template for%> à l'itération %E\n"
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "requis récursivement par la substitution de %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "requis par la substitution de %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "requis récursivement par %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "requis par %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "requis récursivement depuis ici\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "requis depuis ici\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "[ passe outre %d contextes d'instanciation, utilisez -ftemplate-backtrace-limit=0 pour désactiver ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "dans l'expansion %<constexpr%> de %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "requis par les contraintes de %q#D\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "requis par la satisfaction de %qE"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "requis pour la satisfaction de la contrainte\n"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr "dans les besoins avec "
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, gcc-internal-format
 msgid "in requirements "
 msgstr "dans les besoins "
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr "(pas d'argument)"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr "[...]"
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les listes d'initialisation étendues sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les opérateurs de conversion explicites sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les patrons variadiques sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les expressions lambda sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "le auto du C++11 est uniquement disponible avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les enums fortement typés sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les fonctions par défaut ou supprimées sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les espaces de noms en ligne sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "le contrôle de la redéfinition (override/final) est uniquement disponible avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les initialisations de membres de données non statiques sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les littéraux définis par l'utilisateur sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les constructeurs délégués sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les constructeurs hérités sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les attributs C++11 sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les qualificatifs de références sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "type %qT incomplet utilisé dans un spécificateur de noms imbriqué"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "la référence à %<%T::%D%> est ambiguë"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD n'est pas un membre de %qT; vouliez-vous employer %qs ?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD n'est pas un membre de %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD n'est pas un membre de %qD; vouliez-vous employer %qs ?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD n'est pas un membre de %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> n'a pas été déclaré; vouliez-vous employer %qs ?"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> n'a pas été déclaré"
@@ -62855,7 +62921,7 @@ msgstr "la référence %qD n'est pas encore liée à une valeur lorsqu'elle est
 msgid "member %qD is used uninitialized"
 msgstr "le membre %qD est utilisé sans avoir été initialisé"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "le tableau doit être initialisé avec une initialisation entre accolades"
@@ -62971,7 +63037,7 @@ msgstr "le type %qT n'est pas une base directe ou virtuelle de %qT"
 msgid "type %qT is not a direct base of %qT"
 msgstr "le type %qT n'est pas une base directe de %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -63162,42 +63228,42 @@ msgstr "problème possible détecté dans l'invocation de l'opérateur %<delete
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "ni le destructeur ni l'opérateur %<delete[]%> spécifique à la classe seront appelés, même s'ils sont déclarés lorsque la classe est définie"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "fin prématurée de l'initialisation"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "taille du tableau inconnue dans delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, gcc-internal-format
 msgid "operator %<delete%> used on incomplete type"
 msgstr "opérateur %<delete%> utilisé sur un type incomplet"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "problème possible détecté dans l'invocation de %<operator delete%>"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "ni le destructeur ni %<operator delete%> spécifique à la classe seront appelés, même s'ils sont déclarés lorsque la classe est définie"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "la destruction d'un objet de la classe abstraite %qT qui a un destructeur non virtuel provoquera un comportement indéfini"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "la destruction d'un objet de la classe polymorphique %qT qui a un destructeur non virtuel pourrait produire un comportement indéfini"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "le type passé au delete vectoriel n'est ni un pointeur ni un type tableau"
@@ -63232,82 +63298,90 @@ msgstr "capture par copie du type incomplet %qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "les liaisons structurées capturées sont une extension du C++20"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr "tentative de capturer %qD dans une instanciation d'une lambda générique"
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr "la capture implicite de %qE via %<[=]%> est dépréciée en C++20"
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr "ajoutez la capture %<this%> ou %<*this%> explicitement"
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> n'a pas été capturé pour cette fonction lambda"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "le nom décoré de %qT a changé avec %<-fabi-version=20%> (GCC 15.1)"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "le nom décoré de %qT change avec %<-fabi-version=20%> (GCC 15.1)"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr "%qD n'est plus capturé dans une fonction lambda noexcept dans l'ABI v21 (GCC 16)"
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "%<#pragma %s%> invalide"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "%<#pragma vtable%> n'est plus supporté"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%<#pragma implementation%> pour %qs apparaît après l'inclusion du fichier"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD n'est pas défini"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<requires%> uniquement disponible avec %<-std=c++20%> ou %<-fconcepts%>"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD n'a pas été déclaré dans cette portée; vouliez-vous employer %qs ?"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD n'a pas été déclaré dans cette portée"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "il n'y a pas d'argument pour %qD qui dépend d'un paramètre du patron, aussi une déclaration de %qD doit être disponible"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(si vous utilisez %<-fpermissive%>, G++ acceptera votre code, mais permettre l'utilisation d'un nom non déclaré est obsolète)"
@@ -63317,64 +63391,57 @@ msgstr "(si vous utilisez %<-fpermissive%>, G++ acceptera votre code, mais perme
 msgid "  # %E"
 msgstr "  # %E"
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "décoration de %<typeof%>, utilisez plutôt %<decltype%>"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr "utilisation du trait interne %qT dans la signature de la fonction, utilisez plutôt la bibliothèque des traits"
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr "décoration du type d'index de paquet"
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr "utilisation du trait interne %qE dans la signature de la fonction, utilisez plutôt la bibliothèque des traits"
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "décoration de %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "l'opérande omis au milieu de %<?:%> ne peut pas être décoré"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr "le nom décoré pour %qD changera dans le C++17 car la spécification de l'exception fait partir du type de la fonction"
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "le nom décoré de %qD a changé entre %<%s=%d%> (%qD) et %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "le nom décoré de %qD change entre %<%s=%d%> (%qD) et %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "le nom décoré d'un fragment pour %qD change entre %<-fabi-version=%d%> et %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "le nom décoré de %qD change entre %<-fabi-version=%d%> et %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "le nom décoré de la variable de protection de l'initialisation pour %qD change entre %<-fabi-version=%d%> et %<-fabi-version=%d%>"
@@ -63760,7 +63827,7 @@ msgstr "déclaration existante ici sans étiquette"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "édition de lien du langage conflictuel pour la déclaration importée %#qD"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "type conflictuel pour la déclaration importée %#qD"
@@ -63775,425 +63842,425 @@ msgstr "liste d'arguments conflictuelle pour la déclaration importée %#qD"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "types d'arguments conflictuels pour la déclaration importée %#qD"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "spécificateur %<noexcept%> conflictuel pour la déclaration importée %#qD"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "type de retour déduit conflictuel pour la déclaration importée %#qD"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "%<constexpr%> conflictuel pour la déclaration importée %#qD"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "déclaration importée %#qD conflictuelle"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "déclaration %#qD existante"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "argument par défaut conflictuel pour %#qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, gcc-internal-format
 msgid "existing default declared here"
 msgstr "celui par défaut existant est déclarée ici"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "argument par défaut conflictuel pour le paramètre %P de %q#D"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "la définition de %qD ne concorde pas"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "définition %qD existante"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "l'énumérateur %qD ne concorde pas avec ..."
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "... cet énumérateur %qD"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr "énumérateurs supplémentaires commençant par %qD"
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr "la plage d'énumération diffère"
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qD est un alias pour le type local TU %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%qD est une spécialisation du patron local TU %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "%qD est déclaré avec une liaison interne"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD n'a pas de liaison et est déclaré dans un espace de noms anonyme"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD n'a pas de liaison et est déclaré dans l'entité locale TU %qT"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD n'a pas de liaison et est déclaré avec l'entité locale TU %qD"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr "%qT n'a pas de nom et ne peut pas être différencié des lambda similaires dans d'autres TU"
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr "%qT n'a pas de nom et n'est pas défini dans une classe, fonction ou initialiseur"
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD a l'argument de patron local TU %qD"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qD a l'argument de patron local TU %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr "%qD fait référence à l'objet local TU %qD"
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD fait référence à la fonction locale TU %qD"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "l'instanciation expose l'entité locale TU %qD"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr "%qD expose l'entité locale TU %qD"
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr "%qD est aussi local TU mais il a été exposé ailleurs"
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr "%qD fait référence à l'entité locale TU %qD, ce qui peut causer des problèmes si elle est instanciée dans d'autres TU"
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr "%qD fait référence à l'entité locale TU %qD et ne peut pas être instanciée dans d'autres TU"
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD est déclaré %<constexpr%> et est initialisé à une valeur locale TU"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr "%qD est une référence déclarée %<inline%> et est initialisé de manière constante à une valeur locale TU"
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr "chargement tardif à la demande récursif"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr "le module %qs dépend de lui-même"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "le module %qs est déclaré ici"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "l'import indirect %qs n'est pas déjà chargé"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr "l'import %qs a un CRC non concordant"
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr "pas d'export de %<#define %E%> car il est un mot-clé"
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "la définition de macro de %qE est corrompue"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "définition de macro %qE importée de manière inconsistante"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr "%<#undef %E%>"
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr "%<#define %s%>"
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "le fichier du module compilé est %qs"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "le module compilé est %sversion %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr "le compilateur est %sversion %s%s%s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr "module %qs trouvé"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr "module d'en-tête attendu, module %qs trouvé"
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr "module %qs attendu, module d'en-tête trouvé"
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr "désaccord dans la CRC du module %qs"
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr "la cible et l'hôte sont %qs:%qs, %qs:%qs attendu"
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr "le dialecte du langage %qs diffère, %qs attendu"
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "le module contient OpenMP, utilisez %<-fopenmp%> pour l'activer"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr "le module contient OpenMP, utilisez %<-fopenmp%> ou %<-fopenmp-simd%> pour l'activer"
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "le module contient OpenACC, utilisez %<-fopenacc%> pour l'activer"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "désaccord dans l'arbre fixe"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "la partition de l'interface n'est pas exportée"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "échec de la lecture de la grappe %u du module compilé : %s"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "échec de la lecture du module compilé : %s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr "envisagez d'utiliser %<-fno-module-lazy%>, augmenter la valeur de %<-param-lazy-modules=%u%> ou d'augmenter la limite des descripteurs de fichiers par processus"
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr "les imports doivent être construit avant d'être importés"
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr "retour à la porte pour un problème mécanique"
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "la déclaration de %qD dans le module %qs est en conflit avec une fonction interne dans le module global"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "la déclaration %qD est en conflit avec la fonction interne"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "la redéclaration %qD dans le module %qs est en conflit avec l'import"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "la redéclaration %qD dans le module global est en conflit avec l'import"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "l'import est déclaré comme étant attaché au module %qs"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr "l'import est déclaré dans le module global"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "déclaration conflictuelle de %qD dans le module %qs"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "déclaration conflictuelle de %qD dans le module global"
 
 # la phrase fait référence à une variable ou une fonction (cf les deux messages ci-dessus) d'où le féminin
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "précédemment déclarée dans le module %qs"
 
 # la phrase fait référence à une variable ou une fonction (cf les deux messages ci-dessus) d'où le féminin
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "précédemment déclaré dans le module global"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr "la définition de %qD avec liaison externe dans l'en-tête du module doit être déclarée %<inline%>"
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "exportation de la déclaration %qD déclarée dans un espace de noms non nommé"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "exportation de la déclaration %qD avec liaison interne"
 
 # le %qs est un nom de région non traduit tel que « parallel », « task », « teams ».
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "lecture du CMI %qs"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "échec du chargement de la liaison %<%E%s%E%>"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr "échec du chargement de la liaison %<%E%s%E@%s%>"
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr "durant le chargement de la liaison %<%E%s%E%>"
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr "durant le chargement de la liaison %<%E%s%E@%s%>"
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "échec lors du chargement des pendings pour %<%E%s%E%>"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "durant le chargement des pendings pour %<%E%s%E%>"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "importer %qs dans sa propre unité d'implémentation"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, gcc-internal-format
 msgid "module declared here"
 msgstr "le module est déclaré ici"
@@ -64205,107 +64272,107 @@ msgstr "le module est déclaré ici"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr "import du module nommé %qs à l'intérieur d'un bloc de liaison du langage"
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr "module déjà déclaré"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr "module déjà importé"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "module %qs importé ici"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr "interface de module compilé non concordante : avait %qs, a eu %qs"
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "interface de module compilé inconnue : %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr "impossible de déterminer la traduction %<#include%> de %s : %s"
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr "inclusion %qs traduite en import"
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr "l'importation de %qs a échoué, utilisation de l'inclusion à la place"
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr "inclusion %qs traitée textuellement"
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "les modules C++ sont incompatibles avec les en-têtes précompilés"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "les modules C++ sont incompatibles avec le prétraitement traditionnel"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "nom d'en-tête %qs invalide"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "nom de module %qs invalide"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr "%<-fmodule-only%> utilisé pour une non-interface"
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "écriture CMI %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr "pas d'écriture du module %qs à cause d'erreurs dans les corps des patrons"
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr "activez %<-Wtemplate-body%> pour plus de détails"
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "la première erreur dans %qD est apparue ici"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "échec de l'écriture du module compilé : %s"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "type d'en-tête %qs inconnu"
@@ -64320,7 +64387,7 @@ msgstr "l'ensemble surchargé pour la recherche dépendant de l'argument de %<%D
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "ignore %qD déclaré ici avec un lien externe"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "la déclaration indépendante du nom est uniquement disponible avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
@@ -64365,261 +64432,271 @@ msgstr "la déclaration de %q#D masque un paramètre"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "la déclaration de %qD masque un membre de %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr "annotation appliquée à la portée de bloc externe %qD"
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "annotation appliquée au paramètre %qD d'une portée de bloc externe"
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "déclaration amie %qD dans la classe locale sans déclaration locale antérieure"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %<%s(%E)%> %p %d"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "export de %q#D qui n'a pas un lien externe"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q#D déclaré ici sans liaison"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%q#D déclaré ici avec un lien externe"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q#D déclaré ici avec une liaison de module"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T%s%D%> nomme le destructeur"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "déclaration « using » pour un non membre au niveau de la portée de la classe"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using%> avec la portée énumérée %q#T uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT n'est pas une classe, un espace de noms ou une énumération"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "la déclaration « using » non membre nomme le constructeur de %qT"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "déclaration « using » pour un membre en dehors de la portée de la classe"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "%qT n'est pas une base directe de %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr "vouliez-vous utiliser %<using enum %T::%D%> ?"
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD n'a pas été déclaré dans %qD"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "la déclaration « using » ne peut pas nommer l'espace de noms %qD"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> nomme le constructeur dans %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "la déclaration de %qD n'est pas dans l'espace de noms entourant %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "qualificatifs explicites dans la déclaration de %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD aurait dû être déclaré à l'intérieur de %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD n'a pas été déclaré dans %qD"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "uniquement ici comme un %<friend%>"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "l'attribut %qD requiert un seul argument NTBS"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "l'attribut %qD n'a pas de signification puisque les membres de l'espace de noms anonyme obtiennent des symboles locaux"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "l'attribut %qD est ignoré sur l'espace de noms anonyme"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "l'attribut %qD est ignoré sur l'espace de noms pas en ligne"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "la directive d'attribut %qD est ignorée"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "limite maximale de %d espaces de noms recherchés pour %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "alternative suggérée:"
 msgstr[1] "alternatives suggérées:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr "%<std::%s%> est défini dans l'en-tête %qs ; cela peut probablement être corrigé en ajoutant %<#include %s%>"
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<std::%s%> est uniquement disponible à partir de %s"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "la macro %qs n'a pas encore été définie"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr "elle a été définie ici plus tard"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "la déclaration de %<std::initializer_list%> ne correspond pas à %<#include <initializer_list>%> et n%'est pas un patron"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "la directive « using » %<strong%> n'est plus supportée"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr "vous pouvez utiliser un espace de noms en ligne à la place"
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<omp::%E%> ne peut pas être spécifié dans ce contexte"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "annotation de la directive « using »"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "impossible d'imbriquer plus de %d espaces de noms"
 
 # %qs est le nom d'une procédure d'où le féminin
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%<namespace %E%> est ambigu"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "l'alias de l'espace de noms %qD n'est pas permis ici, on suppose %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "exportation de l'espace de noms %qD avec liaison interne"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD a une liaison interne car il a été déclaré dans un espace de noms non nommé"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr "exportation d'un espace de noms non nommé"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "un espace de noms en ligne doit être spécifié à la définition initiale"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "l'espace de noms %s %qD est en conflit avec la définition atteignable"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "définition atteignable %s ici"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX entre dans %<pop_everything ()%>"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr "XXX quitte %<pop_everything ()%>"
@@ -64649,7 +64726,7 @@ msgstr "l'identificateur %qE est un mot clé en C++26"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr "%<LEXER_DEBUGGING_ENABLED_P%> n'est pas défini à vrai"
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> pas immédiatement suivi par une déclaration ou une définition de fonction"
@@ -64694,7 +64771,7 @@ msgstr "%<::%E%> n'a pas été déclaré"
 msgid "request for member %qE in non-class type %qT"
 msgstr "requête du membre %qE dans le type %qT qui n'est pas une classe"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> n'a pas été déclaré"
@@ -64764,7 +64841,7 @@ msgstr "(un point virgule est peut-être manquant après la définition de %qT)"
 msgid "%qE is not a class template"
 msgstr "%qE n'est pas un patron de classe"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE n'est pas un patron"
@@ -65076,1691 +65153,1701 @@ msgstr "l'indexation de paquets est uniquement disponible avec %<-std=c++2c%> ou
 msgid "pack index missing"
 msgstr "indexation de paquets manquante"
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr "une réflexion est uniquement disponible avec %<-freflection%>"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "une réflexion d'un type est attendue"
 
-#: cp/parser.cc:6341
-#, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "une réflexion d'un patron de fonction est attendue"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr "%<template%> supplémentaire dans une tranche de la portée"
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "%<template%> manquant dans une tranche de la portée avec des arguments de patron"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr "%<template%> peut uniquement être omis quand la tranche de la portée est précédée de %<typename%>"
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "une réflexion d'une classe, un espace de noms ou une énumération est attendue"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "types en virgule fixe pas supportés en C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "le C++ ISO interdit les groupes d'accolades à l'intérieur des expressions"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "les expressions-instructions ne sont pas permises en dehors des fonctions ni dans les listes d'arguments du patron"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "les expressions fold sont uniquement disponibles avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "expression primaire attendue"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> ne peut pas être utilisé dans ce contexte"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "une déclaration de patron ne peut pas apparaître au niveau d'un bloc"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "le paramètre %qD ne peut pas apparaître dans ce contexte"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "la variable locale %qD ne peut pas apparaître dans ce contexte"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "la réflexion est uniquement disponible en C++26 avec %<-freflection%>"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr "mot-clé %qs attendu avant le nom du patron dépendant"
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "expression id attendue"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "la portée %qT avant %<~%> n'est pas un nom de classe"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "le mot-clé %<template%> n'est pas permis dans le nom du destructeur"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr "template-id n'est pas permis pour un destructeur en C++20"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr "retirez le %qs"
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "déclaration de %<~%T%> comme membre de %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "nom du typedef %qD utilisé comme déclaration de destructeur"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "unqualified-id attendu"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD n'est pas un patron"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "%<:%> trouvé dans le spécificateur de nom imbriqué, %<::%> attendu"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%<decltype%> est évalué en %qT qui n'est ni une classe ni un type énuméré"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "template-id de la fonction %qD dans le spécificateur de nom imbriqué"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "concept-id %qD dans le spécificateur de nom imbriqué"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "template-id de la variable %qD dans le spécificateur de nom imbriqué"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "spécificateur de nom imbriqué attendu"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "les types ne peuvent pas être définis dans les transtypages"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "les types ne peuvent pas être définis dans une expression %<typeid%>"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "mauvais nombre d'arguments pour %<__builtin_addressof%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "mauvais nombre d'arguments pour %<__builtin_launder%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "mauvais nombre d'arguments pour %<__builtin_assoc_barrier%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "mauvais nombre d'arguments pour %<__builtin_shufflevector%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr "l'appel à %<__builtin_operator_new%> ne sélectionne pas la fonction d'allocation globale remplaçable"
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "l'appel à %<__builtin_operator_delete%> ne sélectionne pas la fonction de désallocation globale remplaçable"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, gcc-internal-format
 msgid "selected function declared here"
 msgstr "la fonction sélectionnée est déclarée ici"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "le C++ ISO interdit les littéraux composés"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr "deux %<[%> consécutifs n'introduiront qu'un attribut"
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "des types ne peuvent pas être définis dans des appels %<__builtin_classify_type%>"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr "un indice multidimensionnel ne peut pas être utilisé dans une section de tableau OpenMP"
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "utilisation invalide de %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> n'est pas un membre de classe"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "type non scalaire"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%<template%> doit suivre un nom de spécificateur imbriqué"
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "%<^^%> ne peut pas être appliqué à un type à remplacer"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<^^%> ne peut pas être appliqué à cet opérande"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "le C++ ISO ne permet pas %<alignof%> avec un non type"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "les types ne peuvent pas être définis dans des expressions %<noexcept%>"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%<co_await%> ne peut être utilisé dans des arguments par défaut"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "les types ne peuvent pas être définis dans une expression %qs"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "%<__builtin_has_attribute%> avec un argument dépendant n'est pas encore supporté"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "les types ne peuvent pas être définis dans une expression « new »"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "les limites de tableau sont interdites après un type-id entre parenthèses"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "essayez d'enlever les parenthèses autour du type-id"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr "l'initialisation de l'expression « new » pour le type %<auto%> exige exactement un élément"
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "liste-expression ou type-id attendu"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "les types ne peuvent pas être définis dans un new-type-id"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "attributs ignorés sur le type de tableau le plus à l'extérieur dans l'expression new"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "l'expression dans la déclaration « new » doit être un type entier ou un type énuméré"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "utilisation d'un vieux style de transtypage vers %q#T"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "l'opérateur %<>>%> est traité comme deux caractères > en C++11"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "parenthèses suggérées autour de l'expression %<>>%>"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "le C++ ISO ne permet pas d'omettre l'opérande du milieu de %<?:%>"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "une expression avec une virgule au plus haut niveau dans l'indice d'un tableau est déprécié"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "des types ne peuvent pas être définis dans %<__builtin_offsetof%>"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr "le dernier argument de %<__type_pack_element%> n'est pas un type"
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les expressions lambda dans un contexte non évalué sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les expressions lambda dans un argument de patron sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "une expression lambda non locale ne peut pas avoir de capture par défaut"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "fin de liste de capture attendue"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les captures par copie explicite de %<this%> avec la capture par copie par défaut sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "%qD déjà capturé dans l'expression lambda"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "la capture de %<*this%> est uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "ne peut capturer %<this%> par référence"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les captures d'initialisation compactes ne sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr "%<&%> devrait apparaître avant %<...%>"
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "les initialisations par capture des fonctions lambda sont uniquement disponibles avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr "initialisation vide pour la capture par initialisation d'une fonction lambda"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "capture de %qE qui n'est pas une variable"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "capture de la variable %qD avec une durée de stockage non automatique"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr "trop de %<...%> dans la capture lambda"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "la capture par copie explicite de %qD est redondante avec la capture par copie par défaut"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "la capture par référence explicite de %qD est redondante avec la capture par référence par défaut"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les patrons lambda sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "argument par défaut spécifié pour un paramètre lambda"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "la déclaration d'un paramètre avant des spécificateurs de déclarations lambda est uniquement optionnelle avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr "une lambda avec capture ne peut pas avoir un paramètre objet explicite d'un type sans rapport"
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "spécificateur de lambda %<mutable%> avec un paramètre objet explicite"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr "l'objet de fermeture passé ne sera pas muté car il est pris par valeur"
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr "déclarez plutôt le paramètre objet explicite comme une référence non constante"
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr "le paramètre objet explicite est déjà une référence mutable"
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "spécificateur de lambda %<static%> avec un paramètre objet explicite"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr "spécificateur de lambda %<static%> avec la capture lambda"
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "la déclaration d'un paramètre avant le qualificatif d'une transaction lambda est uniquement optionnelle avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "la déclaration d'un paramètre avant la spécification d'une exception lambda est uniquement optionnelle avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "la déclaration d'un paramètre avant le type de retour de fin d'une lambda est uniquement optionnelle avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "les lambda %<constexpr%> sont uniquement disponibles avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr "%qE n'est pas implicitement capturé par une assertion de contrat"
+
+#: cp/parser.cc:13754
+#, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "%q#E déclaré ici"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "une étiquette à la fin d'une instruction composée est uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "les attributs au début d'une instruction sont ignorés"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "instruction étiquetée attendue"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "le « case » %qE n'est pas à l'intérieur de l'instruction « switch »"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr "étiquette d'identificateur %qE dans le corps de %<template for%>"
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "%<typename%> doit être utilisé avant %qE car %qT est une portée dépendante"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "%qE nomme le constructeur, pas le type"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "instruction composée dans une fonction %<constexpr%>"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr "les boucles internes doivent être parfaitement imbriquées avec la clause %<tile%>"
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<if constexpr%> uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<if consteval%> uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr "%<if consteval%> requiert une instruction composée"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "l'instruction init dans des instructions de sélection est uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "instruction de sélection attendue"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr "la condition déclare un tableau"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, gcc-internal-format
 msgid "condition declares a function"
 msgstr "la condition déclare une fonction"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "des types ne peuvent pas être définis dans des conditions"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "initialisation attendue"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les boucles %<for%> parcourant une plage avec un initialiseur sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr "la variable de boucle %qD de type %qT est liée à un temporaire construit depuis le type %qT"
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr "utilisez le type non référence %qT pour faire une copie explicite ou %qT pour empêcher la copie"
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "la variable de boucle %qD crée une copie du type %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr "utilisez un type de référence pour empêcher la copie"
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "l'expression %<for%> parcourant une plage de type %qT a un type incompatible"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "types différents pour « begin » et « end » de l'instruction %<for%> parcourant une plage: %qT et %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "instruction d'itération attendue"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "les déclarations de synonymes dans l'instruction init sont uniquement disponibles avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "les boucles %<for%> parcourant une plage sont uniquement disponibles avec %<-std=c++11%> ou %<-std=gnu++11%>"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<template for%> est uniquement disponible avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr "désignateurs dans l'initialiseur %<template for%>"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "une déclaration de  portée d'une boucle « for » ne peut pas être « constinit »"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<goto%> dans une fonction %<constexpr%> uniquement disponible avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "le C++ ISO interdit les gotos calculés"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "instruction de saut attendue"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr "partition de module attendu"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr "nom de module attendu"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "la déclaration de module n'est pas permise dans une unité d'en-tête"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr "la déclaration de module doit être dans la portée globale"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr "portée ouverte ici"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr "fragment de module privé"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr "le fragment de module privé est uniquement permis dans le domaine d'interface de module ou de partition"
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr "le déclaration de module est uniquement permise comme première déclaration ou à la fin d'un fragment de module global"
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr "les imports de déclarations post modules doivent être contigües"
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr "insérez peut-être un saut de ligne après %<import%> ou une autre résolution d'ambigüité pour empêcher ceci d'être considéré comme une ligne de contrôle de module"
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "la déclaration d'import doit être dans la portée globale"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr "un import spécifiant une partition de module doit apparaître après une déclaration de module nommée"
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr "les imports de déclarations post modules ne doivent pas être traduits en inclusions"
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr "les imports de déclarations post modules ne doivent pas provenir de l'inclusion d'en-tête"
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr "%qE peut uniquement apparaître après une déclaration d'interface de module"
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "%qE peut uniquement apparaître une seule fois dans une déclaration d'export"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr "%<export%> ne fait pas partie de la directive de module suivante"
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "un %<;%> supplémentaire en dehors d'une fonction est uniquement autorisé en C++11"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr "%<;%> supplémentaire en dehors d'une fonction"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr "un %<;%> supplémentaire à l'intérieure d'une structure est uniquement autorisé en C++11"
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr "%<;%> supplémentaire à l'intérieure d'une structure"
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "%<;%> supplémentaire après la définition dans la classe"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "les attributs ne sont pas permis à cette position"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "les attributs ne peuvent pas être insérés ici"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "les spécialisations explicites ne sont pas permises ici"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr "une spécialisation est toujours exportée avec sont patron primaire"
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "les instanciations explicites ne sont pas permises ici"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "les déclarations d'export ne sont pas permises ici"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> pas au début du bloc"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr "non variable %qD dans la déclaration avec plus d'une déclaration contenant un type à remplacer"
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "déduction incohérente pour %qT: %qT et puis %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "mélanger des déclarations et des définitions de fonctions est interdit"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "des types ne peuvent pas être définis dans la déclaration d'une instruction « for » parcourant une plage"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "initialisation dans une boucle %<for%> parcourant une plage"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "déclarations multiples dans une boucle %<for%> parcourant une plage"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr "paquet de liaison structurée en dehors du patron"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "plusieurs paquets dans la déclaration de la liaison structurée"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "les paquets de liaisons structurées sont uniquement disponibles avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "les liaisons structurées avec des identificateurs attribués sont uniquement disponibles avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr "annotation sur une liaison structurée"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "les liaisons structurées dans des conditions sont uniquement disponibles avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "les liaisons structurées sont uniquement disponibles avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "déclaration de liaison structurée vide"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "initialisation invalide pour la déclaration de liaison structurée"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "la déclaration d'une plage de boucle « for » ne peut pas être %qs"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "%<this%> doit être le premier spécificateur dans la déclaration des paramètres"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> utilisé en dehors d'une classe"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "le mot-clé %<bool%> n'est pas permis dans une définition de concept en C++20"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr "la syntaxe de définition d'un concept en C++20 est %<concept <name> = <expr>%>"
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "le spécificateur %<typedef%> est en conflit avec %qs"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> a changé de signification en C++11; retirez-le"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "%qD est invalide dans une condition"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD est invalide dans une lambda"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD uniquement valide dans une lambda avec %<-std=c++23%> ou %<-std=gnu++23%>"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "spécificateur de type invalide dans une lambda"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr "attributs standard au milieu de spécificateurs de déclaration"
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr "les attributs standards doivent précéder les spécificateurs de déclaration pour être appliqués sur la déclaration ou les suivre pour être appliqués sur le type"
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "la définition de classe ne peut pas être déclarée comme amie"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "les patrons ne peuvent pas être %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "les types ne peuvent pas être définis dans une spécification explicite"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<explicit(bool)%> est uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "spécification de classe de liaison invalide"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "un %<static_assert%> sans message est uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "un %<static_assert%> avec un message qui n'est pas une chaîne de caractères est uniquement disponible avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "le spécificateur de type %<decltype(auto)%> est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "les types ne peuvent pas être définis dans les expressions %<decltype%>"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "les types ne peuvent pas être définis dans un conversion-type-id"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "utilisation invalide de %<auto%> dans un opérateur de conversion"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "un %<auto%> dans un opérateur de conversion d'un patron membre ne peut jamais être déduit"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "seuls les constructeurs prennent des initialisions membres"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "impossible de développer l'initialisation du membre %qD"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "l'initialisation en mémoire pour %qD suit la délégation du constructeur"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "la délégation du constructeur suit l'initialisation en mémoire pour %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "ancien style anachronique d'initialisation de classe de base"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "le mot-clé %<typename%> n'est pas permis dans ce contexte (une initialisation de membre qualifiée est implicitement un type)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "une espace entre les guillemets et le suffixe est déprécié en C++23"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "mot-clé inattendu; enlevez l'espace entre les guillemets et l'identificateur du suffixe"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "identificateur de suffixe attendu"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "une chaîne vide était attendue après le mot-clé %<operator%>"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "préfixe d'encodage invalide dans l'opérateur littéral"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "opérateur attendu"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "le mot-clé %<export%> n'est pas implémenté et sera ignoré"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "le mot-clé %<export%> est déprécié et est ignoré"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "le mot-clé %<-export%> est activé avec %<-fmodules%>"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "paramètre de type contraint invalide"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "paramètre de type qualifié avec CV"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "utilisation invalide de %<auto%> dans l'argument par défaut du patron"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "le paquet de paramètres %qD du patron ne peut pas avoir d'argument par défaut"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "les paquets de paramètres des patrons ne peuvent pas avoir d'arguments par défaut"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "template-id attendu"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> ne peut pas être au début d'une liste d'arguments d'un patron"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> est une écriture alternative pour %<[%>. Insérer un espace entre %<<%> et %<::%>"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(si vous utilisez %<-fpermissive%> ou %<-std=c++11%> ou %<-std=gnu++11%> G++ acceptera votre code)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "liste d'arguments de patron invalide"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr "un nom de fonction comme opérande dans le membre de gauche de %<<%> est toujours mal formé en C++20; incluez le nom de la fonction dans %<()%>"
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "%<(%> attendu après la liste d'arguments de patron"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "erreur d'analyse dans la liste des arguments du patron"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "nom de patron attendu"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "%qD n'est pas un patron mais il est utilisé comme patron"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "utilisez %<%T::template %D%> pour indiquer que c'est un patron"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "paquet de paramètres attendu avant %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "argument de patron attendu"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "argument de patron invalide car ce n'est pas un type"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "une expression de tranche sans parenthèses ne peut pas être utilisée comme argument de patron"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "une instanciation explicite ne doit pas utiliser le spécificateur %<inline%>"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "une instanciation explicite ne doit pas utiliser le spécificateur %<constexpr%>"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "une instanciation explicite ne doit pas utiliser le spécificateur %<consteval%>"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "spécialisation de patron avec édition de liens C"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "spécificateur du type attendu"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "l'utilisation de %<auto%> dans la déclaration d'un paramètre lambda est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "l'utilisation de %<auto%> dans une déclaration de paramètre est uniquement disponible avec %<-std=c++20%> ou %<-fconcepts%>"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "l'utilisation de %<auto%> dans une déclaration de paramètre est uniquement disponible avec %<-std=c++14%> ou %<-std=gnu++14%>"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "utilisation de %<auto%> dans un argument de patron"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "template-id attendu pour le type"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "un nom de type attendu"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "%qE ne contraint pas un type"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr "concept défini ici"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "utilisation invalide du nom de concept %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "%<auto%> ou %<decltype(auto)%> attendu après %qE"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr "type à remplacer (« placeholder ») inattendu dans le type de retour contraint"
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "un spécificateur de type élaboré pour un enum fortement typé ne peut pas utiliser le mot-clé %qD"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "la déclaration %qD ne déclare rien du tout"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "attributs ignorés sur un type non instancié"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "attributs ignorés sur une instanciation de patron"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "attributs ignorés sur un spécificateur de type élaboré qui n'est pas une déclaration anticipée"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD est un patron d'énumération"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD ne nomme pas une énumération dans %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "un enum fortement typé sans nom n'est pas permis"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "les types ne peuvent pas être définis dans la base d'un enum"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr "la déclaration d'une énumération sans type sous-jacent fixé et aucune liste d'énumération n'est permis que dans une déclaration autonome"
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "%<;%> ou %<{%> attendu"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "impossible d'ajouter une liste d'énumération à l'instanciation d'un patron"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "le spécificateur de nom imbriqué %qT pour la déclaration d'un enum ne nomme pas une classe ou un espace de noms"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "déclaration de %qD dans l'espace de noms %qD lequel n'englobe pas %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "déclaration de %qD dans %qD lequel n'englobe pas %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "qualification supplémentaire pas permise"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "le C++ ISO interdit un enum vide et sans nom"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "spécificateur enum opaque sans nom"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "un spécificateur enum opaque doit utiliser un simple identificateur"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr "paquet de paramètres non déroulés dans l'énumérateur dans la lambda"
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD n'est pas un nom d'espace de nom; vouliez-vous utiliser %qs ?"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD n'est pas un espace de noms"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "espace de noms attendu"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les définitions d'espace de noms imbriqués en ligne sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr "les attributs standards sur les espaces de noms doivent précéder le nom de l'espace de noms"
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "les définitions d'espace de noms imbriqués sont uniquement disponibles avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "nom d'espace de noms imbriqué attendu"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr "nom d'espace de noms attendu"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "une définition d'espace de noms imbriqué ne peut pas avoir d'attribut"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "une définition d'un espace de noms imbriqué ne peut pas être « inline »"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "entrée dans l'espace de noms %qD"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "la définition %<namespace%> n'est pas permise ici"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "l'expansion de paquets dans une déclaration « using » est uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "un template-id ne peut pas apparaître dans l'utilisation de la déclaration"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "une liste séparée par des virgules dans une déclaration « using » est uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "les déclarations d'accès sont dépréciées en faveur des déclarations « using »; suggestion: ajoutez le mot-clé %<using%>"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using enum%> est uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "%<using enum%> du type dépendant %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%<using enum%> du type non-énuméré %q#T"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "%<using enum%> du type incomplet %qT"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr "%<using enum%> de %qT avant le spécificateur de son énmuération"
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "déclaration enum opaque ici"
 
 # alias template est un patron appliqué à un alias == patron d'alias
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "les types ne peuvent pas être définis dans des déclarations de patrons d'alias"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "littéral chaîne ou constexpr entre parenthèses attendu"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<asm%> dans une fonction %<constexpr%> uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "qualificatif %<asm%> %qT dupliqué"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "le qualificatif %<asm%> %qT est ignoré en dehors du corps d'une fonction"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT n'est pas un qualificatif %<asm%>"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "qualificatif %<asm%> en dehors du corps de la fonction"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "attributs ignorés dans la déclaration %<asm%>"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "l'ambigüité sur les parenthèses vides a été résolue par une déclaration de fonction"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "retirez les parenthèses pour initialiser par défaut une variable"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr "ou remplacez les parenthèses par des accolades pour initialiser par agrégation une variable"
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr "ou remplacez les parenthèses par des accolades pour initialiser par valeur une variable"
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "l'ambigüité sur les parenthèses a été levée par un déclaration de fonction"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr "remplacez les parenthèses par des accolades pour déclarer une variable"
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "ajoutez des parenthèses pour déclarer une variable"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "impossible de gérer le nom qualifié pour une fonction variante"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr "les directives de déclaration de variantes ne sont pas autorisées sur les constructeurs"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr "les directives de déclaration de variantes ne sont pas autorisées sur les destructeurs"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "ne peut gérer le nom d'identificateur %s"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "pas de déclaration de la fonction de base %qs dans cette portée"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "la fonction de base est ambigüe"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr "la fonction variante doit être dans la même portée que la fonction de base %qs"
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr "la fonction variante doit être dans la même portée que la fonction de base %qE"
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "les directives de déclaration de variantes ne sont pas autorisées sur les fonctions virtuelles"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "les directives de déclaration de variantes ne sont pas autorisées sur les fonctions par défaut"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "les directives de déclaration de variantes ne sont pas autorisées sur les fonctions supprimées"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "les directives de déclaration de variantes ne sont pas autorisées sur les fonctions immédiates"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "une définition de fonction n'est pas permise ici"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "une spécification %<asm%> n'est pas permise dans une définition de fonction"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "des attributs ne sont pas permis dans une définition de fonction"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "constructeur, destructeur ou conversion de type attendu"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "initialisation fournie pour une fonction"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "les attributs après l'initialisation entre parenthèses sont ignorés"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "la non fonction %qD est déclarée comme un patron implicite"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "la limite du tableau n'est pas une constante entière"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "impossible de définir le membre du typedef dépendant %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> n'est pas un type"
@@ -66769,275 +66856,275 @@ msgstr "%<%T::%E%> n'est pas un type"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "déclarateur invalide"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "utilisation invalide du constructeur comme patron"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "utilisez %<%T::%D%> au lieu de %<%T::%D%> pour nommer le constructeur dans un nom qualifié"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "qualified-id dans une déclaration"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "déclarateur attendu"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD est un espace de noms"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "impossible de former un pointeur vers un membre de la non classe %q#T"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "opérateur pointeur attendu"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "qualificatif CV dupliqué"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "qualificatifs de référence multiples"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "%qE requiert %<-fgnu-tm%>"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "spécificateurs virtuels (virt-specifier) multiples"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "arguments de patron manquants après %qE"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "%qT pas permis dans un argument de patron"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "utilisation invalide de %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "les types ne peuvent pas être définis dans les arguments du patron"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "utilisation invalide de %<auto%> dans un argument de patron"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "spécificateur de type attendu"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr "l'omission de %<,%> avant le %<....%> variadique est déprécié en C++26"
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "%<,%> ou %<...%> attendu"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "des types ne peuvent pas être définis dans des types de paramètres"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "spécificateur %<this%> dans la déclaration des paramètres d'un patron"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr "spécificateur %<this%> dans une expression qui requiert un paramètre"
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "un paramètre objet explicite ne peut pas être un paquet de paramètres"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "des arguments par défaut sont uniquement permis pour des paramètres de fonction"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "le paquet de paramètres %qD ne peut pas avoir d'argument par défaut"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "le paquet de paramètres du patron ne peut pas avoir d'argument par défaut"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "le paquet de paramètres ne peut pas avoir d'argument par défaut"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "un paramètre objet explicite ne peut pas avoir d'argument par défaut"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "le corps d'un function-try-block d'un constructeur %<constexpr%> est uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "le corps du function-try-block de la fonction %<constexpr%> est uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr "une virgule ou un opérateur manque probablement avant"
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les initialisations désignées du C++ sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "le C++ ISO ne permet pas des initialisations par désignation de GNU"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "le C++ ISO ne permet pas des initialisations par désignation du C99"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr "soit toutes les instructions d'initialisation devraient être désignées ou aucune ne devrait l'être"
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "%<...%> pas permis dans une liste d'initialisation par désignation"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr "désignateur %<.%s%> utilisé plusieurs fois dans la même liste d'initialiseurs"
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "nom de classe attendu"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "%<;%> attendu après la définition de la classe"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "%<;%> attendu après la définition de la structure"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "%<;%> attendu après la définition de l'union"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "spécificateur %qD multiple"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "%<{%> ou %<:%> attendu"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "la qualification globale du nom de la classe est invalide"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "le nom qualifié ne nomme pas une classe"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "le mot-clé %<template%> n'est pas permis dans class-head-name (NdT: nom de classe)"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "nom de classe invalide dans la déclaration de %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "déclaration de la spécialisation partielle dans une déclaration d'export sans accolades"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr "une instanciation explicite ne peut pas avoir une définition ; utilisez %<template <>%> pour déclarer une spécialisation"
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "une spécialisation explicite doit être précédée par %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "le patron de fonction %qD est redéclaré comme un patron de classe"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "impossible de résoudre le type de typename"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "définition précédente de %q#T"
@@ -67045,269 +67132,269 @@ msgstr "définition précédente de %q#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr "paquet de paramètres non déroulés dans la classe locale d'un lambda"
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "mot-clé de type classe (class ou struct) attendu"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "le C++ ISO interdit le mot-clé typename dans un paramètre de patron qui est un patron; utilisez %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "%<class%> ou %<typename%> attendu"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "en C++03, le mot-clé class (ou struct) doit être utilisé lors de la déclaration d'un ami"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "les amis variadique de déclarations de types amis avec plusieurs type est uniquement disponible avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "la déclaration amie ne nomme pas une classe ou une fonction"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr "une classe de stockage sur un agrégat anonyme dans une classe n'est pas permis"
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les initialiseurs de membre par défaut pour les champs de bits sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "initialiseur d'un membre par défaut pour un champ de bits sans nom"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr "le C++ ISO autorise les attributs de champs de bits uniquement avant l'élément %<:%>"
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "champ de bits %qD a le type non entier %qT"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "spécificateur pur sur une définition de fonction"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "%<,%> égarée à la fin de la déclaration du membre"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "%<;%> attendu à la fin de la déclaration du membre"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "la raison de %<delete%> est uniquement disponible avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "spécificateur pur invalide (seul %<= 0%> est autorisé)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "une initialisation entre accolades n'est par permise ici"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "les attributs sur des spécificateurs de base sont ignorés"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "%<virtual%> spécifié plus d'une fois dans le spécificateur de base"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "plus d'un spécificateur d'accès dans le spécificateur de base"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "le mot-clé %<typename%> n'est pas permis dans ce contexte (la classe de base est implicitement un type)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "les types ne peuvent pas être définis dans une spécification d'exception"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "le C++17 ISO n'autorise pas la spécification dynamique des exceptions"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "les spécifications dynamiques d'exceptions sont dépréciées en C++11"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "utilisation invalide de %<auto%> dans une spécification d'exception"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<try%> dans une fonction %<constexpr%> uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "des types ne peuvent pas être définis dans une déclaration d'exception"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr "%<alignas%> dans une déclaration d'exception"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%<co_yield> ne peut être utilisé dans des arguments par défaut"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "argument d'attribut attendu comme séquence de jeton équilibrée"
 
 # Je ne suis pas sûr du tout de la signification de « scoped attribute token »…
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "l'attribut de préfixe « using » est utilisé en même temps qu'un élément d'attribut agissant sur une portée"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "un identificateur est attendu pour le nom d'attribut"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr "les parenthèses doivent être omises si la liste d'arguments d'attributs %qE est vide"
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "l'attribut %qs est spécifié plusieurs fois"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr "mélange d'annotations et d'attributs dans la même liste"
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "attribut attendu avant %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "un attribut sans argument ne contient aucun paquet de paramètres"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "expression conditionnelle attendue"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "%qs est uniquement disponible avec %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, gcc-internal-format
 msgid "attributes are ignored on %qs"
 msgstr "les attributs sont ignorés sur %qs"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "les attributs sont ignorés sur les spécificateurs de contrat de fonction"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr "les contrats sont uniquement disponibles avec %qs"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "les annotations sont uniquement disponibles avec %<-std=c++2c%> ou %<-std=gnu++2c%>"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "l'attribut de préfixe « using » est uniquement disponible avec %<-std=c++17%> ou %<-std=gnu++17%>"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "l'expression doit être comprise entre parenthèses"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr "%<requires%> additionnel manquant pour démarrer une expression « requires »"
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr "teste si un id de concept est une expression valide ; ajoutez %<requires%> pour vérifier la satisfaction"
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "le type de résultat n'est pas un contrainte de type simple"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "l'exigence sur le type de retour n'est pas une contrainte de type"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "la syntaxe %<template<>%> est requise pour spécialiser %<%T::%E%>"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "déclaration invalide de %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "trop peu de listes de paramètres pour le patron"
@@ -67316,432 +67403,432 @@ msgstr "trop peu de listes de paramètres pour le patron"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "trop de listes de paramètres pour le patron"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr "template-id n'est pas permis pour un constructeur en C++20"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "les valeurs nommées à retourner ne sont plus supportées"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr "le C++ ISO n'a pas adopté les patrons d'opérateurs de chaînes littérales prenant un paquet d'arguments de caractères"
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "le patron de l'opérateur littéral %qD a une liste de paramètres invalide. On attendait un paquet de paramètres de type non patron %<<char...>%> ou un unique paramètre non-type de type class"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "le patron de l'opérateur littéral %qD a une liste de paramètres invalide. On attendait un paquet de paramètres de type non patron tel que %<<char...>%>"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "déclaration invalide du patron membre dans la classe locale"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "patron avec liaison C"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "spécialisation explicite invalide"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "déclaration de patron de %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "une déclaration de patron de classe ne doit rien déclarer d'autre"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "une spécialisation explicite de patron ne peut pas avoir une classe de stockage"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%> devrait être %<> >%> à l'intérieur d'une liste d'arguments de patron imbriqués"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "le %<>>%> est faux, utilisez %<>%> pour terminer la liste d'arguments du patron"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%qs devrait être %qs pour terminer une liste d'arguments du patron"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "l'argument %<sizeof...%> doit être entouré de parenthèses"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "utilisation invalide de %qD dans la spécification de la classe de liaison"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "le spécificateur %qD est en conflit avec %qs"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> avant %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "le spécificateur %qD est en conflit avec %<typedef%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "le C++ ISO 1998 ne permet pas %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "%<__thread%> et %<thread_local%> sont tous les deux spécifiés"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "%qD dupliqué"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "%qs dupliqué"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "%<new%> attendu"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "%<delete%> attendu"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "%<return%> attendu"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "%<extern%> attendu"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "%<static_assert%> attendu"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "%<decltype%> attendu"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "%<operator%> attendu"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "%<class%> attendu"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "%<template%> attendu"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "%<namespace%> attendu"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "%<using%> attendu"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "%<asm%> attendu"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "%<try%> attendu"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "%<catch%> attendu"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "%<throw%> attendu"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "%<auto%> attendu"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "%<__label__%> attendu"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "%<@try%> attendu"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "%<@synchronized%> attendu"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "%<@throw%> attendu"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "%<__transaction_atomic%> attendu"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "%<__transaction_relaxed%> attendu"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "%<co_yield%> attendu"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "%<::%> attendu"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "%<...%> attendu"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "%<*%> attendu"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "%<~%> attendu"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "%<:%> ou %<::%> attendu"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "%<class%>, %<typename%> ou %<template%> attendu"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "%<:]%> attendu"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr "clé d'énumération redondante dans %<enum%s%> en référence à %q#T"
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "étiquette %qs utilisée en nommant %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T a été précédemment déclaré ici"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "clé de classe %qs redondante en référence à %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT est déclaré avec clé de classe %qs non concordante"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr "retirez la clé de classe ou remplacez là par %qs"
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "remplacez la clé de classe avec %qs"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "%qT est défini en tant que %qs ici"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qT déclaré en tant que %qs pour la première fois ici"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD redéclaré avec un accès différent"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "en C++98, %<template%> (afin de lever une ambigüité) est seulement permis à l'intérieur des patrons"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "fin de fichier dans l'argument par défaut"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "construction Objective-C++ %<@%D%> mal placée"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "récepteur de message objective-c++ attendu"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "un ou des argument(s) de message objective-c++ est/sont attendu(s)"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> doit spécifier un type comme un argument"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "nom de sélecteur Objective-C++ invalide"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "une déclaration de méthode objective-c++ est attendue"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "les attributs de méthodes doivent être spécifiés à la fin"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "%qs égaré entre des méthodes Objective-C++"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "type invalide pour la variable d'instance"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "identificateur attendu après %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "des attributs ne peuvent pas être spécifiés avant le mot-clé %<@%D%> en Objective-C++"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "les attributs de préfixes sont ignorés avant %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "type invalide pour une propriété"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "attribut de propriété %qE inconnu"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "liste d'expressions entières attendue"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "l'expression %<wait%> doit être un nombre entier"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "%<scalar%>, %<aggregate%> ou %<all%> attendu"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "identificateur de réduction invalide"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr "la syntaxe de traits historique %<%E(%E)%> n'est pas permise dans la clause %<uses_allocators%> lorsque des modificateurs sont utilisés"
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "des types ne peuvent pas être définis dans des types d'itérateurs"
@@ -67750,173 +67837,173 @@ msgstr "des types ne peuvent pas être définis dans des types d'itérateurs"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "%<#pragma omp allocated%> n'est pas encore supporté"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "une initialisation entre parenthèses n'est pas permise dans une boucle %<for%> de OpenMP"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "clause %<ordered%> avec un paramètre sur une boucle %<for%> basée sur une portée"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "la variable d'itération %qD ne devrait pas être une réduction"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp declare %s%> suivi de %<#pragma omp declare %s%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma omp dispatch%> doit être suivi d'un appel de fonction direct avec une affectation optionnelle"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD n'est pas un pointeur C"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr "une clause %qs peut uniquement être spécifiée si le sélecteur %<dispatch%> de l'ensemble du sélecteur de construction apparaît dans la clause %<match%>"
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr "la directive OpenMP autre que %<declare simd%> ou %<declare variant%> appartient à une déclaration"
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "%<target%> attendu"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "clause d'initialisation invalide"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "expression id (arguments) attendue"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr "un des arguments de l'appel de l'initialisation devrait être %<omp_priv%> ou %<&omp_priv%>"
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "des types ne peuvent pas être définis dans une liste de types de réductions"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr "type arithmétique %qT prédéclaré dans %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr "type tableau ou fonction %qT dans %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr "type référence %qT dans %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "un qualificatif %<const%>, %<volatile%> ou %<__restrict%> est appliqué au type %qT dans %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "des types ne peuvent pas être définis dans %<declare mapper%>"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "%<simd%>, %<reduction%>, %<target%>, %<mapper%> ou %<variant%> attendu"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr "%<#pragma acc routine%> nomme un ensemble de surcharges"
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD ne fait pas référence à une fonction à l'intérieur de l'espace de noms"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "les directives OpenMP ne peuvent pas apparaitre dans des fonctions %<constexpr%>"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr "%<atomic_cancel%>"
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "le %<__transaction_cancel%> extérieur n'est pas à l'intérieur d'un %<__transaction_atomic%> extérieur"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  ou une fonction %<transaction_may_cancel_outer%>"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "%<#pragma GCC pch_preprocess%> mal composé"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp require%> peut uniquement être utilisé dans la portée du fichier ou de l'espace de noms"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp assume%> peut uniquement être utilisé dans la portée du fichier ou de l'espace de noms"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "%<#pragma GCC %s%> doit être à l'intérieur d'une fonction"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "la compilation multi source n'est pas implémentée pour le C++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "les types à remplacer ne sont pas permis dans ce contexte"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "les patrons implicites ne peuvent pas être %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr "édition de liens %<extern \"C\"%> démarrée ici"
@@ -68388,495 +68475,500 @@ msgstr "utilisez %<template<>%> pour une spécialisation explicite"
 msgid "redeclaration of %qD with different constraints"
 msgstr "redéclaration de %qD avec des contraintes différentes"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "classe locale dans la lambda d'une liste de paramètres du patron"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT n'est pas un type de patron"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "spécificateurs de patron pas spécifiés dans la déclaration de %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "redéclaré avec %d paramètre dans le patron"
 msgstr[1] "redéclaré avec %d paramètres dans le patron"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "la déclaration précédente %qD utilisait %d paramètre dans le patron"
 msgstr[1] "la déclaration précédente %qD utilisait %d paramètres dans le patron"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "paramètre %q+#D du patron"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "redéclaré ici comme %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr "redéclaré ici"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "déclaration du paramètre de patron %q+#D avec des contraintes différentes"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "la déclaration originale apparaît ici"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "redéclaration de %q#D avec des contraintes différentes"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE n'est pas un argument de patron valide pour le type %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "il doit être l'adresse d'une fonction avec une classe de liaison externe"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "il doit être le nom d'une fonction avec une classe de liaison externe"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car %qD n'a pas de classe de liaison"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car %qD n'a pas de classe de liaison externe"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "il doit être un pointeur vers un membre de la forme %<&X::Y%>"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "car il est un membre de %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  n%'a pu déduire le paramètre %qD du patron"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  les types %qT et %qT ont des qualificatifs CV incompatibles"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  types %qT et %qT non concordants"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "  le paramètre %qD du patron n'est pas un paquet de paramètres mais l'argument %qD en est un"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "  l'argument %qE du patron ne correspond pas à la constante %qE qui est un pointeur vers un membre"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE n'est pas équivalent à %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  déduction du paquet de paramètres inconsistante entre %qT et %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  types déduits conflictuels pour le paramètre %qT (%qT et %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  valeurs déduites conflictuelles pour le paramètre non type %qE (%qE et %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "  le type tableau %qT dimensionné par une variable n'est pas un argument de patron valable"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  le type fonction membre %qT n'est pas un argument de patron valable"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  le candidat attend au moins %d argument, %d fourni(s)"
 msgstr[1] "  le candidat attend au moins %d arguments, %d fourni(s)"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  le candidat attend %d argument, %d fourni(s)"
 msgstr[1] "  le candidat attend %d arguments, %d fourni(s)"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  ne peut convertir %qE (type %qT) vers le type %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT est une classe de base ambigüe de %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT n'est pas dérivé de %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  les paramètres du patron d'un argument de patron qui est lui-même un patron sont inconsistants avec les autres arguments déduits pour le patron"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  impossible de déduire un patron pour %qT depuis le type non patron %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "  l'argument de patron %qE ne correspond pas à %qE"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car %qE n'est pas une variable ni une fonction"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE n'est pas un argument de patron valable de type %qT en C++98 car %qD n'a pas une classe de liaison externe"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car %qD n'a pas de classe de liaison"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "l'adresse de %qD n'est pas un argument de patron valable"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "l'adresse du sous-objet %qT de %qD n'est pas un argument de patron valable"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "l'adresse de %qD n'est pas un argument de patron valable car elle n'a pas une durée de stockage statique"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD n'est pas un argument de patron valable car %qD est une variable, pas une adresse d'une variable"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE n'est pas un argument de patron valable pour %qT car ce n'est pas l'adresse d'une variable"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car les chaînes littérales ne peuvent jamais être utilisées dans ce contexte"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "dans l'argument de patron pour le type %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "l'argument de patron %qE pour le type %qT n'est pas une constante durant la compilation"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT à cause de conflits dans les qualificatifs CV"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car ce n'est pas une l-valeur"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D n'est pas un argument de patron valable pour le type %qT car une variable de référence n'a pas une adresse constante"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car il est un pointeur"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "essayez d'utiliser %qE à la place"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE n'est pas un argument de patron valable pour le type %qT car il est du type %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "les attributs sur l'argument %qT du patron sont ignorés"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "les attributs dans l'argument %qE du patron sont ignorés"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "nom de classe injecté %qD utilisé comme argument de patron qui est lui-même un patron"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "utilisation invalide du destructeur %qE comme un type"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "pour faire référence à un membre type d'un paramètre de patron, utilisez %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "non concordance de type/valeur pour l'argument %d dans la liste des paramètres du patron de %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  on attendait une constante de type %qT, on a obtenu %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "  l'argument de patron ambigu pour le paramètre de patron non type est traité comme un type fonction"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  on attendait un patron de classe, on a obtenu %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  on attendait un type, on a obtenu %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  on attendait un type, on a obtenu %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  on attendait un patron de classe, on a obtenu %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  on attendait un patron de type %qD, on a obtenu %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "désaccord de contrainte à l'argument %d dans la liste des paramètres du patron pour %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  on attendait %qD, on a obtenu %qD"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "impossible de convertir l'argument %qE du patron de %qT vers %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "l'argument %d du patron est invalide"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "nombre erroné d'arguments du patron (%d, devrait être %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "nombre erroné d'arguments du patron (%d, devrait être au moins %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr "fournis pour %qD"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "argument d'expansion du paquet pour le paramètre non paquet %qD du patron d'alias %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "argument d'expansion du paquet pour le paramètre non paquet %qD du concept %qD"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr "ainsi, toute instanciation avec un paquet de paramètres non vide serait mal formée"
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D n'est pas un patron de fonction"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "type non patron %qT utilisé comme un patron"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "pour la déclaration du patron %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "échec de la contrainte du patron pour %qD"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "utilisation du patron de variable invalide %qE"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "la profondeur d'instanciation du patron excède le maximum qui est %d (utilisez %<-ftemplate-depth=%> pour augmenter le maximum)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "l'argument du score doit être une expression entière constante"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "l'argument du score doit être non négatif"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "la propriété doit être une expression entière constante ou une chaîne littérale"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "la propriété doit être une expression entière constante"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "instanciation d'un patron erroné"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr "la première erreur est apparue ici"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "membre tableau flexible %qD dans l'union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr "repli de l'expansion vide sur %O"
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE n'est pas le motif entier de l'expansion du paquet"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "les longueurs des paquets d'arguments sont en désaccord durant l'expansion de %qT"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "les longueurs des paquets d'arguments sont en désaccord durant l'expansion de %qE"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr "impossible d'indexer un paquet vide"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "  lors de l'instanciation de l'argument par défaut pour l'appel à %qD"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "création d'un pointeur vers la fonction membre d'un type non classe %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr "les longueurs des paquets d'arguments sont en désaccord (%d vs %d)"
@@ -68894,122 +68986,122 @@ msgstr "les longueurs des paquets d'arguments sont en désaccord (%d vs %d)"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "la variable %qD a un type fonction"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "type de paramètre %qT invalide"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "dans la déclaration de %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "fonction retournant un tableau"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "fonction retournant une fonction"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "%qE n'est pas utilisable dans un type combiné (splice type)"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE n'est pas utilisable dans une portée combinée (splice scope)"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "formation d'une référence vers void"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "formation d'un pointeur vers le type de référence %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "formation d'une référence vers le type de référence %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "formation d'un pointeur vers le type de fonction qualifié %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "formation d'une référence vers le type de fonction qualifié %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "création d'un pointeur vers le membre d'un type non classe %qT"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "création d'un pointeur vers le type de référence au membre %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "création d'un pointeur vers le membre de type void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "création d'un tableau de %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr "%qD étendu à plus d'un élément"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr "%qD est instancié pour un paquet vide"
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT n'est pas un type class, struct ou union"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT est résolu en %qT qui n'est pas un type d'énumération"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT est résolu en %qT qui n'est pas un type de classe non-union"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT est résolu en %qT qui n'est pas un type d'union"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "une réflexion d'un patron de type est attendue"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "utilisation de %qs dans le patron"
@@ -69017,206 +69109,206 @@ msgstr "utilisation de %qs dans le patron"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "la déclaration de %<%T::%D%> dépend d'elle-même"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "le type qualifié %qT ne correspond pas au nom du destructeur ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "le nom dépendant %qE est analysé comme un non type, mais son instanciation produit un type"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "utilisez %<typename %E%> si un type est désiré"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "l'initialiseur pour %q#D est développé en une liste vide d'expressions"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "utilisation invalide de l'expression d'expansion d'un paquet"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "utilisez %<...%> pour dérouler le paquet d'arguments"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "initialisation vide dans l'initialisation par capture de la fonction lambda"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD n'a pas été déclaré dans cette portée et aucune déclaration a été trouvée par le recherche dépendant des arguments au point d'instanciation"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "les déclarations dans la base dépendante %qT ne sont pas trouvées par une recherche non qualifiée"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "utilisez plutôt %<this->%D%>"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "utilisez plutôt %<%T::%D%>"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qD déclaré ici, plus loin dans l'unité de traduction"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "mauvais nombre d'arguments pour %<__builtin_convertvector%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "nombre erroné d'arguments pour l'attribut %<assume%>"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT n'est pas une classe ou un espace de noms"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD n'est pas une classe ou un espace de noms"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "utilisation du champ %qD invalide"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT est/utilise un type anonyme"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "l'argument du patron pour %qD utilise le type local %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT est un type modifié par une variable"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "l'expression intégrale %qE n'est pas une constante"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  tentative d'instancier %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "instanciation de patron ambiguë pour %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "instanciation de patron ambiguë pour %q#D"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr "%s %#qS"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "instanciation explicite du non patron %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD n'est pas un membre de données statique d'un patron de classe"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "aucun patron correspondant trouvé pour %qD"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "le type %qT pour l'instanciation explicite %qD ne correspond pas au type déclaré %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "instanciation explicite de %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "instanciation explicite dupliquée pour %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "le C++ ISO 1998 interdit l'utilisation de %<extern%> sur des instanciations explicites"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "classe de stockage %qD appliquée à l'instanciation du patron"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "instanciation explicite du patron non classe %qD"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "instanciation explicite du type non patron %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "instanciation explicite de %q#T avant la définition de patron"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "le C++ ISO interdit l'utilisation de %qE sur des instanciations explicites"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "instanciation explicite dupliquée de %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "la spécification d'exception %qD dépend d'elle-même"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "la spécification de l'exception de %qD n'est pas disponible avant la fin de la définition de la classe"
@@ -69228,512 +69320,567 @@ msgstr "la spécification de l'exception de %qD n'est pas disponible avant la fi
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "instanciation explicite de %qD mais pas de définition disponible"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "la profondeur d'instanciation du patron excède le maximum de %d lors de l'instanciation de %q+D, peut-être via la génération de la table virtuelle (utilisez %<-ftemplate-depth=%> pour augmenter le maximum)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les paramètres de patrons non typés du type classe déduit sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%qT n'est pas un type valide pour un paramètre non type du patron car il n'est pas structurel"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "les paramètres de patrons non typés du type classe sont uniquement disponibles avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "le paramètre non type du patron est invalide"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T n'est pas un type valide pour un paramètre non type du patron"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "le mot-clé %<template%> n'est pas permis dans declarator-id"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "un concept ne peut être contraint"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "le concept %qE n'est pas dans la portée de l'espace de noms"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "le concept %qE a plusieurs listes de paramètres de patrons"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "la déduction à partir d'une liste d'initialisation entre accolades requiert %<#include <initializer_list>%>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "le patron %qT ne peut être déduit et il est utilisé sans arguments de patron"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "la déduction du patron synonyme est uniquement disponible avec %<-std=c++20%> ou %<-std=gnu++20%>"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "utilisez directement %qD à la place"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr "impossible de déduire les arguments du patron pour l'initialisation par copie de %qT car il n'a pas de guides de déduction non explicites ou de constructeur déclaré par l'utilisateur"
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "impossible de déduire les arguments du patron de %qT car il n'a pas de guides de déduction viables"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "la déduction des arguments du patron de classe a échoué:"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "les guides de déduction explicites ne sont pas pris en compte pour l'initialisation par copie"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "la déduction de l'argument du patron de classe pour %qT a échoué : guide de déduction explicite sélectionné dans l'initialisation par copie de liste"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "guide de déduction explicite déclaré ici"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "%qT peut ne pas avoir l'intention de supporter la déduction d'argument pour un patron de classe"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr "ajoutez un guide de déduction pour supprimer cet avertissement"
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr "l'initialisation par liste directe de %<auto%> requiert exactement un élément"
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr "pour la déduction de %<std::initializer_list%>, utilisez l'initialisation par liste copiée (c-à-d ajoutez %<=%> avant le %<{%>)"
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "impossible de déduire le type de retour de la lambda à partir de %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "impossible de déduire %qT à partir de %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "les contraintes sur le type à remplacer ne sont pas satisfaites"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "l'initialisation déduite ne satisfait pas les contraintes du type à remplacer"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "le type retourné déduit ne satisfait pas les contraintes du type à remplacer"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "le type déduit pour l'expression ne satisfait pas les contraintes du type à remplacer"
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "%<^^%> ne peut pas être appliqué à un type à remplacer"
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "%<^^%> ne peut être appliqué à un index de paquet"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%<^^%> ne peut pas être appliqué au paramètre de patron non-type %qD"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "%<^^%> ne peut pas être appliqué à une capture %qD"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr "%<^^%> ne peut pas être appliqué au paramètre local d'une expression requise %qD"
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr "%<^^%> ne peut pas être appliqué à une entité locale pour laquelle il n'y a pas d'expression lambda intervenante"
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "%<^^%> ne peut être appliqué à une déclaration « using »"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "%<^^%> ne peut être appliqué à une vérification de concept"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr "impossible de prendre la réflexion d'un ensemble surchargé"
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "type %qT incorrect de l'argument %d, %qT attendu"
+
+#: cp/reflect.cc:476
 #, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<std::ranges%> n'est pas un espace de noms"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr "%<reflect_constant_string%> appelé avec %qT plutôt que %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> ou %<char32_t%>"
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "l'argument %<reflect_constant_array%> avec %qT qui n'est pas un type structuré"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr "l'argument %<reflect_constant_array%> avec %qT qui ne peut pas être construit par copie"
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr "l'argument %<reflect_constant_array%> avec %qT qui n'est pas compatible avec %qT %<std::ranges::range_reference_t%>"
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr "l'argument %<reflect_constant_array%> avec %qT qui ne peut pas être construit depuis %qT %<std::ranges::range_reference_t%>"
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr "%<std::ranges::data%> ou %<std::ranges::size%> ne sont pas des objets avec des points de personnalisation"
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr "%<std::ranges::begin%> ou %<std::ranges::end%> manquant"
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr "type %qT incorrect de %<std::ranges::begin(arg)%>"
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr "type %qT incorrect de %<std::ranges::end(arg)%>"
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr "%qD devrait lever %qs ; %<what()%>: %qs"
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr "les exceptions sont désactivées, traitées comme non constantes"
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr "n%'a pu lever %qs"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr "%<std::meta::operators%> inattendu"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr "impossible de rechercher %<%D::%D%>"
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, gcc-internal-format
 msgid "couldn%'t look up %qs"
 msgstr "impossible de rechercher %qs"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr "type inattendu en retour de %qs"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr "%qT doit être un type structure sans qualificatif cv qui n'est pas un type de référence"
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr "%qT doit être un type objet"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "%qT doit être un type fonction"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr "impossible d%'instancier %<std::%s<%T>%>"
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "argument de %<data_member_options%> inattendu"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "le premier argument de %<define_aggregate%> n'est pas une réflexion de type classe"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr "le premier argument de %<define_aggregate%> est une réflexion d'un synonyme de type"
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr "le premier argument de %<define_aggregate%> est une réflexion d'un type de classe qualifié CV"
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr "le premier argument de %<define_aggregate%> est une réflexion d'un type de classe complète"
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr "le premier argument de %<define_aggergate%> est une réflexion d'un type de classe %qT en cours de définition"
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr "l'argument de %<define_aggregate%> n'est pas une description de membre de donnée"
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr "l'argument %<define_aggregate%> a une description de membre de donnée sans type complet"
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr "le nom %qD est utilisé dans plusieurs descriptions de membre de données"
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "ne peut déclarer le champ de bits dans le type %<warn_if_not_aligned%>"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr "%<define_aggregate%> n'est pas évalué depuis le bloc %<consteval%>"
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr "%<define_aggregate%> est évalué depuis le bloc %<consteval%> qui englobe %qT en cours de définition"
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "le bloc %<consteval%> est défini ici"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr "%qD intervient entre la portée %qT et le bloc %<consteval%> duquel %<define_aggregate%> est évalué"
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr "%qT intervient entre la portée %qT et le bloc %<consteval%> duquel %<define_aggregate%> est évalué"
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr "%qD intervient entre le bloc %<consteval%> duquel %<define_aggregate%> est évalué et la portée %qT"
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr "%qT intervient entre le bloc %<consteval%> duquel %<define_aggregate%> est évaluée et la portée %qT"
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr "%<define_aggregate%> est évalué depuis le bloc %<consteval%> inclus par %qD tandis que le type %qT en cours de définition est inclus par %qD"
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr "%<define_aggregate%> est évalué depuis le bloc %<consteval%> inclus par %qD tandis que le type %qT en cours de définition est inclus par %qT"
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr "%<define_aggregate%> est évalué depuis le bloc %<consteval%> inclus par %qT tandis que le type %qT en cours de définition est inclus par %qD"
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr "%<define_aggregate%> est évalué depuis le bloc %<consteval%> inclus par %qT tandis que le type %qT en cours de définition est inclus par %qT"
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
-msgstr "%<access_context::current%> est utilisé en dehors d'une évaluation manifestement constante"
+msgid "%qs used outside of manifestly constant-evaluation"
+msgstr "%qs utilisé en dehors d'une évaluation manifestement constante"
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "argument %<access_context%> invalide"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr "%<access_context::scope()%> inattendu"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr "%<access_context::designating_class()%> inattendu"
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "argument de %qs inattendu"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "type %qT incorrect de l'argument %d, %qs attendu"
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "type de retour %qT incorrect, %qs attendu"
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "type de retour %qT incorrect, %qT attendu"
+
+#: cp/reflect.cc:7826
 #, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "métafonction %qD inconnue"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "l'argument combiné (splice argument) doit être une expression de type %qs"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "impossible de combiner une réflexion nulle"
+
+#: cp/reflect.cc:8540
+#, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "impossible d'utiliser la réflexion du paramètre de la fonction %qD dans une expression combinée"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr "appliquez %<std::meta::variable_of%> dessus avant de le combiner"
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr "la variable uniquement consteval %qD qui n'est pas déclarée %<consteval%> est utilisée en dehors d'un contexte évalué constant"
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "ajouter %<constexpr%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "les expressions uniquement consteval sont uniquement autorisées dans un texte évalue constant"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "une fonction de type uniquement consteval doit être déclarée %qs"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr "une réflexion ou une expression est attendue"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "ajoutez %<typename%> pour indiquer un type en dehors d'un contexte de type uniquement"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "impossible d'utiliser le constructeur ou le destructeur %qD dans une expression combinée"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "impossible d'utiliser le champ de bits non nommé %qD dans une expression combinée"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "impossible de référencer implicitement un membre de classe %qD au travers d'une combinaison"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "accès à un membre de classe invalide du type de patron %qE"
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr "ne peut utiliser %qE pour accéder à un membre de classe"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr "%<&%> unaire applique à un membre d'union anonyme %qD qui n'est pas un membre direct d'une classe nommée"
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "utilisation d'une variable locale avec un stockage automatique dans la fonction contenante dans une expression combinée"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "impossible d'utiliser une annotation %qE dans une expression combinée"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr "impossible d'utiliser une spécification de membre de données dans une expression combinée"
 
+#: cp/reflect.cc:9114
+#, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "une réflexion d'un patron de fonction est attendue"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr "une réflexion d'une fonction ou d'un patron variable est attendu"
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -70064,585 +70211,585 @@ msgstr "définition invalide du type qualifié %qT"
 msgid "invalid base-class specification"
 msgstr "spécification de classe de base invalide"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "impossible de capturer le membre %qD d'une union anonyme"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD n'est pas capturé"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "la lambda n'a pas de capture par défaut"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr "la lambda dans la classe locale %q+T ne sait pas capturer des variables du contexte englobant"
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "utilisation d'une variable locale avec un stockage automatique dans la fonction contenante"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "utilisation d'un paramètre dans la fonction contenante"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "utilisation du paramètre en dehors du corps de la fonction"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr "arguments de patron manquants"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "le paramètre %qD du patron, du type %qT, n'est pas permis dans une expression constante intégrale parce qu'il n'est pas d'un type intégral ou énuméré"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "utilisation du patron de classe %qT comme expression"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "l'accès au membre %qD est ambigu dans un réseau d'héritages multiples"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD ne peut pas apparaître dans une expression constante"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr "%qD « this » requis en accédant au membre à l'intérieur de la vérification de contrat de la précondition d'un constructeur ou la postcondition d'un destructeur"
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "le type de %qE est inconnu"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT n'est pas un type énuméré"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "le paquet d'index a le type non entier %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "l'index du paquet n'est pas une constante entière"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "l'index du paquet %qE est négatif"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr "l'index du paquet %qE est hors limites pour le paquet de longueur %qd"
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "Le paquet de paramètres %<__bases%> est uniquement valable dans la déclaration d'un patron"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "impossible d'appliquer %<offsetof%> au destructeur %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "impossible d'appliquer %<offsetof%> à la fonction membre %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "impossible d'appliquer %<offsetof%> à la fonction membre"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "impossible d'appliquer %<offsetof%> à un énumérateur %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "l'utilisation de %<offsetof%> à l'intérieur du type %qT (qui ne respecte pas l'agencement standard) est supporté conditionnellement"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "la correspondance d'un pointeur vers un membre %qE n'est pas supportée"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "la recherche de la réduction définie par l'utilisateur est ambiguë"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %#qD"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "%qE dans la clause %<reduction%> est un tableau de taille nulle"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE a le type const pour %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr "réduction définie par l'utilisateur avec une initialisation du constructeur pour la classe de base %qT"
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "%qT n'est pas une structure, une union ou un type de classe dans %<#pragma omp declare mapper%>"
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "%qT doit être une classe de base virtuelle dans %<#pragma acc declare mapper%>"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "littéral de chaîne ou expression entière constante attendue au lieu de %qE"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr "modificateur autre que %<val%> spécifié dans la clause %<linear%> sur des constructions %<simd%> ou %<for%> en utilisant des modificateurs OpenMP 5.2"
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr "la clause linéaire avec le modificateur %qs est appliquée à la variable non référence ayant le type %qT"
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr "clause linéaire appliquée à la variable non entière non pointeur ayant le type %qT"
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "l'expression du pas de « linear » doit être un entier"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr "%<this%> est autorisé dans OpenMP uniquement dans les clauses %<declare simd%>"
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD n'est pas une variable dans la clause %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD n'est pas une variable dans la clause %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD n'est pas une variable dans la clause %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "l'expression statique %<gang%> doit être un entier"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "la valeur statique de %<gang%> doit être positive"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "l'expression numérique de %<gang%> doit être un entier"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "l'expression de longueur de %<vector%> doit être un entier"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "l'expression numérique de %<worker%> doit être un entier"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "la valeur numérique de %<gang%> doit être positive"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "la valeur de longueur de %<vector%> doit être positive"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "la valeur numérique de %<worker%> doit être positive"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "l'expression de taille des tranches d'ordonnancement doit être un entier"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "l'expression de longueur de %qs doit être un entier"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "l'expression de longueur %qs doit être une expression entière constante positive"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "l'expression de %<async%> doit être un entier"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "l'expression de %<thread_limit%> doit être un entier"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "l'identifiant de %<device%> doit être entier"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "l'expression de la taille des tranches de %<dist_schedule%> doit être un entier"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD n'est pas une variable dans la clause %<aligned%>"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr "%qE dans la clause %<aligned%> n'est ni un pointeur ni un tableau ni une référence vers un pointeur ou un tableau"
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses %<aligned%>"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "l'expression d'alignement de la clause %<aligned%> doit être un entier"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD n'est pas une variable dans la clause %<nontemporal%>"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses %<nontemporal%>"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%<this%> n'est pas autorisé dans la clause %<allocate%>"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD n'est pas une variable dans la clause %<allocate%>"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD apparaît plus d'une fois dans les clauses %<allocate%>"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "le membre de classe %qE n'est pas encore supporté dans la clause %<uses_allocators%>"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "les modificateurs ne peuvent pas être utilisé dans les allocateurs prédéfinis"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr "les tableaux de traits de longueur variable ne sont pas encore supportés"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD n'est pas une expression l-valeur ni une section de tableau dans une clause %qs"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "patron %qE dans la clause %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr "nom de fonction surchargée %qE dans la clause %qs"
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "l'expression de %<grainsize%> doit être un entier"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "l'expression de %<priority%> doit être un entier"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "l'expression %<hint%> doit être un nombre entier"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "l'expression %<hint%> doit être une expression entière constante"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "l'expression %<filter%> doit être un nombre entier"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "la variable %qs n'est ni un pointeur ni une référence à un pointeur"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "la variable %qs n'est ni un pointeur ni un tableau ni une référence à un pointeur ou un tableau"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "l'argument de %<tile%> doit être de type entier"
 
 # Cette traduction aurait du sens si on pouvait changer l'ordre des %. Je n'arrive pas à savoir si c'est possible.
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "%<const%> qualifiant %qE sans membre %<mutable%> ne peut apparaître que dans les clauses %<shared%> ou %<firstprivate%>"
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD n'est pas un fichier, un espace de noms ou une variable déclarée dans un bloc"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "la directive %<threadprivate%> %qE n'est pas dans la définition de %qT"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "la différence entre %qE et %qD n'est pas un type entier"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<#pragma omp simd%> utilisé avec la variable d'itération de classe %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic update%> utilise deux expressions différentes pour la mémoire"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr "la chaîne constexpr doit être une chaîne littérale ou un objet avec les membres %<size%> et %<data%>"
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr "la chaîne constexpr %<size()%> doit pouvoir être implicitement convertie en %<std::size_t%>"
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr "la chaîne constexpr %<data()%> doit pouvoir être implicitement convertie en %<const char*%>"
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "la chaîne constepxr %<size()%> doit être une expression constante"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr "la chaîne constexpr %<size()%> %qE est trop grande"
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr "retour non géré depuis %<data()%>"
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "la chaîne constexpr %<data()[%d]%> doit être une expression constante"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "la chaîne constexpr %<data()%> doit être une expression constante du noyau"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr "impossible de convertir une chaîne constexpr depuis l'encodage UTF-8 vers l'ensemble de caractères source"
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr "impossible de convertir une chaîne constexpr depuis un encodage littéral ordinaire vers un ensemble de caractères source"
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "l'assertion statique a échoué : %.*s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "condition non constante pour l'assertion statique"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "l'argument de %<decltype%> doit être une expression"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%<decltype%> ne sait pas résoudre l'adresse d'une fonction surchargée"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "%qT n'est pas un type de classe non union"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "%qT n'est pas un type ayant une disposition standard"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr "%<__builtin_is_pointer_interconvertible_with_class%> a besoin d'un seul argument"
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr "l'argument de %<__builtin_is_pointer_interconvertible_with_class%> n'est pas un pointeur vers un membre"
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr "%<__builtin_is_corresponding_member%> n'est pas bien défini pour des unions anonymes"
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_is_corresponding_member%> a besoin de deux arguments"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr "l'argument de %<__builtin_is_corresponding_member%> n'est pas un pointeur vers un membre"
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_is_string_literal%> a besoin d'un seul argument"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr "l'argument de %<_builtin_is_string_literal%> n'est pas %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> ou %<const char32_t*%>"
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr "vérification de %qs pour le type %qT avec un destructeur qui ne peut pas être appelé"
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "%qs a l'argument %qT qui est une référence"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qD n'est pas un patron de classe ou un alias"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "l'opérande de l'expression fold n'a aucun paquet de paramètres non déroulé"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "les deux arguments dans le fold binaire ont des paquets de paramètres non déroulés"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr "aucun paquet de paramètres non déroulés dans le fold binaire"
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "le type %qT de l'argument de %<__builtin_launder%> n'est pas un pointeur vers un type objet"
@@ -70650,342 +70797,342 @@ msgstr "le type %qT de l'argument de %<__builtin_launder%> n'est pas un pointeur
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr "%<__builtin_bit_cast%> a le type de destination %qT qui est un type tableau"
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr "%<__builtin_bit_cast%> a le type de destination %qT qui n'est pas trivialement copiable"
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "%<__builtin_bit_cast%> ne peut pas être utilisé avec des types uniquement consteval"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr "%<__builtin_bit_cast%> a le type source %qT qui n'est pas trivialement copiable"
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr "%<__builtin_bit_cast%> a la taille source %qE qui n'est pas égale à la taille du type destination %qE"
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "les qualificatifs %qV ne peuvent pas être appliqués à %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr "%<-fabi-version=13%> (GCC 8.2) corrige la convention d'appel pour %qT qui a changé accidentellement en 8.1"
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr "%<-fabi-version=12%> (GCC 8.1) change accidentellement la convention d'appel pour %qT"
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr " déclaré ici"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "la convention d'appel pour %qT change avec %<-fabi-version=13%> (GCC 8.2)"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr " car tous ses constructeurs par copie et déplacement sont supprimés"
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "%qT est un type en virgule flottante"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "%qT est un type en virgule fixe"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qD ne rempli pas tous les bits de %q#T"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr "%qD a le type %qT qui n'a pas de représentation objet unique"
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr "%q#T n'a pas de champs de données"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr "%<std::nullptr_t%> a des bits de remplissage mais pas de bits de valeur"
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr "la base %qT n'a pas de représentation objet unique"
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr "%qD avec le type %qT n'a pas de représentation objet unique"
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr "le remplissage a lieu entre %qD et %qD"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr "le champ de bits sans nom insère du remplissage avant %qD"
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr "le remplissage a lieu avant %qD"
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr "le remplissage a lieu après %qD"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "%qT a du remplissage mais pas de champs de données"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "la classe de base %qT n'est pas publique"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%qD n'est pas public"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD n'est pas mutable"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qD a un type non structurel"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "l'attribut %qE peut uniquement être appliqué aux fonctions ou aux paramètres"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "l'argument de l'attribut %qE doit être une constante de chaîne de caractères"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "l'attribut %qE peut uniquement être appliqué aux fonctions ou aux classes ou aux types énumérés"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "l'attribut %qE peut uniquement être appliqué aux membres de données non statiques"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "l'attribut %qE ne peut pas être appliqué à un champ de bits"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "l'attribut %qE ne prend pas d'argument"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "l'attribut %qE du C++ ISO ne s'applique pas aux fonctions; il est traité comme %<[[gnu::%E]]%>"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "%<alignas%> sur une déclaration de fonction"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%<alignas%> sur un type énuméré"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr "%<alignas%> sur un type autre qu'une classe"
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr "%<alignas%> sur un champ de bits"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr "%<alignas%> sur un alias de type"
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qE sur un type autre qu'une classe ou une définition d'énumération"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "%qE sur un champ de bits sans nom"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr "%qE sur une étiquette %<case%> ou %<default%>"
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "%qE sur une déclaration autre qu'un paramètre ou une variable automatique"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "le %<init_priority%> demandé n'est pas une constante entière"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "l'attribut %qE peut uniquement être utilisé sur les définitions dans la portée du fichier d'objets de type classe"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "le %<init_priority%> %i demandé est hors des limites [0, %i]"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "le %<init_priority%> %i demandé est réservé pour un usage interne"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "la redéclaration de %qD ajoute l'étiquette d'ABI %qE"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "l'attribut %qE requiert des arguments"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "les arguments de l'attribut %qE doivent être des chaînes littérales étroites"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "les arguments de l'attribut %qE doivent contenir des identificateurs valables"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%c%> n'est pas un premier caractère valable pour un identificateur"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%c%> n'est pas un caractère valable dans un identificateur"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "attribut %qE appliqué au type %qT qui n'est ni une classe ni un enum"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "attribut %qE appliqué à %qT après sa définition"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "l'attribut %qE est ignoré car il est appliqué à l'instanciation du patron %qT"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "l'attribut %qE est ignoré car il est appliqué à la spécialisation du patron %qT"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "attribut %qE appliqué à %qD qui n'est ni une fonction ni une variable"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "attribut %qE appliqué à la déclaration extern \"C\" %qD"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "l'argument de l'attribut %qE doit être une expression qui est évaluée à vrai ou faux"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "annotation sur un type autre qu'une classe ou une définition d'énumération"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, gcc-internal-format
 msgid "annotation applied to a label"
 msgstr "annotation appliquée à une étiquette"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "annotation sur un champ de bits sans nom"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, gcc-internal-format
 msgid "annotation on void parameter"
 msgstr "annotation sur un paramètre « void »"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr "l'annotation n'a pas un type structurel"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, gcc-internal-format
 msgid "annotation does not have copy constructible type"
 msgstr "l'annotation n'a pas un type qui peut être construit par copie"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "vérification de %<lang_*%> : échec dans %s, à %s:%d"
@@ -71185,795 +71332,800 @@ msgstr "%q#T n'a pas de membre nommé %qE; vouliez-vous utiliser %q#D ? (pas ac
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%q#T n'a pas de membre nommé %qE; vouliez-vous utiliser %qE ?"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> n'est pas un membre de %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "%q#D n'est pas un membre de %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD n'est pas une fonction patron membre"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT n'est pas un type pointeur vers un objet"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "utilisation invalide de l'indexation de tableau sur un pointeur vers un membre"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "utilisation invalide du %<*%> unaire sur un pointeur vers un membre"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "utilisation invalide de la conversion implicite d'un pointeur vers un membre"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr "l'opérande de gauche de %<->*%> doit être un pointeur vers une classe mais il est un pointeur vers un membre du type %qT"
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "indice manquant dans la référence du tableau"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "l'accès indicé du tableau est déclaré %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "la valeur indicée n'est ni un tableau ni un pointeur"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "objet manquant dans l'usage de %qE"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr "aucune version par défaut dans la portée"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "le C++ ISO interdit l'appel de %<::main%> depuis l'intérieur du programme"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "il faut utiliser %<.*%> ou %<->*%> pour appeler une fonction via un pointeur vers un membre dans %<%E (...)%>, par ex: %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "%qT ne peut pas être utilisé comme une fonction"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE ne peut pas être utilisé comme une fonction"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD ne peut pas être utilisé comme une fonction"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "l'expression ne peut pas être utilisée comme une fonction"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "trop d'arguments pour le constructeur %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "pas assez d'arguments pour le constructeur %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "trop d'arguments pour la fonction membre %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "trop peu d'arguments pour la fonction membre %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "trop d'arguments pour la fonction %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "trop peu d'arguments pour la fonction %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "trop d'arguments pour la méthode %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "pas assez d'arguments pour la méthode %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "trop d'arguments pour la fonction"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "trop peu d'arguments pour la fonction"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "le paramètre %P de %qD a un type incomplet %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "le paramètre %P a un type incomplet %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "l'adresse de %qE ne sera jamais NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "l'adresse de %qD ne sera jamais NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "le compilateur peut supposer que l'adresse de %qE ne sera jamais NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr "comparaison du résultat de l'addition de pointeur %qE et NULL"
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "le compilateur peut supposer que l'adresse de %qD ne sera jamais NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "opération au niveau des bits entre les types énumérés différents %qT et %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "l'opération au niveau des bits entre les types énumérés différents %qT et %qT est dépréciée"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "arithmétique entre des types énumérés différents %qT et %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "l'arithmétique entre des types énumérés différents %qT et %qT est dépréciée"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "comparaison du type énuméré %qT avec le type en virgule flottante %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "comparaison du type en virgule flottante %qT avec le type énuméré %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr "la comparaison du type énuméré %qT avec le type en virgule flottante %qT est dépréciée"
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "la comparaison du type en virgule flottante %qT avec le type énuméré %qT est dépréciée"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "arithmétique entre le type énuméré %qT et le type en virgule flottante %qT"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "arithmétique entre le type en virgule flottante %qT et le type énuméré %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr "l'arithmétique entre le type énuméré %qT et le type en virgule flottante %qT est déprécié"
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr "l'arithmétique entre le type en virgule flottante %qT et le type énuméré %qT est déprécié"
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "suppose un transtypage vers le type %qT depuis la fonction surchargée"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL utilisé en arithmétique"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "le C++ ISO interdit la comparaison entre un pointeur et un entier"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "les types des opérandes sont %qT et %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr "comparaison à trois voies de vecteurs"
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "comparaison ordonnée d'un pointeur avec un zéro entier (%qT et %qT)"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "comparaison non ordonnée sur un argument n'étant pas en virgule flottante"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "conversion implicite de %qH vers %qI pour correspondre à d'autres opérandes de l'expression binaire"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "les opérandes des types %qT et %qT sont invalides pour le %qO binaire"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "le C++ ISO interdit l'utilisation d'un pointeur de type %<void *%> dans une soustraction"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "le C++ ISO interdit l'utilisation d'un pointeur vers une fonction dans une soustraction"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "le C++ ISO interdit l'utilisation d'un pointeur vers une méthode dans une soustraction"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "utilisation invalide d'un pointeur vers un type incomplet dans un pointeur arithmétique"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "prise de l'adresse du destructeur %qD"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "prise de l'adresse du destructeur %qD"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "utilisation invalide de %qE pour former un pointeur vers une fonction membre"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  un qualified-id est requis"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "les parenthèses autour de %qE ne peuvent pas être utilisées pour former un pointeur vers une fonction membre"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "le C++ ISO interdit de prendre l'adresse d'une fonction membre non statique non qualifié ou entre parenthèses pour former un pointeur vers une fonction membre. Utilisez %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "le C++ ISO interdit de prendre l'adresse d'une fonction membre non statique non qualifié ou entre parenthèses pour former un pointeur vers une fonction membre d'un objet explicite"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "le C++ ISO interdit de prendre l'adresse d'une fonction membre liée pour former un pointeur vers une fonction membre. Utilisez %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "le C++ ISO interdit de prendre l'adresse d'une fonction membre liée pour former un pointeur vers une fonction membre d'un objet explicite"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "un pointeur vers une fonction membre d'un objet explicite peut seulement être formé avec %<&%T::%D%>"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "prise de l'adresse d'une r-valeur"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "le C++ ISO interdit de prendre l'adresse de la fonction %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "ne peut créer un pointeur vers le membre de référence %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "tentative de prendre l'adresse d'un champ de bits"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<~%> sur une expression de type %<bool%>"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr "vouliez-vous utiliser le non logique (%<!%>) ?"
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "le C++ ISO interdit d'incrémenter un enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "le C++ ISO interdit de décrémenter un enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "ne peut incrémenter un pointeur vers le type incomplet %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "ne peut décrémenter un pointeur vers le type incomplet %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "le C++ ISO interdit d'incrémenter un pointeur du type %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "le C++ ISO interdit de décrémenter un pointeur du type %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr "l'expression %qs du type qualifié avec %<volatile%> est dépréciée"
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr "l'utilisation d'un opérande du type %qT dans %<operator--%> est interdite"
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr "l'utilisation d'un opérande du type %qT dans %<operator++%> est interdite en C++17"
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr "l'utilisation d'un opérande du type %qT dans %<operator++%> est dépréciée"
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "ne peut prendre l'adresse de %<this%> qui est une expression r-valeur"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "adresse requise pour %qD qui est déclaré %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "une initialisation par liste pour un type non classe ne doit pas être entre parenthèses"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "la liste d'expressions est traitée comme une expression composée dans l'initialisation"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "la liste d'expressions est traitée comme une expression composée dans l'initialisation mémoire"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "la liste d'expressions est traitée comme une expression composée dans le transtypage fonctionnel"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "la liste d'expressions dans « %s » est traitée comme une expression composée"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "pas de contexte pour résoudre le type de %qE"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "le transtypage du type %qT vers le type %qT élimine les qualificatifs"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "utiliser %<static_cast%> pour transtyper du type %qT vers le type %qT élimine les qualificatifs"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "utiliser %<reinterpret_cast%> pour transtyper du type %qT vers le type %qT élimine les qualificatifs"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "transtypage inutile vers le type %q#T"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "les qualificatifs de type sont ignorés sur le type résultant du transtypage"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "%<static_cast%> invalide depuis le type %qT vers le type %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "le type classe %qT est incomplet"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr "conversion de %qH vers %qI"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "transtypage invalide d'une expression pr-valeur du type %qT vers le type %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr "le transtypage de %qH vers %qI perd en précision"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr "transtypage entre types de fonctions incompatibles de %qH vers %qI"
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "transtypage entre des pointeurs incompatibles vers des types membres de %qH vers %qI"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "le transtypage de %qH vers %qI augmente l'alignement requis pour le type ciblé"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "le transtypage entre un pointeur vers une fonction et un pointeur vers un objet est supporté conditionnellement"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "transtypage invalide à partir du type %qT vers le type %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "utilisation invalide de %<const_cast%> avec le type %qT qui n'est pas un pointeur, une référence, ni un type pointeur vers une donnée membre"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "utilisation invalide de %<const_cast%> avec le type %qT qui est un pointeur ou une référence à un type fonction"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "%<const_cast%> invalide d'une r-valeur du type %qT vers le type %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "%<const_cast%> invalide à partir du type %qT vers le type %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "le C++ ISO interdit le transtypage vers un type tableau %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "transtypage invalide vers le type fonction %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr "déplacement de %qE de type %qT sur lui-même"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  lors de l'évaluation de %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "affectation à un tableau depuis une liste d'initialisation"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "types incompatibles dans l'affectation de %qT vers %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "tableau utilisé comme initialisation"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "affectation de tableau invalide"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   dans la conversion d'un pointeur vers une fonction membre"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "conversion d'un pointeur vers un membre via la base virtuelle %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   dans la conversion d'un pointeur vers un membre"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "conversion invalide vers le type %qT à partir du type %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "ne peut convertir %qH en %qI dans l'argument par défaut"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "ne peut convertir %qH en %qI dans le passage d'argument"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "ne peut convertir %qH en %qI dans l'initialisation"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr "ne peut convertir %qH en %qI dans le retour"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "ne peut convertir %qH en %qI dans l'affectation"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "le paramètre %qP de %qD pourrait être un candidat pour un attribut de format"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "le paramètre pourrait être un candidat pour un attribut de format"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "la cible de la conversion pourrait être une candidate pour un attribut de format"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "la cible de l'initialisation pourrait être une candidate pour un attribut de format"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "le membre de gauche de l'affectation pourrait être un candidat pour un attribut de format"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "dans le passage de l'argument %P de %qD"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "retourne une référence vers un temporaire"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "retourne un pointeur vers un temporaire"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr "retourner une %<initializer_list%> temporaire n'étend pas la durée de vie du tableau sous-jacent"
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "référence vers la variable locale %qD retournée"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr "retourner la variable %<initializer_list%> locale %qD n'étend pas la durée de vie du tableau sous-jacent"
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "adresse de l'étiquette %qD retournée"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "adresse de la variable locale %qD retournée"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr "déplacer un objet temporaire empêche l'élision de la copie"
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr "supprime l'appel à %<std::move%>"
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr "déplacer un objet local dans une instruction de retour empêche l'élision de la copie"
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "déplacement redondant dans l'instruction de retour"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "déplacement redondant dans l'initialisation"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "retourne une valeur depuis un destructeur"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "ne peut retourner depuis le gestionnaire d'un try..catch sur tout le constructeur"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "retourne une valeur depuis un constructeur"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "instruction « return » sans valeur dans une fonction retournant %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr "liste d'initialisation retournée"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "les types incohérents %qT et %qT sont déduits du type retourné par la lambda"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "déduction incohérente pour le type de retour auto: %qT et puis %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "instruction « return » avec une valeur dans une fonction retournant %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> ne doit pas retourner NULL à moins qu'il soit déclaré %<throw()%> (ou %<-fcheck-new%> est actif)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "copie non élidée au retour de %qD"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr "copie non élidée au retour dans %qD"
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "utilisation d'une r-valeur comme l-valeur"
@@ -72377,17 +72529,17 @@ msgstr "impossible d'ouvrir le fichier journal %<vtv_set_ptr_data.log%>: %m"
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "impossible d'ouvrir le fichier journal %<vtv_count_data.log%>: %m"
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "attribut %qs inconnu"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%q+D déclaré faible après avoir été utilisé"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr "seuls les fanions %<inbranch%> et %<notinbranch%> sont permis pour l'attribut %<simd%>"
@@ -72412,43 +72564,43 @@ msgstr "initialiseurs qui se chevauchent pour le champ %qT.%qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "l'adresse de %qD ne sera jamais %<null%>"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr "%<this%> est nécessaire pour accéder au membre %qE"
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr "tentative de réaliser une division modulo en virgule flottante sur %qT"
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "impossible d'obtenir un pointeur de trame vers %qs"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr "corps manquant pour la fonction imbriquée"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qs est une fonction imbriquée, elle n'est pas accessible depuis %qs"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr "la variable %qs a une destruction dans la portée, impossible de créer la fermeture"
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "la variable de registre explicite %qs ne peut pas être utilisée dans une fonction imbriquée"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "référence anticipée vers une trame de %qs"
@@ -72526,32 +72678,32 @@ msgstr "argument invalide pour %<-fmodule-file=%> : %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "argument invalide pour %<-fversion=%> : %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "ne peut ouvrir %s en écriture : %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "écriture du fichier de sortie %s : %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "ne peut ouvrir %s en lecture : %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "lecture du fichier ddoc %s : %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr "l'argument de %<-fonly=%> est différent de celui du premier nom de fichier en entrée"
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr "impossible de résoudre la référence anticipée dans la définition"
@@ -72648,7 +72800,7 @@ msgstr "manière de supprimer %qs inconnue"
 msgid "%qs is not an associative array"
 msgstr "%qs n'est pas un tableau associatif"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr "%<this%> est nécessaire pour accéder au membre %qs"
@@ -72663,22 +72815,22 @@ msgstr "les délégués sont uniquement pour des fonctions non statiques"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs n'est pas un champ mais un %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "référence %qs récursive"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr "expression %qs non constante"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%qs n'est pas une expression"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "le type %qs n'est pas une expression"
@@ -72769,17 +72921,17 @@ msgstr "impossible de lever une exception sur des objets COM"
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "les instruction assembleur en-ligne pour D ne sont pas supportées dans GDC."
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr "l'expression %qs requiert %<object.TypeInfo%> et ne peut pas être utilisée avec %<-fno-rtti%>"
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<object.TypeInfo%> ne peut pas être utilisé avec %<-fno-rtti%>"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr "%<objet.TypeInfo%> n'a pas été trouvé mais il est implicitement utilisé"
@@ -73101,8 +73253,8 @@ msgstr "La référence de tableau à %C ne peut pas avoir plus de %d dimensions"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "Co-tableaux désactivés à %C, utilisez %<-fcoarray=%> pour l'activer"
@@ -73379,7 +73531,7 @@ msgstr "La constante littérale BOZ à %L ne peut pas être un argument effectif
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "Les arguments de %qs à %L et %L ne peuvent pas être tous les deux des constantes littérales BOZ"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "Utilisation invalide de la constant littérale BOZ à %L"
@@ -73454,7 +73606,7 @@ msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être REAL ou COMPLEX"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être INTEGER ou PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être une constante"
@@ -73594,7 +73746,7 @@ msgstr "La constante littérale BOZ à %L ne peut pas apparaître dans un sous-p
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "Les arguments %qs et %qs de l'intrinsèque %qs à %L doivent avoir le même type"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "Sous-types différents à %L"
@@ -73609,7 +73761,7 @@ msgstr "Le NULL à %L n'est pas permis comme argument effectif de la fonction in
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être un POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L ne sera point co-indexé"
@@ -73750,8 +73902,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "L'argument errmsg= à %L doit être une variable caractère du sous-type par défaut"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "Co-tableaux désactivés à %L, utilisez %<-fcoarray=%> pour l'activer"
@@ -73850,9 +74002,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "la constante BOZ à %L ne peut pas apparaître dans le sous-programme intrinsèque COMPLEX"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "Intrinsèque %qs avec l'argument KIND à %L"
@@ -73867,12 +74019,12 @@ msgstr "L'argument %qs de l'intrinsèque %qs à %L a une forme invalide dans la
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit avoir le rang %d ou être un scalaire"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être numérique ou LOGICAL"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "Les types des arguments de l'intrinsèque %qs à %L doivent correspondre (%s/%s)"
@@ -73967,618 +74119,618 @@ msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être une entité de don
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "L'intrinsèque %qs à %L doit avoir au moins deux arguments"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Argument %qs manquant pour l'intrinsèque %s à %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Argument %qs dupliqué à %L pour l'intrinsèque %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Argument %qs inconnu à %L pour l'intrinsèque %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "Sous-types de caractères différents à %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "L'argument %<a%d%> de l'intrinsèque %qs à %L doit être %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "Intrinsèque %qs avec un argument CHARACTER à %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "L'argument %<a1%> de l'intrinsèque %qs à %L doit être INTEGER, REAL, CHARACTER ou UNSIGNED"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "L'argument %<a1%> de l'intrinsèque %qs à %L doit être INTEGER, REAL ou CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Formes différentes sur la dimension 1 des arguments %qs et %qs à %L pour l'intrinsèque matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Formes différentes sur la dimension 2 de l'argument %qs et la dimension 1 de l'argument %qs à %L pour l'intrinsèque matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être de rang 1 ou 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être en conformité avec le type de l'argument %qs à %L"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être INTEGER ou UNSIGNED"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être un INTEGER"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr "STAT= ou ERRMSG= à %L n'est pas supporté"
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "L'argument FROM de MOVE_ALLOC à %L ne sera point co-indexé"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "L'argument TO de MOVE_ALLOC à %L ne sera point co-indexé"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "Les arguments TO dans MOVE_ALLOC à %L doivent être polymorphiques si FROM est polymorphique"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "Les arguments FROM et TO de l'intrinsèque MOVE_ALLOC à %L doivent avoir le même rang %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "Les arguments FROM et TO de l'intrinsèque MOVE_ALLOC à %L doivent avoir le même co-rang %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr "Les arguments FROM et TO à %L violent les restrictions d'aliasing (F2003 12.4.1.7)"
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "L'argument %<S%> de NEAREST à %L ne sera point zéro"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être POINTER, ALLOCATABLE ou un pointeur de procédure"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "Intrinsèque NULL avec MOLD allouable à %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L n'apparaîtra que si %qs est du type REAL et que %qs est du type INTEGER ou UNSIGNED"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit fournir au moins autant d'éléments qu'il y a de valeurs .TRUE. dans %qs (%ld/%d)"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être une variable muette"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être une variable muette OPTIONAL"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L ne doit pas être un sous-objet de %qs"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "L'argument de l'intrinsèque RANK à %L doit être un objet de données"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "L'argument ARRAY à %L de REDUCE ne sera point polymorphique"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "L'argument DIM à %L, si présent, doit être un scalaire entier"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr "L'argument MASK à %L, si présent, doit être un tableau logique avec le même rang que ARRAY"
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr "MASK présent à %L sans IDENTITY"
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "L'argument ORDERED à %L, si présent, doit être un scalaire logique"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr "L'argument IDENTITY à %L, si présent, doit être un scalaire avec le même type que ARRAY"
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "L'argument %<shape%> de l'intrinsèque %<reshape%> à %L doit être un tableau de taille constante"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L est vide"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "L'argument %<shape%> de l'intrinsèque %<reshape%> à %L a plus de %d éléments"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L a un élément négatif (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L a un mauvais nombre d'éléments (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L a une dimension hors limite (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L a une permutation invalide des dimensions (dimension %qd dupliquée)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Sans rembourrage, il n'y a pas assez d'éléments dans la source de l'intrinsèque RESHAPE à %L pour correspondre à la forme"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L ne peut pas être du type %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être d'un type extensible"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "SELECTED_REAL_KIND sans argument %<P%> ni %<R%> à %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "Intrinsèque %qs avec un argument RADIX à %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "L'argument %<source%> de l'intrinsèque %<shape%> à %L ne doit pas être un tableau de taille tacite"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L ne sera point une procédure"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L ne sera point TYPE(*)"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L ne sera point un tableau de taille tacite"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr "is_c_interoperable(): gfc_simplify_expr a échoué"
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être une entité de données interopérable: %s"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr "L'argument C_PTR_1 à %L pour C_ASSOCIATED aura le type TYPE(C_PTR) ou TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr "L'argument C_PTR_2 à %L pour C_ASSOCIATED aura le même type que C_PTR_1: %s trouvé au lieu de %s"
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr "L'argument CPTR à %L pour C_F_POINTER aura le type TYPE(C_PTR)"
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "L'argument FPTR à %L pour C_F_POINTER doit être un pointeur"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "L'argument FPTR à %L pour C_F_POINTER ne sera point polymorphique"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "L'argument FPTR à %L pour C_F_POINTER ne sera point co-indexé"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Argument SHAPE inattendu à %L pour C_F_POINTER avec FPTR scalaire"
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr "Argument SHAPE inattendu pour C_F_POINTER avec FPTR tableau à %L"
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "L'argument SHAPE à %L pour C_F_POINTER doit avoir la même taille que le RANK de FPTR"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "Argument LOWER à %L pour C_F_POINTER"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Argument LOWER inattendu à %L pour C_F_POINTER avec FPTR scalaire"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "L'argument LOWER à %L pour C_F_POINTER doit avoir la même taille que le RANK de FPTR"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr "FPTR polymorphique à %L pour C_F_POINTER"
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "l'argument FPTR de C_F_POINTER à %L est une fonction retournant un pointeur"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Argument au tableau FPTR non interopérable avec C_F_POINTER à %L : %s"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr "L'argument CPTR à %L pour C_F_PROCPOINTER n'aura point le type TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "L'argument FPTR à %L pour C_F_PROCPOINTER sera un pointeur de procédure"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "L'argument FPTR à %L pour C_F_PROCPOINTER ne sera point co-indexé"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr "Pointeur de procédure non interopérable à %L pour C_F_PROCPOINTER"
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "L'argument X à %L pour C_FUNLOC ne sera point co-indexé"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "Le résultat %qs de la fonction à %L est invalide comme argument X pour C_FUNLOC"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr "L'argument X à %L pour C_FUNLOC ne sera point une procédure ou un pointeur de procédure"
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Procédure non interopérable à %L pour C_FUNLOC"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "L'argument X à %L pour C_LOC ne sera point co-indexé"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "L'argument X à %L pour C_LOC ne sera point polymorphique"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "L'argument X à %L pour C_LOC aura soit l'attribut POINTER ou soit l'attribut TARGET"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "L'argument X à %L pour C_LOC ne sera point une chaîne de longueur nulle"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "L'argument à %L pour C_LOC ne sera point polymorphique"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "Tableau non interopérable à %L comme argument pour C_LOC: %s"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr "Tableau d'un type interopérable à %L pour C_LOC qui n'est pas allouable et n'a pas de taille tacite ni de taille explicite"
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "Section de tableau à %L pour C_LOC"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "argument REAL pas en double précision pour l'intrinsèque %s à %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être moins que le rang %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L n'est pas un index de dimension valide"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit avoir une longueur d'au moins 1"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "L'argument %s pour IMAGE_INDEX doit être un tableau de rang un à %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "Le nombre d'éléments du tableau de l'argument SUB pour IMAGE_INDEX à %L sera %d (co-rang) et non %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "argument %<team%> ou %<team_number%> pour %qs à %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr "Le premier argument de l'intrinsèque %<this_image%> à %L doit être une variable co-tableau ou un objet de type %<team_type%> du module intrinsèque %<ISO_FORTRAN_ENV%>"
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr "Le deuxième argument de l'intrinsèque %<this_image%> à %L doit être un %<INTEGER%> de type scalaire ou un objet de type %<team_type%> du module intrinsèque %>ISO_FORTRAN_ENV%>"
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "L'argument %<dim%> sans argument %<coarray%> n'est pas permis pour l'intrinsèque %<this_image%> à %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Argument %<team%> pour %<this_image%> à %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr "Au plus un argument de type %<team_type%> depuis le module intrinsèque %<ISO_FORTRAN_ENV%> vers %<this_image%> à %L est autorisé"
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr "L'argument %<MOLD%> de l'intrinsèque %<TRANSFER%> à %L est un tableau et n'aura pas une taille de stockage 0 quand l'argument %<SOURCE%> a une taille plus grande que 0"
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "L'argument %<SOURCE%> de l'intrinsèque %<TRANSFER%> à %L ne doit pas être un %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "L'argument %<MOLD%> de l'intrinsèque %<TRANSFER%> à %L ne doit pas être un %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "L'argument %<MOLD%> de l'intrinsèque %<TRANSFER%> à %L ne doit pas être %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "L'intrinsèque TRANSFER à %L a un résultat partiellement indéfini: taille de la source %zd < taille du résultat %zd"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit avoir le même rang que %qs ou être un scalaire"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "Les arguments %qs et %qs de l'intrinsèque %qs à %L doivent avoir des formes identiques."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "L'argument VALUES de DATE_AND_TIME à %L a un sous-type pas par défaut"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "L'argument de VALUES de DATE_AND_TIME à %L doit avoir une plage exponentielle décimale d'au moins quatre"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "La taille de l'argument %qs de l'intrinsèque %qs à %L est trop petite (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Trop d'arguments pour %s à %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr "La chaîne fe_runtime_error doit être terminée par un zéro"
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "fe_runtime_error: Mauvais nombre d'arguments (%d au lieu de %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "L'argument COUNT de SYSTEM_CLOCK à %L a un sous-type pas par défaut"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "L'argument COUNT de SYSTEM_CLOCK à %L a un sous-type plus petit que l'entier par défaut"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr "Argument réel COUNT_RATE de SYSTEM_CLOCK à %L"
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "L'argument COUNT_RATE de SYSTEM_CLOCK à %L a un sous-type pas par défaut"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "L'argument COUNT_RATE de SYSTEM_CLOCK à %L a un sous-type plus petit que l'entier par défaut"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "L'argument COUNT_MAX de SYSTEM_CLOCK à %L a un sous-type pas par défaut"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "L'argument COUNT_MAX de SYSTEM_CLOCK à %L a un sous-type plus petit que l'entier par défaut"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "Les arguments entiers de SYSTEM_CLOCK à %L ont des paramètres de sous-types différents"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être d'un sous-type pas plus large que le sous-type par défaut (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "L'argument effectif à %L de l'intrinsèque %qs sera une pointeur associé"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "L'argument %qs de l'intrinsèque %qs à %L doit être INTEGER, LOGICAL ou une constante littérale BOZ"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr "La fonction intrinsèque NULL à %L ne peut pas être un argument effectif de STORAGE_SIZE car il retourne un pointeur dissocié"
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "Niveau d'extension maximum atteint avec le type %qs à %L"
@@ -74643,12 +74795,12 @@ msgstr "Chaîne d'initialisation inutilisée à %L car la variable a une longueu
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "La chaine d'initialisation à %L a été tronquée pour tenir dans la variable (%wd/%wd)"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "L'index de départ de la sous-chaîne à %L est plus petit que un"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "L'index de fin de la sous-chaîne à %L excède la longueur de la chaîne"
@@ -74698,2058 +74850,2058 @@ msgstr "L'objet non pointeur %qs avec l'initialisation par défaut n'apparaîtra
 msgid "Simplification error"
 msgstr "Erreur de simplification"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr "Le paramètre de requête ne peut pas apparaître dans une data-stmt-object-list à %C"
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "La variable %qs associée à l'hôte ne peut pas être dans l'instruction DATA à %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "initialisation de la variable de bloc commun %qs dans l'instruction DATA à %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Le symbole %qs doit être un PARAMETER de l'instruction DATA à %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Initialisation %s invalide dans l'instruction Data à %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "BOZ à %L ne peut pas apparaître dans une initialisation dans le style ancien"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr "La constante littérale BOZ près de %L ne peut pas être assignée à une variable %qs initialisée dans le style ancien"
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "L'initialisation à %C n'est pas permise dans une procédure PURE"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "L'instruction DATA à %C ne peut pas apparaître dans une INTERFACE"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Sous-chaîne invalide dans le « do » avec donnée implicite à %L dans l'instruction DATA"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr "Composant allouable ou tableau de forme différée près de %C dans l'instruction DATA"
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "La constante littérale BOZ à %L ne peut pas apparaître dans un constructeur de structure"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "L'instruction DATA à %C n'est pas permise dans une procédure PURE"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr "part-ref avec un attribut pointeur près de %L n'est pas le part-ref le plus à droite ou data-stmt-object"
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "Liste d'initialisation vide dans l'ancien style à %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Le tableau dans la liste d'initialisation à %L doit avoir une forme explicite"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "Le spécificateur de répétition est invalide dans l'initialisation d'un scalaire à %C "
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "Le spécificateur de répétition doit être un entier à %C"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Donnée constante attendue après le spécificateur de répétition à %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "Fin de l'initialisation du scalaire attendue à %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "Pas assez d'éléments dans l'initialisation du tableau à %C"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "Trop d'éléments dans l'initialisation du tableau à %C"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Erreur de syntaxe dans la liste d'initialisation dans l'ancien style à %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "Le tableau de rang tacite à %C n'aura point de co-dimension"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr "La somme du tableau de rang %d et de co-rang %d à %C excède les dimensions maximales autorisées de %d"
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Mauvaise spécification INTENT à %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "paramètre de type différé à %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr "Expression INTEGER scalaire attendue à %L"
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Longueur de caractère dans l'ancien style à %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Erreur de syntaxe dans la spécification de la longueur de caractère à %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "La procédure %qs à %C est déjà définie à %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "La procédure contenue %qs à %C entre en conflit avec la procédure définie à %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Le nom %qs à %C est déjà défini comme une interface générique à %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "La procédure %qs à %C a une interface explicite d'une déclaration précédente"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr "La procédure %qs définie dans le corps de l'interface à %L entre en conflit avec la procédure interne définie à %C"
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "La procédure %qs à %L doit avoir l'attribut BIND(C) pour être interopérable avec le C"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "La variable %qs à %L est un argument muet de la procédure BIND(C) %qs mais elle n'est pas interopérable avec le C car le type dérivé %qs n'est pas interopérable avec le C"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "La variable %qs à %L est un argument muet de la procédure BIND(C) %qs mais elle n'est pas interopérable avec le C car elle est polymorphique"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "La variable %qs à %L est un argument muet de la procédure BIND(C) %qs mais elle pourrait ne pas être interopérable avec le C"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "L'argument muet %qs à %L ne peut pas être un pointeur avec l'attribut CONTIGUOUS car la procédure %qs est BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "L'argument muet initialisé par défaut %qs avec l'attribut %s à %L n'est pas permis dans la procédure BIND(C) %qs"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "L'argument muet avec caractères allouables %qs à %L doit avoir une longueur différée car la procédure %qs est BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "L'argument muet pointeur vers des caractères %qs à %L doit avoir une longueur différée car la procédure %qs est BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "L'argument muet caractère à longueur différée %qs à %L de la procédure %qs avec l'attribut BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "L'argument muet caractère %qs à %L doit avoir la longueur 1 car il a l'attribut VALUE"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "L'argument muet caractère d'une longueur tacite %qs à %L de la procédure %qs avec l'attribut BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr "L'argument muet caractères %qs à %L doit avoir une longueur constante de un ou une longueur tacite à mois qu'il ait une forme tacite ou un rang tacite car la procédure %qs a l'attribut BIND(C)"
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Variable %qs à %L avec l'attribut ALLOCATABLE dans la procédure %qs avec BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Variable %qs à %L avec l'attribut POINTER dans la procédure %qs avec BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "La variable %qs à %L ne peut pas avoir les deux attributs OPTIONAL et VALUE car la procédure %qs est BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Variable %qs à %L avec l'attribut OPTIONAL dans la procédure %qs qui est BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Tableau de forme tacite %qs à %L comme argument muet à la procédure BIND(C) %qs à %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr "F2018: C8102 %s à %L est déjà importé par une instruction %s et il ne doit pas être redéclaré"
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Le symbole %qs à %C est aussi déclaré comme un type à %L"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "La variable %qs dans le bloc commun %qs à %C doit être déclarée avec un sous-type interopérable avec le C puisque le bloc commun %qs est BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "La longueur de CHARACTER doit être une constante à %L"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "L'expression CHARACTER à %L est tronquée (%ld/%ld)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Les éléments CHARACTER dans le constructeur du tableau à %L doivent avoir la même longueur (%ld/%ld)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Initialisation interdite pour PARAMETER %qs à %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "Le PARAMETER à %L n'a pas d'initialisation"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "La variable %qs à %C avec une initialisation apparaît déjà dans une instruction DATA"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Impossible d'initialiser un tableau de paramètres à %L avec des éléments de longueur variable"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Désaccord de rang pour le tableau à %L et son initialiseur (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "Impossible d'initialiser un tableau de forme implicite à %L avec un scalaire"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "Mauvaise forme de l'initialiseur à %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "Impossible de déterminer la forme de l'initialiseur à %L"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Limite inférieure non constante dans la déclaration avec une forme implicite à %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "L'entité %qs à %L est incompatible avec une constante littérale BOZ"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Le composant à %C doit avoir l'attribut POINTER"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Le composant %qs avec CLASS à %C doit être allouable ou un pointeur"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Le composant tableau de structures à %C doit avoir une forme explicite ou différée"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Le composant %qs à %C est déjà déclaré à %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Le composant tableau de pointeurs de structures à %C doit avoir une forme différée"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Le composant allouable de structures à %C doit avec une forme différée"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Le composant tableau de structures à %C doit avoir une forme explicite"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "Le paramètre de type %qs à %C n'a pas d'entrée correspondante dans la liste des noms de paramètres de types à %L"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "L'initialisation NULL() à %C est ambiguë"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "L'initialisation NULL() à %C ne peut pas avoir MOLD"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "L'initialisation du pointeur à %C n'est pas permise dans une procédure PURE"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Erreur dans l'initialisation du pointeur à %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "Initialisation d'un pointeur non NULL à %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr "La variable RESULT %qs à %L interdit le nom de FUNCTION %qs à %C d'apparaître dans une instruction de spécification"
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "%qs n'est pas autorisé en dehors de STRUCTURE à %C"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%qs à %C est une extension DEC, activez-la avec %<-fdec-structure%>"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "L'entité %qs ne peut pas avoir d'attribut à %C"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Caractère %qc invalide dans le nom de la variable à %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Le symbole non PARAMETER %qs à %L ne peut pas avoir une forme implicite"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Tableau de forme implicite à %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "La forme de tableau explicite à %C doit être une constante de type INTEGER et non de type %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr "Tableau de forme explicite avec des limites non constantes à %C"
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr "%qs à %L est une redéfinition de la déclaration dans l'interface correspondante pour MODULE PROCEDURE %qs"
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "L'entité %qs ne peut pas avoir un initialiseur à %L"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Spécificateur de tableau dupliqué pour le pointé de type Cray à %L"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "Impossible de définir la spécification du tableau pointé"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Initialisation dans l'ancien style à %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "Initialisation dans l'ancien style invalide pour le composant de type dérivé à %C"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Erreur de syntaxe dans l'initialisation de %s dans l'ancien style à %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "L'initialisation à %C n'est pas pour une variable pointeur"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "L'initialisation du pointeur à %C requiert %<=>%> et non %<=%>"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Une expression d'initialisation est attendue à %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "L'initialisation de la variable à %C n'est pas permise dans une procédure PURE"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "L'initialisation du composant allouable à %C n'est pas permise"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "L'initialisation d'un composant de structure avec une constante HOLLERITH à %L n'est pas permise"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr "Le composant avec l'attribut KIND ou LEN à %C n'apparaît pas dans la liste des paramètres de type à %L"
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr "Le composant à %C qui apparaît dans la liste des paramètres de types à %L n'a ni l'attribut KIND ni l'attribut LEN"
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Le composant à %C, qui est un paramètre de type, doit être un scalaire"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "La constante littérale BOZ à %L ne peut pas apparaître comme une initialisation"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr "Initialisation incompatible entre une entité de type dérivé et une entité avec le type %qs à %C"
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "La déclaration du type %s*%d dans l'ancien style n'est pas supportée à %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Déclaration du type non standard %s*%d à %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Parenthèse droite manquante à %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Expression d'initialisation attendue à %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Expression d'initialisation d'un scalaire attendue à %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Le sous-type %d n'est pas supporté pour le type %s à %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Le paramètre d'un type du sous-type C est pour le type %s mais le type à %L est %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Parenthèse droite ou virgule manquante à %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Le sous-type %d n'est pas supporté pour CHARACTER à %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Erreur de syntaxe dans la déclaration CHARACTER à %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "RECORD à %C est une extension, activez-la avec %<-fdec-structure%>"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Nom de structure attendu après RECORD à %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr "La liste de spec des paramètres de type à %C ne peut pas contenir les paramètres ASSUMED et DEFERRED en même temps"
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "La liste de spec des paramètres de types à %C ne contient pas assez d'expressions de paramètres"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "Le paramètre dérivé %qs à %C n'a pas de valeur par défaut"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "L'expression paramètre de type à %L doit être de type INTEGER et non de type %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "L'expression paramètre à %C doit être de type INTEGER et non de type %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "L'expression paramètre à %C ne se simplifie pas en une constante INTEGER"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr "Le paramètre KIND %qs à %C ne peut pas être ASSUMED ou DEFERRED"
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "La valeur pour le paramètre KIND à %qs à %C ne se réduit pas en une expression constante"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr "La liste de spec des paramètres de type à %C contient trop d'expressions de paramètres"
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "Le type dérivé paramétrisé à %C est ambigu"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "Type BYTE à %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "Le type BYTE utilisé à %C n'est pas disponible sur la machine cible"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Le type tacite à %C n'est pas autorisé pour des composants"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "Type tacite à %C"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "TYPE avec une spécification de type intrinsèque à %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "Spécification de type mal formée à %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "DOUBLE COMPLEX à %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Le nom de type %qs à %C est ambigu"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "Instruction CLASS à %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "Le nom du type %qs à %C est en conflit avec l'entité précédemment déclarée à %L qui a le même nom"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr "Le type %qs n'est pas paramétrisé et, par conséquent, la liste de spécification du paramètre de type à %C ne peut pas apparaître"
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Instruction IMPLCIT NONE dupliquée à %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "IMPLICIT NONE avec une liste de spécifications à %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Plage de caractères manquante dans IMPLICIT à %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Les lettres doivent être dans l'ordre alphabétique dans l'instruction IMPLICIT à %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "L'instruction IMPLICIT à %C suit une instruction IMPLICIT NONE (type)"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Instruction IMPLICIT vide à %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "L'instruction IMPORT à %C est uniquement permise dans un corps d'INTERFACE"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "F2008: l'instruction IMPORT C1210 à %C n'est pas permise dans le corps d'interface d'une procédure d'un module"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "Instruction IMPORT à %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr "le nom d'import %qs à %C est dans la portée locale"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "Impossible d'utiliser IMPORT %qs depuis l'unité dans la portée de l'hôte à %C – n'existe pas."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "%qs est déjà IMPORTé depuis l'unité dans la portée de l'hôte à %C"
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction IMPORT à %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "F2018: l'instruction IMPORT C897 à %C ne peut pas apparaître dans un programme principal, un sous-programme externe, un module ou une donnée bloc"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr "F2018: L'instruction IMPORT C898 à %C n'est pas permise car une unité de portée a un spécificateur ONLY, peut uniquement avoir IMPORT avec un spécificateur ONLY"
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr "F2018: IMPORT C899, NONE ne peut apparaître dans l'unité de portée d'un sous-module « as » à %C"
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "F2018: l'instruction IMPORT C8100 à %C n'est pas permise car %s a déjà été déclaré, il doit être unique dans l'unité de portée"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Liste d'entités nommées attendue à %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Spécification de co-dimension manquante à %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Spécification de dimension manquante à %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Attribut %s dupliqué à %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s à %L est une extension DEC, activez-la avec %<-fdec-static%>"
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Attribut ALLOCATABLE à %C dans une définition TYPE"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Attribut ALLOCATABLE à %C dans une définition STRUCTURE"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Attribut KIND à %C dans une définition TYPE"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Attribut KIND à %C dans une définition STRUCTURE"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "Le composant avec l'attribut KIND à %C doit être un INTEGER"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Attribut LEN à %C dans une définition TYPE"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Attribut LEN à %C dans une définition STRUCTURE"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "Le composant avec l'attribut LEN à %C doit être un INTEGER"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "L'attribut à %L n'est pas permis dans une définition TYPE"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "L'attribut à %L n'est pas permis dans une définition STRUCTURE"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Attribut %s à %L dans une définition TYPE"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "L'attribut %s à %L n'est pas permis en dehors de la partie de la spécification d'un module"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "L'attribut à %L n'est pas permis en dehors d'une définition TYPE"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "Attribut ASYNCHRONOUS à %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "Attribut CONTIGUOUS à %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "PROTECTED à %C est uniquement autorisé dans la partie de la spécification d'un module"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "Attribut PROTECTED à %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "Attribut VALUE à %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "Attribut VOLATILE à %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr "match_attr_spec(): Mauvais attribut"
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Identificateurs multiples fournis avec un seul spécificateur NAME= à %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "La déclaration implicite de la fonction BIND(C) %qs à %L pourrait ne pas être interopérable avec le C"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "La variable %qs dans le bloc commun %qs à %L ne peut pas être un sous-type interopérable avec le C bien que le bloc commun %qs est BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "La déclaration de type %qs à %L n'est pas interopérable avec le C mais elle est BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "La variable %qs à %L peut ne pas être d'un sous-type interopérable avec le C mais elle est BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "La variable %qs dans le bloc commun %qs à %L ne peut pas être déclarée avec BIND(C) puisqu'elle n'est pas globale"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "La variable %qs à %L ne peut pas avoir les attributs POINTER et BIND(c) en même temps"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "La variable %qs à %L ne peut pas avoir les attributs ALLOCATABLE et BIND(C) en même temps"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Le type de retour de la fonction BIND(C) %qs à %L ne peut pas être un tableau"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Le type de retour de la fonction BIND(C) %qs de type caractère à %L doit avoir la longueur 1"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "Le symbole %qs à %L est marqué PRIVATE mais il est accessible via son nom de liaison par défaut %qs"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "L'instruction de spécification d'attribut a besoin de soit un nom d'entité ou soit un nom de bloc commun à %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Il manque le nom d'entité ou le nom de bloc commun pour l'instruction de spécification d'attribut à %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Symbole manquant"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "Instruction BIND(C) à %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "L'entité CLASS à %C ne peut pas avoir l'attribut PARAMETER"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Le type dérivé à %C n'a pas été précédemment défini et, par conséquent, il ne peut pas apparaître dans une définition de type dérivé"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Erreur de syntaxe dans la déclaration de la structure anonyme à %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Erreur de syntaxe dans la déclaration de donnée à %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "Préfixe de MODULE à %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "préfixe MODULE à %C trouvé en dehors d'un module, sous-module ou interface"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "Procédure IMPURE à %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE et IMPURE ne peuvent pas apparaître ensemble à %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Le préfixe ELEMENTAL dans l'interface MODULE PROCEDURE est manquant à %L"
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Le préfixe PURE dans l'interface MODULE PROCEDURE est manquant à %L"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Le préfixe RECURSIVE dans l'interface MODULE PROCEDURE est manquant à %L"
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "Une liste de paramètre de types est requis à %C"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "Argument de retour alternatif à %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "Un nom de paramètre est requis à %C"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Le nom %qs à %C est le nom de la procédure"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Liste de paramètres attendue dans la déclaration du type à %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Rebut inattendu dans la liste d'arguments formels à %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Nom %qs en double dans la liste des paramètres à %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Symbole %qs dupliqué dans la liste d'arguments formels à %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "L'argument formel %qs de MODULE PROCEDURE est en conflit avec le retour alterné à %C"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr "L'argument formel de MODULE PROCEDURE est un retour alterné qui est en conflit avec %qs dans la déclaration séparée à %C"
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr "Désaccord dans les noms des arguments formels de MODULE PROCEDURE (%s/%s) à %C"
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Désaccord dans le nombre d'arguments formels de MODULE PROCEDURE à %C"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "La variable RESULT à %C doit être différente du nom de la fonction"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Rebut inattendu après la déclaration de la fonction à %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "L'attribut BIND(C) à %L ne peut pas être spécifié pour une procédure interne"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "L'attribut BIND(C) à %C requiert une interface avec BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "La procédure BIND(C) avec NAME ne peut pas avoir l'attribut POINTER à %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "La procédure muette à %C ne peut pas avoir d'attribut BIND(C) avec NAME"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "La procédure %qs à %L a déjà le type de base de %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction PROCEDURE à %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "%<::%> attendu après les attributs de liaison à %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "NOPASS ou interface explicite requise à %C"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Composant de pointeur de procédure à %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Erreur de syntaxe dans un composant de pointeur de procédure à %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE à %C doit être une interface générique"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "double : dans l'instruction MODULE PROCEDURE à %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "Instruction PROCEDURE à %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Liste d'arguments formels attendue dans la définition de la fonction à %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "L'attribut BIND(C) à %L peut uniquement être utilisé pour des variables ou des blocs communs"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr "Désaccord dans les noms de BIND(C) (%qs/%qs) à %C"
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "Instruction ENTRY à %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un PROGRAM"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un MODULE"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un SUBMODULE"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "L'instruction ENTRY à %C ne peut apparaître dans un BLOCK DATA"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans une INTERFACE"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc STRUCTURE"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc DERIVED TYPE"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc IF-THEN"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc DO"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc SELECT"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc FORALL"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un bloc WHERE"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans un sous programme contenu"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Instruction ENTRY inattendue à %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "L'instruction ENTRY à %C ne peut pas apparaître dans une procédure contenue"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Parenthèse requise manquante avant BIND(C) à %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "L'instruction ENTRY à %L avec BIND(C) est interdite dans une procédure élémentaire"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "L'argument fictif du retour alternatif ne peut pas apparaître dans une SUBROUTINE avec l'attribut BIND(C) à %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Identificateur C invalide dans le spécificateur NAME= à %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Erreur de syntaxe dans le spécificateur NAME= pour l'étiquette de liaison à %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "Le spécificateur NAME= à %C devrait être une expression constante"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr "Le spécificateur NAME= à %C devrait être un scalaire du sous-type de caractère par défaut"
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Parenthèse fermante manquante pour l'étiquette de liaison à %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Le nom de liaison n'est pas permis dans BIND(C) à %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "Pour la procédure muette %s, aucun nom de liaison est autorisé dans BIND(C) à %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "NAME pas autorisé sur BIND(C) pour ABSTRACT INTERFACE à %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Instruction END inattendue à %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "Instruction END au lieu de l'instruction %s à %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "Instruction %s attendue à %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "On attendait l'instruction %s à %L"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "On attendait le nom du bloc de %qs dans l'instruction %s à %L"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "On attendait un nom de terminaison à %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "On attendait l'étiquette %qs pour l'instruction %s à %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Spécification de tableau manquante à %L dans l'instruction DIMENSION"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Dimensions spécifiées pour %s à %L après son initialisation"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Spécification de tableau manquante à %L dans l'instruction CODIMENSION"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "La spécification de tableau doit être différée à %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Caractère inattendu dans la liste de variable à %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "%<(%> attendu à %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Nom de variable attendu à %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Le pointeur Cray à %C doit être un entier"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Le pointeur Cray à %C a %d octets de précision; les adresses mémoire requièrent %d octets"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "« , » attendu à %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "Ne peut définir la spécification de tableau dans le pointé de type Cray"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Spécificateur de tableau dupliqué pour le pointé de type Cray à %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "« ) » attendue à %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "%<,%> ou fin d'instruction attendue à %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT n'est pas permis à l'intérieur de BLOCK à %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "OPTIONAL n'est pas permis à l'intérieur du BLOCK à %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "La déclaration de pointeur Cray à %C requiert l'option %<-fcray-pointer%>"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "Instruction CONTIGUOUS à %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "La spécification d'accès de l'opérateur %s à %C a déjà été spécifiée"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "La spécification d'accès de l'opérateur .%s. à %C a déjà été spécifiée"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "Instruction PROTECTED à %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction PROTECTED à %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "L'instruction PRIVATE à %C est uniquement permise dans la partie de la spécification d'un module"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "L'instruction PUBLIC à %C est uniquement permise dans la partie de la spécification d'un module"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Nom de variable attendu à %C dans l'instruction PARAMETER"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Signe = attendu dans l'instruction PARAMETER à %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Expression attendue à %C dans l'instruction PARAMETER"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Initialisation d'une variable déjà initialisée à %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr "PARAMETER sans « () » à %C"
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Caractères inattendus dans l'instruction PARAMETER à %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s à %C est une extension DEC, activez-la avec %<-fdec-static%>"
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Liste d'entités attendue dans l'instruction AUTOMATIC à %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction AUTOMATIC à %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Liste d'entités attendue dans l'instruction STATIC à %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction STATIC à %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "L'instruction SAVE générale à %C suit une instruction SAVE précédente"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "L'instruction SAVE à %C suit une instruction SAVE générale"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "SAVE du bloc COMMON %qs à %C n'est pas permis dans une construction BLOCK"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction SAVE à %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "VALUE n'est pas autorisé à l'intérieur de BLOCK à %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "Instruction VALUE à %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction VALUE à %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "Instruction VOLATILE à %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "Spécification de VOLATILE pour la variable co-tableau %qs à %C qui est associée à use ou à l'hôte"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction VOLATILE à %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Instruction ASYNCHRONOUS à %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction ASYNCHRONOUS à %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "Déclaration de MODULE PROCEDURE à %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE à %C doit être dans une interface de module générique"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "La procédure intrinsèque à %L ne peut pas être un MODULE PROCEDURE"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Symbole ambigu dans la définition TYPE à %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Le symbole %qs à %C n'a pas été défini précédemment"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "%qs dans l'expression EXTENDS à %C n'est pas un type dérivé"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "%qs ne peut pas être étendu à %C car il est BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qs ne peut pas être étendu à %C car il est un type SEQUENCE"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Le type dérivé à %C peut uniquement être PRIVATE dans la partie de spécification d'un module"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Le type dérivé à %C peut uniquement être PUBLIC dans la partie de spécification d'un module"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "Type ABSTRACT à %C"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Échec lors de la création du type structure « %s » à %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "La définition du type de %qs à %C a déjà été définie à %L"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "Rebut après l'instruction MAP à %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Rebut après l'instruction UNION à %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%s à %C est une extension DEC, activez-la avec %<-fdec-structure%>"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Nom de structure attendu dans la déclaration de structure non imbriquée à %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Rebut après l'instruction STRUCTURE non imbriquée à %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Le nom de structure %qs à %C ne peut pas être le même qu'un type intrinsèque"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ":: attendu dans la définition de TYPE à %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "Définition du type dérivé décoré à %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Le nom de type %qs à %C ne peut pas être le même qu'un type intrinsèque"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Le nom du type dérivé %qs à %C a déjà le type de base %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Le nom du type dérivé %qs à %C a déjà un type de base"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "L'argument muet %qs à %L ne peut pas être un type dérivé à %C"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "La définition du type dérivé %qs à %C a déjà été défini"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Rebut après la déclaration PARAMETERIZED TYPE à %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Le pointé de type Cray à %C ne peut pas être un tableau de forme tacite"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "ENUM et ENUMERATOR à %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "L'énumérateur excède le type entier du C à %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L pas initialisé avec une expression entière"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "Instruction de définition ENUM attendue avant %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Erreur de syntaxe dans la définition ENUMERATOR à %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Spécificateurs d'accès dupliqués à %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Les attributs de liaison spécifient déjà « PASS », NOPASS illégal à %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Les attributs de liaison spécifient déjà « PASS »; PASS illégal à %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Attribut POINTER dupliqué à %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "NON_OVERRIDABLE dupliqué à %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "DEFERRED dupliqué à %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Spécificateur d'accès attendu à %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Attribut de liaison attendu à %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE et DEFERRED ne peuvent pas apparaître tous les deux à %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "L'attribut POINTER est requis pour un composant de pointeur de procédure à %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Nom d'interface attendu après %<(%> à %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "%<)%> attendu à %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Une interface doit être spécifiée pour une liaison DEFERRED à %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDURE(interface) à %C devrait être déclarée DEFERRED"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Nom de liaison attendu à %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "Liste PROCEDURE à %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%<=> target%> est invalide pour la liaison DEFERRED à %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "%<::%> nécessaire dans une liaison PROCEDURE avec une cible explicite à %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Cible de liaison attendue après %<=>%> à %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "Le type %qs contenant la liaison DEFERRED à %C n'est pas ABSTRACT"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Il y a déjà une procédure avec le nom de liaison %qs pour le type dérivé %qs à %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "%<::%> attendu à %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Nom générique ou descripteur d'opérateur attendu à %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Instruction GENERIC mal formée à %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "%<=>%> attendu à %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr "La spécification d'accès à %L n'est pas dans un module"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr "Le nom de spec générique %qs à %C est en conflit avec le nom de l'entité déclarée à %L qui n'est pas une procédure"
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Il y a déjà une procédure non générique avec le nom %qs à %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "La spécification d'accès à %L est en conflit avec celle déjà donnée à %qs"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "La spécification d'accès à %L répète celle déjà données à %qs"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr "La spec générique dans l'instruction générique à %C a un type de la déclaration à %L"
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "L'opérateur utilisateur à %L doit avoir la même spécification d'accès que l'opérateur utilisateur déjà défini %qs"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr "L'opérateur utilisateur à %L répète la spécification d'accès de l'opérateur utilisateur déjà défini %qs"
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr "Nom de procédure spécifique attendu à %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr "Le nom %qs de la procédure spécifique à %C est en conflit avec celle de la spec générique"
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%qs est déjà défini comme une procédure spécifique pour le générique %qs à %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "Rebut après l'instruction GENERIC à %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "Le GENERIC à %C doit être à l'intérieur du type dérivé CONTAINS"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Il y a déjà une procédure non générique avec le nom de liaison %qs pour le type dérivé %qs à %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "La liaison à %C doit avoir le même accès que la liaison %qs déjà définie"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Nom de liaison spécifique attendu à %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%qs est déjà défini comme liaison spécifique pour le %qs générique à %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Rebut après la liaison GENERIC à %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "La déclaration FINAL à %C doit être à l'intérieur d'une section CONTAINS du type dérivé"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "La déclaration de type dérivé avec FINAL à %C doit être dans la partie de spécification d'un MODULE"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "FINAL vide à %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Nom de procédure de module attendu à %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "%<,%> attendu à %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Nom de procédure %qs inconnu à %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "%qs à %C est déjà défini comme procédure FINAL"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Attribut inconnu dans l'instruction !GCC$ ATTRIBUTES à %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Erreur de syntaxe dans l'instruction !GCC$ ATTRIBUTES à %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr "Directive %<GCC unroll%> requiert une constante entière non négative plus petite ou égale à %u à %C"
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Erreur de syntaxe dans la directive !GCC$ UNROLL à %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Erreur de syntaxe dans la directive !GCC$ IVDEP à %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Erreur de syntaxe dans la directive !GCC$ VECTOR à %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "Erreur de syntaxe dans la directive !GCC$ NOVECTOR à %C"
@@ -76892,408 +77044,408 @@ msgstr "RE part_ref à %C"
 msgid "IM part_ref at %C"
 msgstr "IM part_ref à %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "les arguments de fonction élémentaire à %C ne sont pas conformes"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Opérandes numérique ou CHARACTER requis dans l'expression à %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "L'opérateur de concaténation dans l'expression à %L doit avoir deux opérandes de type CHARACTER"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "L'opérateur de concaténation à %L doit concaténer des chaînes du même sous-type"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "L'opérateur .NOT. dans l'expression à %L doit avoir un opérande LOGICAL"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "Des opérandes LOGICAL sont requis dans l'expression à %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Seuls des opérateurs intrinsèques peuvent être utilisés dans l'expression à %L"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Des opérandes numériques sont requis dans l'expression à %L"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Expression d'initialisation invalide pour le composant ALLOCATABLE %qs dans le constructeur de structure à %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Variable de longueur de caractère tacite ou différée %qs dans l'expression constante à %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "L'intrinsèque transformationnel %qs à %L n'est pas permis dans une expression d'initialisation"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Évaluation d'une expression d'initialisation non standard à %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "La fonction %qs dans l'expression d'initialisation à %L doit être une fonction intrinsèque"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "La fonction intrinsèque %qs à %L n'est pas permise dans une expression d'initialisation"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "PARAMETER %qs est utilisé à %L avant que sa définition soit complète"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "Le tableau de taille tacite %qs à %L n'est pas permis dans une expression d'initialisation"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Le tableau de forme tacite %qs à %L n'est pas permis dans une expression d'initialisation"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Le tableau de forme tacite %qs à %L n'est pas permis dans une expression d'initialisation"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "Le tableau différé %qs à %L n'est pas permis dans une expression d'initialisation"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Le tableau %qs à %L est une variable qui ne se réduit pas en une expression constante"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "Le tableau de rang tacite %qs à %L n'est pas permis dans une expression d'initialisation"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Le paramètre %qs à %L n'a pas été déclaré ou est une variable qui ne se réduit pas en une expression constante"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "check_init_expr(): Type d'expression inconnu"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "La fonction de spécification %qs à %L ne peut pas être une fonction-instruction"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "La fonction de spécification %qs à %L ne peut pas être une fonction interne"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "La fonction de spécification %qs à %L doit être PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "La fonction de spécification %qs à %L ne peut pas être RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "L'argument muet %qs n'est pas autorisé dans l'expression à %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "L'argument muet %qs à %L ne peut pas être OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "L'argument muet %qs à %L ne peut pas être INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "La variable %qs ne peut pas apparaître dans l'expression à %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "check_restricted(): Type d'expression inconnu"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "L'expression à %L doit être du type INTEGER et non %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "La fonction %qs à %L doit être PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "L'expression à %L doit être un scalaire"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr "débordement de optype_msgid :%d"
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Rangs incompatibles dans %s (%d et %d) à %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Forme différente pour %s à %L sur la dimension %d (%d et %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "Paramètres de type %qs(%d/%d) %s non concordants à %L/%L"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "L'affectation à un part_ref LEN ou KIND à %L n'est pas permis"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs à %L n'est pas une VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Affectation illégale à une procédure externe à %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Rangs incompatibles %d et %d dans l'affectation à %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Le type de la variable est inconnu dans l'affectation à %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL apparaît dans le membre de droite de l'affectation à %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Une fonction avec la valeur d'un POINTER apparaît dans le membre de droite de l'affectation à %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr "La constante littérale BOZ près de %L ne peut pas être assignée à la variable %qs"
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "L'affectation à un composant KIND ou LEN d'un type paramétrisé à %L n'est pas permis"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Types incompatibles dans l'instruction DATA à %L; tentative de conversion de %s en %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "La cible de l'affectation du pointeur n'est pas un POINTER à %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "%qs dans l'affectation de pointeur à %L ne peut pas être une l-valeur puisqu'il est une procédure"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Spécification de limites attendue pour %qs à %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Spécification des limites pour %qs dans une affectation de pointeur à %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "Le pas ne doit pas être présent à %L"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Le remappage de rang requiert une liste de spécifications %<borne-inf : borne-sup%> à %L"
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Liste de %<borne-inf :%> ou liste de %<borne-inf : borne-sup%> attendue à %L"
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "L'objet pointeur à %L ne sera point un co-index"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Affectation de pointeur de procédure invalide à %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Le résultat de la fonction %qs est invalide comme cible de procédure dans l'affectation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "L'interface abstraite %qs est invalide dans l'affectation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "La fonction-instruction %qs est invalide dans l'affectation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "La procédure interne %qs est invalide dans l'affectation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "L'intrinsèque %qs à %L est invalide dans une affectation du pointeur de procédure"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "La procédure élémentaire non intrinsèque %qs est invalide dans l'affectation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "Désaccord dans l'affectation du pointeur de procédure à %L: désaccord dans la convention d'appel"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Désaccord d'interface dans l'affectation du pointeur de procédure à %L: %qs n'est pas une sous-routine"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Interface explicite requise pour le composant %qs à %L: %s"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Interface explicite requise pour %qs à %L: %s"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Interface non concordante dans l'affectation du pointeur de procédure à %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr "La cible du pointeur de procédure %qs à %L doit être un intrinsèque, associé à l'hôte or à use, référencé ou avoir l'attribut EXTERNAL"
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "La cible de l'affectation du pointeur ne peut pas être une constante à %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr "L'objet pointeur de données à %L doit être polymorphique illimité ou être d'un type avec l'attribut BIND ou SEQUENCE pour être compatible avec une cible polymorphique illimitée"
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Types différents dans une affectation de pointeur à %L; tentative d'affecter %s à %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Paramètres de type de sous-type différents dans l'affectation de pointeur à %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Rangs différents dans l'affectation du pointeur à %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "La cible du remappage du rang est plus petite que la taille du pointeur (%ld < %ld) à %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr "La cible de rang tacite à %L est une fonctionnalité expérimentale de F202y. Utilisez l'option -std=f202y pour l'activer"
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "La cible du remappage du rang doit avoir le rang 1 ou être simplement contigüe à %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "La cible du remappage du rang n'a pas le rang 1 à %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr "La cible de données à %L est un objet de rang tacite et, par conséquent, le data-pointer-object %s doit avoir une liste de réorganisation des limites (liste de lbound:ubound pour chaque dimension)"
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "La cible de données de rang tacite à %L doit être contigüe"
@@ -77301,197 +77453,197 @@ msgstr "La cible de données de rang tacite à %L doit être contigüe"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "La cible de données à %L n'aura point de co-index"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "L'expression cible dans l'affectation de pointeur à %L doit fournir un pointeur comme résultat"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr "Tableau de taille nulle détecté à %L où une entité avec l'attribut TARGET est attendu"
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "La cible de l'affectation du pointeur dans l'expression d'initialisation n'a pas l'attribut TARGET à %L"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Chaque indice de la spécification cible à %L doit être une expression constante"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr "Les points de départ et de fin de la sous-chaîne de spécification de cible à %L doivent être des expressions constantes"
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "La cible de l'affectation du pointeur n'est ni TARGET ni POINTER à %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Mauvaise cible dans l'affectation du pointeur dans la procédure PURE à %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Affectation de pointeur avec un indice de vecteur dans le membre de droite à %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "La cible de l'affectation du pointeur a l'attribut PROTECTED à %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr "Affectation à un pointeur contigu depuis une cible non contigüe à %L"
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "Le pointeur à %L dans l'affectation de pointeur pourrait vivre plus longtemps que la cible pointée"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr "Le composant %qs à %L du type dérivé %qs a un type paramétrisé ou des paramètres de longueur de tableau qui n'est pas compatible avec un initialiseur par défaut"
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "La cible de l'initialisation de pointeur à %L ne doit pas être ALLOCATABLE"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "La cible de l'initialisation du pointeur à %L ne doit pas avoir l'attribut TARGET"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "La cible de l'initialisation du pointeur à %L doit avoir l'attribut SAVE"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "La cible de l'initialisation du pointeur de procédure à %L ne peut pas être un pointeur de procédure"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "La procédure interne %qs est invalide dans l'initialisation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "La procédure fictive %qs est invalide dans l'initialisation du pointeur de procédure à %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr "generate_isocbinding_initializer(): mauvais type iso_c_binding, %<c_ptr%> ou %<c_funptr%> attendu"
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008: Fonctions pointeurs dans le contexte de la définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Expression non variable dans le contexte de définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "Constante nommée %qs dans le contexte de la définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%qs dans le contexte de définition de variable (%s) à %L n'est pas une variable"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Non POINTER dans le contexte d'association de pointeur (%s) à %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "Type inaccessible dans le contexte de définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE dans le contexte de définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT dans un contexte de définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "Requête de paramètre %qs pour %qs dans le contexte de la définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "Argument muet %qs avec INTENT(IN) dans un contexte d'association de pointeur (%s) à %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "Argument muet %qs avec INTENT(IN) dans le contexte de définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "La variable %qs est PROTECTED et ne peut pas apparaître dans le contexte d'association de pointeur (%s) à %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "La variable %qs est PROTECTED et ne peut pas apparaître dans le contexte de définition de variable (%s) à %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "La variable %qs ne peut pas apparaître dans le contexte de définition de variable (%s) à %L dans la procédure PURE"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "%qs à %L associé à la cible vecteur indexé ne peut pas être utilisé dans le contexte de définition de variable (%s)"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "%qs à %L associé a une expression ne peut pas être utilisé dans un contexte de définition de variable (%s)"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "%qs à %L est associé a un pointeur qui cible une fonction qui est utilisé dans un contexte de définition de variable (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Le nom associé %qs ne peut pas apparaître dans le contexte de définition de variable (%s) à %L car sa cible à %L ne le peut pas non plus"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "Éléments avec la même valeur à %L et %L dans l'indice de vecteur dans le contexte de définition de variable (%s)"
@@ -77512,7 +77664,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr "Identifiant illégal dans copy_walk_reduction_arg"
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -77573,42 +77725,42 @@ msgstr "La variable %qs à %L a une valeur non définie à l'intérieur de la bo
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "La variable %qs à %L n'est pas définissable à l'intérieur de la boucle commençant à %L comme argument INTENT(INOUT) de la sous-routine %qs"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "La référence au tableau à %L est en dehors des limites (%ld < %ld) dans la boucle commençant à %L"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "La référence au tableau à %L est en dehors des limites (%ld > %ld) dans la boucle commençant à %L"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "La variable %qs à %L a une valeur non définie à l'intérieur de la boucle commençant à %L comme argument INTENT(OUT) de la fonction %qs"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "La variable %qs à %L n'est pas définissable à l'intérieur de la boucle commençant à %L comme argument INTENT(INOUT) de la fonction %qs"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr "Le code pour réallouer le tableau allouable à %L sera ajouté"
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr "La transformation en scalaire grâce à DIMEN_RANGE n'est pas implémentée"
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr "Interchangeage de boucles à %L"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "%s entre %L et %L"
@@ -77733,12 +77885,12 @@ msgstr "Le premier argument de l'affectation définie à %L doit être INTENT(OU
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Le deuxième argument de l'affection définie à %L doit être INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Le premier argument de l'interface de l'opérateur à %L doit être INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Le deuxième argument de l'interface de l'opérateur à %L doit être INTENT(IN)"
@@ -78164,307 +78316,312 @@ msgstr "L'argument effectif pour %qs doit être ALLOCATABLE à %L"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr "L'argument effectif pour %qs à %L est le résultat d'une fonction et l'argument muet est ALLOCATABLE"
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "L'argument effectif qui est une section de tableau avec des indices de vecteur à %L est incompatible avec l'attribut INTENT(OUT), INTENT(INOUT), VOLATILE ou ASYNCHRONOUS de l'argument muet %qs"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "L'argument effectif de forme tacite à %L est incompatible avec l'argument muet de forme non tacite %qs à cause de l'attribut VOLATILE"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "L'argument effectif qui est une section de tableau à %L est incompatible avec l'argument muet de forme non tacite %qs à cause de l'attribut VOLATILE"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "L'argument effectif qui est un tableau de pointeurs à %L requiert un argument muet de forme tacite ou un tableau de pointeurs %qs à cause de l'attribut VOLATILE"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "L'argument effectif de la fonction ISO_C_BINDING à %L requiert que l'argument muet %qs ait un type correspondant de ISO_C_BINDING"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Spécification de retour alternatif manquant dans l'appel de la sous-routine à %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Argument effectif manquant pour l'argument %qs à %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "compare_actual_expr(): Mauvais code de composant"
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr "check_some_aliasing(): Liste non concordante"
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr "check_some_aliasing(): donnée corrompue"
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Le même argument effectif est associé avec l'argument INTENT(%s) %qs et l'argument INTENT(%s) %qs à %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr "check_intents(): Liste non concordante"
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "L'argument de procédure à %L est local dans une procédure PURE et a l'attribut POINTER"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "L'argument effectif co-indexé à %L dans une procédure PURE est passé à un argument INTENT(%s)"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "L'argument effectif co-indexé à %L dans une procédure PURE est passé à un argument muet de type POINTER"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "L'argument effectif polymorphique co-indexé à %L est passé à l'argument muet polymorphique %qs"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "La procédure %qs appelée à %L n'est pas explicitement déclarée, vouliez-vous employer %qs ?"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "La procédure %qs appelée à %L n'est pas explicitement déclarée"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Procédure %qs appelée avec une interface implicite à %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "L'objet pointeur %qs à %L doit avoir une interface de fonction explicite ou être déclaré comme un tableau"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "L'objet allouable %qs à %L doit avoir une interface de fonction explicite ou être déclaré comme un tableau"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "La fonction allouable %qs à %L doit avoir une interface de fonction explicite"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Interface explicite requise pour l'argument polymorphique à %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "L'argument mot-clé requiert une interface explicite pour la procédure %qs à %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "L'argument de type tacite %s à %L requiert une interface explicite"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "L'argument effectif de LOCK_TYPE ou avec un composant LOCK_TYPE à %L requiert une interface explicite pour la procédure %qs"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "L'argument effectif de EVENT_TYPE ou avec un composant EVENT_TYPE à %L requiert une interface explicite pour la procédure %qs"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "Argument MOLD requis pour NULL à %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Passer l'intrinsèque NULL comme argument effectif à %L requiert une interface explicite"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Un argument de rang tacite requiert une interface explicite à %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Composant pointeur de procédure %qs appelé avec une interface implicite à %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "L'argument mot-clé requiert une interface explicite pour le composant pointeur de procédure %qs à %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "MOLD= est requis dans l'argument NULL() à %L: Ambigüité entre les fonctions spécifiées %s et %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "Impossible de trouver le symbole %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "L'entité %qs à %L est déjà présente dans l'interface"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "gfc_add_interface(): Mauvais type d'interface"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "Ne peut écraser GENERIC %qs à %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%qs à %L redéfini une liaison de procédure déclarée NON_OVERRRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "%qs à %L ne doit pas être DEFERRED car il redéfini une liaison non DEFERRED"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%qs à %L redéfini une procédure PURE et doit aussi être PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%qs à %L redéfini une procédure ELEMENTAL et doit aussi être ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%qs à %L redéfini une procédure non ELEMENTAL et ne doit pas être ELEMENTAL non plus"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%qs à %L redéfini une SUBROUTINE et doit aussi être une SUBROUTINE"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%qs à %L redéfini une FUNCTION et doit aussi être une FUNCTION"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Résultat non concordant pour la redéfinition de la procédure %qs à %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%qs à %L redéfini une procédure PUBLIC et ne doit pas être PRIVATE"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "L'argument muet %qs de %qs à %L devrait être nommé %qs pour correspondre à l'argument équivalent de la procédure redéfinie"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Argument non concordant pour la procédure redéfinissante %qs à %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "%qs à %L doit avoir le même nombre d'arguments formels que la procédure redéfinie"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%qs à %L redéfini une liaison NOPASS et doit aussi être NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%qs à %L redéfini une liaison PASS et doit aussi être PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "L'argument muet %qs de type objet passé à %L doit être à la même position que l'argument muet de type objet passé à la procédure redéfinie"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "L'argument muet DTIO à %L doit être du type %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "L'argument muet DTIO à %L doit avoir KIND = %d"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "L'argument muet DTIO à %L doit être un scalaire"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "L'argument muet DTIO à %L doit être ASSUMED SHAPE ARRAY"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "L'argument caractère DTIO à %L doit avoir une longueur tacite"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "L'argument muet DTIO à %L doit avoir INTENT %s"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "Le retour alternatif à %L n'est pas permis dans une procédure DTIO"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "La procédure DTIO %qs à %L doit être une sous-routine"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Trop peu d'arguments muets dans la procédure DTIO %qs à %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "Trop d'arguments muets dans la procédure DTIO %qs à %L"
@@ -78653,7 +78810,7 @@ msgstr "Conversion de %s vers %s à %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "Impossible de convertir %s en %s à %L"
@@ -79199,7 +79356,7 @@ msgstr "NAMELIST %qs dans l'instruction READ à %L contient le symbole %qs qui n
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "L'objet NAMELIST %qs dans la liste de noms %qs à %L est polymorphique et requiert une procédure d'entrée/sortie définie"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "Objet NAMELIST %qs dans la liste de noms %qs à %L avec des composants ALLOCATABLE ou POINTER"
@@ -79370,12 +79527,12 @@ msgstr "débordement de l'identificateur : %d"
 msgid "check_charlen_present(): length not set"
 msgstr "check_charlen_present(): longueur non définie"
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr "GET_TEAM à %L a besoin de USE du module intrinsèque ISO_FORTRAN_ENV pour définir son type résultat TEAM_TYPE"
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr "TODO: MOLD polymorphique illimité dans l'intrinsèque TRANSFER à %L"
@@ -79877,7 +80034,7 @@ msgstr "Le code STOP à %L doit être un caractère par défaut avec KIND=%d"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "Le code STOP à %L doit être un entier par défaut avec KIND=%d"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "Le spécificateur QUIET à %L doit être un scalaire LOGICAL"
@@ -80390,93 +80547,93 @@ msgstr "Nom de bloc %qs attendu pour la construction SELECT à %C"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "SELECT TYPE à %C ne peut pas apparaître dans cette portée"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "erreur d'analyse dans l'instruction SELECT TYPE à %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "Le sélecteur dans SELECT TYPE à %C n'est pas une variable nommée; utilisez associate-name=>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "Instruction SELECT RANK à %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr "Le sélecteur de SELECT RANK à %C doit être une variable de rang tacite"
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "erreur d'analyse dans l'instruction SELECT RANK à %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Instruction CASE inattendue à %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Erreur de syntaxe dans la spécification CASE à %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Instruction TYPE IS inattendue à %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr "La spécification de type ne spécifiera point un type dérivé d'une séquence ou un type avec l'attribut BIND dans SELECT TYPE à %C [F2003:C815]"
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr "Tous les paramètres de type LEN dans l'instruction TYPE IS à %C doivent être ASSUMED"
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Erreur de syntaxe dans la spécification TYPE IS à %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Erreur de syntaxe dans la spécification CLASS IS à %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "Instruction RANK inattendue à %C"
 
 # %s est toujours « INTEGER » et rien d'autre
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "L'expression SELECT RANK CASE à %C doit être une constante entière scalaire"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr "La valeur de l'expression SELECT RANK CASE à %C ne peut pas être inférieure à zéro ou plus grande que %d"
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "Erreur de syntaxe dans la spécification RANK à %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "Instruction ELSEWHERE à %C pas englobée dans un bloc WHERE"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "L'étiquette %qs à %C ne correspond pas à l'étiquette %qs de WHERE"
@@ -81461,7 +81618,7 @@ msgstr "La clause DEPEND à %L de la construction OMP DEPOBJ n'aura point de typ
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr "La clause DEPEND à %L de la construction OMP DEPOBJ n'aura qu'un seul localisateur"
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "La clause MESSAGE à %L requiert une expression scalaire CHARACTER du type par défaut"
@@ -81496,12 +81653,12 @@ msgstr "Liste spécifiée avec la clause d'ordre de mémoire dans la directive F
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Rebut inattendu après l'instruction $OMP FLUSH à %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr "Redéfinition de %s !$OMP DECLARE REDUCTION prédéfini à %L"
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr "Redéfinition de !$OMP DECLARE REDUCTION prédéfini à %L"
@@ -81975,7 +82132,7 @@ msgstr "Rebut inattendu après la clause NOWAIT à %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "La clause %s à %L requiert une expression INTEGER scalaire"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "L'expression INTEGER de la clause %s à %L doit être positive"
@@ -81995,7 +82152,7 @@ msgstr "Objet pointeur Cray %qs du type dérivé dans la clause %s à %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Objet pointé Cray %qs du type dérivé dans la clause %s à %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "Objet POINTEUR %qs du type polymorphique dans la clause %s à %L"
@@ -82025,17 +82182,17 @@ msgstr "Tableau de rang tacite %s dans la clause %s à %L"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "Objet POINTER %qs dans la clause %s à %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Objet pointeur Cray %qs dans la clause %s à %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Objet pointé Cray %qs dans la clause %s à %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "Objet ALLOCATABLE %qs dans la clause %s à %L"
@@ -82156,8 +82313,8 @@ msgstr "Le paramètre de la clause ORDERED est plus petit que COLLAPSE à %L"
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "la clause ORDER ne doit pas être utilisée avec ORDERED à %L"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "La clause IF à %L requiert une expression LOGICAL scalaire"
@@ -82237,7 +82394,7 @@ msgstr "L'objet %qs n'est pas une variable à %L; les paramètres ne peuvent pas
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr "La clause pour l'objet %qs à %L est ignorée car elle est un paramètre"
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "L'objet %qs n'est pas une variable à %L"
@@ -82260,7 +82417,7 @@ msgstr "clause SCHEDULE spécifiée en même temps que la clause %<inscan%> REDU
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "Le symbole %qs est présent dans de multiples clauses à %L"
@@ -82300,7 +82457,7 @@ msgstr "Le symbole %qs est présent à la fois dans les clauses data et map à %
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qs apparaît plus d'une fois dans %<allocate%> à %L"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr "%qs spécifié dans la clause %<allocate%> à %L mais pas dans une clause de privatisation explicite"
@@ -82613,603 +82770,613 @@ msgstr "Seul DEFAULT est permis comme modificateur de réduction dans la clause
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr "!$OMP DECLARE REDUCTION %s pas trouvé pour le type %s à %L"
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr "Désolé, l'objet ALLOCATABLE %qs dans la clause LINEAR sur une construction d'une boucle de partage de travail à %L n'est pas encore supportée"
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr "Désolé, le tableau %qs dans la clause LINEAR d'une construction de boucle de partage de travail à %L n'est pas encore supportée"
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr "Modificateur de clause LINEAR utilisé sur la construction DO ou SIMD à %L"
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr "Modificateur de clause LINEAR autre que VAL utilisé sur la construction DO ou SIMD à %L"
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "La variable LINEAR %qs doit être INTEGER à %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "Argument muet LINEAR %qs avec l'attribut VALUE et le modificateur %s à %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%qs dans la clause LINEAR à %L requiert une expression de pas linéaire qui soit un entier scalaire"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%qs dans la clause LINEAR à %L requiert une expression de pas linéaire qui soit un entier constant ou un argument muet spécifié dans une clause UNIFORM"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "Dans la clause %s, la variable %qs à %L n'est ni un POINTER ni un tableau"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr "La borne inférieure de NUM_TEAMSà %L est plus grande que la borne supérieure à %L"
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "La valeur de la clause HINT à %L sera une expression d'indice de constante valide"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "Le chunk_size de la clause DIST_SCHEDULE à %L requiert une expression INTEGER scalaire"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "la clause %<GRAINSIZE%> à %L ne doit pas être utilisée avec la clause %<NUM_TASKS%>"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "la clause %<REDUCTION%> à %L ne doit pas être utilisée avec la clause %<NOGROUP%>"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "la clause %<FULL%> à %C ne doit pas être utilisée avec la clause %<PARTIAL%>"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Utilisation incompatible de TILE et COLLAPSE à %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "TARGET DATA doit contenir au moins une des clauses MAP, USE_DEVICE_PTR ou USE_DEVICE_ADDR à %L"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%s doit contenir au moins une clause MAP à %L"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "SIZES requiert une expression constante à %L"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr "%qs à %L devrait être un type scalaire de type integer(kind=omp_event_handle_kind)"
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "L'identificateur d'événement à %L ne doit pas être un élément de tableau"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "L'identificateur d'événement à %L ne doit pas faire partie d'un type dérivé ou d'une classe"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "la clause %<DETACH%> à %L ne doit pas être utilisée avec la clause %<MERGEABLE%>"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr "la construction %<host_data%> à %L requiert la clause %<use_device%>"
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr "IF attendu à %L dans la capture de comparaison atomique"
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr "ELSE attendu à %L dans la capture de comparaison atomique"
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr "Expression de comparaison atomique %<==%>, %<.EQ.%> ou %<.EQV.%> attendue à %L"
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr "Variable intrinsèque scalaire attendue à %L dans la comparaison atomique"
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Expression intrinsèque scalaire attendue à %L dans la comparaison atomique"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "L'instruction !$OMP ATOMIC doit définir une variable scalaire ou un type intrinsèque à %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "L'instruction !$OMP ATOMIC doit assigner une expression de type intrinsèque à %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "!$OMP ATOMIC avec une variable ALLOCATABLE à %L"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "L'instruction !$OMP ATOMIC READ doit lire depuis une variable scalaire ou un type intrinsèque à %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr dans l'affectation var = expr de !$OMP ATOMIC WRITE doit être scalaire et ne peut pas faire référence à var à %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "L'instruction de capture !$OMP ATOMIC doit définir une variable scalaire d'un type intrinsèque à %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "L'instruction de capture !$OMP ATOMIC requiert une variable scalaire de type intrinsèque à %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "L'instruction de capture !$OMP ATOMIC CAPTURE lit depuis une variable différente de celle dans laquelle la mise à jour écrit à %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "Pour !$OMP ATOMIC COMPARE, le premier opérande dans la comparaison à %L doit être la variable %qs dans laquelle l'instruction de mise à jour écrit à %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr dans l'affectation var = expr de !$OMP ATOMIC COMPARE doit être scalaire et ne peut pas faire référence à var à %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr "!$OMP ATOMIC UPDATE à %L avec la clause FAIL requiert soit la clause COMPARE ou l'utilisation de la procédure intrinsèque MIN/MAX"
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "L'opérateur d'affectation !$OMP ATOMIC doit être un opérateur binaire dans la liste +, *, -, /, .AND., .OR., .EQV. ou .NEQV. à %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "L'affectation !$OMP ATOMIC doit être var = var op expr ou var = expr op var à %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP ATOMIC var = var op expr n'est pas mathématiquement équivalent à var = var op (expr) à %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "expr dans l'affectation !$OMP ATOMIC var = var op expr doit être scalaire et ne peut pas faire référence à var à %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "L'affectation intrinsèque IAND, IOR ou IEOR de !$OMP ATOMIC doit avoir deux arguments à %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "L'affectation intrinsèque !$OMP ATOMIC doit être MIN, MAX, IAND, IOR ou IEOR à %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "Les arguments intrinsèques de !$OMP ATOMIC sauf un ne doivent pas faire référence à %qs à %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "Les arguments intrinsèques de !$OMP ATOMIC doivent être scalaires à %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Le premier ou le dernier argument intrinsèque de !$OMP ATOMIC doit être %qs à %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "L'affectation de !$OMP ATOMIC doit avoir un opérateur ou un intrinsèque dans le membre de droite à %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "expression !$OMP ATOMIC inattendue à %L"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr "Avec INSCAN à %L, on attend un corps de boucle avec !$OMP SCAN entre deux séquences de blocs structurés"
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr "!$OMP SCAN à %L avec zéro instructions exécutables dans la séquence de blocs structurés précédente"
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr "!$OMP SCAN à %L avec zéro instructions exécutables dans la séquence de blocs structurés suivante"
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr "%s ne peut pas contenir de boucle dans le code intervenant à %L"
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr "%s ne peut pas contenir d'appel à l'api OpenMP dans le code intervenant à %L"
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr "%s ne peut pas contenir de directive OpenMP dans le code intervenant à %L"
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr "La clause SIZES est requise sur la construction !$OMP TILE à %L"
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%s ne peut pas être DO WHILE ou DO sans contrôle de boucle à %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr "%s ne peut pas être une boucle DO CONCURRENT à %L"
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr "La boucle générée par la construction UNROLL à %L sans la clause PARTIAL n'a pas la forme canonique"
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr "La construction UNROLL à %L sans la clause PARTIAL génère juste une boucle avec la forme canonique mais %d boucles sont nécessaires"
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr "La construction TILE à %L génère %d boucles avec la forme canonique mais %d boucles sont nécessaires"
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr "Boucle imparfaitement imbriquée en utilisant les boucles générées"
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "La variable d'itération %s doit être d'un type entier à %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "La variable d'itération %s ne doit pas être THREADPRIVATE à %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "Variable d'itération %s présente sur une clause autre que PRIVATE, LASTPRIVATE ou ALLOCATE à %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "Variable d'itération %s présente sur une clause autre que PRIVATE, LASTPRIVATE, ALLOCATE ou LINEAR à %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "La variable d'itération %s est utilisée dans plus d'une boucle à %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "la variable d'itération %s à %L est liée dans du code intervenant"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr "l'expression de début de boucle %s n'est pas sous la forme canonique à %L"
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr "l'expression de début de boucle %s à %L utilise une variable liée dans du code intervenant"
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "l'expression de fin de la boucle %s n'est pas sous la forme canonique à %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr "l'expression de fin de boucle %s à %L utilise une variable liée dans du code intervenant"
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "les limites de la boucle %s font référence à des variables d'itération différentes à %L"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr "l'incrément de la boucle %s n'est pas sous la forme canonique à %L"
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr "l'expression d'incrément de boucle %s à %L utilise une variable liée dans du code intervenant"
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr "Les boucles non rectangulaires depuis des boucles générées ne sont pas supportées"
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "pas assez de boucle DO pour le %s coalescé (niveau %d) à %L"
 
 # %s peut être « tiled » ou « collapsed », sans traduction…
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "les boucles internes %s doivent être parfaitement imbriquées avec la clause ORDERED à %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr "les boucles internes %s doivent être parfaitement imbriquées avec la clause REDUCTION INSCAN à %L"
 
 # %s peut être « tiled » ou « collapsed », sans traduction…
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "les boucles internes %s doivent être parfaitement imbriquées à %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "l'argument %<score%> doit être une expression entière constante à %L"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "l'argument %<score%> doit être non négatif à %L"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "la propriété doit être une expression logique à %L"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "la propriété doit être une expression entière à %L"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "la propriété doit être une expression logique constante à %L"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "la propriété doit être une expression entière constante à %L"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr "la propriété doit être un numéro de périphérique conforme à %L"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr "La directive %s ne peut pas être spécifiée dans une région %s à %L"
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$ACC LOOP ne peut pas être DO WHILE ou DO sans contrôle de boucle à %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "!$ACC LOOP ne peut pas être une boucle DO CONCURRENT à %L"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "La variable d'itération !$ACC LOOP doit être d'un type entier à %L"
 
 # %s peut être « tiled » ou « collapsed », sans traduction…
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "Les boucles %s !$ACC LOOP ne forment pas un espace d'itération rectangulaire à %L"
 
 # %s peut être « tiled » ou « collapsed », sans traduction…
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "Les boucles %s !$ACC LOOP sont imparfaitement imbriquées à %L"
 
 # %s peut être « tiled » ou « collapsed », sans traduction…
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "pas assez de boucles DO pour la boucle %s !$ACC LOOP à %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr "Une boucle découpée en blocs ne peut pas être parallélisée sur plusieurs « gangs », « workers » ou vecteurs en même temps à %L"
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "TILE requiert une expression constante à %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "L'objet %qs à %L est ignoré car les paramètres n'ont pas besoin d'être copiés"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "Les sections de tableaux %qs ne sont pas permises dans !$ACC DECLARE à %L"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "NOM %qs ne fait pas référence à une sous-routine ou une fonction dans !$ACC ROUTINE ( NOM ) à %L"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "NOM %qs invalide dans !$ACC ROUTINE ( NOM ) à %L"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "la région !$OMP TARGET à %L avec un TEAMS imbriqué à %L ne peut contenir aucune autre instruction, déclaration ou directive en dehors de la seule construction TEAMS"
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "la région !$OMP TARGET à %L dans un TEAMS imbriqué ne peut contenir aucune autre instruction, déclaration ou directive en dehors de la seule construction TEAMS"
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr "la directive %<OMP DISPATCH%> à %L doit être suivie d'un appel de procédure avec une affectation optionnelle"
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr "la directive %<OMP DISPATCH%> à %L ne peut pas être suivie par un pointeur de procédure"
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr "OMP TARGET UPDATE à %L requiert au moins une clause TO ou FROM"
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr "OMP CRITICAL à %L avec la clause HINT requiert un NAME sauf quand omp_sync_hint_none est utilisé"
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr "!$OMP SCAN inattendu à %L en dehors de la construction de boucle avec la clause %<inscan%> REDUCTION"
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr "!$OMP DECLARE SIMD devrait faire référence à la procédure contenante %qs à %L"
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Expression de décalage entière scalaire non négative constante attendue à %L"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr "Pour %<adjust_args%> basé sur une plage, une expression entière scalaire positive constante est requise à %L"
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Nom de paramètre muet ou entier positif attendu à %L"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Une variable autre que OMP_PRIV ou OMP_ORIG est utilisée dans la clause INITIALIZER de !$OMP DECLARE REDUCTION à %L"
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Une variable autre que OMP_OUT ou OMP_IN est utilisée dans le combinateur de !$OMP DECLARE REDUCTION à %L"
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr "Opérateur invalide pour !$OMP DECLARE REDUCTION %s à %L"
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr "La longueur de CHARACTER dans !$OMP DECLARE REDUCTION %s n'est pas constante à %L"
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Appel à une sous-routine avec des retours alternatifs dans le combinateur de !$OMP DECLARE REDUCTION à %L"
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Appel à une sous-routine avec des retours alternatifs dans la clause INITIALIZER de !$OMP DECLARE REDUCTION à %L"
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr "Un des arguments effectifs de la sous-routine dans la clause INITIALIZER de !$OMP DECLARE REDUCTION doit être OMP_PRIV à %L"
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr "Clause INITIALIZER manquante pour !$OMP DECLARE REDUCTION du type dérivé sans initialisation par défaut à %L"
@@ -83873,64 +84040,64 @@ msgstr "la directive %<GCC vector%> n'est pas au début d'une boucle à %C"
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr "la directive %<GCC novector%> n'est pas au début d'une boucle à %C"
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "La procédure contenue %qs à %C est déjà ambigüe"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Instruction %s inattendue dans la section CONTAINS à %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Instruction CONTAINS sans instruction FUNCTION ou SUBROUTINE à %L"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "L'instruction %s à %C ne peut apparaitre après des instructions exécutables"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "L'instruction CONTAINS à %C est déjà dans une unité de programme contenue"
 
 # Le dernier %s est un mot clé tel que « FUNCTION », « PROGRAM », « MODULE » etc, d'où le « un(e) »
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Le nom de liaison globale %qs à %L est déjà utilisé comme un(e) %s à %L"
 
 # Le dernier %s est un mot clé tel que « FUNCTION », « PROGRAM », « MODULE » etc, d'où le « un(e) »
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Le nom global %qs à %L est déjà utilisé comme un(e) %s à %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Le nom de liaison globale %qs à %L est déjà utilisé à %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Le nom global %qs à %L est déjà utilisé à %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "Le BLOCK DATA blanc à %C est en conflit avec le BLOCK DATA précédent à %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Instruction %s inattendue dans BLOCK DATA à %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Instruction %s inattendue dans MODULE à %C"
@@ -83938,7 +84105,7 @@ msgstr "Instruction %s inattendue dans MODULE à %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Deux PROGRAM principaux à %L et %C"
@@ -84395,1086 +84562,1086 @@ msgstr "le PARAMÈTRE %qs n'apparaitra point dans une instruction DATA à %C"
 msgid "%qs at %C is not a variable"
 msgstr "%qs à %C n'est pas une variable"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs à %L est du type ABSTRACT %qs"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "Type ABSTRACT %qs utilisé à %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "L'interface %qs à %L est déclarée dans une instruction PROCEDURE ultérieure"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "L'interface %qs à %L ne peut pas être générique"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "L'interface %qs à %L ne peut pas être une fonction-instruction"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "La procédure intrinsèque %qs n'est pas permise dans une instruction PROCEDURE à %L"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "L'interface %qs à %L doit être explicite"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "La PROCEDURE %qs à %L ne peut pas être utilisée comme sa propre interface"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Le spécificateur de retour alternatif dans la sous-routine élémentale %qs à %L n'est pas permis"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Le spécificateur de retour alternatif dans la fonction %qs à %L n'est pas permis"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "L'argument %qs qui fait référence à lui-même à %L n'est pas permis"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "La procédure muette %qs d'une procédure PURE à %L doit aussi être PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Argument %qs de la fonction pure %qs à %L avec l'attribut VALUE mais sans INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "L'argument %qs de la fonction pure %qs à %L doit être INTENT(IN) ou VALUE"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Argument %qs de la sous-routine pure %qs à %L avec l'attribut VALUE mais sans INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "L'argument %qs de la sous-routine pure %qs à %L doit avoir un INTENT spécifié ou avoir l'attribut VALUE"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "L'argument INTENT(OUT) %qs de la procédure pure %qs à %L ne peut pas être polymorphique"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Argument muet co-tableau %qs à %L pour une procédure élémentale"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "L'argument %qs de la procédure élémentale à %L doit être scalaire"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "L'argument %qs de la procédure élémentale à %L ne peut pas avoir l'attribut ALLOCATABLE"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "L'argument %qs de la procédure élémentale à %L ne peut pas avoir l'attribut POINTER"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "La procédure muette %qs n'est pas permise dans la procédure élémentale %qs à %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "L'argument %qs de la procédure élémentale %qs à %L doit avoir un INTENT spécifié ou avoir l'attribut VALUE"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "L'argument %qs de la fonction-instruction %qs à %L doit être scalaire"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "L'argument %qs avec une valeur de caractère pour la fonction-instruction à %L doit avoir une longueur constante"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "La procédure contenue %qs à %L a le même nom que sa procédure contenante"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "La fonction contenue %qs à %L n'a pas le type IMPLICIT"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Le résultat %qs de la fonction contenue %qs à %L n'a pas le type IMPLICIT"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "La procédure de module %qs avec une valeur de caractère à %L ne peut pas avoir une longueur tacite"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "La fonction interne %qs avec une valeur de caractère à %L ne peut pas avoir une longueur tacite"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "La fonction %s à %L a des entrées avec des spécifications de tableau non concordantes"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "La fonction %s à %L a l'entrée %s avec des caractéristiques non concordantes"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "La fonction %s à %L a des entrées qui retournent des variables de longueurs de chaînes différentes"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Le résultat de FUNCTION %s ne peut pas être un tableau dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Le résultat de ENTRY %s ne peut pas être un tableau dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Le résultat de FUNCTION %s ne peut pas être un POINTER dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Le résultat de ENTRY %s ne peut pas être un POINTER dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Le résultat de FUNCTION %s ne peut pas être ALLOCATABLE dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Le résultat de ENTRY %s ne peut pas être ALLOCATABLE dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Le résultat de FUNCTION %s ne peut pas être du type %s dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Le résultat de ENTRY %s ne peut pas être du type %s dans FUNCTION %s à %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "L'entité globale %qs à %L ne peut pas apparaître dans un bloc COMMON à %L"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "L'entité globale %qs à %L ne peut pas apparaître dans un bloc COMMON"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr "Bloc COMMON à %L"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "La variable %qs à %L est dans COMMON mais seule l'initialisation dans BLOCK DATA est permise"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "La variable %qs à %L est initialisée dans un COMMON blanc mais l'initialisation est uniquement permise dans des communs nommés"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "%qs à %L ne peut pas apparaître dans COMMON [F2008:C5100]"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "L'objet automatique %qs à %L ne peut pas apparaître dans COMMON à %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "La variable %qs, d'un type dérivé, dans COMMON à %L n'a ni l'attribut SEQUENCE ni l'attribut BIND(C)"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "La variable %qs, d'un type dérivé, dans COMMON à %L a un composant ultime qui est allouable"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "La variable %qs, d'un type dérivé, dans COMMON à %L ne peut pas avoir une initialisation par défaut"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr "En Fortran 2003, le bloc COMMON %qs à %L est un identificateur global et doit donc avoir le même nom de liaison que le bloc COMMON similairement nommé à %L: %s vs %s"
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "Le bloc COMMON %qs à %L utilise le même identificateur global que l'entité à %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "Fortran 2008: Le bloc COMMON %qs avec l'étiquette de liaison à %L partage l'identificateur avec l'entité de bloc non COMMON globale à %L"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "Le bloc COMMON à %L avec le label de liaison %qs utilise le même identificateur global que l'entité à %L"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "Le bloc COMMON %qs à %L est utilisé comme PARAMETER à %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "Le bloc COMMON %qs à %L ne peut pas avoir d'attribut EXTERNAL"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "Le bloc COMMON %qs à %L est aussi une procédure intrinsèque"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "Le bloc COMMON %qs à %L qui est aussi un résultat de fonction"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "Le bloc COMMON %qs à %L qui est aussi une procédure globale"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr "Le paramètre KIND %qs dans le constructeur PDT à %C n'a pas de valeur"
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Le rang de l'élément dans le constructeur de structure à %L ne correspond pas à celui du composant (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "L'élément dans le constructeur de structure à %L, pour le composant pointeur %qs, est %s mais il devrait être %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Longueurs de caractères inégales (%wd/%wd) pour le composant pointeur %qs dans le constructeur à %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "Le NULL dans le constructeur de structure à %L est appliqué au composant %qs qui n'est ni un POINTER ni ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Désaccord d'interface pour le composant pointeur de procédure %qs dans le constructeur de structure à %L: %s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Mauvaise spécification de tableau du composant %qs référencé dans le constructeur de structure à %L"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "La forme du composant %qs dans le constructeur de structure à %L diffère de la forme du composant déclaré pour la dimension %d (%ld/%ld)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "L'élément dans le constructeur de structure à %L pour le composant pointeur %qs devrait être un POINTER ou un TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "La cible de l'affectation de pointeur à %L a un indice vectoriel"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Expression invalide dans le constructeur de structure pour le composant pointeur %qs à %L dans une procédure PURE"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "La limite supérieure dans la dernière dimension doit apparaître dans la référence du tableau de taille tacite %qs à %L"
 
 # %qs est le nom d'une procédure d'où le féminin
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%qs à %L est ambigüe"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "La procédure GENERIC %qs n'est pas permise comme argument effectif à %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Le type spécifié pour la fonction intrinsèque %qs à %L est ignoré"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "La sous-routine intrinsèque %qs à %L n'aura point de spécificateur de type"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "%qs déclaré INTRINSIC à %L n'existe pas"
 
 # %s est une chaîne non traduite telle que "available since Fortran 77".
 # voir bugs #38573 et #52279 à ce sujet.
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "L'intrinsèque %qs déclaré INTRINSIC à %L n'est pas disponible avec les paramètres standard actuels mais est %s. Utilisez l'option %<-std=*%> appropriée ou activez %<-fall-intrinsics%> de manière à pouvoir l'utiliser."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "La procédure non RECURSIVE %qs du module %s s'appelle peut-être elle-même récursivement dans la procédure %qs. Déclarez la RECURSIVE ou utilisez %<-frecursive%>"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "La procédure non RECURSIVE %qs à %L semble s'appeler elle-même récursivement. Déclarez la RECURSIVE ou utilisez %<-frecursive%>"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "L'étiquette %d référencée à %L n'est jamais définie"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Le type dérivé %qs est utilisé comme argument effectif à %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "La fonction-instruction %qs à %L n'est pas permise comme argument effectif"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "L'intrinsèque %qs à %L n'est pas permis comme argument effectif"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Procédure interne %qs utilisée comme argument effectif à %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "La procédure ELEMENTAL non INTRINSIC %qs n'est pas permise comme argument effectif à %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Impossible de trouver une procédure INTRINSIC spécifique pour la référence %qs à %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Le symbole %qs à %L est ambigu"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "L'argument par valeur à %L n'est pas un type numérique"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "L'argument par valeur à %L ne peut pas être un tableau ou une section de tableau"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "L'argument par valeur à %L n'est pas permis dans ce contexte"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Passer la procédure interne à %L par position n'est pas permis"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "Le composant pointeur de procédure ELEMENTAL %qs n'est pas permis comme argument effectif à %L"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Argument effectif co-indexé à %L avec un composant pointeur ultime"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "La procédure %qs à %L est utilisée comme un vrai argument mais elle n'a ni interface explicite ni l'attribut EXTERNAL"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "%qs à %L est un tableau et est OPTIONAL; s'il n'est pas présent, il ne peut pas être l'argument effectif d'une procédure ELEMENTAL à moins qu'il y ait un argument non optionnel avec le même rang (Fortran 2018, 15.5.2.12)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "L'argument effectif à %L pour le muet INTENT(%s) %qs de la sous-routine ELEMENTAL %qs est un scalaire mais un autre argument effectif est un tableau"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Désaccord dans le type de retour de la fonction %qs à %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Non concordance de l'interface dans la procédure globale %qs à %L: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "Il n'y a pas de fonction spécifique pour la fonction générique %qs à %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "La fonction générique %qs à %L n'est pas cohérente avec l'interface intrinsèque spécifique"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "La fonction %qs à %L est INTRINSIC mais elle est incompatible avec un intrinsèque"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Impossible de résoudre la fonction spécifique %qs à %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr "Déclaration explicite manquante avec l'attribut EXTERNAL pour le symbole %qs à %L"
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "La fonction %qs à %L n'a pas de type IMPLICIT, vouliez-vous employer %qs ?"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "La fonction %qs à %L n'a pas de type IMPLICIT"
 
 # %s à la fin est le texte non traduit "mask" ou "block"
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "Référence à la fonction impure à %L à l'intérieur d'un DO CONCURRENT"
 
 # %s à la fin est le texte non traduit "mask" ou "block"
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "Référence à la fonction impure %qs à %L à l'intérieur d'un FORALL %s"
 
 # %s à la fin est le texte non traduit "mask" ou "block"
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "Référence à la fonction impure %qs à %L à l'intérieur d'un DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Référence à la fonction impure %qs à %L dans une procédure PURE"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "Rebut inattendu après %qs à %L"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs à %L n'est pas une fonction"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ABSTRACT INTERFACE %qs ne doit pas être référencée à %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr "ABSTRACT INTERFACE %qs à %L ne doit pas avoir un résultat d'une longueur de caractères tacite (F2008: C418)"
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "La fonction %qs est déclarée CHARACTER(*) et ne peut pas être utilisée à %L car elle n'est pas un argument muet"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Listes d'arguments différentes dans la fonction muette externe %s à %L et %L"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "resolve_function(): mauvais type de fonction"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr "Une constante littérale BOZ à %L ne peut pas apparaître comme un argument effectif dans une référence de fonction"
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "La fonction %qs non ELEMENTAL définie par l'utilisateur à %L n'est pas permise dans la construction WORKSHARE"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "ENTRY %qs à %L ne peut pas être appelé récursivement car la fonction %qs n'est pas RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "La fonction %qs à %L ne peut pas être appelée récursivement car elle n'est pas RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "L'utilisation de la fonction %qs à %L est obsolète"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "La procédure muette %qs à %L requiert un attribut EXTERNAL"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "L'appel de sous-routine à %L dans le bloc DO CONCURRENT n'est pas PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "L'appel de sous-routine à %qs dans le bloc FORALL à %L n'est pas PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "L'appel de sous-routine à %qs dans le bloc DO CONCURRENT à %L n'est pas PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "L'appel de sous-routine à %qs à %L n'est pas PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Il n'y a pas de sous-routine spécifique pour le générique %qs à %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "La sous-routine générique %qs à %L n'est pas cohérente avec l'interface de sous-routine intrinsèque"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "La sous-routine %qs à %L est INTRINSIC mais elle n'est pas compatible avec un intrinsèque"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Impossible de résoudre la sous-routine spécifique %qs à %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr "F2018 : C8102 %qs à %L est associé à l'hôte mais n'apparaît pas dans un IMPORT ou une liste IMPORT, ONLY"
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr "F2018 : C8102 %qs à %L est associé à l'hôte dans une portée qui a IMPORT, NONE"
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "%qs à %L a un type, ce qui n'est pas cohérent avec l'appel CALL à %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "ENTRY %qs à %L ne peut pas être appelé récursivement car la sous-routine %qs n'est pas RECURSIVE"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "SUBROUTINE %qs à %L ne peut pas être appelée récursivement car elle n'est pas RECURSIVE"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr "Liste d'arguments différentes dans la sous-routine muette externe %s à %L et %L"
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "resolve_subroutine(): mauvais type de fonction"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "L'utilisation de la sous-routine %qs à %L est obsolète"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Les formes pour les opérandes à %L et %L ne sont pas conformes"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "logical_to_bitwise(): Mauvais intrinsèque"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "La fonction impure %qs à %L pourrait ne pas être évaluée"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "La fonction impure à %L pourrait ne pas être évaluée"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "La constante littérale BOZ à %L ne peut pas être un opérande de l'opérateur unaire %qs"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "La négation d'une expression non signée à %L n'est pas permise "
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr "Les opérandes à %L et %L ne peuvent pas apparaître comme opérandes de l'opérateur binaire %qs"
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Contexte invalide pour un pointeur NULL() à %L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "L'opérande de l'opérateur numérique unaire %qs à %L est %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Les opérandes de l'opérateur numérique binaire %qs à %L sont %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Rangs inconsistant pour l'opérateur à %L et %L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "Entités de type dérivé inattendues dans l'opérateur numérique intrinsèque binaire %qs à %L"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Les opérandes de l'opérateur de concaténation de chaînes à %L sont %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Les opérandes de l'opérateur logique %qs à %L sont %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr "L'opérande de l'opérateur .not. à %L est %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "Les quantités COMPLEX ne peuvent pas être comparées à %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "La constante littérale BOZ près de %L ne peut pas apparaître comme opérande d'un opérateur relationnel"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Types inconsistants pour l'opérateur à %L et %L : %s et %s"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr "Comparaison égalitaire pour %s à %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr "Comparaison inégalitaire pour %s à %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Les valeurs logiques à %L doivent être comparées avec %s au lieu de %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Les opérandes de l'opérateur de comparaison %qs à %L sont %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "Opérateur %qs inconnu à %L; vouliez-vous utiliser %qs ?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "Opérateur %qs inconnu à %L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "L'opérande de l'opérateur utilisateur %qs à %L est %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Les opérandes de l'opérateur utilisateur %qs à %L sont %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "resolve_operator(): Mauvais intrinsèque"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "La condition dans l'expression conditionnelle doit être un logique scalaire à %L"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "L'expression à %L et l'expression à %L dans l'expression conditionnelle doit avec le même type déclaré"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "L'expression à %L et l'expression à %L dans l'expression conditionnelle doivent avoir le même paramètre de sous-type"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "L'expression à %L et l'expression à %L dans l'expression conditionnelle doivent avoir le même rang"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr "Désolé, seuls des entiers, des logiques, des réels, des complexes et des types caractères sont actuellement supportés pour les expressions conditionnelles à %L"
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr "Désolé, le tableau n'est actuellement pas supporté pour les expressions conditionnelles à %L"
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "La référence au tableau à %L est en dehors des limites (%ld < %ld) dans la dimension %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "La référence au tableau à %L est en dehors des limites (%ld < %ld) dans la co-dimension %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "La référence au tableau à %L est en dehors des limites (%ld > %ld) dans la dimension %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "La référence au tableau à %L est en dehors des limites (%ld > %ld) dans la co-dimension %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Pas nul illégal à %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "La référence inférieure au tableau à %L est hors des limites (%ld < %ld) dans la dimension %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "La référence inférieure au tableau à %L est en dehors des limites (%ld > %ld) dans la dimension %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "La référence supérieure au tableau à %L est hors des limites (%ld < %ld) dans la dimension %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "La référence supérieure au tableau à %L est hors des limites (%ld > %ld) dans la dimension %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "check_dimension(): Mauvaise référence de tableau"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "La limite supérieure la plus à droite de la section du tableau de taille tacite n'est pas spécifiée à %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Désaccord de rang dans la référence au tableau à %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Désaccord du rang du co-index dans la référence au tableau à %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Le co-index de la co-dimension %d doit être un scalaire à %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "L'index de tableau à %L doit être scalaire"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "L'index de tableau à %L doit être du type INTEGER, on a trouvé %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "Index de tableau REAL à %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "L'argument dim à %L doit être scalaire"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "L'argument dim à %L doit être du type INTEGER"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Référence de tableau invalide dans une entité qui n'est pas un tableau à %L"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr "find_array_spec(): « as » inutilisé(1)"
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr "find_array_spec(): « as » inutilisé(2)"
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "L'index de tableau à %L est un tableau de rang %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "L'argument TEAM_NUMBER à %L doit être scalaire"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "L'argument TEAM_NUMBER à %L doit être du type INTEGER et non %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "L'argument TEAM à %L doit être scalaire"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr "L'argument TEAM à %L doit être du type TEAM_TYPE du module intrinsèque ISO_FORTRAN_ENV et non %s"
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "L'argument STAT à %L doit être scalaire"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "L'argument STAT à %L doit être du type INTEGER et non %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr "L'expression de STAT à %L doit être une variable"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "L'index de départ de la sous-chaîne à %L doit être du type INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "L'index de départ de la sous-chaîne à %L doit être scalaire"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "L'index de fin de la sous-chaîne à %L doit être du type INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "L'index de fin de la sous-chaîne à %L doit être scalaire"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "L'index de fin de la sous-chaîne à %L est trop grand"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "resolve_ref(): Mauvaise référence de tableau"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Le composant à droite d'une référence de partie avec un rang non nul ne doit pas avoir l'attribut POINTER à %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Le composant à droite d'une référence de partie avec un rang non nul ne doit pas avoir l'attribut ALLOCATABLE à %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Deux références de parties (ou plus) avec un rang non nul ne peuvent pas être spécifiées à %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr "gfc_expression_rank(): Deux specs de tableau"
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "Index de co-tableau illégal"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK peut uniquement être utilisée comme argument effectif"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "La variable de type tacite %s à %L peut uniquement être utilisée comme argument effectif"
@@ -85483,12 +85650,12 @@ msgstr "La variable de type tacite %s à %L peut uniquement être utilisée comm
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "La variable de type tacite %s à %L comme argument effectif à une fonction de requête sera le premier argument"
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "La variable de rang tacite %s à %L peut uniquement être utilisée comme argument effectif"
@@ -85497,416 +85664,416 @@ msgstr "La variable de rang tacite %s à %L peut uniquement être utilisée comm
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "La variable de rang tacite %s à %L comme argument effectif à une fonction intrinsèque sera le premier argument"
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK n'aura point de référence à un sous-objet"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "La variable de type tacite %s à %L n'aura point de référence à un sous-objet"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "La variable de rang tacite %s à %L n'aura point de référence à un sous-objet"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "La variable scalaire %qs a une référence à un tableau à %L"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "La variable %qs, utilisée dans une expression de spécification, est référencée à %L avant l'instruction ENTRY dans laquelle elle est un paramètre"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "La variable %qs est utilisée à %L avant l'instruction ENTRY dans laquelle elle est un paramètre"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Sous-objet polymorphique d'un objet co-indexé à %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Objet co-indexé avec un sous-composant allouable polymorphique à %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "L'utilisation de la variable %qs à %L est obsolète"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "Référence invalide à un tableau à %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr "%qs à %L est associé à l'hôte à %L dans une procédure contenue avec une procédure interne du même nom"
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "Erreur dans l'appel avec type lié à %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "L'objet passé à %L doit être scalaire"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "L'objet de base pour l'appel de composant pointeur de procédure à %L est du type ABSTRACT %qs"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "L'objet de base pour l'appel de procédure liée au type à %L est du type ABSTRACT %qs"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "L'objet de base pour l'appel de procédure liée au type NOPASS à %L doit être scalaire"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "Aucune liaison spécifique correspondante pour l'appel à GENERIC %qs à %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%qs à %L devrait être une SUBROUTINE"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs à %L devrait être une FUNCTION"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "gfc_resolve_expr(): Mauvais type d'expression"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s à %L doit être un scalaire"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s à %L doit être un entier"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s à %L doit être INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "L'expression de pas dans la boucle DO à %L ne peut pas être zéro"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "La boucle DO à %L sera exécutée zéro fois"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr "La boucle DO à %L est indéfinie car elle déborde"
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr "La boucle DO à %L est indéfinie car elle déborde vers le bas"
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr "La variable %qs référencée dans l'en-tête concurrent à %L ne peut pas apparaître dans une spec de localité LOCAL à %L"
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr "La variable %qs à %L n'est pas spécifiée dans le spécificateur de localité de DO CONCURRENT à %L mais elle est requises à cause de DEFAULT (NONE)"
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Nom de variable attendu dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "La variable %qs à %L a déjà été spécifiée dans une spécification de localité"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "La variable d'index %qs à %L ne peut pas être spécifiée dans une spécification de localité"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "L'attribut OPTIONAL n'est pas permis pour %qs dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Tableau de taille tacite pas permis pour %qs dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "L'attribut ALLOCATABLE n'est pas permis pour %qs dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr "L'argument muet polymorphique qui n'est pas un pointeur n'est pas permis pour %qs dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Co-tableaux pas permis pour %qs dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr "Le type finalisable n'est pas permis pour %qs dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr "Le type avec le composant ultimement allouable n'est pas permis pour %s dans la spécification de localité %s à %L"
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr "L'attribut ASYNCHRONOUS n'est pas permis pour %qs dans la spécification de localité REDUCE à %L"
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr "L'attribut VOLATILE n'est pas permis pour %qs dans la spécification de localité REDUCE à %L"
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Type numérique attendu pour %qs dans REDUCE à %L, %s obtenu"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "Type logique attendu pour %qs dans REDUCE à %L, %qs obtenu"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr "Type INTEGER, REAL ou CHARACTER attendu pour %qs dans REDUCE avec MIN/MAX à %L, %s obtenu"
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr "Type entier attendu pour %qs dans REDUCE avec IAND/IOR/IEOR à %L, %s obtenu"
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "La variable %qs dans la spécification de localité à %L n'est pas utilisée"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "Le nom d'index FORALL à %L doit être un INTEGER scalaire"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "L'expression de départ de FORALL à %L doit être un INTEGER scalaire"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "L'expression de fin de FORALL à %L doit être un INTEGER scalaire"
 
 # %s est toujours « INTEGER » et rien d'autre
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "L'expression de pas de FORALL à %L doit être un %s scalaire"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "L'expression de pas de FORALL à %L ne peut pas être zéro"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "L'index %qs de FORALL ne peut pas apparaître dans une spécification de triplet à %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "L'objet allouable à %L doit être ALLOCATABLE ou un POINTER"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Objet allouable co-indexé à %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "L'objet alloué à %L a le rang %d mais l'expression MOLD= à %L a le rang %d"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "L'expression source à %L doit être scalaire ou avoir le même rang que l'objet allouable à %L"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "L'expression source à %L et l'objet allouable à %L doivent avoir la même forme"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "L'intrinsèque NULL ne peut pas être utilisé comme expression source à %L"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "Le type de l'entité à %L a un type incompatible avec l'expression source à %L"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "L'objet allouable à %L et l'expression source à %L auront le même paramètre de sous-type"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "L'expression source à %L n'aura ni le type LOCK_TYPE ni un composant LOCK_TYPE si l'objet allouable à %L est un co-tableau"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "L'expression source à %L n'aura ni le type EVENT_TYPE ni un composant EVENT_TYPE si l'objet allouable à %L est un co-tableau"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "L'allocation de %s du type de base ABSTRACT à %L requiert une spécification de type ou une expression source"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr "Le paramètre de type dans l'instruction ALLOCATE avec spécification de type sera une astérisque puisque l'objet %qs alloué à %L est un argument muet avec un paramètre de type tacite"
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "L'allocation de %s à %L avec la spécification de type requiert la même longueur de caractères dans le paramètre que dans la déclaration"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Spécification de tableau requise dans l'instruction ALLOCATE à %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Une spécification de tableau ou une expression SOURCE= avec une valeur tableau est requise dans l'instruction ALLOCATE à %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Spécification de co-tableau requise dans l'instruction ALLOCATE à %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Mauvaise spécification de co-tableau dans l'instruction ALLOCATE à %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr "La co-borne supérieure est plus petite que la co-borne inférieure à %L"
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr "La co-borne supérieure est plus petite que la co-borne inférieure 1 à %L"
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Mauvaise spécification de tableau dans l'instruction ALLOCATE à %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "%qs ne doit pas apparaître dans la spécification de tableau à %L dans la même instruction ALLOCATE où il est lui-même alloué"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "%<*%> attendu dans la spécification du co-index dans l'instruction ALLOCATE à %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "La variable stat à %L doit être une variable INTEGER scalaire"
 
 # les deux %s sont le même mot-clé "ALLOCATE" ou "DEALLOCATE" utilisés une fois comme mot et comme instruction, merde les mecs, ils pourraient faire attention aux traducteurs…
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "La variable stat à %L ne sera point qualifiée par %s dans la même instruction %s"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "ERRMSG à %L est inutile sans la balise STAT"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "La variable ERRMSG à %L sera une variable CHARACTER du scalaire par défaut"
 
 # les deux %s sont le même mot-clé "ALLOCATE" ou "DEALLOCATE" utilisés une fois comme mot et comme instruction, merde les mecs, ils pourraient faire attention aux traducteurs…
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "La variable errmsg à %L ne sera point qualifiée par %s dans la même instruction %s"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "L'objet alloué à %L apparaît aussi à %L"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "L'objet alloué à %L est un sous-objet d'un objet à %L"
@@ -85915,314 +86082,314 @@ msgstr "L'objet alloué à %L est un sous-objet d'un objet à %L"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "L'étiquette CASE à %L chevauche l'étiquette CASE à %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "L'expression dans l'instruction CASE à %L doit être du type %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "L'expression dans l'instruction CASE à %L doit être du sous-type %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "L'expression dans l'instruction CASE à %L doit être scalaire"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "L'expression de sélection dans le GOTO calculé à %L doit être une expression entière scalaire"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "L'argument de l'instruction SELECT à %L ne peut pas être %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "L'argument de l'expression SELECT à %L doit être une expression scalaire"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "L'expression dans l'instruction CASE à %L n'est pas dans la plage de %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "Le DEFAULT CASE à %L ne peut pas être suivi par un second DEFAULT CASE à %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Une plage logique n'est pas permise dans l'instruction CASE à %L"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "La valeur logique constante est répétée dans l'instruction CASE à %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "La spécification d'étendue à %L ne peut jamais correspondre à quoi que ce soit"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Le bloc SELECT CASE logique à %L a plus de deux cas"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "%s n'a pu être résolu en une fonction spécifique à %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr "(F202Y)Limite manquante ou invalide dans le remappage du rang avec ASSOCIATE du nom associé %s à %L"
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "L'entité associante %qs à %L est un pointeur de procédure"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Le type dérivé %qs ne peut pas être utilisé comme une variable à %L"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "L'entité associante %qs à %L est un nom de procédure"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr "L'expression de sélecteur associant à %L donne une procédure"
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "Le sélecteur à %L ne peut pas NULL()"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "Le sélecteur à %L n'a pas de type"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Le nom associé %qs à %L est utilisé comme tableau"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr "Le sélecteur CLASS à %L a besoin d'un temporaire qui n'est pas encore implémenté"
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Le sélecteur sera polymorphique dans l'instruction SELECT TYPE à %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "Le sélecteur à %L ne doit pas être co-indexé"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "TYPE IS à %L chevauche TYPE IS à %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Le type dérivé %qs à %L doit être extensible"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Le type dérivé %qs à %L doit être une extension de %qs"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Type intrinsèque %qs inattendu à %L"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "La spécification de type à %L doit spécifier que chaque paramètre de type de longueur est tacite"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Bloc CLASS IS en double dans l'instruction SELECT TYPE à %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr "RANK DEFAULT à %L est répété à %L"
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr "RANK (*) à %L est répété à %L"
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr "RANK (%i) à %L est répété à %L"
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr "RANK (*) à %L ne peut pas être utilisé avec un pointeur ou un sélecteur allouable à %L"
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Contexte invalide pour l'intrinsèque NULL () à %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "La procédure DTIO %s à %L doit être récursive"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "L'élément de transfert de données à %L ne peut pas être polymorphique à moins qu'il soit traité par une procédure d'entrée/sortie définie"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "L'élément de transfert de données à %L ne peut pas avoir de composants POINTER à moins qu'il soit traité par une procédure d'entrée/sortie définie"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "L'élément de transfert de données à %L ne peut pas avoir de composants de pointeur de procédure"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "L'élément de transfert de données à %L ne peut pas avoir de composants ALLOCATABLE à moins qu'il soit traité par une procédure d'entrée/sortie définie"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "L'élément de transfert de données à %L ne peut pas avoir de composants PRIVATE"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "L'élément de transfert de données à %L ne peut pas avoir de composants PRIVATE à moins qu'il soit traité par une procédure d'entrée/sortie définie"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "L'élément de transfert de données à %L ne peut pas être une référence complète à un tableau de taille tacite"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "La variable verrou à %L doit être un scalaire de type LOCK_TYPE"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "La variable d'événement à %L doit être un scalaire de type EVENT_TYPE"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "L'argument variable d'événement à %L doit être un co-tableau ou co-indexé"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "L'argument variable d'événement à %L doit être un co-tableau mais pas co-indexé"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "L'argument STAT= à %L doit être une variable INTEGER scalaire"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "L'argument ERRMSG= à %L doit être une variable CHARACTER scalaire"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "L'argument ACQUIRED_LOCK= à %L doit être une variable LOGICAL scalaire"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "L'argument UNTIL_COUNT= à %L doit être une expression INTEGER scalaire"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr "L'argument TEAM à %L doit être une expression scalaire de type TEAM_TYPE du module intrinsèque ISO_FORTRAN_ENV"
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "L'argument %s à %L doit être une variable %s scalaire du sous-type au moins %d"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "L'argument %s à %L doit être un scalaire %s du sous-type au moins %d"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "L'argument imageset à %L doit être une expression scalaire ou INTEGER de rang 1"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "L'argument imageset à %L doit être entre 1 et num_images()"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "L'instruction à %L n'est pas une instruction cible valable pour l'instruction de branchement à %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Le branchement à %L peut conduire à une boucle infinie"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "L'instruction GOTO à %L quitte une construction CRITICAL pour l'étiquette à %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "L'instruction GOTO à %L quitte une construction DO CONCURRENT pour l'étiquette à %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "L'instruction GOTO à %L quitte une construction CHANGE TEAM pour l'étiquette à %L"
@@ -86230,212 +86397,212 @@ msgstr "L'instruction GOTO à %L quitte une construction CHANGE TEAM pour l'éti
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "L'étiquette à %L n'est pas dans le même bloc que l'instruction GOTO à %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "Le masque WHERE à %L a une forme inconsistante"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "La cible de l'affectation WHERE à %L a une forme inconsistante"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Affectation définie par l'utilisateur non ELEMENTAL dans WHERE à %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Instruction non supportée à l'intérieur de WHERE à %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Affectation à une variable d'index FORALL à %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "Le FORALL avec l'index %qs n'est pas utilisé dans le membre de gauche de l'affectation à %L et, par conséquent, pourrait causer de multiples affectations à cet objet"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "Construction FORALL à %L"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "Le nom d'index de FORALL à %L doit être une variable scalaire de type entier"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Une construction de boucle FORALL extérieure a déjà un index avec ce nom à %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr "Le nom d'une variable masquée doit commencer par _"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "La clause WHERE/ELSEWHERE à %L requiert un tableau LOGICAL"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "gfc_resolve_blocks(): Mauvais type de bloc"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "La variable dans l'assignation ordinaire à %L est un composant pointeur de procédure"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "Impossible d'assigner %s à %s à %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "L'expression CHARACTER sera tronquée dans l'affectation (%wd/%wd) à %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "L'expression co-indexée à %L est affectée à une variable de type dérivé avec un composant POINTER dans une procédure PURE"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr "Dans un sous-programme pure, un argument fictif INTENT(IN) ne sera point utilisé comme l'expression à %L d'une instruction d'affectation intrinsèque dans laquelle la variable est d'un type dérivé si le type dérivé a un composant pointeur à n'importe quel niveau de la sélection du composant."
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Affectation à une variable co-indexée à %L dans une procédure PURE"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "L'affectation à un co-tableau polymorphique à %L n'est pas permise"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Affectation à une variable polymorphique allouable à %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "L'affectation à une variable polymorphique allouable à %L requiert %<-frealloc-lhs%>"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "La variable non allouable ne doit pas être polymorphique dans l'affectation intrinsèque à %L – vérifiez qu'il existe une sous-routine spécifique correspondante pour l'opérateur %<=%>"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "La variable co-indexée ne doit pas avoir un composant ultimement allouable dans l'affectation à %L"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr "À FAIRE: la/les affectation(s) liée(s) au type à %L n'ont pas été réalisées car des références multiples à des parties de tableaux apparaîtraient dans des expressions intermédiaires."
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "Affectation à une procédure pointeur à %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "Le résultat de la fonction dans le membre de gauche de l'affectation à %L doit avoir l'attribut pointeur."
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "L'instruction ASSIGNED GOTO à %L requiert une variable INTEGER scalaire"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Une étiquette cible n'a pas été affectée à la variable %qs à %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "L'instruction RETURN alternatif à %L requiert un spécificateur de retour SCALAR-INTEGER"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Assignation intrinsèque attendue dans OMP WORKSHARE à %L"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "L'instruction ASSIGN à %L requiert une variable scalaire INTEGER par défaut"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "NULL invalide à %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "L'instruction IF arithmétique à %L requiert une expression scalaire REAL ou INTEGER"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "gfc_resolve_code(): Pas d'expression dans le DO WHILE"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "La condition de sortie de la boucle DO WHILE à %L doit être une expression LOGICAL scalaire"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "La clause de masque FORALL à %L requiert une expression scalaire LOGICAL"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_resolve_code(): Mauvais code d'instruction"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "L'utilisation du paramètre %qs déclaré à %L est obsolète"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "La variable %qs avec l'étiquette de liaison %qs à %L utilise le même identificateur global que l'entité à %L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "La variable %qs du module %qs avec l'étiquette de liaison %qs à %L utilise le même identificateur global que l'entité à %L du module %qs"
@@ -86443,1058 +86610,1058 @@ msgstr "La variable %qs du module %qs avec l'étiquette de liaison %qs à %L uti
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "La procédure %qs avec l'étiquette de liaison %qs à %L utilise le même identificateur global que l'entité à %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "La longueur de chaîne à %L est trop grande"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Le tableau allouable %qs à %L doit avoir une forme différée ou un rang tacite"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "L'objet scalaire %qs à %L ne peut pas être ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Le pointeur tableau %qs à %L doit avoir une forme différée ou un rang tacite"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Le tableau %qs à %L ne peut pas avoir une forme différée"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "Le type %qs de la variable CLASS %qs à %L n'est pas extensible"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "La variable CLASS %qs à %L doit être muette, allouable ou pointeur"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Le type %qs ne peut pas être associé à un hôte à %L car il est bloqué par un objet incompatible du même nom déclaré à %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "SAVE implicite pour la variable module %qs à %L, nécessaire à cause de l'initialisation par défaut"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "L'entité %qs à %L a un paramètre de type différé et requiert soit l'attribut POINTER ou ALLOCATABLE"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "La variable automatique %qs à %L ne peut pas avoir l'attribut SAVE"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Le tableau %qs à %L du module ou du programme principal doit avoir une forme constante"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "L'entité avec une longueur de caractère tacite à %L doit être un argument muet ou un PARAMETER"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "%qs à %L doit avoir une longueur de caractère constante dans ce contexte"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "La variable COMMON %qs à %L doit avoir une longueur de caractère constante"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "L'allouable %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "L'externe %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Le muet %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "L'intrinsèque %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Le résultat de fonction %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Le tableau automatique %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s à %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "La fonction-instruction %qs avec une valeur de caractère à %L doit avoir une longueur constante"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "%qs est d'un type PRIVATE et ne peut pas être un argument muet de %qs, qui est PUBLIC à %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "La procédure %qs dans l'interface PUBLIC %qs à %L prend des arguments muets de %qs qui est PRIVATE"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "La fonction %qs à %L ne peut pas avoir une initialisation"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "L'objet externe %qs à %L ne peut pas avoir d'initialisation"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "La fonction ELEMENTAL %qs à %L doit avoir un résultat scalaire"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "La fonction-instruction %qs à %L ne peut pas avoir l'attribut pointeur ou allouable"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "La fonction CHARACTER(*) %qs à %L ne peut pas avoir la valeur d'un tableau"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "La fonction CHARACTER(*) %qs à %L ne peut pas avoir la valeur d'un pointeur"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "La fonction CHARACTER(*) %qs à %L ne peut pas être pure"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "La fonction CHARACTER(*) %qs à %L ne peut pas être récursive"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "Fonction CHARACTER(*) %qs à %L"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "Le pointeur de procédure %qs à %L ne sera point élémental"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "La procédure muette %qs à %L ne sera point élémentale"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "La variable résultat %qs de la fonction à %L de la fonction élémentale %qs n'aura point l'attribut ALLOCATABLE ou POINTER"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr "La variable résultat %qs de la fonction pure à %L est allouable polymorphique"
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "La variable résultat %qs de la fonction pure à %L a le composant allouable polymorphique %qs"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "L'attribut PROCEDURE est en conflit avec l'attribut SAVE dans %qs à %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "L'attribut PROCEDURE est en conflit avec l'attribut INTENT dans %qs à %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "L'attribut PROCEDURE est en conflit avec l'attribut RESULT dans %qs à %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "L'attribut EXTERNAL est en conflit avec l'attribut FUNCTION dans %qs à %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "Le résultat du pointeur de procédure %qs à %L n'a pas d'attribut pointeur"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Désaccord sur l'attribut ELEMENTAL entre MODULE PROCEDURE à %L et son interface dans %s"
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Désaccord sur l'attribut PURE entre MODULE PROCEDURE à %L et son interface dans %s"
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Désaccord sur l'attribut RECURSIVE entre MODULE PROCEDURE à %L et son interface dans %s"
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr "%s entre la déclaration MODULE PROCEDURE dans MODULE %qs et la déclaration à %L dans (SUB)MODULE %qs"
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "L'interface de %qs à %L doit être explicite"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "La procédure FINAL %qs à %L n'est pas une SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "La procédure FINAL à %L doit avoir exactement un argument"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "L'argument de la procédure FINAL à %L doit être du type %qs"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr "La procédure FINAL à %L avec un argument de rang tacite doit être le seul finaliseur avec le même genre/type (F2018: C790)"
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "L'argument de la procédure FINAL à %L ne peut pas être un POINTER"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "L'argument de la procédure FINAL à %L ne peut pas être ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "L'argument de la procédure FINAL à %L ne peut pas être OPTIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "L'argument de la procédure FINAL à %L ne peut pas être INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "La procédure FINAL non scalaire à %L devrait avoir un argument de forme tacite"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "La procédure FINAL %qs déclarée à %L a le même rang (%d) que %qs"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Seules des procédures FINAL tableaux déclarées pour le type dérivé %qs à %L, une scalaire est également suggérée à moins qu'un finaliseur de rang tacite a été déclaré"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "%qs et %qs ne peuvent pas être FUNCTION/SUBROUTINE mixte pour GENERIC %qs à %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "%qs et %qs pour GENERIC %qs à %L sont ambigus"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "Liaison spécifique %qs non définie comme cible du GENERIC %qs à %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "GENERIC %qs à %L doit cibler une liaison spécifique, %qs est GENERIC aussi"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "GENERIC %qs à %L ne peut écraser la liaison spécifique avec le même nom"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "L'opérateur lié au type à %L ne peut pas être NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "%qs doit être une procédure de module ou une procédure externe avec une interface explicite à %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "La procédure %qs avec PASS(%s) à %L n'a pas d'argument %qs"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "La procédure %qs avec PASS à %L doit avoir au moins un argument"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Argument muet passé comme objet non polymorphique de %qs à %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "L'argument %qs de %qs avec PASS(%s) à %L doit être du type dérivé %qs"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "L'argument %qs de %qs avec PASS(%s) à %L doit être du type paramétré dérivé %qs"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr "Tous les paramètres de type LEN de l'argument muet %qs de %qs à %L doivent être ASSUMED."
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "L'argument muet de type objet passé de %qs à %L doit être scalaire"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "L'argument muet de type objet passé de %qs à %L ne peut pas être ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "L'argument muet de type objet passé de %qs à %L ne peut pas être POINTER"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "La procédure %qs à %L a le même nom qu'un composant de %qs"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "La procédure %qs à %L a le même nom qu'un composant hérité de %qs"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "Le type dérivé %qs déclaré à %L doit être ABSTRACT car %qs est DEFERRED et pas redéfini"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Le composant co-tableau %qs à %L doit être allouable avec une forme différée"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Le composant %qs à %L ayant TYPE(C_PTR) ou TYPE(C_FUNPTR) ne sera point un co-tableau"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "Le composant %qs à %L avec le composant co-tableau sera un scalaire non pointeur, non allouable"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "Le composant %qs à %L a l'attribut CONTIGUOUS mais n'est pas un pointeur de tableau"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Le composant %qs du type BIND(C) à %L doit avoir la longueur un"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Le composant pointeur de procédure %qs avec PASS(%s) à %L n'a pas d'argument %qs"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Le composant pointeur de procédure %qs avec PASS à %L doit avoir au moins un argument"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "L'argument %qs de %qs avec PASS(%s) à %L doit être du type dérivé %qs"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "L'argument %qs de %qs avec PASS(%s) à %L doit être scalaire"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "L'argument %qs de %qs avec PASS(%s) à %L ne peut pas avoir l'attribut POINTER"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "L'argument %qs de %qs avec PASS(%s) à %L ne peut pas être ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Le composant %qs de %qs à %L a le même nom qu'une procédure liée au type héritée"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "La longueur de caractère du composant %qs doit être une expression de spécification constante à %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "L'expression de longueur de caractère du composent %qs à %L doit être du type INTEGER et non %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "Le composant caractère %qs de %qs à %L avec une longueur différée doit être POINTER ou ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "le composant %qs est un type PRIVATE et ne peut pas être un composant de %qs, qui est PUBLIC à %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Le composant polymorphique %s à %L dans le type %s SEQUENCE ou BIND(C)"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Le composant %s du type SEQUENCE déclaré à %L n'a pas l'attribut SEQUENCE"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Initialisations conflictuelles dans l'union à %L et %L"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "Puisque l'extension du type %qs à %L a un composant co-tableau, le type parent %qs en aura un aussi"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Le type dérivé non extensible %qs à %L ne peut pas être ABSTRACT"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr "Le type paramétrisé %qs n'a pas de composant correspondant au paramètre %qs à %L"
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Nom générique %qs de la fonction %qs à %L étant le même nom que le type dérivé à %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Le type dérivé %qs à %L n'a pas été déclaré"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr "Échec de la construction du composant de classe PDT à %L"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Le tableau de taille tacite %qs dans la liste de noms %qs à %L n'est pas permis"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "Objet tableau NAMELIST %qs avec la forme tacite dans la liste de noms %qs à %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "Objet tableau NAMELIST %qs avec la forme non constante dans la liste de noms %qs à %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "Objet NAMELIST %qs avec une longueur de caractère non constante dans la liste de noms %qs à %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "L'objet NAMELIST %qs a été déclaré PRIVATE et ne peut pas être membre de la liste de noms PUBLIC %qs à %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "L'objet NAMELIST %qs a des composants PRIVATE associés à USE et ne peut pas être membre de la liste de noms %qs à %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "L'objet NAMELIST %qs a des composants PRIVATE et ne peut pas être un membre de la liste de noms PUBLIC %qs à %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "L'attribut PROCEDURE est en conflit avec l'attribut NAMELIST dans %qs à %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Le tableau paramètre %qs à %L ne peut pas être automatique ou de forme différée"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Le PARAMETER %qs implicitement typé à %L ne concorde pas avec le type IMPLICIT ultérieur"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Type dérivé incompatible dans PARAMETER à %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "La variable CLASS %qs à %L ne peut pas avoir l'attribut PARAMETER"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "Expression constante attendue près de %L"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "L'entité %qs à %L a un paramètre LEN différé %qs et requiert soit l'attribut POINTER ou soit l'attribut ALLOCATABLE"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr "L'objet AUTOMATIC %qs à %L ne doit pas avoir l'attribut SAVE ou être une variable déclarée dans le programme principal, un module ou un sous-module(F08/C513)"
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr "L'objet %qs à %L avec des paramètres de type ASSUMED doit être fictif ou un sélecteur SELECT TYPE(F08/4.2)"
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr "Désolé, les composants allouables/pointeurs dans des co-tableaux de types polymorphiques (CLASS) à %L ne sont pas supportés"
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr "%<omp_all_memory%>, déclaré à %L, peut uniquement être utilisé dans la clause OpenMP DEPEND"
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "L'attribut PROTECTED est en conflit avec l'attribut EXTERNAL à %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "L'attribut PROCEDURE est en conflit avec l'attribut PROTECTED à %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "%qs à %L a l'attribut CONTIGUOUS mais il n'est pas un pointeur de tableau ou un tableau de forme tacite ou de rang tacite"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "Mauvaise spécification pour le tableau de taille tacite à %L"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Le tableau de taille tacite à %L doit être un argument muet"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Le tableau de forme tacite à %L doit être un argument muet"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Le tableau de rang tacite à %L doit être un argument muet"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr "Le tableau de rang tacite à %L ne peut pas avoir les attributs VALUE ou CODIMENSION"
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Le symbole à %L n'est pas une variable MUETTE"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "%qs à %L ne peut pas avoir l'attribut VALUE car ce n'est pas un argument muet"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "La variable muette caractère %qs à %L avec l'attribut VALUE doit avoir une longueur constante"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "La variable muette caractère %qs, interopérable avec le C, à %L avec l'attribut VALUE doit avoir la longueur un"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Le type dérivé %qs à %L est du type %qs qui n'a pas été défini"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK sera un argument muet"
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK sera du type TYPE(*) ou d'un type intrinsèque numérique"
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK ne peut pas avoir les attributs ALLOCATABLE, CODIMENSION, POINTER ou VALUE"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK ne peut pas avoir l'attribut INTENT(OUT)"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "La variable %s à %L avec l'attribut NO_ARG_CHECK sera soit un scalaire ou un tableau de taille tacite"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "Le type tacite de la variable %s à %L est uniquement permis pour des variables muettes"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "La variable de type tacite %s à %L ne peut pas avoir les attributs ALLOCATABLE, CODIMENSION, POINTER ou VALUE"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "La variable de type tacite %s à %L ne peut pas avoir l'attribut INTENT(OUT)"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "La variable de type tacite %s à %L ne sera point un tableau de forme explicite"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "La variable %qs à %L ne peut pas être BIND(C) car elle n'est ni un bloc COMMON ni déclarée au niveau du module"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "La variable BIND(C) %qs à %L doit avoir la longueur un"
 
 # %s est soit « parameter » ou « variable » sans traduction
 # voir bug #80195
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "PUBLIC %s %qs à %L du type dérivé PRIVATE %qs"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "La variable %s à %L du type LOCK_TYPE ou avec un sous-composant de type LOCK_TYPE doit être un co-tableau"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "La variable %s à %L du type EVENT_TYPE ou avec un sous-composant du type EVENT_TYPE doit être un co-tableau"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "L'argument muet INTENT(OUT) %qs à %L est ASSUMED SIZE et, par conséquent, ne peut pas avoir une initialisation par défaut"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "L'argument muet %qs à %L qui est LOCK_TYPE ne sera point INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "L'argument muet %qs à %L qui est EVENT_TYPE ne sera point INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Le résultat %qs de la fonction à %L ne sera point un co-tableau et n'aura point un composant co-tableau"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "La variable %qs à %L du TYPE(C_PTR) ou TYPE(C_FUNPTR) ne sera point un co-tableau"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "La variable %qs à %L avec un composant co-tableau doit être un scalaire non pointeur, non allouable qui n'est pas un co-tableau"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "La variable %qs à %L est un co-tableau qui n'est pas ALLOCATABLE, SAVE ni un argument muet"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "La variable co-tableau %qs à %L n'aura pas de co-dimensions avec une forme différée sans être allouable"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "La variable co-tableau allouable %qs à %L doit avoir une forme différée"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "La variable %qs à %L est INTENT(OUT) et ne peut donc pas être un co-tableau allouable ou avoir des composants co-tableaux"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "La variable muette co-tableau %qs à %L n'est pas permise dans la procédure BIND(C) %qs"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "Argument muet LOGICAL %qs à %L avec le sous-type non C_Bool dans la procédure BIND(C) %qs"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "Variable résultat LOGICAL %qs à %L avec le sous-type non C_Bool dans la procédure BIND(C) %qs"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "La liste de noms %qs ne peut pas être un argument de la sous-routine ou de la fonction à %L"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Le threadprivate à %L n'est pas sauvegardé avec SAVE"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "La variable OpenMP groupprivate %qs à %L doit avoir l'attribut SAVE"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "La variable !$OMP GROUPPRIVATE %qs à %L ne doit pas avoir d'initialiseur"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr "La variable !$OMP DECLARE TARGET %qs à %L n'est pas sauvegardée avec SAVE"
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "Entité définissable attendue près de %L"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "L'élément BLOCK DATA %qs à %L doit être dans COMMON"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "Le tableau DATA %qs à %L doit être spécifié dans une déclaration précédente"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "L'élément DATA %qs à %L ne peut pas avoir un co-index"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "L'élément DATA %qs à %L est un pointeur et doit donc être un tableau à part entière"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr "L'objet DATA près de %L a l'attribut pointeur et la valeur DATA correspondante n'est pas une cible de donnée initiale valable"
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "L'élément DATA %qs à %L ne peut pas avoir l'attribut ALLOCATABLE"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Section de tableau non constante à %L dans l'instruction DATA"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "L'instruction DATA à %L a plus de variables que de valeurs"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Longueur de caractère non constante à %L dans l'instruction DATA"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "Le début de la boucle DO implicite à %L n'a pas pu être simplifiée en une valeur constante"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "La fin de la boucle DO implicite à %L n'a pas pu être simplifiée en une valeur constante"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "Le pas de la boucle DO implicite à %L n'a pas pu être simplifiée en une valeur constante"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "le pas de la boucle DO implicite à %L ne sera point zéro"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "L'instruction DATA à %L a plus de valeurs que de variables"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "L'étiquette %d à %L est définie mais non utilisée"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "L'étiquette %d à %L est définie mais ne peut pas être utilisée"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "La variable de type dérivé %qs à %L doit avoir l'attribut SEQUENCE pour être un objet EQUIVALENCE"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "La variable de type dérivé %qs à %L ne peut pas avoir des composants ALLOCATABLE pour être un objet EQUIVALENCE"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "La variable de type dérivé %qs à %L avec une initialisation par défaut ne peut pas être dans une EQUIVALENCE avec une variable dans COMMON"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "La variable de type dérivé %qs à %L avec un ou des composants pointeurs ne peut pas être dans un objet EQUIVALENCE"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Erreur de syntaxe dans l'instruction EQUIVALENCE à %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Soit aucun ou tous les objets dans l'ensemble EQUIVALENCE à %L aura l'attribut PROTECTED"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "Le membre %qs du bloc COMMON à %L ne peut pas être un objet EQUIVALENCE dans la procédure pure %qs"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "La constante nommée %qs à %L ne peut pas être un objet EQUIVALENCE"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr "Séquence %s avec des composants mélangés dans l'instruction EQUIVALENCE à %L avec différent objets de type"
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr "Objet de type pas par défaut ou séquence %s dans une instruction EQUIVALENCE à %L avec des objets de types différents"
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr "Objet non CHARACTER %qs dans l'instruction CHARACTER EQUIVALENCE par défaut à %L"
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Objet non NUMERIC %qs dans l'instruction NUMERIC EQUIVALENCE par défaut à %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Le tableau %qs à %L avec des limites non constantes ne peut pas être un objet EQUIVALENCE"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Le composant de structure %qs à %L ne peut pas être un objet EQUIVALENCE"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "La sous-chaîne à %L a une longueur zéro"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Référence à elle-même dans l'expression de longueur de caractère pour %qs à %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "Fonction PUBLIC %qs à %L du type PRIVATE %qs"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY %qs à %L n'a pas de type IMPLICIT"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "La procédure opérateur utilisateur %qs à %L doit être une FUNCTION"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "La procédure opérateur utilisateur %qs à %L ne peut pas être une longueur de caractère tacite"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "La procédure opérateur utilisateur %qs à %L doit avoir au moins un argument"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Le premier argument de l'interface opérateur à %L ne peut pas être optionnel"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Le deuxième argument de l'interface opérateur à %L ne peut pas être optionnel"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "L'interface opérateur à %L doit avoir, au plus, deux arguments"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "La procédure contenue %qs à %L d'une procédure PURE doit aussi être PURE"
@@ -87514,97 +87681,97 @@ msgstr "Répertoire d'inclusion %qs non existant"
 msgid "%qs is not a directory"
 msgstr "%qs n'est pas un répertoire"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$ACC à %C débute une ligne commentée car il n'est ni suivi d'un espace ni n'est une ligne continuée"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP à %C débute une ligne commentée car il n'est ni suivi d'un espace ni une ligne continuée"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr "La sentinelle %<!$omx%> qui est une extension vendeur est ignorée à %C"
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Ligne tronquée à %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "La limite de %d lignes continuées est dépassée dans l'instruction %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr "Ce qui suit OpenACC est incorrect à %C: on attendait !$ACC et on a trouvé !$OMP"
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr "Ce qui suit OpenMP est incorrect à %C: on attendait !$OMP et on a trouvé !$ACC"
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "%<&%> manquant dans la suite de la constante de caractère à %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Caractère de tabulation non conforme à %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "Caractère 0x%s invalide à %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "%<&%> pas permis seul à la ligne %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Caractère de tabulation non conforme à la colonne %d de la ligne %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "le fichier %qs a été quitté mais n'a pas été entré"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "Directive du préprocesseur illégale"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr "Le fichier %qs est inclus récursivement"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "Ne peut ouvrir le fichier %qs"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "Ne peut ouvrir le fichier inclus %qs"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "Ne peut ouvrir le fichier de pré-inclusion %qs"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "Le fichier inclus %qs n'est pas un fichier régulier"
@@ -87769,218 +87936,218 @@ msgstr "Si le premier argument de ATAN2PI à %L est zéro, alors le second argum
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim(): Mauvais type"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "dans gfc_simplify_exp(): Mauvais type"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor(): Mauvais sous-type"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "L'argument de IACHAR à %L doit être de longueur un"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "L'argument de la fonction IACHAR à %L est en dehors de la plage 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "La somme des deuxième et troisième arguments de IBITS excède la taille des bits à %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr "IBITS: Bit incorrect"
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "L'argument de ICHAR à %L doit être de longueur un"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Le deuxième argument de %s est négatif à %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "L'amplitude du deuxième argument de %s dépasse la taille des bits à %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "L'amplitude du deuxième argument de ISHFTC excède le BIT_SIZE du premier argument à %C"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "La valeur absolue de SHIFT sera plus petite ou égale à SIZE à %C"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "L'argument DIM à %L est en dehors des limites"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "L'argument de LOG à %L ne peut pas être inférieur ou égal à zéro"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "L'argument complexe de LOG à %L ne peut pas être zéro"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "gfc_simplify_log: mauvais type"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "L'argument de LOG10 à %L ne peut pas être inférieur ou égal à zéro"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr "simplify_min_max(): Mauvais type dans la liste d'arguments"
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "L'argument %qs de MOD à %L ne sera point zéro"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_simplify_mod(): Mauvais arguments"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "L'argument %qs de MODULO à %L ne sera point zéro"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr "gfc_simplify_modulo(): Mauvais arguments"
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Le résultat de NEAREST est NaN à %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "L'argument NCOPIES de l'intrinsèque REPEAT est négatif à %L"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "L'argument NCOPIES de l'intrinsèque REPEAT est trop grand à %L"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr "L'évaluation d'une chaîne plus grande que 2**28 à %L est différée à l'exécution, attendez-vous à des bogues"
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr "Le tableau SHAPE pour l'intrinsèque RESHAPE à %L a une valeur négative %d pour la dimension %d"
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr "Les formes de ORDER à %L et SHAPE à %L sont différentes"
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr "Les tailles de ORDER à %L et SHAPE à %L sont différentes"
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr "L'élément avec une valeur de %d dans ORDER à %L doit être dans la plage [1, ..., %d] pour l'intrinsèque RESHAPE près de %L"
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr "ORDER à %L n'est pas une permutation de la taille de SHAPE à %L"
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Le tableau qui a changé de forme est trop grand à %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Le résultat de SCALE déborde de son sous-type à %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "L'argument DIM (%d) pour la taille intrinsèque à %L est hors limites (1:%d)"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Mauvais type dans gfc_simplify_sign"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "dans gfc_simplify_sin(): Mauvais type"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr "Échec en récupérant la longueur d'un tableau constant."
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "Le nombre d'éléments (%d) dans le constructeur du tableau à %L requiert une augmentation de la limite supérieure permise %d. Voyez l'option %<-fmax-array-constructor%>."
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "La simplification de SPREAD à %C n'est pas encore implémentée"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "L'argument de SQRT à %L a une valeur négative"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "argument invalide pour SQRT à %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "Limites enfreintes dans IMAGE_INDEX à %L pour la dimension %d, SUB vaut %ld et la limite inférieure de COARRAY est %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "Limites enfreintes dans IMAGE_INDEX à %L pour la dimension %d, SUB vaut %ld et la limite supérieure de COARRAY est %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "Le caractère %qs dans la chaîne à %L ne peut pas être converti en un caractère du sous-type %d"
@@ -88318,74 +88485,74 @@ msgstr "Étiquette de fin de DO %d partagée à %C"
 msgid "Labeled DO statement at %L"
 msgstr "Instruction DO étiquetée à %L"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Le nom %qs à %C est une référence ambigüe à %qs depuis le module %qs"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Le nom %qs à %C est une référence ambigüe à %qs depuis l'unité de programme actuelle"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Le symbole %qs à %C a déjà été associée à un hôte"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr "verify_bind_c_derived_type(): Le symbole donné est NULL de manière inattendue"
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Le type dérivé %qs, déclaré à %L, doit avoir l'attribut BIND pour être interopérable avec le C"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Le type dérivé %qs avec l'attribut BIND(C) à %L n'a pas de composants"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "Le type dérivé %qs avec l'attribut BIND(C) à %L est vide et peut être inaccessible pour le processeur C compagnon"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Le composant %qs à %L ne peut pas avoir l'attribut POINTER car il est un membre du type dérivé BIND(C) %qs à %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "Le composant pointeur de procédure %qs à %L ne peut pas être un membre du type dérivé BIND(C) %qs à %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Le composant %qs à %L ne peut pas avoir l'attribut ALLOCATABLE car il est un membre du type dérivé BIND(C) %qs à %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "Le composant %qs dans le type dérivé %qs à %L peut ne pas être interopérable avec le C bien que le type dérivé %qs soit BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "Le composant %qs dans le type dérivé %qs à %L peut ne pas être interopérable avec le C"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Le type dérivé %qs à %L ne peut pas avoir l'attribut SEQUENCE car il est BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "Le symbole %qs est utilisé à %L avant qu'un type lui soit assigné"
@@ -88415,29 +88582,34 @@ msgstr "Initialisations inégales et se chevauchant dans EQUIVALENCE à %L"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Initialisations inégales et se chevauchant dans EQUIVALENCE à %C"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr "Le constructeur de structure à %L a été rendue finale. Cette fonctionnalité a été enlevée par f08/0011. Utilisez -std=f2018 ou -std=gnu pour éliminer la finalisation."
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr "La vérification des bornes d'un index élémental à %L déclenchera deux appels à %qs qui n'est pas déclarée PURE ou n'est pas implicitement pure."
 
+#: fortran/trans-array.cc:7109
+#, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "L'initialiseur du tableau à %L ne se réduit pas en une expression constante"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "Le nombre d'éléments dans le constructeur du tableau à %L requiert une augmentation de la limite supérieure permise %d. Voyez l'option %<-fmax-array-constructor%>"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Création d'un temporaire pour le tableau à %L dans l'argument %qs"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "mauvais type d'expression durant le parcours (%d)"
@@ -88539,113 +88711,113 @@ msgstr "Affecter une valeur autre que 0 ou 1 à un LOGICAL produit un résultat
 msgid "non-constant initialization expression at %L"
 msgstr "expression d'initialisation non constante à %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr "Le tableau %qs à %L est plus grand que la limite définie par %<-fmax-stack-var-size=%>, il est déplacé de la pile vers la zone de stockage statique. Ceci rend la procédure non sûr lorsqu'elle est appelée récursivement ou simultanément depuis plusieurs threads. Envisagez d'augmenter la limite de %<-fmax-stack-var-size=%> (ou d'utiliser %<-frecursive%> qui implique %<-fmax-stack-var-size%>) – ou changez le code pour utiliser un tableau ALLOCATABLE. Si la variable n'est jamais accédée de manière concurrentielle, cet avertissement peut être ignoré et la variable pourrait aussi être déclarée avec l'attribut SAVE."
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr "Désolé, OMP GROUPPRIVATE n'est pas implémenté, utilisé par %qs déclaré à %L"
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr "Désolé, OMP DECLARE TARGET avec la clause LOCAL n'est pas implémenté, utilisé par %qs déclaré à %L"
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%s à %L n'a pas de type par défaut"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "variable intrinsèque qui n'est pas une procédure"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "La valeur de retour de la fonction %qs à %L n'est pas définie"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "Paramètre de type différé pas encore supporté"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "Le backend decl pour la variable de module %qs existe déjà"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "La variable de module PRIVATE %qs inutilisée est déclarée à %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "Le symbole %qs à %L a l'attribut WEAK mais c'est un argument muet"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "Le symbole %qs à %L a l'attribut WEAK mais il est une variable locale"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "L'argument muet %qs à %L a été déclaré INTENT(OUT) mais n'a pas reçu de valeur"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "L'argument muet %qs d'un type dérivé à %L a été déclaré INTENT(OUT) mais n'a pas reçu de valeur et n'a pas d'initialisation par défaut"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Argument muet %qs inutilisé à %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "La variable de module %qs est inutilisée mais elle a été importée explicitement à %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Variable %qs inutilisée déclarée à %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Paramètre %qs inutilisé déclaré à %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Le paramètre %qs est inutilisé mais il a été importé explicitement à %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "La valeur de retour %qs de la fonction %qs est déclarée à %L mais ne reçoit pas de valeur"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr "Désolé, !$ACC DECLARE à %L n'est pas permis dans une construction BLOCK"
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Non signé par encore implémenté"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr "Le symbole %qs à %L est déclaré dans une unité de programme BLOCK DATA mais ce n'est pas un bloc COMMON"
@@ -88675,12 +88847,12 @@ msgstr "Désolé, un accès co-indexé à un composant polymorphique illimité 
 msgid "Unknown intrinsic op"
 msgstr "Op intrinsèque inconnue"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Fonction de liste d'arguments inconnue à %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr "Si le remappage des limites est spécifié à %L, la cible du pointeur ne sera point NULL"
@@ -88696,12 +88868,12 @@ msgstr "Fonction intrinsèque %qs (%d) non reconnue"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "L'argument %<dim%> de l'intrinsèque %s à %L n'est pas un index de dimension valide"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "Désolé, le composant de l'événement du type dérivé à %L n'est pas encore supporté"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "La variable d'événement à %L ne sera point co-indexée"
@@ -88726,182 +88898,182 @@ msgstr "Désolé, les tableaux polymorphiques ne sont pas encore supportés pour
 msgid "implicit mapping of assumed size array %qD"
 msgstr "correspondance implicite du tableau de taille tacite %qD"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr "Le mapping de l'élément de liste polymorphique illimité %qD a un comportement non spécifié et non supporté"
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr "Le mapping d'un élément de liste polymorphique %qD a un comportement non spécifié"
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, gcc-internal-format
 msgid "optional class parameter"
 msgstr "paramètre de classe optionnel"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "type d'expression non géré"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr "expression non gérée"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr "clause %<uses_allocators%> avec des trais et des espaces mémoire"
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr "%<!OMP %s%> à %L requiert %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr "Tous les fichiers qui pourraient désallouer une telle variable doivent être compilés avec %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr "Ceci inclut explicitement DEALLOCATE, la réallocation d'affectations intrinsèques, INTENT(OUT) pour des arguments muets allouables et la réallocation de composant allouables alloués avec un allocateur OpenMP"
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr "boucle imbriquée non rectangulaire avec un pas non constant pour %qs"
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr "Utilisé ici"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Mauvais code d'instruction"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "Le nom de base pour %<declare variant%> doit être spécifié à %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Le nom de base à %L ne correspond pas au nom de la procédure courante"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "Le nom de base à %L ne doit pas un nom d'entrée"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "Le nom de base à %L ne doit pas être un nom générique"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "Le nom de base à %L ne doit pas être un pointeur de procédure"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "La procédure de base à %L doit avoir une interface explicite"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "Impossible de trouver le symbole %qs à %L"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "la variante %qs à %L n'est ni une fonction ni une sous-routine"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "la variante %qs à %L est la même que la fonction de base"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "la variante %qs et la base %qs à %L ont des types incompatibles : %s"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr "la clause %<append_args%> implique que %qs a %d arguments muets de type entier avec le sous-type %<omp_interop_kind%>"
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr "%qs à %L doit être un argument muet entier scalaire non pointeur et non allouable du sous-type %<omp_interop_kind%> car il est utilisé avec la clause %<append_args%> à %L"
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr "%qs à %L avec l'attribut OPTIONAL n'est pas supporté lorsqu'il est utilisé avec la clause %<append_args%> à %L"
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr "%qs à %L a %d mais il requiert %d arguments muets du sous-type %<omp_interop_kind%> car il est utilisé avec la clause %<append_args%> à %L"
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr "la clause %qs peut uniquement être spécifiée si le sélecteur %<dispatch%> de l'ensemble du sélecteur du constructeur apparaît dans la clause %<match%> à %L"
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "Index d'argument positif attendu à %L"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "L'index de l'argument à %L dépasse le nombre d'arguments %d"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr "L'index de l'argument le plus grand est plus petit que le plus petit à %L"
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "L'élément de liste %qs à %L, déclaré à %L, n'est pas un argument muet"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "L'argument %qs à %L pour lister l'élément dans %<need_device_ptr%> à %L doit être un scalaire de TYPE(C_PTR)"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr "Envisagez plutôt d'utiliser %<need_device_addr%>"
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "L'argument %qs à %L pour lister l'élément dans %<need_device_addr%> à %L ne peut pas avoir d'attribut VALUE"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "%qs à %L est spécifié plus d'une fois"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "%<need_device_addr%> n'est pas encore supporté"
@@ -89238,7 +89410,7 @@ msgstr "fermeture: %s"
 msgid "two or more sections for %s"
 msgstr "deux sections ou plus pour %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr "la taille de partition minimale ne peut pas être plus grande que la taille de partition maximale"
@@ -89563,32 +89735,32 @@ msgstr "le type du tableau doit être initialisé"
 msgid "array element value must be the same type as its declaration"
 msgstr "la valeur de l'élément du tableau doit être du même type que sa déclaration"
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr "la borne inférieure pour la sous-plage a débordé"
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr "la borne supérieure pour la sous-plage a débordé"
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "l'alignement demandé n'est pas une constante"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "l'alignement demandé n'est pas une puissance de 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "l'alignement demandé est trop grand"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "l'alignement ne peut pas être spécifié pour %qD"
@@ -90636,6 +90808,22 @@ msgstr "paramètre %qE inutilisé"
 msgid "are you trying to break %s? how dare you?"
 msgstr "essayez-vous de casser %s ? Comment osez vous ?"
 
+#, no-c-format
+#~ msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+#~ msgstr "Le multiplicateur d'échelle, sous forme de pourcentage, à appliquer aux coûts de toutes les boucles scalaires en réalisant l'analyse de profitabilité de la vectorisation. La valeur par défaut est 100."
+
+#, gcc-internal-format, gfc-internal-format
+#~ msgid "%s:%d: ignoring subscripts"
+#~ msgstr "%s:%d: indices ignorés"
+
+#, gcc-internal-format
+#~ msgid "%qT is not consteval-only"
+#~ msgstr "%qT n'est pas consteval-only"
+
+#, gcc-internal-format
+#~ msgid "mangling type pack index"
+#~ msgstr "décoration du type d'index de paquet"
+
 #, gcc-internal-format
 #~ msgid "expected a string but got something else or NULL"
 #~ msgstr "une chaîne est attendue mais on a obtenu autre chose ou NULL"
@@ -91268,10 +91456,6 @@ msgstr "essayez-vous de casser %s ? Comment osez vous ?"
 #~ msgid "cannot import module in its own purview"
 #~ msgstr "impossible d'importer le module dans sa propre portée"
 
-#, gcc-internal-format
-#~ msgid "lambda-expression in template parameter type"
-#~ msgstr "expression lambda dans le type du paramètre du patron"
-
 #, gcc-internal-format
 #~ msgid "preconditions cannot be statements"
 #~ msgstr "les pré-conditions ne peuvent pas être des instructions"
@@ -95068,9 +95252,6 @@ msgstr "essayez-vous de casser %s ? Comment osez vous ?"
 #~ msgid "looser throw specifier for %q+#F"
 #~ msgstr "génération d'exception plus lâche pour %q+#F"
 
-#~ msgid "cannot call function %qD"
-#~ msgstr "impossible d'appeler la fonction %qD"
-
 #~ msgid "right rotate count is negative"
 #~ msgstr "le compteur de rotations vers la droite est négatif"
 
@@ -98021,9 +98202,6 @@ msgstr "essayez-vous de casser %s ? Comment osez vous ?"
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "méthode non statique %q+D écrase la méthode statique"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D utilisé précédemment avant sa déclaration"
-
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "Dans %+D : chevauchement de variable et plage d'exception à %d"
 
@@ -98266,11 +98444,6 @@ msgstr "essayez-vous de casser %s ? Comment osez vous ?"
 #~ msgid "%qs and floating point or vector arguments"
 #~ msgstr "étendues en virgules flottantes"
 
-#, fuzzy
-#~| msgid "incompatible type for argument %d of `%s'"
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "type incompatible pour l'argument n°%d de « %s »"
-
 #, fuzzy
 #~| msgid "%J'%E' attribute applies only to functions"
 #~ msgid "%q+D:'selectany' attribute applies only to initialized objects"
--- a/src/gcc/po/hr.po
+++ b/src/gcc/po/hr.po
@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc-15.2.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2025-08-10 15:30+0200\n"
 "Last-Translator: Božidar Putanec <bozidarp@yahoo.com>\n"
 "Language-Team: Croatian <lokalizacija@linux.hr>\n"
@@ -1257,12 +1257,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr ""
@@ -2081,13 +2081,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2536,7 +2536,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr ""
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr ""
@@ -2611,7 +2611,7 @@ msgstr ""
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2648,7 +2648,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr ""
@@ -2758,7 +2758,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2804,7 +2804,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5072,7 +5072,7 @@ msgstr ""
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5431,7 +5431,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5736,212 +5736,217 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "%qs is deprecated"
 msgid "This option is deprecated."
@@ -11279,7 +11284,7 @@ msgstr ""
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18209,77 +18214,77 @@ msgstr "U skladu sa standardom ISO Fortran 2023."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 msgid "argument must be passed by copying"
 msgstr "argument mora biti proslijeđen kopiranjem"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 msgid "volatile function type"
 msgstr "tip nestabilne funkcije"
 
-#: calls.cc:2614
+#: calls.cc:2615
 msgid "nested function"
 msgstr "ugniježđena funkcije"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr "nedosljedan broj izbačenih argumenata"
 
-#: calls.cc:2646
+#: calls.cc:2647
 msgid "frontend does not support sibling call"
 msgstr ""
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 msgid "variable size arguments"
 msgstr "argumenti različitih veličina"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr ""
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr ""
 
@@ -18400,12 +18405,12 @@ msgstr "operand ‘%%l’ nije oznaka"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "konstanta s pomičnim zarezom (floating constant) korištena je na pogrešan način"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19735,13 +19740,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "ovo je insn:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "invalid operand address"
 msgid "unable to reload address in "
 msgstr "nevaljani operand adrese"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "ne može generirati ponovno učitavanje za:"
 
@@ -19962,7 +19967,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC heuristika: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonymous>"
@@ -20340,20 +20345,20 @@ msgstr "nepodržani operand za kȏd ‘%c’"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "nevaljani operand za ‘%%%c’"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "nevaljana vektorska konstanta"
@@ -20398,91 +20403,91 @@ msgstr "nevaljani prefiks operanda ‘%%%c’"
 msgid "invalid address mode"
 msgstr "nevaljani način adresiranja"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "nevaljana konverzija od tipa %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "nevaljana konverzija u tip %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "negation operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "plus operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "minus operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "multiply operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "divide operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "shift operation not permitted on svbool_t"
 msgstr "nelegalna operacija na tipu %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "operacija nije dopuštena na tipu %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "ne mogu se kombinirati GNU i SVE vektori u binarnoj operaciji"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20499,13 +20504,13 @@ msgid "invalid %%r value"
 msgstr "nevaljana %%r vrijednos"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "nevaljana %%R vrijednost"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "nevaljana %%N vrijednost"
@@ -20520,7 +20525,7 @@ msgstr "nevaljana %%P vrijednost"
 msgid "invalid %%h value"
 msgstr "nevaljana %%h vrijednost"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "nevaljana %%L vrijednost"
@@ -20535,7 +20540,7 @@ msgstr "nevaljana %%m vrijednost"
 msgid "invalid %%M value"
 msgstr "nevaljana %%M vrijednost"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "nevaljana %%U vrijednost"
@@ -20868,7 +20873,7 @@ msgstr "nepodržani operand"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21113,127 +21118,127 @@ msgstr ""
 msgid "Expected register or constant integer."
 msgstr ""
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr ""
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr ""
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr ""
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "nevaljana veličina operanda za operand kȏd ‘O’"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "nevaljana veličina operanda za operand kȏd ‘z’"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "nevaljani tip operanda korišten s operandom kȏda ‘%c’"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "nevaljana veličina operanda za operand kȏd ‘%c’"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "operand nije kȏd uvjeta, nevaljani operand kȏd ‘Y’"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "operand nije kȏd uvjeta, nevaljani operand kȏd ‘D’"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "operand nije kȏd uvjeta, nevaljani operand kȏd ‘%c’"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "operand nije pokretljiva (offsettable) referencija memorije, nevaljani operand kȏd ‘H’"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "operand nije cijeli broj, nevaljani operand kȏd ‘K’"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "operand nije određeni cijeli broj, nevaljani operand kȏd ‘r’"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "operand nije cijeli broj, nevaljani operand kȏd ‘R’"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "operand nije određeni cijeli broj, nevaljani operand kȏd ‘R’"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "operand nije pokretljiva (offsettable) referencija memorije, nevaljani operand kȏd ‘H’"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "nevaljani operand kȏd ‘%c’"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "nevaljano ograničenje za operand"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr "nevaljana vektorska konstanta"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "nepoznati insn način"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "nevaljana konverzija od tipa %<__bf16%> bez opcije %<-msse2%> "
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "nevaljana konverzija od tipa %<_Float16%> bez opcije %<-msse2%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "nevaljana konverzija u tip %<__bf16%> bez opcije %<-msse2%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "nevaljana konverzija u tip %<_Float16%> bez opcije %<-msse2%>"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr "nelegalna operacija na tipu%<__bf16%> bez opcije %<-msse2%>"
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr "nelegalna operacija na tipu %<_Float16%> bez opcije %<-msse2%>"
 
@@ -21312,9 +21317,9 @@ msgstr ""
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr ""
@@ -21379,7 +21384,7 @@ msgid "insn contains an invalid address !"
 msgstr ""
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr ""
 
@@ -21454,7 +21459,7 @@ msgstr "nevaljana relokacija"
 msgid "invalid %%H value"
 msgstr ""
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr ""
@@ -21504,34 +21509,34 @@ msgstr ""
 msgid "unsupported memory expression:"
 msgstr ""
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, c-format
 msgid "invalid vector operand"
 msgstr "nevaljani vektorski operand"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr "modifikator ‘N’ zahtijeva operand registra"
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, c-format
 msgid "invalid register number for 'N' modifier"
 msgstr "nevaljani broj registra za ‘N’ modifikator"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, fuzzy, c-format
 #| msgid "modifier 'N' require register operand"
 msgid "modifier 'H' require register operand"
 msgstr "modifikator ‘N’ zahtijeva operand registra"
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "modifier 'N' require register operand"
 msgid "modifier 'H' is for integer registers only"
 msgstr "modifikator ‘N’ zahtijeva operand registra"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr ""
@@ -21588,7 +21593,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "nevaljana %%A vrijednost"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr ""
@@ -21628,7 +21633,7 @@ msgstr ""
 msgid "invalid %%k value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr ""
@@ -21658,17 +21663,17 @@ msgstr ""
 msgid "invalid %%u value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "nevaljana %%V vrijednost"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr ""
@@ -21877,27 +21882,27 @@ msgstr ""
 msgid "floating-point constant not a valid immediate operand"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, c-format
 msgid "'h' operand is not SImode register"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr ""
@@ -21953,24 +21958,24 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr ""
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr ""
 
@@ -22002,7 +22007,7 @@ msgstr "{pogrešan}"
 msgid "aka"
 msgstr "također poznat kao"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anoniman})"
 
@@ -22027,8 +22032,8 @@ msgstr "({anoniman})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "očekivano je %<;%>"
@@ -22056,7 +22061,7 @@ msgstr "očekivano je %<:%> ili %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "očekivano je %<)%>"
@@ -22064,7 +22069,7 @@ msgstr "očekivano je %<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "očekivano je %<]%>"
@@ -22084,13 +22089,13 @@ msgstr "očekivano je %<;%>, %<,%> ili %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "očekivano je %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "očekivano je %<[%>"
@@ -22099,7 +22104,7 @@ msgstr "očekivano je %<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22116,13 +22121,13 @@ msgstr "očekivano je %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "očekivano je %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "očekivano je %<while%>"
@@ -22132,7 +22137,7 @@ msgstr "očekivano je %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "očekivano je %<,%>"
@@ -22142,18 +22147,18 @@ msgid "expected %<.%>"
 msgstr "očekivano je %<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "očekivano je %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "očekivano je %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "očekivano je %<,%> ili %<)%>"
@@ -22163,45 +22168,45 @@ msgstr "očekivano je %<,%> ili %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "očekivano je %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "očekivano %<)%> or %<,%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "očekivano je %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "očekivano %<else%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "očekivano je %<#pragma omp section%> ili %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr ""
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "očekivano je %<<%>"
@@ -22226,7 +22231,7 @@ msgstr ""
 msgid "  after user-defined conversion:"
 msgstr ""
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] ""
@@ -22327,7 +22332,7 @@ msgstr ""
 msgid "<statement>"
 msgstr ""
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<nepoznato>"
@@ -22354,286 +22359,322 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr ""
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr ""
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "requested alignment is not a constant"
-msgid "array element not a constant integer"
-msgstr "zatraženo poravnanje nije konstanta"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "expected constant size"
 msgid "reflect_constant failed"
 msgstr "očekivana je veličina konstante"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "requested alignment is not a constant"
+msgid "array element not a constant integer"
+msgstr "zatraženo poravnanje nije konstanta"
+
+#: cp/reflect.cc:1117
 msgid "reflection does not represent a type"
 msgstr ""
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "The following options take separate arguments"
 msgid "reflection does not have template arguments"
 msgstr "Sljedeće opcije uzimaju odvojene argumente"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 msgid "reflection does not represent a function or function type"
 msgstr ""
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "%<counted_by%> argument is not an identifier"
 msgid "operators argument is not a valid operator"
 msgstr "argument %<counted_by%> nije identifikator"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 msgid "reflection does not have a type"
 msgstr ""
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr ""
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr ""
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr ""
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr ""
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "function not considered for inlining"
 msgid "reflection not suitable for alignment_of"
 msgstr "funkcija se ne smatra kandidatom za umetanje (inlining)."
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "volatile function type"
 msgid "alignment_of on function type"
 msgstr "tip nestabilne funkcije"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "expected function name"
 msgid "reflect_function failed"
 msgstr "očekivano je ime funkcije"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "invalid embedcfg: missing Files"
 msgid "value member missing"
 msgstr "nevaljani embedcfg: nema Files"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "expected loop number"
 msgid "unexpected value of value member"
 msgstr "očekivan je broj petlje"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr ""
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 msgid "reflection does not represent a template"
 msgstr ""
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid arguments"
 msgid "invalid argument to can_substitute"
 msgstr "nevaljani argumenti"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "type %s is not an opaque type"
 msgid "type is not object or reference type"
 msgstr "tip %s nije neproziran tip"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%<counted_by%> argument is not an identifier"
 msgid "name is not a valid identifier"
 msgstr "argument %<counted_by%> nije identifikator"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr ""
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "field width specifier"
 msgid "both alignment and bit_width specified"
 msgstr "specifikacija širine polja"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "specifikacija širine polja"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr ""
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a constant"
 msgid "alignment is not power of two"
 msgstr "zatraženo poravnanje nije konstanta"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr ""
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "poravnanje %qD je veće od originalne deklaracije"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+msgid "reflection does not have non-array object type"
+msgstr ""
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr ""
+
+#: cp/reflect.cc:6526
+msgid "current scope does not represent a class nor a member function"
+msgstr ""
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete application of insn"
 msgid "incomplete parent class"
 msgstr "Interna greška: incomplete application of insn"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr ""
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 msgid "not a complete class type"
 msgstr ""
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 msgid "value cannot be extracted"
 msgstr ""
 
@@ -22677,52 +22718,52 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr ""
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "pogrešni tip argumenta za unarni minus"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "pogrešni tip argumenta za unarni plus"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "pogrešni tip argumenta za bit-kompement"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "pogrešni tip argumenta za abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "wrong type argument to konjugaciju"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr ""
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -22738,59 +22779,59 @@ msgstr " [vidi %<-fallow-invalid-boz%>]"
 msgid "BOZ constant truncated at %L"
 msgstr "konstanta BOZ scraćena pri %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "argumenti ‘a%d’ i ‘a%d’ za intrinsični ‘%s’"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "argumenti ‘%s’ i ‘%s’ za intrinsični ‘%s’"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "argumenti ‘%s’ i ‘%s’ za intrinsični ‘%s’"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr "NULL() nije interoperabilan"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 msgid "BOZ literal constant"
 msgstr "literalna konstanta BOZ"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr "Izraz je polimorfni"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr "Izraz je neinteroperabilni izvedeni tip"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 msgid "Procedure unexpected as argument"
 msgstr "Neočekivani postupak (procedura) kao argument"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr "Proširenje za korištenje LOGICAL koji nije kompatibilan sa C_Bool"
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr "Proširenje za korištenje CHARACTER koji nije kompatibilan sa C_CHAR"
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr "Tip mora biti znak dužine 1"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr "Coarrays nisu interoperabilane"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr "Polja s pretpostavljenom veličinom nisu interoperabilana"
 
@@ -22872,7 +22913,7 @@ msgstr "Izbrisane značajke:"
 msgid "Unsigned:"
 msgstr "Nepotpisano:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "dodjela polja"
 
@@ -22881,17 +22922,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr "Indeksna varijabla %qs redefinirana pri %L u proceduri %qs pozvanoj iz DO petlje pri %L"
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr "Nevaljan opseg u argumentu B u intrinsičnom MATMUL-u u dimenziji 1: je %ld, treba biti %ld"
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "Neusklađene granice polja za dimenziju 1 polja (%ld/%ld"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "Neusklađene granice polja za dimenziju 2 polja (%ld/%ld"
@@ -23067,11 +23108,11 @@ msgstr "blok IF"
 msgid "implied END DO"
 msgstr "implicirani END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr ""
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr ""
 
@@ -23079,125 +23120,125 @@ msgstr ""
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr ""
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr ""
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr ""
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr ""
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr ""
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr ""
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr ""
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr ""
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr ""
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr ""
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr ""
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -23206,31 +23247,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -23293,27 +23334,27 @@ msgstr ""
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23410,7 +23451,7 @@ msgid "expected boolean type"
 msgstr ""
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "očekivan je cijeli broj"
@@ -23473,7 +23514,7 @@ msgstr ""
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr ""
@@ -23868,7 +23909,7 @@ msgstr "podrška za profiler za VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "ciljni OS ne podržava neusklađene pristupe"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "profiliranje još nije implementirano za ovu arhitekturu"
@@ -24112,13 +24153,13 @@ msgstr "iznimka ‘%s’"
 msgid "Global declarative %s for %s"
 msgstr "Globalna deklarativa %s za %s"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr "%s:%d: nevaljani %<symbol_type_t%> %d"
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24284,12 +24325,12 @@ msgstr "%qs je zastario; koristite -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs je zastario; koristite -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "nepoznata autovec postavka %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "nepoznato LDP/STP pravilo %qs"
@@ -24724,8 +24765,8 @@ msgstr ""
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr ""
@@ -24742,7 +24783,7 @@ msgstr ""
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr ""
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr ""
@@ -24752,7 +24793,7 @@ msgstr ""
 msgid "expected %i or more, found %i"
 msgstr "očekivano je %i ili više, pronađeno %i"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "očekivano je %i, pronađeno je %i"
@@ -24835,12 +24876,12 @@ msgstr ""
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -24960,135 +25001,135 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "function symbol is not function"
 msgid "location is after end of function"
 msgstr "simbol funkcije nije funkcija"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "TAG nije očekivan."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "ne može otvoriti profil datoteku %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr ""
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read %<LTO_section_decls%> from %s"
 msgid "cannot read summary information from %s"
 msgstr "ne može pročiati %<LTO_section_decls%> od %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr ""
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr ""
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot open profile file %s"
 msgid "cannot read module profile from %s"
@@ -25099,7 +25140,7 @@ msgstr "ne može otvoriti profil datoteku %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr ""
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr ""
@@ -25202,7 +25243,7 @@ msgstr ""
 msgid "illegal argument 0 to %qs"
 msgstr ""
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr "treći argument za ugrađen %<crc%> mora biti konstanta"
@@ -25276,12 +25317,12 @@ msgstr ""
 msgid "cannot tail-call: %s"
 msgstr "ne može tail-call: %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr ""
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr ""
@@ -25924,342 +25965,342 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr ""
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr ""
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr ""
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr ""
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr ""
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr ""
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr ""
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr ""
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr ""
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr ""
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr ""
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr ""
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr ""
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr ""
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr ""
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr ""
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr ""
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr ""
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr ""
@@ -27023,17 +27064,17 @@ msgstr ""
 msgid "impossible constraint in %<asm%>"
 msgstr ""
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "funkcija vraća agregat"
@@ -27702,7 +27743,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -27742,7 +27783,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr ""
@@ -27762,24 +27803,24 @@ msgstr ""
 msgid "function may return address of local variable"
 msgstr "funkcija može vratiti adresu lokalne varijable"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "funkcija vraća adresu lokalne varijable"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -28682,7 +28723,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr ""
@@ -28752,204 +28793,204 @@ msgstr ""
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, gcc-internal-format
 msgid "call to %qD here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr ""
@@ -29763,264 +29804,264 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr ""
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "varijabla s istim imenom asemblera kao i virtualna tablica definirana je u drugoj prijevodnoj jedinici"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr ""
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr ""
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr ""
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "tip s različitom preciznošću definiran je u drugoj prevodilačkoj jedinici"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "tip vektora s različitim brojem elemenata je definiran u drugoj prevodilačkoj jedinici"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "tip s različitim ‘signedness’ definiran je u drugoj prevodilačkoj jedinici"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "to je definirano kao pokazivač u različitom adresnom prostoru u drugoj prevodilačkoj jedinici"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "to je definirano kao pokazivač na drugačiji način u drugoj prevodilačkoj jedinici"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
@@ -30028,7 +30069,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
@@ -30036,7 +30077,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
@@ -30044,7 +30085,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
@@ -30052,7 +30093,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
@@ -30060,7 +30101,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
@@ -30068,47 +30109,47 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr ""
@@ -30128,7 +30169,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr ""
@@ -30358,12 +30399,12 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr ""
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr ""
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -30730,7 +30771,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -32112,22 +32153,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr ""
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -33067,167 +33108,167 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr ""
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "nevaljana pozicija ili veličina operanda za %qs"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr ""
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr ""
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "nevaljani offset operator %qs"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "nevaljani adresni operator za %qs"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "nevaljani offset operand u %qs"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr ""
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr ""
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr ""
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr ""
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -33238,599 +33279,599 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr ""
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr ""
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr ""
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr ""
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr ""
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr ""
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr ""
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr ""
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr ""
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr ""
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr ""
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument %qs for %qs"
 msgid "invalid type for %qs"
 msgstr "nevaljani argument %qs za %qs"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr ""
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "nevaljani operandi (pokazivača) %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr ""
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr ""
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument %qs for %qs"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "nevaljani argument %qs za %qs"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr ""
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "nevaljan argument veličine %qs za učitavanje"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr ""
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr ""
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr ""
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr ""
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr ""
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr ""
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr ""
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr ""
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr ""
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr ""
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr ""
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr ""
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr ""
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr ""
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr ""
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr ""
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr ""
@@ -34010,12 +34051,12 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr ""
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr ""
@@ -34531,7 +34572,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -34951,30 +34992,30 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr ""
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr ""
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "section type conflict for section %qs"
 msgid "%qD conflicts for version %qB"
 msgstr "konflikt tipa odjeljka za odjeljak %qs"
 
-#: tree.cc:15817
+#: tree.cc:15837
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr ""
 
@@ -35048,7 +35089,7 @@ msgstr ""
 msgid "no initializers are allowed in section %qs"
 msgstr ""
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr ""
@@ -35193,7 +35234,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr ""
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr ""
@@ -35238,53 +35279,53 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr ""
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr ""
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr ""
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr ""
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr ""
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr ""
@@ -35299,12 +35340,12 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr ""
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr ""
@@ -35511,12 +35552,12 @@ msgstr ""
 msgid "mode %qs applied to inappropriate type"
 msgstr ""
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr ""
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr ""
@@ -35526,18 +35567,18 @@ msgstr ""
 msgid "section attribute argument not a string constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr ""
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr ""
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr ""
@@ -35625,7 +35666,7 @@ msgstr "argument %<counted_by%> nije identifikator"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr ""
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr ""
@@ -35671,12 +35712,12 @@ msgstr ""
 msgid "%qE attribute is only applicable on functions"
 msgstr ""
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr ""
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr ""
@@ -35686,12 +35727,12 @@ msgstr ""
 msgid "%<symver%> attribute argument not a string constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -35782,23 +35823,23 @@ msgstr ""
 msgid "visibility argument not a string"
 msgstr ""
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr ""
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr ""
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -35815,7 +35856,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr ""
@@ -35886,7 +35927,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr ""
@@ -35961,7 +36002,7 @@ msgstr ""
 msgid "%qE argument is not a function"
 msgstr ""
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr ""
@@ -36027,7 +36068,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "zanemareni atribut %qE na ‘non-enumeration’"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr ""
@@ -36188,15 +36229,15 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr ""
@@ -36462,7 +36503,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr ""
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr ""
@@ -36633,8 +36674,8 @@ msgstr ""
 msgid "missing sentinel in function call"
 msgstr ""
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -37643,7 +37684,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr ""
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -37698,7 +37739,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr ""
@@ -37713,17 +37754,17 @@ msgstr ""
 msgid "%qE is not initialized"
 msgstr ""
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr ""
@@ -37733,7 +37774,7 @@ msgstr ""
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr ""
@@ -37828,18 +37869,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD nije argument funkcije"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -37849,8 +37890,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr ""
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr ""
@@ -38366,7 +38407,7 @@ msgstr ""
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr ""
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr ""
@@ -38438,8 +38479,8 @@ msgstr ""
 msgid "wrong type argument to %s"
 msgstr ""
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -38925,17 +38966,17 @@ msgstr ""
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr ""
@@ -39202,7 +39243,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -40140,7 +40181,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -40786,7 +40827,7 @@ msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr ""
@@ -40832,7 +40873,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -40883,7 +40924,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -40976,19 +41017,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41034,209 +41075,209 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "nepoznata tuning opcija (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, fuzzy, gcc-internal-format
 #| msgid "%<-fsanitize=shadow-call-stack%> not supported in current platform"
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "%<-fsanitize=shadow-call-stack%> nije podržan na trenutnoj platformi"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "nevaljani argument %qs za %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41244,195 +41285,195 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%qD je već ranije ovdje deklariran"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "%q+D je ovdje definiran"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -41620,12 +41661,12 @@ msgstr ""
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41758,22 +41799,22 @@ msgid "argument of %qE attribute ignored"
 msgstr ""
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "atribut %qE je primjenliv samo na varijable"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr ""
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr ""
@@ -42306,12 +42347,12 @@ msgstr ""
 msgid "%<-fPIE%> is not supported"
 msgstr ""
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr ""
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr ""
@@ -42321,7 +42362,7 @@ msgstr ""
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr ""
@@ -42648,7 +42689,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr ""
@@ -42964,7 +43005,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -43130,168 +43171,168 @@ msgstr ""
 msgid "parameter to builtin not valid: %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, gcc-internal-format
 msgid "invalid third argument"
 msgstr "treći argument nije valjan"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "drugi argument mora biti konstanta (const)"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr ""
@@ -43686,8 +43727,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr ""
@@ -43930,7 +43971,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -43955,12 +43996,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -43970,128 +44011,128 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr ""
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr ""
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr ""
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr ""
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr ""
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -44142,7 +44183,7 @@ msgstr ""
 msgid "argument %qd is not a constant"
 msgstr ""
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr ""
@@ -44152,7 +44193,7 @@ msgstr ""
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr ""
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr ""
@@ -44306,49 +44347,49 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "argument %qs is not supported for %qs on this target"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "argument %qs nije podržan za %qs na ovom cilju"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not supported in this configuration"
 msgid "%qs is not supported in target attribute"
@@ -45102,7 +45143,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr ""
@@ -45325,82 +45366,82 @@ msgstr "ne može privremenu ptx datoteku"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "atribut %qE nije dopušten s ‘auto’ klasom skladište (storage)"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "weak alias definicije nisu podržane u ovoj konfiguraciji"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "non-function alias definicije nisu podržane u ovoj konfiguraciji"
@@ -45630,322 +45671,322 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized state string %qs"
 msgid "unrecognized RVV builtin"
 msgstr "neprepoznato stanje %qs stringa"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr ""
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr ""
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "%qs zahtijeva cijelobrojnu (integer) konstantu"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr ""
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, gcc-internal-format
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr ""
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr ""
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr "ne može dodijeliti vl registar za %qs na ovoom cilju"
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -46941,22 +46982,22 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "atribut %<__BELOW100__%> nije dopušten s ‘auto’ klasom skladište (storage)"
@@ -47176,32 +47217,32 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47287,7 +47328,7 @@ msgstr ""
 msgid "%qs attribute only applies to variadic functions"
 msgstr ""
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47377,8 +47418,8 @@ msgstr ""
 msgid "could not get size of source file"
 msgstr "nije bilo moguće pročitati pomak (offset) datoteke"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr ""
@@ -47858,7 +47899,7 @@ msgstr ""
 msgid "%qE defined as wrong kind of tag"
 msgstr ""
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr ""
@@ -48007,7 +48048,7 @@ msgstr ""
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr ""
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr ""
@@ -48017,7 +48058,7 @@ msgstr ""
 msgid "%q+D is usually a function"
 msgstr ""
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr ""
@@ -48093,7 +48134,7 @@ msgstr ""
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr ""
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -48294,7 +48335,7 @@ msgstr "klasa skladište (storage) specificirana za parametar %qE"
 msgid "storage class specified for unnamed parameter"
 msgstr "klasa skladište (storage) specificirana za bezimeni parametar"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "klasa skladište (storage) specificirana za tip-ime (typename)"
@@ -48467,7 +48508,7 @@ msgstr ""
 msgid "function definition has qualified void return type"
 msgstr ""
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr ""
@@ -48594,7 +48635,7 @@ msgstr ""
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr ""
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr ""
@@ -48806,7 +48847,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr ""
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr ""
@@ -48871,7 +48912,7 @@ msgstr ""
 msgid "struct has no members"
 msgstr ""
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr ""
@@ -48936,7 +48977,7 @@ msgstr ""
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr ""
@@ -48991,7 +49032,7 @@ msgstr ""
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr ""
@@ -49141,12 +49182,12 @@ msgstr ""
 msgid "argument %qD doesn%'t match prototype"
 msgstr ""
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr ""
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr ""
@@ -49228,7 +49269,7 @@ msgstr ""
 msgid "two or more data types in declaration specifiers"
 msgstr ""
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr ""
@@ -49336,7 +49377,7 @@ msgstr ""
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr ""
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr ""
@@ -49493,12 +49534,12 @@ msgstr "%<signed _BitInt%> argument mora biti najmanje 2"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -49558,37 +49599,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr ""
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr ""
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr ""
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr ""
@@ -49608,7 +49649,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "očekivan je kraj retka"
@@ -49618,7 +49659,7 @@ msgstr "očekivan je kraj retka"
 msgid "ISO C forbids an empty translation unit"
 msgstr ""
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49665,8 +49706,8 @@ msgid "unknown type name %qE"
 msgstr ""
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr ""
@@ -49701,7 +49742,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr ""
@@ -49716,12 +49757,12 @@ msgstr ""
 msgid "unexpected attribute"
 msgstr ""
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr ""
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr ""
@@ -49764,7 +49805,7 @@ msgstr ""
 msgid "%qs may only be used with a single declarator"
 msgstr ""
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr ""
@@ -49800,7 +49841,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "povratni tip funkcije ne može biti funkcija"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr ""
@@ -49830,7 +49871,7 @@ msgstr ""
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr ""
@@ -49884,8 +49925,8 @@ msgstr ""
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr ""
@@ -49915,12 +49956,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr ""
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr ""
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50001,22 +50042,22 @@ msgstr ""
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "očekivano je ime direktive OpenMP"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "očekivano je %<directive%> ili %<sequence%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr ""
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr ""
@@ -50026,7 +50067,7 @@ msgstr ""
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr ""
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr ""
@@ -50056,17 +50097,17 @@ msgstr ""
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr ""
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -50076,44 +50117,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "atribut %qs ne prima nikakve argumente"
@@ -50144,7 +50185,7 @@ msgstr ""
 msgid "expected %<}%> before %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -50159,7 +50200,7 @@ msgstr ""
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr ""
@@ -50194,27 +50235,27 @@ msgstr ""
 msgid "declaration in the controlling expression must have an initializer"
 msgstr ""
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr ""
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -50234,12 +50275,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr ""
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -50254,8 +50295,8 @@ msgstr ""
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr ""
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -50277,12 +50318,12 @@ msgstr ""
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr ""
@@ -50457,7 +50498,7 @@ msgstr ""
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr ""
@@ -50472,12 +50513,12 @@ msgstr ""
 msgid "ISO C forbids braced-groups within expressions"
 msgstr ""
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr ""
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -50624,7 +50665,7 @@ msgstr "pogrešni broj argumenata za %<__builtin_counted_by_ref%>"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "pogrešni broj argumenata za %<__builtin_counted_by_ref%>"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr ""
@@ -50664,7 +50705,7 @@ msgstr ""
 msgid "rotate count is negative"
 msgstr ""
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -50774,7 +50815,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -50814,12 +50855,12 @@ msgstr ""
 msgid "no type or storage class may be specified here,"
 msgstr "ovdje se ne smije specificirati ni tip ni klasa skladište (storage),"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, gcc-internal-format
 msgid "missing property attribute"
 msgstr ""
@@ -50829,57 +50870,57 @@ msgstr ""
 msgid "unknown property attribute %<%s%s%>"
 msgstr ""
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr ""
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "očekivano je ime selektora za %qE"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -50889,12 +50930,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr ""
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr ""
@@ -50904,11 +50945,11 @@ msgstr ""
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr ""
@@ -50923,58 +50964,58 @@ msgstr ""
 msgid "%qD is not a variable"
 msgstr ""
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr ""
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "‘collapse’ argument treba biti pozitivni, cjelobrojni izraz"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "očekivano je %<none%> ili %<present%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "očekivano je %<none%>, %<shared%>, %<private%> ili %<firstprivate%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "očekivan je konstantni logički izraz"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "očekivano je %<data%>, %<update%>, %<enter%> ili %<exit%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "očekivano je %<data%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr ""
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -50997,22 +51038,22 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr ""
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr ""
@@ -51022,99 +51063,99 @@ msgstr ""
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "očekivan je %<scalar%>, %<aggregate%>, %<pointer%> ili %<all%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr ""
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "neočekivani argument"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr ""
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "%<scalar%>, %<aggregate%> or %<pointer%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "očekivano je %<concurrent%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "očekivano je %<teams%>, %<parallel%> ili %<thread%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "‘ordered’ argument treba biti pozitivni, cjelobrojni izraz"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr ""
@@ -51124,38 +51165,38 @@ msgstr ""
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "očekivano je %<allocator%> ili %<align%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -51171,22 +51212,22 @@ msgstr "očekivano je %<class%> ili %<typename%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "višekratni linearni modifikatori"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr ""
@@ -51196,7 +51237,7 @@ msgstr ""
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51211,316 +51252,316 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr ""
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "nevaljana vrsta ovisnosti"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "nevaljana ‘doacross’ vrsta"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<target%> modifier"
 msgid "expected %<fallback%> modifier"
 msgstr "duplicirani modifikator %<target%>"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "očekivano je %<read%>, %<write%>, %<update%>, ili %<capture%> klauzula"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be non-negative"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "argument %<score%> ne smije biti negativan"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<target%> modifier"
 msgid "too many %<iterator%> modifiers"
 msgstr "duplicirani modifikator %<target%>"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier at %C"
 msgid "expected identifier or %<default%>"
 msgstr "očekivano je identifikator pri %C"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "nevaljana vrsta dodjele"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "očekivano je %<ancestor%> ili %<device_num%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr ""
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr ""
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "očekivano je %<host%>, %<nohost%> ili %<any%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "argument %<partial%> treba biti pozitivni, cjelobrojni izraz"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "nepoznati strani ‘runtime’ identifikator %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "očekivan je literalni string ili konstantni cjelobrojni izraz"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "očekivan je %<fr%> ili selektor preferencija %<attr%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr ""
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "duplicirani modifikator %<target%>"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "očekivano je  %<prefer_type%>, %<target%> ili %<targetsync%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr "nedostaje zahtijevani %<target%> i/ili %<targetsync%> modifikator"
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "očekivana je OpenACC klauzula"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr ""
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr ""
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "očekivana je OpenMP klauzula"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "očekivano je %<data%> iza %<#pragma acc %s%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -51535,7 +51576,7 @@ msgstr ""
 msgid "expected function name"
 msgstr "očekivano je ime funkcije"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr ""
@@ -51545,22 +51586,22 @@ msgstr ""
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr ""
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -51585,7 +51626,7 @@ msgstr ""
 msgid "modified here"
 msgstr "izmijenjeno ovdje"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -51620,110 +51661,110 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "očekivano je %<read%>, %<write%>, %<update%>, ili %<capture%> klauzula"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "očekivano je %<seq_cst%>, %<acquire%> ili %<relaxed%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr ""
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr ""
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr ""
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "očekivan je %<==%> usporedba u uvjetu %<if%>"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "očekivano je %<else%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr ""
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr ""
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr ""
@@ -51733,27 +51774,27 @@ msgstr ""
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "izraz %<destroy%> nije izraz lvalue"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "očekivano %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> ili %<inoutset%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "očekivano je %<depend%>, %<destroy%> ili %<update%> klauzula"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "očekivano je %<seq_cst%>, %<acq_rel%>, %<release%> ili %<acquire%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -51763,32 +51804,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr ""
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "očekivano je %<inclusive%> ili %<exclusive%> klauzula"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "očekivano je %<#pragma omp scan%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr ""
@@ -51796,68 +51837,68 @@ msgstr ""
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, gcc-internal-format
 msgid "loop nest expected"
 msgstr "petlja nije očekivana"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr ""
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr ""
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "očekivano je %<for%> iza %qs"
@@ -51867,7 +51908,7 @@ msgstr "očekivano je %<for%> iza %qs"
 msgid "expected a function name"
 msgstr "očekivano je ime funkcije"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, gcc-internal-format
 msgid "expected target-function call"
 msgstr "očekivan je poziv ciljane funkcije (target-function) "
@@ -51877,47 +51918,47 @@ msgstr "očekivan je poziv ciljane funkcije (target-function) "
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "očekivano je %<point%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -51932,57 +51973,57 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr ""
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr ""
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "argument %<score%> mora biti konstantan cjelobrojni izraz"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "argument %<score%> ne smije biti negativan"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr ""
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "svojstvo (property) mora biti cjelobrojni izraz"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "%<requires%> selektor još nije podržan"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "očekivano je ime konteksta skupa selektora"
@@ -51992,28 +52033,28 @@ msgstr "očekivano je ime konteksta skupa selektora"
 msgid "variant %qD is not a function"
 msgstr ""
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD redeclared as function"
 msgid "variant %qD is the same as base function"
 msgstr "varijable %qD je ponovno deklarirana kao funkcija"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "očekivano je %<match%>, %<adjust_args%> ili %<append_args%> klauzula"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -52023,7 +52064,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr "%qD nije tip pokazivača>"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "očekivano je %<nothing%> ili %<need_device_ptr%>"
@@ -52033,17 +52074,17 @@ msgstr "očekivano je %<nothing%> ili %<need_device_ptr%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr ""
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "očekivano je %<nothing%> ili %<need_device_ptr%> slijeđen s/sa %<:%>"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "očekivano je %<interop%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>"
 msgid "expected %<match%> clause"
@@ -52066,12 +52107,12 @@ msgstr "%<requires%> selektor još nije podržan"
 msgid "base function %qD declared here"
 msgstr "odabrana funkcija deklarirana je ovdje"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr ""
@@ -52081,7 +52122,7 @@ msgstr ""
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr ""
@@ -52091,7 +52132,7 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -52107,87 +52148,87 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr "nepoznata spec funkcija %qs"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr ""
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>"
 msgid "expected %<match%>"
 msgstr "očekivano je %<data%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "očekivano je %<none%> ili %<present%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<declare target%> or %<assumes%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "očekivano %<declare target%> ili %<assumes%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "očekivano %<declare%> ili %<assumes%>"
@@ -52213,13 +52254,13 @@ msgstr ""
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%qD je već ranije ovdje deklariran"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected clause"
 msgstr "neočekivani argument"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "missing mapper"
 msgid "missing %<map%> clause"
@@ -52281,32 +52322,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "očekivano je %<simd%>, %<reduction%>, %<target%> ili %<variant%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "očekivano je %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> ili %<seq_cst%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -52321,160 +52362,160 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "očekivano je %<sizes%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr ""
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "očekivano je %<at%>, %<severity%> ili %<message%> klauzula"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "očekivano je %qs ili %qs"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "očekivana je barem jedna klauzula pretpostavki"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr "očekivano je ime direktive"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "nepoznata klauzula pretpostavki %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "očekivana je klauzula pretpostavki"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "očekivano je %<when%>, %<otherwise%> ili %<default%> klauzula"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, gcc-internal-format
 msgid "unknown directive name"
 msgstr "nepoznato ime direktive"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr ""
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr ""
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -52484,7 +52525,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -52499,7 +52540,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr ""
@@ -52530,168 +52571,168 @@ msgstr ""
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr ""
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "tipovi funkcija nisu kompatibilni s ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr ""
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "povratni tipovi funkcija nisu kompatibilni zbog %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr ""
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr ""
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr ""
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr ""
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr ""
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "Expected array subscript at %C"
 msgid "array subscript is negative"
 msgstr "Indeks polja očekivan je pri %C"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr ""
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr ""
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr ""
@@ -52699,1851 +52740,1851 @@ msgstr ""
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr ""
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr ""
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr ""
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr ""
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr ""
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr ""
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr ""
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr ""
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr ""
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr ""
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr ""
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr ""
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr ""
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr ""
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr ""
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr ""
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr ""
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr ""
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr ""
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr ""
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr ""
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr ""
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "prvi izraz ima tip %qT"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "drugi izraz ima tip %qT"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr ""
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr ""
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr ""
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr ""
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr ""
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr ""
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr ""
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr ""
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr ""
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr ""
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr ""
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 msgid "expected %e but argument is of type %e"
 msgstr "očekivan je %e ali argument je tip %e"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr ""
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 msgid "%e declared here"
 msgstr "%e je deklariran ovdje"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr ""
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "očekivan %qT ali pokazivač je tipa %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 msgid "returning %e from a function with incompatible return type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr ""
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr ""
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr ""
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr ""
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr ""
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr ""
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr ""
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr ""
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr ""
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr ""
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr ""
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr ""
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr ""
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr ""
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr ""
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "funkcija vraća adresu lokalne varijable"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr ""
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr ""
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr ""
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr ""
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr ""
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr ""
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr ""
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr ""
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr ""
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr ""
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr ""
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr ""
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr ""
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr ""
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "očekivan je pokazivač (pointer) u %qs klauzuli"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr ""
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr ""
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "nepodržani %qE izraz mape"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr ""
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr ""
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "%qD ne smije biti konstanta"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -54812,253 +54853,248 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "%s ne bi treabalo biti nula"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr ""
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s: nevaljani tip polja  %s"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr ""
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr ""
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "nepoznati  %<setop_t%> kod %d"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr ""
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55067,72 +55103,82 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "Dani tip nije deklaracija ili TYPE"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "Nepoznati tip %d"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr ""
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55142,12 +55188,12 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, gcc-internal-format
 msgid "Too many subscripts"
 msgstr ""
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr ""
@@ -55162,63 +55208,63 @@ msgstr "%s PID %ld prekinut je s %s"
 msgid "%s exited with status %d"
 msgstr "%s je završio sa statusom %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr ""
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "spec %qs has invalid %<%%0%c%>"
 msgid "%s: %s %s has invalid encoding"
 msgstr "spec %qs ima nevaljani %<%%0%c%>"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr "%s: regcomp: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "nije uspjelo kompilirati %s"
@@ -55657,7 +55703,7 @@ msgstr ""
 msgid "%q#D is private within this context"
 msgstr ""
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr ""
@@ -55667,7 +55713,7 @@ msgstr ""
 msgid "%q#D is protected within this context"
 msgstr ""
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr ""
@@ -55991,7 +56037,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr ""
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr ""
 
@@ -56010,7 +56056,7 @@ msgstr ""
 msgid "call to non-function %qD"
 msgstr ""
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -56604,7 +56650,7 @@ msgstr ""
 msgid "next member %q#D declared here"
 msgstr ""
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr ""
@@ -56614,7 +56660,7 @@ msgstr ""
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -56745,7 +56791,7 @@ msgstr ""
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -56798,7 +56844,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -56835,845 +56881,845 @@ msgstr "iznimka ‘%s’"
 msgid "uncaught exception of type %qT"
 msgstr "prvi izraz ima tip %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr ""
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr ""
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate array: size not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "ne moguće dodijeliti polje: veličina nije konstanta"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr ""
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr ""
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure unexpected as argument"
 msgid "%qD called with unexpected %qs argument"
 msgstr "Neočekivani postupak (procedura) kao argument"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %qs"
 msgid "wrong number of arguments to %qs call"
 msgstr "loš, krivi broj argumenata za %qs"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr ""
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr ""
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr ""
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr ""
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr ""
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr ""
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr ""
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr "ne moguće dodijeliti polje: veličina nije konstanta"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr ""
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr ""
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr ""
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr ""
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "referencija za %qD nije konstantni izraz"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr ""
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr ""
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr ""
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr ""
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "pointed-to object declared here"
 msgid "%qT object created here"
 msgstr "pointed-to objekt deklariran ovdje"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr ""
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr ""
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr ""
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr ""
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr ""
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr ""
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, gcc-internal-format
 msgid "use of %qD"
 msgstr ""
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr ""
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "pointed-to objekt deklariran ovdje"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr ""
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr ""
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr ""
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr ""
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr ""
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "extra %<;%> outside of a function"
 msgid "%<continue%> outside of a loop"
 msgstr "dodatni %<;%> je izvan funkcije"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is not a constant expression"
 msgid "%<return%> in a statement expression"
 msgstr "referencija za %qD nije konstantni izraz"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr ""
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr ""
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "definicija oznake u funkciji %<constexpr%> je dostupna samo s %<-std=c++23%> or %<-std=gnu++23%>"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr ""
@@ -57805,412 +57851,412 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy assignable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "  %qT ne može dodijeliti kopiju pomoću ‘nothrow’"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow default constructible"
 msgstr "  %qT nije nothrow default constructible"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "%qT is not nothrow copy constructible"
 msgstr "  %qT nije nothrow copy constructible"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially copyable"
 msgid "%qT is not trivially copy assignable"
 msgstr "  %qT nije trivially copyable"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not trivially default constructible"
 msgstr "  %qT nije zadano constructible"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "%qT is not trivially copy constructible"
 msgstr "  %qT nije nothrow copy constructible"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially constructible from %qE"
 msgid "%qT is not trivially destructible"
 msgstr "  %qT nije trivijalno constructible iz %qE"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr ""
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a virtual base of %qT"
 msgid "%qT does not have a virtual destructor"
 msgstr "  %qT nije virtualna baza od %qT"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an array"
 msgid "%qT is not an abstract class"
 msgstr "  %qT nije polje"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an aggregate"
 msgid "%qT is not an aggregate"
 msgstr "  %qT nije agregat"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an array"
 msgid "%qT is not an array"
 msgstr "  %qT nije polje"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not assignable from %qT"
 msgid "%qT is not assignable from %qT, because"
 msgstr "  %qT nije moguće dodijeliti iz %qT"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr ""
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a bounded array"
 msgid "%qT is not a bounded array"
 msgstr "  %qT nije ograničeno polje"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an array"
 msgid "%qT is not a class"
 msgstr "  %qT nije polje"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
 msgid "%qT is not a const type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not default constructible, because"
 msgstr "  %qT nije zadano constructible"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not constructible from %qE"
 msgid "%qT is not constructible from %qT, because"
 msgstr "  %qT nije constructible iz %qE"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not destructible, because"
 msgstr "  %qT nije zadano constructible"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT is not an empty class"
 msgstr "  %qT nije tip objekta"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a scoped enum"
 msgid "%qT is not an enum"
 msgstr "  %qT nije enum s valjanim opsegom"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "%qT is not a final class"
 msgstr "%qT nije funkcija"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "%qT is not a function"
 msgstr "%qT nije funkcija"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not invocable"
 msgid "%qT is not invocable, because"
 msgstr "  %qT nije moguće pozvati"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not invocable by %qE"
 msgid "%qT is not invocable by %qT, because"
 msgstr "  %qT nije moguće pozvati s/sa %qE"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "%qT is not a literal type"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member function pointer"
 msgid "%qT is not a member function pointer"
 msgstr "%qT nije član pokazivača> funkcije"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member object pointer"
 msgid "%qT is not a member object pointer"
 msgstr "  %qT nije član pokazivača> objekta"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member pointer"
 msgid "%qT is not a member pointer"
 msgstr "  %qT nije član pokazivača>"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow assignable from %qT"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "  %qT nije moguće dodijeliti s ‘nothrow’ od %qT"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "  %qT nije nothrow default constructible"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow constructible from %qE"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "  %qT nije nothrow constructible iz %qE"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow convertible from %qE"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "  %qT nije nothrow convertible iz %qE"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow destructible, because"
 msgstr "  %qT nije nothrow default constructible"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow invocable"
 msgid "%qT is not nothrow invocable, because"
 msgstr "  %qT nije nothrow invocable"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow invocable by %qE"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "  %qT nije nothrow invocable s %qE"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT is not an object type"
 msgstr "  %qT nije tip objekta"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a virtual base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "  %qT nije virtualna baza od %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
 msgid "%qT is not a POD type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "  %qT nije pokazivač"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "%qT is not a polymorphic type"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference"
 msgid "%qT is not a reference"
 msgstr "  %qT nije referencija"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not the same as %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "  %qT nije ista vrsta kao %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a scoped enum"
 msgid "%qT is not a scoped enum"
 msgstr "  %qT nije enum s valjanim opsegom"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT is not a standard layout type"
 msgstr "  %qT nije tip objekta"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "%qT is not a trivial type"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially assignable from %qT"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "  %qT nije moguće trivijalno dodijeliti iz %qT"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not trivially default constructible, because"
 msgstr "  %qT nije zadano constructible"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially constructible from %qE"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "  %qT nije trivijalno constructible iz %qE"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially copyable"
 msgid "%qT is not trivially copyable"
 msgstr "  %qT nije trivially copyable"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially constructible from %qE"
 msgid "%qT is not trivially destructible, because"
 msgstr "  %qT nije trivijalno constructible iz %qE"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an unbounded array"
 msgid "%qT is not an unbounded array"
 msgstr "  %qT nije neograničeno polje"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "%qT is not a union"
 msgstr "%qT nije funkcija"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a virtual base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "  %qT nije virtualna baza od %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "%qT is not a volatile type"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
-msgid "%qT is not consteval-only"
+msgid "%qT is not a structural type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT cannot yield a rank"
 msgid "%qT cannot yield a rank"
 msgstr "  %qT ne može dato ramg"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot be used here"
 msgid "%qT and %qT cannot be ordered"
 msgstr "ovdje se ne može koristiti %qs"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not destructurable"
 msgstr "  %qT nije zadano constructible"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "  %qD is not deducible from %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "  %qD nije moguće izvesti iz %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, gcc-internal-format
 msgid "invalid constraints"
 msgstr ""
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr ""
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr ""
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -58242,49 +58288,49 @@ msgstr ""
 msgid "previous declaration with fewer contracts here"
 msgstr "ponovna deklaracija %qD s drukčijim ograničenjima"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here"
 msgid "parameter declared here"
 msgstr "ponovno deklarirano ovdje"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr ""
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here"
 msgid "first declared here"
 msgstr "ponovno deklarirano ovdje"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr ""
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr ""
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr ""
@@ -58354,7 +58400,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr ""
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr ""
@@ -58426,83 +58472,83 @@ msgstr ""
 msgid "awaitable type %qT is not a structure"
 msgstr ""
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs ne može se koristiti u kontekstu koji nije evaluiran"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr ""
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr ""
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr ""
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr ""
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "dvostruke informacije za %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr "‘await’ izraz nije dopušten u rukovateljima (handlers)"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -58528,68 +58574,74 @@ msgstr "%qD je promovirana u trenutnu funkciju"
 msgid "%qs used outside of constant expressions"
 msgstr "Loši tip u konstantom izrazu"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "unexpected %<:%> at %C"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "neočekivano %<:%> pri %C"
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr ""
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -58630,7 +58682,7 @@ msgstr ""
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr ""
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr ""
@@ -59018,7 +59070,7 @@ msgstr ""
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr ""
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr ""
@@ -59240,12 +59292,12 @@ msgstr ""
 msgid "previous specification in %q#D here"
 msgstr ""
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr ""
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "ranije deklarirana ovdje bez izvoza (exporting)"
@@ -59450,7 +59502,7 @@ msgstr ""
 msgid "  enters %<template for%> statement"
 msgstr ""
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr ""
@@ -59495,664 +59547,664 @@ msgstr "%<typename %T::%D%> imena %q#D, koja nisu tip"
 msgid "template parameters do not match template %qD"
 msgstr "parametri predloška ne podudaraju %qD predloška"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr ""
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr ""
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr ""
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr ""
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr ""
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr ""
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr ""
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr ""
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr ""
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr ""
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr ""
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr ""
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "klasa skladište (storage) se može specificirati samo za objekte i funkcije"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr ""
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr ""
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr ""
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr ""
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "atribut je zanemaren"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr ""
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr ""
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr ""
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr ""
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr ""
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr ""
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr ""
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr ""
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr ""
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD definiran %<thread_local%> u funkciji %qs dostupan je samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD definiran %<static%> u funkciji %qs dostupan je samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr ""
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr ""
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr ""
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr ""
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr ""
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr ""
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr ""
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr ""
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr ""
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr ""
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr ""
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr ""
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr ""
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr ""
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr ""
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr ""
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr ""
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr ""
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr ""
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr ""
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr ""
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr ""
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr ""
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr ""
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr ""
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr ""
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr ""
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr ""
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr ""
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr ""
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr ""
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr ""
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr ""
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr ""
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO-C++17 ne dopušta specifikaciju klase skladište (storage) %<register%>"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "korišten je %<register%> klasa skladište (storage)"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr ""
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr ""
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr ""
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr ""
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr ""
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturirana povezivanja u uvjetima dostupna su samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr ""
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr ""
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, gcc-internal-format
 msgid "lambda declared here"
 msgstr "lambda je deklarirana ovdje"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr ""
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, gcc-internal-format
 msgid "in base class of %qT"
 msgstr ""
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr ""
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr ""
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr ""
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr ""
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
@@ -60160,7 +60212,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
@@ -60168,7 +60220,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
@@ -60176,1741 +60228,1751 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr ""
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr ""
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr ""
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr ""
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr ""
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr ""
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr ""
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr ""
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr ""
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr ""
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr ""
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr ""
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr ""
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr ""
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr ""
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr ""
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr ""
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr ""
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr ""
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr ""
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr ""
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr ""
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr ""
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr ""
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr ""
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "deduction guide %qD mora imati isti pristup kao %qT"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr ""
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr ""
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr ""
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr ""
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr ""
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr ""
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr ""
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr ""
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr ""
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr ""
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr ""
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr ""
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr ""
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr ""
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr ""
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr ""
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr ""
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr ""
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr ""
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr ""
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr ""
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr ""
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr ""
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr ""
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr ""
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr ""
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr ""
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr ""
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr ""
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr ""
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr ""
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 msgid "%e and %e specified together"
 msgstr ""
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr ""
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr ""
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr ""
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr ""
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr ""
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr ""
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr ""
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr ""
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr ""
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr ""
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr ""
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr ""
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr ""
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr ""
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr ""
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr ""
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr ""
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr ""
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr ""
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr ""
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "klasa skladište (storage) specificirana za parametar %qs predloška"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "klasa skladište (storage) specificirana za parametar %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr ""
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr ""
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturirana povezivanja u uvjetima dostupna su samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr ""
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "nekoliko klasa skladište (storage) u deklaraciji od %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "klasa skladište (storage) specificirana za %qs\""
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "ugniježđena funkcija %qs je deklarirana kao %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "%qs opseg funkcije je implicitno auto i deklariran kao %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "specifikacije klasa skladište (storage) je nevaljana u deklariracijama ‘friend’ funkcija"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr ""
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "eksplicitna funkcija člana objekta dostupna je samo s %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr ""
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "nevaljana upotreba ograničenog %<auto%> tipa"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr ""
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs je deklariran kao funkcija koja vraća funkciju"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs deklariran kao funkcija koja vraća polje"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr ""
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr ""
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr ""
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD ne može biti eksplicitna funkcija člana objekta"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr ""
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr ""
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr ""
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr ""
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr ""
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr ""
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr ""
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr ""
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr ""
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr ""
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr ""
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr ""
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr ""
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr ""
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr ""
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr ""
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr ""
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr ""
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr ""
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr ""
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr ""
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr ""
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr ""
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr ""
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr ""
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr ""
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr ""
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr ""
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr ""
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%qD ne može bit %qs"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr ""
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr ""
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr ""
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr ""
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr ""
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr ""
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr ""
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "klasa skladište (storage) %<auto%> nije valjana za funkciju %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "klasa skladište (storage) %<register%> nije valjana za funciju %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "klasa skladište (storage) %<__thread%> nije valjana za funkciju %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "klasa skladište (storage) %<thread_local%> nije valjana za funkciju %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr ""
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr ""
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr ""
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr ""
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr ""
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr ""
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs dobiva početnu vrijednost i deklarira se kao %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs ima i %<extern%> i početnu vrijednost"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr ""
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr ""
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr ""
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr ""
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr ""
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr ""
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD mora biti član funkcije"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr ""
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr ""
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr ""
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr ""
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr ""
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr ""
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr ""
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr ""
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr ""
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr ""
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr ""
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr ""
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr ""
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr ""
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr ""
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr ""
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr ""
@@ -61922,100 +61984,100 @@ msgstr ""
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr ""
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr ""
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr ""
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr ""
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr ""
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr ""
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr ""
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr ""
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr ""
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr ""
@@ -62024,87 +62086,93 @@ msgstr ""
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr ""
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr ""
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr ""
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr ""
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr ""
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr ""
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr ""
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr ""
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr ""
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr ""
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr ""
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr ""
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr ""
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr "koristimo %qs"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%qs defined without first defining %qs"
+msgid "%qs used without %qs declaration"
+msgstr "%qs je definiran bez prethodnog definiranja %qs"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -62534,348 +62602,348 @@ msgstr "funkcija %qD se koristi s nezadovoljenim ograničenjima"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    umetnuto (inlined) iz %qD pri %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    umetnuto (inlined) iz %qD pri %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "    umetnuto (inlined) iz %qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "U funkciji statičnog člana %qD"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "U kopiji constructor %qD"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "U constructor %qD"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "U destructor %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "U lambda funkciji"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "U funkciji člana eksplicitnog objekta %qD"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, gcc-internal-format
 msgid "In member function %qD"
 msgstr "U funkciji člana %qD"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr "U funkciji %qD"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
 msgid "but %qE is a type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "bad expression"
 msgid "but %qE is an expression"
 msgstr "loši izraz"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 #| msgid "<structured bindings>"
 msgid "but %qE is a structured binding"
 msgstr "<strukturirana vezivanja>"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "class %qE is not available"
 msgid "but %qE is a variable"
 msgstr "class %qE nije dostupna"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "parametar funkcije"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "but %qE is a function"
 msgstr "%qT nije funkcija"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member pointer"
 msgid "but %qE is a data member"
 msgstr "  %qT nije član pokazivača>"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a function template"
 msgid "but %qE is a function template"
 msgstr "%q#D nije predložak funkcije"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a function template"
 msgid "but %qE is a class template"
 msgstr "%q#D nije predložak funkcije"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "but %qE is a variable template"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr ""
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr ""
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "%s%s%sIn instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s%s%sIn instance od %q#D:\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s%s%sIn supstitucija od %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s%s%sIn instance od %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from here\n"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "rekurzivni zahtjev odavde\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, fuzzy, gcc-internal-format
 #| msgid "required for the satisfaction of %qE"
 msgid "required from %<template for%> iteration %E\n"
 msgstr "potrebno za udovoljenje %qE"
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "rekurzivni zahtjev substitucije %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "zahtjev substitucije %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "rekurzivni zahtjev od %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "zahtjev od %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "rekurzivni zahtjev odavde\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "zahtjev odavde\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "[ preskačemo %d konteksta instantacije, upotrebite -ftemplate-backtrace-limit=0 da to onemogućite ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "u %<constexpr%> zamijeni %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "potrebno zbog ograničenja %q#D\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "potrebno za udovoljenje %qE"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr ""
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr "u zahtjevima s/sa"
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, gcc-internal-format
 msgid "in requirements "
 msgstr "u zahtjevima"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr ""
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr ""
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr ""
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr ""
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr ""
@@ -63098,7 +63166,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr ""
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -63214,7 +63282,7 @@ msgstr ""
 msgid "type %qT is not a direct base of %qT"
 msgstr ""
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -63405,42 +63473,42 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr ""
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, gcc-internal-format
 msgid "operator %<delete%> used on incomplete type"
 msgstr ""
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
@@ -63475,82 +63543,90 @@ msgstr ""
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr ""
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr ""
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr ""
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr ""
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr ""
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr ""
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr ""
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -63560,64 +63636,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -64006,7 +64075,7 @@ msgstr "postojeća deklaracija je ovdje bez oznakam"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr ""
@@ -64021,422 +64090,422 @@ msgstr ""
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr ""
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr ""
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, gcc-internal-format
 msgid "existing default declared here"
 msgstr "postojeća zadana vrijednost (default) deklarirana je ovdje"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr ""
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr ""
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr ""
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr ""
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr ""
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr ""
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr ""
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr ""
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr ""
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr ""
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr ""
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr ""
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr ""
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr ""
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr ""
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr ""
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "kompilirani modul je %sversion %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr "kompilator je %sversion %s%s%s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr ""
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr ""
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr ""
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "nije uspjelo pročitati kompilirani modul: %s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr ""
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr ""
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr ""
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "ranije deklarirano u modulu %qs"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "ranije deklarirano u globalnom modulu"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "izvozimo deklariraciju %qD deklariranu u neimenovanom imeskom prostoru"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "izvozimo deklariraciju %qD s internim povezivajem"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "čitamo CMI %qs"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "nije uspjelo učitati vezanja %<%E%s%E%>"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "nije uspjelo učitati jedinice na čekanju za %<%E%s%E%>"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr ""
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "%e declared here"
 msgid "module declared here"
@@ -64449,107 +64518,107 @@ msgstr "%e je deklariran ovdje"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr ""
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr ""
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr ""
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "nepoznato sučelje kompiliranog modula: %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr ""
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr ""
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr ""
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr ""
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr ""
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "nije uspjelo zapisati kompilirani modul: %s"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr ""
@@ -64565,7 +64634,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "izvozimo deklariraciju %qD s internim povezivajem"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "deklaracije neovisne o imenu dostupne su samo s %<-std=c++2c%> ili %<-std=gnu++2c%>"
@@ -64610,152 +64679,162 @@ msgstr ""
 msgid "declaration of %qD shadows a member of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr ""
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr ""
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr ""
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr ""
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr ""
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "atribut-naredba %qD je zanemarana"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
@@ -64763,108 +64842,108 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr ""
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr ""
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr ""
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr ""
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr ""
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr ""
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr ""
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr ""
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -64894,7 +64973,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -64939,7 +65018,7 @@ msgstr ""
 msgid "request for member %qE in non-class type %qT"
 msgstr ""
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr ""
@@ -65009,7 +65088,7 @@ msgstr ""
 msgid "%qE is not a class template"
 msgstr ""
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr ""
@@ -65321,1700 +65400,1710 @@ msgstr "‘pack’ indeksiranje dostupno je samo s/sa %<-std=c++2c%> ili %<-std=
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected a function name"
 msgid "expected a reflection of a type"
 msgstr "očekivano je ime funkcije"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "Expected reduction operator or function name at %C"
-msgid "expected a reflection of a function template"
-msgstr "Očekivan je operator redukcije ili naziv funkcije pri %C"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr ""
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr ""
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr ""
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr ""
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr ""
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr ""
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr ""
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr ""
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr ""
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr ""
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr ""
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr ""
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr ""
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr ""
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr ""
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr ""
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr ""
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, gcc-internal-format
 msgid "selected function declared here"
 msgstr "odabrana funkcija deklarirana je ovdje"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr ""
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr ""
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr ""
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr ""
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr ""
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr ""
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "%<:%> constraint used for output operand"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<:%> ograničenje izkorišteno je izlazni operand"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr ""
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr ""
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr ""
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr ""
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr ""
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr ""
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr ""
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr ""
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr ""
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr ""
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr ""
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr ""
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr ""
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr ""
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr ""
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr ""
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "deklaracija parametara prije specifikaora lambda deklaracije nije obavezna samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "deklaracija parametra prije kvalifikatora lambda transakcije nije obvezna samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "deklaracija parametra prije specifikacije lambda iznimke nije obvezna samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "deklaracija parametra prije lambda zaostajućeg tipa povrata nije obvezna samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%e declared here"
+msgid "%q#E declared here"
+msgstr "%e je deklariran ovdje"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "oznaka na kraju složene naredbe (statement) dostupna je samo s/sa %<-std=c++23%> or %<-std=gnu++23%>"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr ""
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr ""
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr ""
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "treba %<typename%> prije %qE zato jer je %qT ovisan o desegu"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr ""
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<if consteval%> je dostupan samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr ""
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr ""
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, gcc-internal-format
 msgid "condition declares a function"
 msgstr ""
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr ""
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr ""
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr ""
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr ""
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr ""
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<delete%> razlog su dostupni samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qs has both %<extern%> and initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "%qs ima i %<extern%> i početnu vrijednost"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %qD with different constraints"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "ponovna deklaracija %qD s drukčijim ograničenjima"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<goto%> u funkciji %<constexpr%> dostupno je samo s/sa %<-std=c++23%> ili %<-std=gnu++23%>"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr ""
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr ""
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr "očekivan je module-partition"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr "očekivan je module-name"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr ""
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr "doseg je otvoren ovdje"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr ""
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr ""
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr "dodatni %<;%> je izvan funkcije"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr ""
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr ""
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr ""
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "eksplicitne specijalizacije ovdje nisu dopuštene"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "eksplicitne instancije ovdje nisu dopuštene"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "izvozne deklaracije ovdje nisu dopuštene"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr ""
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "multiple packs in structured binding declaration"
 msgstr "nekoliko klasa skladište (storage) u deklaraciji od %qs"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturirana povezivanja u uvjetima dostupna su samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturirana povezivanja s pripisanim identifikatorima dostupna su samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 #| msgid "<structured bindings>"
 msgid "annotation on structured binding"
 msgstr "<strukturirana vezivanja>"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturirana povezivanja u uvjetima dostupna su samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr ""
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr ""
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr ""
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr ""
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr ""
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr ""
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr ""
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr ""
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr ""
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<static_assert%> s non-string porukom je dostupna samo s %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr ""
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr ""
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr ""
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr ""
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr ""
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "ključna riječ %<typename%> nije dopuštena u ovom kontekstu (kvalificirani inicijalizator člana je implicitno tip)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "nevaljani prefiks kodirānja u literalnom operatoru"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr ""
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr ""
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr ""
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr ""
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr ""
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr ""
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr ""
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr ""
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr ""
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr ""
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr ""
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr ""
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr ""
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr ""
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr ""
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr ""
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr ""
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr ""
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr ""
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr ""
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr ""
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr ""
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "nevaljana upotreba %<concept-name%> %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "očekivano je %<auto%> ili %<decltype(auto)%> iza %qE"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr ""
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr ""
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr ""
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr ""
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr ""
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr ""
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr ""
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr ""
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr ""
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr ""
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr ""
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr ""
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr ""
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr ""
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr ""
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr ""
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr ""
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr ""
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr ""
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr ""
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr ""
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr ""
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr ""
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr ""
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr ""
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr ""
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr ""
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr ""
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr ""
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when a function is unused."
 msgid "base function is ambiguous"
 msgstr "Upozori kàda je funkcija neiskorištena."
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr ""
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr ""
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr ""
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr ""
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr ""
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr ""
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr ""
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr ""
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr ""
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr ""
@@ -67023,275 +67112,275 @@ msgstr ""
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr ""
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr ""
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr ""
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr ""
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr ""
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr ""
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr ""
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr ""
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr ""
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr ""
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr ""
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr ""
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr ""
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr ""
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr ""
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr ""
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr ""
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr ""
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr ""
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr ""
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "tijelo function-try-block  u %<constexpr%> constructor dostupno je samo s %<-std=c++20%> ili %<-std=gnu++20%>"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr ""
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr ""
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr ""
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr ""
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr ""
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr ""
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr ""
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr ""
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr ""
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr ""
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr ""
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr ""
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "nije bilo moguće razriješiti ‘typename’ tip"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr ""
@@ -67299,273 +67388,273 @@ msgstr ""
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr ""
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ISO C++ zabranjuje ključ tipa ‘typename’ u parametru predloška; koristite %<-std=c++17%> ili %<-std=gnu++17%>"
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "očekivano je %<class%> ili %<typename%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "promjenjivi prijatelji ili deklaracije tipa prijatelja s više vrsta dostupni su samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr ""
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr "klasa skladište (storage) na anonimnom agregatu u klasnom dosegu nije dopuštena"
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr ""
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<delete%> razlog su dostupni samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr ""
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "ključna riječ %<typename%> nije dopuštena u ovom kontekstu (osnovna klasa je implicitno tip)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr ""
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr ""
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr ""
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr ""
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr ""
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr ""
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr ""
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "očekivan je atribut ispred %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr ""
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected call expression"
 msgid "expected conditional-expression"
 msgstr "očekivan je izraz poziva"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "class %qE is not available"
 msgid "%qs is only available with %qs"
 msgstr "class %qE nije dostupna"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored"
 msgid "attributes are ignored on %qs"
 msgstr "atribut je zanemaren"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored on non-ISR function"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "atribut %qs je zanemaren na non-ISR funkcijama"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "pack indexing only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "‘pack’ indeksiranje dostupno je samo s/sa %<-std=c++2c%> ili %<-std=gnu++2c%>"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr ""
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr ""
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr ""
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr ""
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr ""
@@ -67574,433 +67663,433 @@ msgstr ""
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr ""
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr ""
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr ""
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr ""
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr ""
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "eksplicitna specijalizacija predloška ne može imati klasu skladište (storage)"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr ""
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr ""
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr ""
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr ""
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr ""
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr ""
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "duplikat %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr ""
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr ""
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr ""
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr ""
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr ""
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr ""
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr ""
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr ""
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr ""
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr ""
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr ""
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr ""
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr ""
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr ""
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr ""
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "očekivano je %<auto%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr ""
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr ""
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr ""
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr ""
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr ""
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "očekivano je %<co_yield%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr ""
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr ""
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr ""
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "očekivano je %<class%>, %<typename%> ili %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "očekivano je %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr ""
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr ""
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr ""
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr ""
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr ""
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr ""
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr ""
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr ""
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr ""
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr ""
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr ""
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "atributi prefiksa su zanemareni prije %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr ""
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr ""
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr ""
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr ""
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "očekivano je %<scalar%>, %<aggregate%>, %<all%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr ""
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr ""
@@ -68009,174 +68098,174 @@ msgstr ""
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr ""
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr ""
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr ""
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD nije C pokazivač"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "očekivano je %<target%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr ""
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr ""
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr ""
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr ""
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "očekivano je %<simd%>, %<reduction%>, %<target%> ili %<variant%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr ""
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr ""
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr ""
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr ""
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr ""
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr ""
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -68650,17 +68739,23 @@ msgstr ""
 msgid "redeclaration of %qD with different constraints"
 msgstr "ponovna deklaracija %qD s drukčijim ograničenjima"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "storage class specified for template parameter %qs"
+msgid "local class in lambda in template parameter list"
+msgstr "klasa skladište (storage) specificirana za parametar %qs predloška"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr ""
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr ""
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
@@ -68668,7 +68763,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
@@ -68676,127 +68771,127 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr ""
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr ""
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr "ponovno deklarirano ovdje"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr ""
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr ""
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "ponovljena deklaracija %q#D s drugačijim ograničenjima"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr ""
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr ""
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr ""
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr ""
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
@@ -68804,7 +68899,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
@@ -68812,337 +68907,337 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr ""
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr ""
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr ""
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr ""
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr ""
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr ""
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr ""
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr ""
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr ""
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr ""
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr ""
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr ""
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr ""
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr ""
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr ""
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "za upućivanje na element tipa parametra predloška, koristite %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr ""
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr ""
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr ""
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr ""
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr ""
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr ""
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr ""
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D nije predložak funkcije"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr ""
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr ""
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr ""
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr ""
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr ""
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr ""
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr ""
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr "ovdje se pojavila prva greška"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr ""
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr ""
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr ""
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr ""
@@ -69160,125 +69255,125 @@ msgstr ""
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr ""
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr ""
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr ""
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "funkcija vraća polje"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "funkcija vraća funkciju"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a volatile type"
 msgid "%qE is not usable in a splice type"
 msgstr "  %qT nije nepostojan tip"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr ""
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr ""
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr ""
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr ""
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr ""
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr ""
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr ""
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected a function name"
 msgid "expected a reflection of a type template"
 msgstr "očekivano je ime funkcije"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr ""
@@ -69286,207 +69381,207 @@ msgstr ""
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %qD with different constraints"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "ponovna deklaracija %qD s drukčijim ograničenjima"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr ""
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "recite %<typename %E%> ako se misli na tip"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr ""
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr ""
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr ""
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr ""
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr ""
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr ""
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr ""
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr ""
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr ""
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr ""
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr ""
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr ""
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr ""
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr ""
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr ""
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr ""
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr ""
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr ""
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr ""
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr ""
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr ""
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr ""
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "klasa skladište (storage) %qD primijenjena na instanciranje predloška"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr ""
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr ""
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr ""
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr ""
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr ""
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr ""
@@ -69498,526 +69593,583 @@ msgstr ""
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr ""
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr ""
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr ""
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr ""
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr ""
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr ""
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr ""
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr ""
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr ""
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr ""
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr ""
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr ""
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr ""
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "ograničenja rezerviranog mjesta nisu zadovoljena"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "izvedeni povratni tip ne zadovoljava ograničenja rezerviranog mjesta"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "izvedeni povratni tip ne zadovoljava ograničenja rezerviranog mjesta"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "izvedeni povratni tip ne zadovoljava ograničenja rezerviranog mjesta"
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr ""
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr ""
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr ""
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr ""
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr ""
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr ""
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:476
 #, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr ""
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected %<else%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "očekivano je %<else%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not include %s"
 msgid "couldn%'t look up %qs"
 msgstr "nije (bilo) moguće uključiti %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of file in %qs"
 msgid "unexpected return type of %qs"
 msgstr "Neočekivani kraj datoteke u %qs"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT must be an object type"
 msgstr "  %qT nije tip objekta"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a member function"
 msgid "%qT must be a function type"
 msgstr "%qD mora biti član funkcije"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "neočekivani argument"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr ""
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "%<switch%> name defined here"
 msgid "%<consteval%> block defined here"
 msgstr "ime %<switch%> je definirano ovdje"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument"
 msgid "invalid %<access_context%> argument"
 msgstr "treći argument nije valjan"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected %<else%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "očekivano je %<else%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "neočekivani argument"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown metafunction %qD"
 msgstr "nepoznata spec funkcija %qs"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be constant integer expression"
 msgid "splice argument must be an expression of type %qs"
 msgstr "argument %<score%> mora biti konstantan cjelobrojni izraz"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr ""
+
+#: cp/reflect.cc:8540
+#, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr ""
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr ""
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr ""
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected call expression"
 msgid "expected a reflection of an expression"
 msgstr "očekivan je izraz poziva"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "ključna riječ %<typename%> nije dopuštena izvan predložaka"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr ""
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr ""
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "Expected reduction operator or function name at %C"
+msgid "expected a reflection of a function template"
+msgstr "Očekivan je operator redukcije ili naziv funkcije pri %C"
+
+#: cp/reflect.cc:9130
+#, fuzzy, gcc-internal-format
+#| msgid "Expected reduction operator or function name at %C"
+msgid "expected a reflection of a function or variable template"
+msgstr "Očekivan je operator redukcije ili naziv funkcije pri %C"
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -70348,591 +70500,591 @@ msgstr ""
 msgid "invalid base-class specification"
 msgstr ""
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr ""
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr ""
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr ""
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr ""
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr ""
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr ""
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr ""
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr ""
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "pack index is not an integral constant"
 msgid "pack index has non-integral type %qT"
 msgstr "‘pack’ indeks nije integralna konstanta"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "‘pack’ indeks nije integralna konstanta"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "pack index is out of range"
 msgid "pack index %qE is negative"
 msgstr "‘pack’ indeks je izvan raspona"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, fuzzy, gcc-internal-format
 #| msgid "pack index is out of range"
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr "‘pack’ indeks je izvan raspona"
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr ""
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr ""
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr ""
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr ""
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr ""
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr ""
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr ""
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr ""
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr ""
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr ""
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "weak aliases are not supported"
 msgid "variable length traits arrays are not supported"
 msgstr "slabi aliasi nisu podržani"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr ""
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr ""
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "‘constexpr’ string %<size()%> mora biti 'constant expression’"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "‘constexpr’ string %<data()[%d]%> mora biti 'constant expression’"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "‘constexpr’ string %<data()%> mora biti 'constant expression’"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr ""
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr ""
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr ""
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr ""
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
 msgid "%qT is not a non-union class type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a const type"
 msgid "%qT is not a standard-layout type"
 msgstr "  %qT nije tip konstante"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr ""
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference"
 msgid "%qs argument %qT is a reference"
 msgstr "  %qT nije referencija"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr ""
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr ""
@@ -70940,349 +71092,349 @@ msgstr ""
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr ""
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr ""
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr ""
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not of pointer type"
 msgid "%qT is a floating-point type"
 msgstr "%qD nije tip pokazivača>"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not of pointer type"
 msgid "%qT is a fixed-point type"
 msgstr "%qD nije tip pokazivača>"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a virtual base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "  %qT nije virtualna baza od %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr ""
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr ""
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, fuzzy, gcc-internal-format
 #| msgid "missing format after %qs"
 msgid "padding occurs after %qD"
 msgstr "nema formata iza %qs"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr ""
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr ""
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, gcc-internal-format
 msgid "%qD is not public"
 msgstr ""
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr ""
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr ""
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr ""
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr ""
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr ""
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr ""
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr ""
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr ""
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr ""
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr ""
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr ""
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr ""
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr ""
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr ""
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr ""
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr ""
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr ""
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr ""
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr ""
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr ""
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr ""
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr ""
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr ""
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr ""
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr ""
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr ""
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr ""
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr ""
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr ""
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "atribut %qE je primjenliv samo na varijable"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "parametar funkcije"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr ""
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "annotation does not have copy constructible type"
 msgstr "  %qT nije nothrow copy constructible"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr ""
@@ -71485,796 +71637,802 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr ""
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr ""
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "  %qT is not a member pointer"
+msgid "%q#D is not a member of %qT"
+msgstr "  %qT nije član pokazivača>"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr ""
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr ""
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "nema indeksa u referenciji za polje"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "indeksirana vrijednost nije ni polje ni pokazivač"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr ""
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr ""
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr ""
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot be used in an unevaluated context"
 msgid "%qT cannot be used as a function"
 msgstr "%qs ne može se koristiti u kontekstu koji nije evaluiran"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "previše argumenata za funkciju"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "premalo argumenata za funkciju"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr ""
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ zabranjuje usporedbu između pokazivača i cijelog broja"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "vrste operanda su %qT i %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr ""
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr ""
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr ""
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr ""
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr ""
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr ""
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr ""
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr ""
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr ""
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr ""
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr ""
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr ""
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr ""
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr ""
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr ""
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr ""
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr ""
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr ""
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr ""
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr ""
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr ""
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr ""
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr ""
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr ""
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr ""
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr ""
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr ""
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr ""
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr ""
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr ""
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr ""
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr ""
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr ""
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr ""
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr ""
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr ""
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr ""
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr ""
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr ""
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr ""
@@ -72678,17 +72836,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr ""
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr ""
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -72713,43 +72871,43 @@ msgstr ""
 msgid "the address of %qD will never be %<null%>"
 msgstr ""
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr ""
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr ""
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr ""
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr ""
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr ""
@@ -72827,32 +72985,32 @@ msgstr "loši argument za %<-fmodule-file=%>: %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "loši argument za %<-fversion=%>: %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "ne može otvoriti %s za pisanje: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "pišemo izlaznu datoteku %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "ne može otvoriti %s za čitanje: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "čitamo ddoc datoteku %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -72949,7 +73107,7 @@ msgstr ""
 msgid "%qs is not an associative array"
 msgstr ""
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -72964,22 +73122,22 @@ msgstr ""
 msgid "%qs is not a field, but a %qs"
 msgstr ""
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr ""
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr ""
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr ""
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr ""
@@ -73070,17 +73228,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -73402,8 +73560,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -73680,7 +73838,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr ""
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr ""
@@ -73755,7 +73913,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr ""
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr ""
@@ -73895,7 +74053,7 @@ msgstr ""
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr ""
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr ""
@@ -73910,7 +74068,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr ""
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr ""
@@ -74051,8 +74209,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74151,9 +74309,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr ""
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -74168,12 +74326,12 @@ msgstr ""
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr ""
@@ -74268,620 +74426,620 @@ msgstr ""
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr ""
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr ""
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr ""
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr ""
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr ""
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr ""
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr ""
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr ""
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "Argument DIM pri %L, ako postoji, mora biti cjelobrojni skalar"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "Argument ORDERED pri %L, ako postoji mora biti logički skalar"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr ""
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr ""
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr ""
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr ""
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr ""
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr ""
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr ""
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr ""
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr ""
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr ""
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr ""
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr ""
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr ""
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr ""
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr ""
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr ""
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Previše argumenata za %s pri %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Previše argumenata za %s pri %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr ""
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr ""
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr ""
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Previše argumenata za %s pri %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr ""
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr ""
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr ""
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr ""
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -74947,12 +75105,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -75002,2061 +75160,2061 @@ msgstr ""
 msgid "Simplification error"
 msgstr ""
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr ""
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr ""
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr ""
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr ""
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr ""
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr ""
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr ""
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "PARAMETER pri %L nema početnu vrijednost"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr ""
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "Loš oblik inicijalizatora pri %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr ""
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr ""
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr ""
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "%qs entitet ne može imati inicijalizator pri  %L"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr ""
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Inicijalizacija pri %C nije za varijablu pokazivača"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr ""
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr ""
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr ""
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr ""
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr ""
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr ""
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr ""
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr ""
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr ""
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr ""
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr ""
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr ""
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr ""
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr ""
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr ""
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr ""
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr ""
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "Očekivano je %<(%> pri %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr ""
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr ""
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Nije uspjelo stvoriti strukturu tipa ‘%s’ pri %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Ime strukture %qs pri %C ne može biti isto kao intrinsična vrsta"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Ime vrste %qs pri %C ne može biti isto kao intrinsična vrsta"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr ""
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr ""
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr ""
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "Očekivano je %<::%> pri %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr ""
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "Očekivano je %<=>%> pri %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding %qs"
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "Vezanje pri %C mora imati isti pristup kao već definirano vezanje %qs"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected associate name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Očekivano je asocijativno ime pri %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in %s statement at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Sintaktička pogreška u naredbi %s na %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "Vezanje pri %C mora imati isti pristup kao već definirano vezanje %qs"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "Očekivano je %<,%> pri %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr ""
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr ""
@@ -77199,408 +77357,408 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr ""
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr ""
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr ""
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr ""
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr ""
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr ""
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr ""
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr ""
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr ""
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr ""
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -77608,197 +77766,197 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr ""
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -77819,7 +77977,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -77880,42 +78038,42 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr ""
@@ -78040,12 +78198,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -78471,307 +78629,312 @@ msgstr ""
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Isti stvarni argument pridružen s INTENT(%s) argumentom %qs i INTENT(%s) argumentom %qs na %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr ""
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr ""
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr ""
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr ""
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr ""
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr ""
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr ""
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr ""
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr ""
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr ""
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr ""
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr ""
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr ""
@@ -78960,7 +79123,7 @@ msgstr ""
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr ""
@@ -79506,7 +79669,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -79677,12 +79840,12 @@ msgstr ""
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -80185,7 +80348,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr ""
@@ -80698,92 +80861,92 @@ msgstr ""
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr ""
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr ""
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -81769,7 +81932,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -81804,12 +81967,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -82286,7 +82449,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr ""
@@ -82306,7 +82469,7 @@ msgstr ""
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -82336,17 +82499,17 @@ msgstr ""
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -82466,8 +82629,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -82547,7 +82710,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr ""
@@ -82570,7 +82733,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -82610,7 +82773,7 @@ msgstr ""
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr ""
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -82922,601 +83085,611 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr ""
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be constant integer expression"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "argument %<score%> mora biti konstantan cjelobrojni izraz"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be non-negative at %C"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%<score%> argument ne smije biti negativan pri %C"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "svojstvo mora biti logički izraz pri %L"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "svojstvo mora biti cjelobrojni izraz prior %L"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "svojstvo mora biti konstantni logički izraz pri %L"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "svojstvo mora biti konstantni cjelobrojni izraz pri %L"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "property must be a logical expression at %L"
 msgid "property must be a conforming device number at %L"
 msgstr "svojstvo mora biti logički izraz pri %L"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Očekivan je nenegativan skalarni cjelobrojni pomak (offset) izraz pri %L"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Očekivano je lažno ime parametra ili pozitivnog cijelog broja pri %L"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -84180,62 +84353,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr ""
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr ""
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -84243,7 +84416,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -84701,1080 +84874,1080 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr ""
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr ""
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr ""
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr ""
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr ""
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr ""
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr ""
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr ""
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr ""
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr ""
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr ""
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr ""
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr ""
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr ""
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "Negacija izraza bez predznaka pri %L nije dopuštena"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr ""
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "Argument za TEAM pri %L mora biti skalar"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "Argument za STAT pri %L mora biti skalar"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr ""
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr ""
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -85783,12 +85956,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -85797,413 +85970,413 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr ""
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Očekivano je ime varijable u specifikaciji lokaliteta %s pri %L"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Coarray nije dopušten za %qs u specifikaciji lokaliteta %s pri %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr ""
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "%qs se ne smije pojaviti u specifikaciji polja pri %L u istoj ALLOCATE izjavi gdje je i sam dodijeljen"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -86212,316 +86385,316 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr ""
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr ""
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TEAM argument at %L must be scalar"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "Argument za TEAM pri %L mora biti skalar"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TEAM argument at %L must be scalar"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Argument za TEAM pri %L mora biti skalar"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr ""
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -86529,213 +86702,213 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name in reduction list at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Očekivano je ime  varijable u redukcijskom popisu pri %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "%s nije moguće odijeliti %s pri %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -86743,1057 +86916,1057 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr ""
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr ""
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr ""
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected constant integer expression at %C"
 msgid "Expecting constant expression near %L"
 msgstr "očekivan je  konstantni cjelobrojni izraz pri %C"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr ""
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr ""
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr ""
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr ""
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr ""
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Podstring pri %L ima duljinu nula"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -87813,97 +87986,97 @@ msgstr "nepostojeći ‘include’ direktorij %qs”"
 msgid "%qs is not a directory"
 msgstr ""
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr ""
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr ""
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "Ne može otvoriti datoteku %qs"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "Ne može otvoriti ‘included’ datoteku %qs"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "Ne može otvoriti ‘pre-included’ datoteku %qs"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr ""
@@ -88068,218 +88241,218 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr ""
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr ""
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr ""
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr ""
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr ""
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr ""
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -88617,74 +88790,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr ""
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -88714,29 +88887,35 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "reference to %qD is not a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "referencija za %qD nije konstantni izraz"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -88838,113 +89017,113 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%s pri %L nema zadani tip (vrstu)"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Objekt bez predznaka (unsigned) još nije implementiran"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -88974,12 +89153,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr ""
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr ""
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -88995,12 +89174,12 @@ msgstr ""
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr ""
@@ -89025,183 +89204,183 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, gcc-internal-format
 msgid "optional class parameter"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "neobrađena vrsta izraza"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr "neobrađeni izraz"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "Ne može naći simbol %qs pir %L"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "%qD source argument is the same as destination"
 msgid "variant %qs at %L is the same as base function"
 msgstr "izvorni argument %qD je isti kao i odredište"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "Očekivan je pozitivni argument indeka pri %L"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Stavka popisa %qs pri %L, deklarirana pri %L, nije lažni argument"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "%<need_device_addr%> nije podržana"
@@ -89539,7 +89718,7 @@ msgstr "zatvori: %s"
 msgid "two or more sections for %s"
 msgstr "dvije ili više sekcija za %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr "najmanja particija ne može biti veća od najveće particije"
@@ -89863,32 +90042,32 @@ msgstr ""
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "zatraženo poravnanje nije konstanta"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "traženo poravnanje je preveliko"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr ""
--- a/src/gcc/po/id.po
+++ b/src/gcc/po/id.po
@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 4.4.1\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2009-11-10 09:00+0700\n"
 "Last-Translator: Arif E. Nugroho <arif_endro@yahoo.com>\n"
 "Language-Team: Indonesian <translation-team-id@lists.sourceforge.net>\n"
@@ -1385,13 +1385,13 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 #| msgid "Specify ABI to use"
 msgid "Specify the PTX ISA version to use."
 msgstr "Spesifikasikan ABI yang akan digunakan"
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers"
 msgid "Initialize ptx registers."
@@ -2326,13 +2326,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2835,7 +2835,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Asumsikan target CPU dikonfigurasikan sebagai big endian"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 #| msgid "Assume target CPU is configured as little endian"
 msgid "Assume target CPU is configured as little endian."
@@ -2921,7 +2921,7 @@ msgstr "Gunakan subroutines untuk fungsi prolog dan epilog"
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 #| msgid "Specify the target CPU"
@@ -2961,7 +2961,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 #| msgid "Omit the frame pointer in leaf functions"
 msgid "Omit the frame pointer in leaf functions."
@@ -3074,7 +3074,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -3121,7 +3121,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5697,7 +5697,7 @@ msgstr "Dukung fungsi dalam dan pembuatan kode AES"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -6096,7 +6096,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "Biaya untuk mengasumsikan untuk sebuah instruksi percabangan"
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -6438,219 +6438,224 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "The register used to access the thread pointer:"
 msgstr "Spesifikasikan bagaimana mengakses penunjuk thread"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "Specify the thread pointer register."
 msgstr "Spesifikasikan bagaimana mengakses penunjuk thread"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 #| msgid "Specify bit size of immediate TLS offsets"
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Spesifikasikan ukuran bit dari ofset TLS langsung"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule given CPU"
 msgid "Use features of architecture ARCH."
 msgstr "Gunakan feature dari dan jadwalkan CPU yang diberikan"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule code for given CPU"
 msgid "Use features of and optimize for CPU."
 msgstr "Gunakan feature dari dan jadwalkan kode untuk CPU yang diberikan"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "Generate code that conforms to the given ABI"
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Hasilkan kode yang konform ke ABI yang diberikan"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate a call to abort if a noreturn function returns"
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Buat sebuah panggilan untuk pembatalan jika sebuah fungsi tanpa kembali kembali"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "%qs is deprecated"
 msgid "This option is deprecated."
@@ -12547,7 +12552,7 @@ msgstr "Aktifkan vektorisasi loop pada pohon"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -20199,93 +20204,93 @@ msgstr "Konform ke standar ISO 1990 C"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument must be a constant"
 msgid "argument must be passed by copying"
 msgstr "argumen harus berupa sebuah konstanta"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 #| msgid "caller edge frequency is negative"
 msgid "callee returns twice"
 msgstr "frekuensi ujung pemanggil negatif"
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 #| msgid "incompatible types in return"
 msgid "callee does not return"
 msgstr "tipe tidak kompatibel dalam kembali"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "variabel %qD memiliki tipe fungsi"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "deleted function %q+D"
 msgid "nested function"
 msgstr "fungsi %q+D terhapus"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "inconsistent number of popped arguments"
 msgstr "jumlah ujung masukan tidak cocok dengan jumlah dari argumen PHI"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s tidak mendukung split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "variable size arguments"
 msgstr "tipe argumen tidak valid"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr ""
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "Memory allocation failed"
 msgid "tail call production failed"
@@ -20413,12 +20418,12 @@ msgstr "'%%l' operan bukan sebuah label"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "konstanta pecahan disalah gunakan"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -21881,13 +21886,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "ini adalah insn:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "Disable indexed addressing"
 msgid "unable to reload address in "
 msgstr "Non-aktifkan pengalamatan terindeks"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "tidak dapat menghasilkan reloads untuk:"
 
@@ -22121,7 +22126,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGCC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonim>"
@@ -22508,11 +22513,11 @@ msgstr "operan tidak valid untuk kode '%c'"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand for '%%%c'"
@@ -22520,9 +22525,9 @@ msgstr "operan tidak valid untuk kode '%c'"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid punctuation %qc in constraint"
 msgid "invalid vector constant"
@@ -22574,79 +22579,79 @@ msgstr "kode operan '%c' tidak valid"
 msgid "invalid address mode"
 msgstr "alamat tidak valid"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "konversi dari %<__fpreg%> tidak valid"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "konversi tidak valid ke tipe %qT dari tipe %qT"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "pointers are not permitted as case values"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "penunjuk tidak diijinkan sebagai nilai case"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands in binary operation"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "operan tidak valid dalam operasi binary"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -22663,13 +22668,13 @@ msgid "invalid %%r value"
 msgstr "nilai %%r tidak valid"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "nilai %%R tidak valid"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "nilai %%N tidak valid"
@@ -22684,7 +22689,7 @@ msgstr "nilai %%P tidak valid"
 msgid "invalid %%h value"
 msgstr "nilai %%h tidak valid"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "nilai %%L tidak valid"
@@ -22699,7 +22704,7 @@ msgstr "nilai %%m tidak valid"
 msgid "invalid %%M value"
 msgstr "nilai %%M tidak valid"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "nilai %%U tidak valid"
@@ -23064,7 +23069,7 @@ msgstr "operan tidak terduga"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -23313,149 +23318,149 @@ msgstr "insn tidak valid:"
 msgid "Expected register or constant integer."
 msgstr "akumulator bukan sebuah konstanta integer"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "UNSPEC tidak valid sebagai operan"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "penggunaan tidak valid dari %<restrict%>"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid use of asm flag output"
 msgstr "lvalue tidak valid dalam keluaran asm %d"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code 'O'"
 msgstr "operan tidak valid untuk kode '%c'"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code 'z'"
 msgstr "operan tidak valid untuk kode '%c'"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "operan tidak valid untuk kode '%c'"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "operan tidak valid untuk kode '%c'"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'D'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "operan bukan sebuah kode kondisi, kode operan 'D' tidak valid"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "kode operan '%c' tidak valid"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "batasan untuk operan tidak valid"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "invalid controlling predicate"
 msgid "invalid vector immediate"
 msgstr "predikat pengontrol tidak valid"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "mode insn tidak diketahui"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "konversi dari %<__fpreg%> tidak valid"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "konversi dari %<__fpreg%> tidak valid"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "konversi ke %<__fpreg%> tidak valid"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "konversi tidak valid ke tipe %qT dari tipe %qT"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -23539,9 +23544,9 @@ msgstr "'%%%c' bukan sebuah awalan operan yang valid"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "penggunaan dari '%%%c' tidak valid"
@@ -23612,7 +23617,7 @@ msgid "insn contains an invalid address !"
 msgstr "alamat tidak valid"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "alamat tidak valid"
 
@@ -23690,7 +23695,7 @@ msgstr "insn rotasi tidak valid"
 msgid "invalid %%H value"
 msgstr "nilai %%H tidak valid"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "nilai %%d tidak valid"
@@ -23747,34 +23752,34 @@ msgstr "kombinasi tidak didukung: %s"
 msgid "unsupported memory expression:"
 msgstr "diduga ekspresi integer"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%c operand"
 msgid "invalid vector operand"
 msgstr "operan %%c tidak valid"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "operan tidak valid untuk pemodifikasi 'b'"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -23839,7 +23844,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "nilai %%H tidak valid"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "nilai %%D tidak valid"
@@ -23880,7 +23885,7 @@ msgstr "kode %%J tidak valid"
 msgid "invalid %%k value"
 msgstr "nilai %%k tidak valid"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "nilai %%K tidak valid"
@@ -23911,18 +23916,18 @@ msgstr "nilai %%T tidak valid"
 msgid "invalid %%u value"
 msgstr "nilai %%u tidak valid"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "nilai %%v tidak valid"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%H value"
 msgid "invalid %%V value"
 msgstr "nilai %%H tidak valid"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "nilai %%x tidak valid"
@@ -24161,28 +24166,28 @@ msgstr "operan %%s tidak valid"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "konstanta titik pecahan bukan sebuah operan langsung yang valid"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "operan 'B' bukan sebuah konstanta"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "operan 'B'  memiliki multiple bits set"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "operan 'o' bukan sebuah konstanta"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "operan 'B' bukan sebuah konstanta"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: kode tidak diketahui"
@@ -24245,24 +24250,24 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr "tidak dapat mengemulasikan %qs"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "tes buruk"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "topeng tidak valid"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "nilai %%t/%%b tidak valid"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "tidak ada register dalam alamat"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "ofset alamat bukan sebuah konstanta"
 
@@ -24296,7 +24301,7 @@ msgstr ""
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 #, fuzzy
 #| msgid "<anonymous>"
 msgid "({anonymous})"
@@ -24323,8 +24328,8 @@ msgstr "<anonim>"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "diduga %<,%>"
@@ -24353,7 +24358,7 @@ msgstr "diduga %<:%> atau %<...%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<)%>"
@@ -24362,7 +24367,7 @@ msgstr "diduga %<{%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<]%>"
@@ -24385,13 +24390,13 @@ msgstr "diduga %<,%>, %<,%> atau %<}%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "diduga %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<[%>"
@@ -24401,7 +24406,7 @@ msgstr "diduga %<{%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -24418,14 +24423,14 @@ msgstr "diduga %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<:%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<while%>"
@@ -24436,7 +24441,7 @@ msgstr "diduga %<{%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<,%>"
@@ -24449,20 +24454,20 @@ msgid "expected %<.%>"
 msgstr "diduga %<{%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@end%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<>%>"
 msgstr "diduga %<{%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<,%> or %<)%>"
@@ -24473,14 +24478,14 @@ msgstr "diduga %<,%> atau %<,%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "diduga %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<)%> or %<,%>"
@@ -24488,35 +24493,35 @@ msgstr "diduga %<,%> atau %<,%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<}%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<else%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "diduga %<#pragma omp section%> atau %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 #, fuzzy
 #| msgid "<anonymous>"
 msgid "(anonymous)"
 msgstr "<anonim>"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<<%>"
@@ -24547,7 +24552,7 @@ msgstr "kandidat 1:"
 msgid "  after user-defined conversion:"
 msgstr "tipe %qs memiliki sebuah konstruktor yang didefinisikan pengguna"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 #, fuzzy
 #| msgid "candidate 1:"
 msgid "candidate is:"
@@ -24670,7 +24675,7 @@ msgstr "parameter template %q+#D"
 msgid "<statement>"
 msgstr "dalam pernyataan"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown src"
 msgid "<unknown>"
@@ -24700,318 +24705,360 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr ""
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 #, fuzzy
 #| msgid "Unknown operator '%s' at %%L"
 msgid "<unknown operator>"
 msgstr "Operator tidak dikenal '%s' di %%L"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "akumulator bukan sebuah konstanta integer"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "floating constant misused"
 msgid "reflect_constant failed"
 msgstr "konstanta pecahan disalah gunakan"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "akumulator bukan sebuah konstanta integer"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "reflection does not have template arguments"
 msgstr "partial spesialisasi %qT tidak menspesialisasikan argumen template apapun"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a function or function type"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "Argument of %s at %L is not a valid type"
 msgid "operators argument is not a valid operator"
 msgstr "Argumen dari %s di %L bukan sebuah tipe valid"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%H%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%H%qE tidak memiliki tipe kelas"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "%Hfriend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "%Hdeklarasi friend tidak bernama sebuah kelas atau fungsi"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr ""
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 #| msgid "non-constant condition for static assertion"
 msgid "non-constant offset for offset_of"
 msgstr "kondisi bukan konstan untuk assertion static"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "dereferencing pointer ke tipe tidak lengkap"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment"
 msgid "reflection not suitable for alignment_of"
 msgstr "Jangan tune writable data alignmen"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "invalid cast to function type %qT"
 msgid "alignment_of on function type"
 msgstr "cast ke fungsi tipe %qT tidak valid"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "dereferencing pointer ke tipe tidak lengkap"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "gimplification failed"
 msgid "reflect_function failed"
 msgstr "gimplification gagal"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "argument to '-Xassembler' is missing"
 msgid "value member missing"
 msgstr "argumen ke '-Xassembler' hilang"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "Unexpected end of module"
 msgid "unexpected value of value member"
 msgstr "Tidak terduga akhir dari modul"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr ""
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "Function does not return a value"
 msgid "reflection does not represent a template"
 msgstr "Fungsi tidak mengembalikan sebuah nilai"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qs attribute"
 msgid "invalid argument to can_substitute"
 msgstr "argumen dari atribut %qs tidak valid"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "new cannot be applied to a reference type"
 msgid "type is not object or reference type"
 msgstr "new tidak dapat diaplikasikan untuk mereferensikan sebuah tipe"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%qs is not a valid output file"
 msgid "name is not a valid identifier"
 msgstr "%qs bukan sebuah berkas keluaran yang valid"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "nama register tidak dispesifikasikan untuk %q+D"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 #, fuzzy
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "bit-field %qD dengan tipe bukan integral"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "alignmen mungkin tidak dispesifikasikan untuk %q+D"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr ""
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "jumlah geser kanan negatif"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a power of 2"
 msgid "alignment is not power of two"
 msgstr "alignmen yang diminta bukan kelipatan dari 2"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "caller edge count is negative"
 msgid "alignment is negative"
 msgstr "jumlah ujung pemanggil negatif"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "function does not return string type"
+msgid "reflection does not have non-array object type"
+msgstr "fungsi tidak mengembalikan tipe string"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "cast to union type from type not present in union"
+msgid "current scope does not represent a function"
+msgstr "cast ke tipe union dari tipe yang tidak ada dalam union"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "%Hfriend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "%Hdeklarasi friend tidak bernama sebuah kelas atau fungsi"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qs"
 msgid "incomplete parent class"
 msgstr "implementasi dari class %qs tidak lengkap"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qT is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qT bukan sebuah class atau namespace"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "%qT is not a class type"
 msgid "not a complete class type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "%qD cannot be defaulted"
 msgid "value cannot be extracted"
@@ -25073,58 +25120,58 @@ msgstr "konversi ke %qT mengubah nilai konstanta %qT"
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "kandidat adalah:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "tipe argumen salah ke unary minus"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "tipe argume salah ke unary plus"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "tipe argumen salah ke bit-complement"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "tipe argumen salah ke abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "tipe argumen salah ke konjugasi"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 #| msgid "wrong type argument to unary plus"
 msgid "in argument to unary !"
 msgstr "tipe argume salah ke unary plus"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 #, fuzzy
 #| msgid "cannot increment a pointer to incomplete type %qT"
 msgid "no pre-increment operator for type"
 msgstr "tidak dapat meningkatkan sebuah penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 #, fuzzy
 #| msgid "cannot decrement a pointer to incomplete type %qT"
 msgid "no pre-decrement operator for type"
 msgstr "tidak dapat mengurangi penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -25142,70 +25189,70 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "konstanta floating dipotong ke nol"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, fuzzy, c-format
 #| msgid "Different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "Bentuk berbeda untuk argumen '%s' dan '%s' di %L untuk intrinsik 'dot_product'"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, fuzzy, c-format
 #| msgid "Different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "Bentuk berbeda untuk argumen '%s' dan '%s' di %L untuk intrinsik 'dot_product'"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, fuzzy, c-format
 #| msgid "Different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "Bentuk berbeda untuk argumen '%s' dan '%s' di %L untuk intrinsik 'dot_product'"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "bad string constant"
 msgid "BOZ literal constant"
 msgstr "konstanta string buruk"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "'%s' in EXTENDS expression at %C is not a derived type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "'%s' dalam ekspresi EXTENDS di %C bukan sebuah tipe turunan"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "%qs expects a constant argument"
 msgid "Procedure unexpected as argument"
 msgstr "%qs diduga sebuah konstanta argumen"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr ""
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "tipe tidak benar benar kompatibel"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -25277,7 +25324,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "penempatan array"
 
@@ -25286,17 +25333,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -25478,11 +25525,11 @@ msgstr "blok IF"
 msgid "implied END DO"
 msgstr "Diimplikasikan END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "assignment"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "assignmen penunjuk"
 
@@ -25490,167 +25537,167 @@ msgstr "assignmen penunjuk"
 msgid "simple IF"
 msgstr "IF sederhana"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "prosedur elemental"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "allocatable argument"
 msgstr "tipe argumen tidak valid"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 #| msgid "no arguments"
 msgid "asynchronous argument"
 msgstr "tidak ada argumen"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 #| msgid "no arguments"
 msgid "optional argument"
 msgstr "tidak ada argumen"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "pointer assignment"
 msgid "pointer argument"
 msgstr "assignmen penunjuk"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 #| msgid "no arguments"
 msgid "target argument"
 msgstr "tidak ada argumen"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "value argument"
 msgstr "tipe argumen tidak valid"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "tidak ada argumen"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 #| msgid "mismatched arguments"
 msgid "assumed-shape argument"
 msgstr "argumen tidak cocok"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 #| msgid "mismatched arguments"
 msgid "assumed-rank argument"
 msgstr "argumen tidak cocok"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 #| msgid "array assignment"
 msgid "coarray argument"
 msgstr "penempatan array"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "parametrized derived type argument"
 msgstr "tipe argumen tidak valid"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "tidak ada argumen"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-type argument"
 msgstr "tipe argumen tidak valid"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 #, fuzzy
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "result with non-constant character length"
 msgstr "'%s' di %L harus memiliki panjang karakter konstan dalam konteks ini"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 #, fuzzy
 #| msgid "elemental procedure"
 msgid "bind(c) procedure"
 msgstr "prosedur elemental"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 #| msgid "%qD is not a variable"
 msgid "iterator variable"
 msgstr "%qD bukan sebuah variabel"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 #, fuzzy
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "Start expression in DO loop"
 msgstr "Ekspresi step dalam loop DO di %L tidak dapat berupa nol"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 #| msgid "invalid expression as operand"
 msgid "End expression in DO loop"
 msgstr "ekspresi sebagai operan tidak valid"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 #, fuzzy
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "Step expression in DO loop"
 msgstr "Ekspresi step dalam loop DO di %L tidak dapat berupa nol"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 #, fuzzy
 #| msgid "DEALLOCATE "
 msgid "DEALLOCATE object"
 msgstr "DEALOKASIKAN "
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 #, fuzzy
 #| msgid "ALLOCATE "
 msgid "ALLOCATE object"
 msgstr "ALOKASIKAN "
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -25660,33 +25707,33 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Pajang KARAKTER berbeda (%d/%d) dalam konstruktor array di %L"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, fuzzy, c-format
 #| msgid "Actual argument contains too few elements for dummy argument '%s' (%lu/%lu) at %L"
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Argumen aktual berisi terlalu sedikit elemen untuk argumen dummy '%s' (%lu/%lu) di %L"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, fuzzy, c-format
 #| msgid "Actual argument contains too few elements for dummy argument '%s' (%lu/%lu) at %L"
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Argumen aktual berisi terlalu sedikit elemen untuk argumen dummy '%s' (%lu/%lu) di %L"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -25753,27 +25800,27 @@ msgstr "Argumen NCOPIES dari REPEAT intrinsik adalah negatif di %L"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Argumen NCOPIES dari REPEAT intrinsik adalah terlalu besar di %L"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -25888,7 +25935,7 @@ msgid "expected boolean type"
 msgstr "diduga bukan tuple"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 #| msgid "Expected integer"
 msgid "expected integer"
@@ -25970,7 +26017,7 @@ msgstr "tidak ada argumen"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments for format"
 msgid "too many arguments"
@@ -26465,7 +26512,7 @@ msgstr "dukungan profiler untuk VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "format target tidak mendukung infinity"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 #| msgid "profiling is still experimental for this target"
 msgid "profiling is not yet implemented for this architecture"
@@ -26731,13 +26778,13 @@ msgstr "Dalam fungsi %qs"
 msgid "Global declarative %s for %s"
 msgstr "global deklarasi %q+#D"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -26918,13 +26965,13 @@ msgstr "%qs sudah ditinggalkan"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown stack check parameter \"%s\""
 msgid "unknown autovec preference %qs"
 msgstr "tidak diketahui parameter pemeriksaan stack \"%s\""
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr ""
@@ -27410,8 +27457,8 @@ msgstr "%qE atribut konflik dengan atribut %s"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "previous declaration here"
@@ -27431,7 +27478,7 @@ msgstr "%qs atribut direktif diabaikan"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%qs atribut direktif diabaikan"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments specified for %qE attribute"
@@ -27443,7 +27490,7 @@ msgstr "jumlah dari argumen salah dispesifikasikan untuk atribut %qs"
 msgid "expected %i or more, found %i"
 msgstr "diduga %<(%> atau akhir dari baris"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %i, found %i"
@@ -27529,12 +27576,12 @@ msgstr "tipe atribut diabaikan setelah tipe telah didefinisikan"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -27657,141 +27704,141 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "ujung %s->%s tidak memiliki korespondensi call_stmt"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 #| msgid "no corresponding deallocation function for %qD"
 msgid "corresponding source location"
 msgstr "tidak ada dealokasi fungsi yang berhubungan untuk %qD"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "location is after end of function"
 msgstr "deklarasi dari %qs sebagai array dari fungsi"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr ""
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "can't open input file: %s"
 msgid "cannot open profile file %s"
 msgstr "tidak dapat membuka berkas masukan: %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "argumen dari tipe %qT tidak cocok dengan %qT"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "can't create repository information file %qs"
 msgid "cannot read summary information from %s"
 msgstr "tidak dapat membuat berkas informasi repositori %qs"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize %qT from %qT"
 msgid "cannot read string table from %s"
 msgstr "tidak dapat menginisialisasi %qT dari %qT"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read function profile from %s"
 msgstr "tidak dapat menemukan berkas untuk class %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't rename module file '%s' to '%s': %s"
 msgid "cannot read module profile from %s"
@@ -27803,7 +27850,7 @@ msgstr "tidak dapat mengubah nama berkas modul '%s' ke '%s': %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "ofset diluar dari jangkauan dari konstanta string"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qE declared here"
@@ -27917,7 +27964,7 @@ msgstr "konstanta argumen diluar dari jangkauan untuk %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "hilang argumen ke \"%s\""
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -27999,12 +28046,12 @@ msgstr "%K argumen terakhir dari %K bukan sebuah konstanta integer diantara 0 da
 msgid "cannot tail-call: %s"
 msgstr "tidak dapat menemukan class %qs"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "pemanggilan fungsi memiliki nilai bersama"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 #| msgid "missing argument to \"%s\""
 msgid "passing too large argument on stack"
@@ -28696,356 +28743,356 @@ msgstr "blok dasar tidak ditempatkan secara berurutan"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "jumlah dari catatan bb dalam rantai instruksi (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 #| msgid "caller edge count is negative"
 msgid "caller edge count invalid"
 msgstr "jumlah ujung pemanggil negatif"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing dimension specification at %C"
 msgid "missing direct call for speculation %i"
 msgstr "Hilang spesifikasi dimensi di %C"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Use control speculation"
 msgid "missing ref for speculation %i"
 msgstr "Gunakan spekulasi kontrol"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "field tambahan diset untuk ujung  %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline clone count is not compatible"
 msgstr "elemen penginisialisasi bukan sebuah konstanta"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr ""
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 #| msgid "Assume symbols might be invalid"
 msgid "local symbols must be defined"
 msgstr "Asumsikan simbol mungkin tidak valid"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "%D renamed after being referenced in assembly"
 msgid "inline clone is referenced by assembly"
 msgstr "%D diubah namanya setelah direferensikan dalam perakitan"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr ""
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "target specific option mismatch"
 msgid "semantic interposition mismatch"
 msgstr "pilihan target spesifik tidak cocok"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "aux field set for edge %s->%s"
 msgid "aux field set for indirect edge from %s"
 msgstr "field tambahan diset untuk ujung  %s->%s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "PIC code generation is not compatible with fast indirect calls"
 msgid "edge count is not compatible with function count"
 msgstr "Pembuatan kode PIC tidak kompatibel dangan panggilan cepat tidak langsung"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "PIC code generation is not compatible with fast indirect calls"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "Pembuatan kode PIC tidak kompatibel dangan panggilan cepat tidak langsung"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "penunjuk inlined_to salah"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "multiple pemanggil inline"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "penunjuk inlined_to diset untuk pemanggil bukan inline"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "caller edge count does not match BB count"
 msgstr "jumlah ujung masukan tidak cocok dengan jumlah dari argumen PHI"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "indirect call count does not match BB count"
 msgstr "jumlah ujung masukan tidak cocok dengan jumlah dari argumen PHI"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "penunjuk inlined_to diset tetapi tidak ada predecessor ditemukan"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "penunjuk inlined_to mereferensikan ke dirinya sendiri"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "shared call_stmt:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "titik ujung ke deklarasi salah:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "hilang ujung callgraph untuk pemanggilan stmt:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "reference to dead statement"
 msgstr "diduga pernyataan"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "ujung %s->%s tidak memiliki korespondensi call_stmt"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "ujung %s->%s tidak memiliki korespondensi call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node gagal"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to '-%s' is missing"
 msgid "%s: section %s.%d is missing"
@@ -29885,17 +29932,17 @@ msgstr "ukuran total dari variabel lokal melebihi batas arsitektur"
 msgid "impossible constraint in %<asm%>"
 msgstr "batasan tidak memungkinkan dalam %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "variabel %q+D mungkin dipotong oleh %<longjmp> atau %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "argumen %q+D mungkin dipotong oleh %<longjmp%> atau %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "fungsi mengembalikan sebuah kumpulan"
@@ -30652,7 +30699,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -30694,7 +30741,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qD defined here"
@@ -30718,24 +30765,24 @@ msgstr "penunjuk circular delegasi terdeteksi"
 msgid "function may return address of local variable"
 msgstr "fungsi mengembalikan alamat dari variabel lokal"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "fungsi mengembalikan alamat dari variabel lokal"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -31632,7 +31679,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr ""
@@ -31708,223 +31755,223 @@ msgstr "fungsi inline %q+D dideklarasikan tetapi tidak pernah didefinisikan"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid memory model %qs for %qD"
 msgstr "mode pointer tidak valid %qs"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for %q+D"
 msgid "invalid memory model %wi for %qD"
 msgstr "nama register tidak valid untuk %q+D"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for %q+D"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "nama register tidak valid untuk %q+D"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of %s function at %L is negative"
 msgid "argument %i value %s is negative"
 msgstr "Argumen dari %s fungsi di %L adalah negatif"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "referencing argument %u of type %qT"
 msgstr "diduga %qT tetapi argumen memiliki tipe %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 #| msgid "%Kcall to %qs declared with attribute error: %s"
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "%K panggilan ke %qs dideklarasikan dengan atribut error: %s"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "tipe vektori tidak valid untuk atribut %qE"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "in a call to function %qD"
 msgstr "panggilan ke bukan-fungsi %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "in a call with type %qT"
 msgstr "  dalam panggilan ke %qD"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "used here"
 msgid "assigned here"
 msgstr "digunakan disini"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "alignmen mungkin tidak dispesifikasikan untuk %q+D"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %q+D"
 msgid "pointer used after %qD"
 msgstr "parameter %q+D tidak digunakan"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD here"
 msgstr "  dalam panggilan ke %qD"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "mode pointer tidak valid %qs"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "mengasumsikan penunjuk ke anggota %qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "mode pointer tidak valid %qs"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qD declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "cannot create temporary file"
 msgid "unnamed temporary defined here"
 msgstr "tidak dapat membuat berkas sementara"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  dalam panggilan ke %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -32783,355 +32830,355 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "penggunaan tidak valid dari %<auto%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 #| msgid "initializer specified for non-virtual method %q+D"
 msgid "contains additional virtual method %qD"
 msgstr "penginisialisasi dispesifikasikan untuk metode %q+D bukan virtual"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in return"
 msgid "the incompatible type is defined here"
 msgstr "tipe tidak kompatibel dalam kembali"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 #| msgid "Array reference out of bounds"
 msgid "array types have different bounds"
 msgstr "Referensi array diluar cakupan"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 #| msgid "Function return value not set"
 msgid "return value type mismatch"
 msgstr "Fungsi mengembalikan nilai tidak diset"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "type mismatch in nontype parameter pack"
 msgid "type mismatch in parameter %i"
 msgstr "tipe tidak cocok dalam paket parameter bukan tipe"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "type %qT should match type %qT"
 msgstr "tipe %qT tidak diturunkan dari tipe %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "has different parameters in another translation unit"
 msgstr "Jenis parameter berbeda dalam penempatan penunjuk di %L"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "Array bound mismatch"
 msgid "memory layout mismatch"
 msgstr "Lingkupan array tidak cocok"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "the extra base is defined here"
 msgstr "%q+#D sebelumnya didefinisikan disini"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -33152,7 +33199,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function in call statement"
 msgid "invalid jump function in LTO stream"
@@ -33401,12 +33448,12 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr "tidak dapat menemukan sebuah register untuk spill dalam kelas %qs"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "batasan operan tidak konsisten dalam sebuah %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Maximum number of times that an insn could be scheduled"
 msgid "maximum number of generated reload insns per insn achieved (%d)"
@@ -33802,7 +33849,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -35297,25 +35344,25 @@ msgstr "secara implisit popped regs harus dikelompokan di ujung dari stack"
 msgid "output operand %d must use %<&%> constraint"
 msgstr "keluaran operan %d harus menggunakan batasan %<&%>"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data: [%u] Buruk nex_regno untuk rantai kosong (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data: Loop dalam rantai regno (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data: [%u] Buruk oldest_regno (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -36336,185 +36383,185 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "konstanta tidak dihitung ketika ADDR_EXPR berubah"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "efek samping tidak diperhitungkan ketika ADDR_EXPR berubah"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "alamat diambil, tetapi bit ADDRESSABLE tidak diset"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr ""
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size operand to %qs"
 msgstr "posisi atau ukuran operan tidak valid ke BIT_FIELD_REF"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, fuzzy, gcc-internal-format
 #| msgid "integral result type precision does not match field size of BIT_FIELD_REF"
 msgid "integral result type precision does not match field size of %qs"
 msgstr "tipe ketepatan hasil integral tidak cocok dengan ukuran field dari BIT_FIELD_REF"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, fuzzy, gcc-internal-format
 #| msgid "mode precision of non-integral result does not match field size of BIT_FIELD_REF"
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "mode ketepatan dari hasil bukan integral tidak cocok dengan ukuran field dari BIT_FIELD_REF"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in array reference"
 msgid "type mismatch in %qs reference"
 msgstr "tipe tidak cocok dalam referensi array"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "cast dari penunjuk ke integer dari ukuran berbeda"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "operan tidak valid ke %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in not expression"
 msgid "type mismatch in %qs"
 msgstr "tipe tidak cocok dalam ekspresi tidak"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid shift operand"
 msgid "invalid %qs offset operator"
 msgstr "operan shift tidak valid"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s operand"
 msgid "invalid address operand in %qs"
 msgstr "operan %%s tidak valid"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid shift operand"
 msgid "invalid offset operand in %qs"
 msgstr "operan shift tidak valid"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "penggunaan tidak valid dari %qD"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "IF sederhana"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "menggunakan nilai tipe struct dimana skalar dibutuhkan"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "ekspresi tidak valid untuk minimal lvalue"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion in gimple call"
 msgid "invalid function in gimple call"
 msgstr "konversi tidak valid dalam panggilan gimple"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "bukan fungsi dalam panggilan gimple"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "pure const state tidak valid untuk fungsi"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "LHS tidak valid dalam panggilan gimple"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "konversi tidak valid dalam panggilan gimple"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion in gimple call"
 msgid "invalid static chain in gimple call"
 msgstr "konversi tidak valid dalam panggilan gimple"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -36525,654 +36572,654 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_next_arg%> dipanggil tanpa sebuah argumen"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 #| msgid "invalid LHS in gimple call"
 msgid "invalid argument to gimple call"
 msgstr "LHS tidak valid dalam panggilan gimple"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "operan tidak valid dalam perbandingan gimple"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in comparison expression"
 msgid "mismatching comparison operand types"
 msgstr "tipe tidak cocok dalam ekspresi perbandingan"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in gimple comparison"
 msgid "non-vector operands in vector comparison"
 msgstr "operan tidak valid dalam perbandingan gimple"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in comparison expression"
 msgid "invalid vector comparison resulting type"
 msgstr "operan tidak valid dalam ekspresi perbandingan"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about comparison of different enum types"
 msgid "bogus comparison result type"
 msgstr "Peringatkan mengenai perbandingan dari tipe enum yang berbeda"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "bukan register seperti RHS dari operasi unary"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "operan tidak valid dalam operasi unari"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid vector types in nop conversion"
 msgstr "tipe tidak valid dalam konversi nop"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "tipe tidak valid dalam konversi nop"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid types in address space conversion"
 msgstr "tipe tidak valid dalam konversi nop"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "tipe tidak valid dalam konversi titik tetap"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in conversion to floating point"
 msgid "invalid types in conversion to floating-point"
 msgstr "tipe tidak valid dalam konversi ke titik pecahan"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "tipe tidak valid dalam konversi ke integer"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in shift expression"
 msgid "type mismatch in %qs expression"
 msgstr "tipe tidak cocok dalam ekspresi shift"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid types for %qs"
 msgstr "tipe abstrak tidak valid untuk %q+D"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid type for %qs"
 msgstr "tipe abstrak tidak valid untuk %q+D"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "konversi bukan trivial dalam operasi unari"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "bukan register seperti LHS dari operasi binari"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "operan tidak valid dalam operasi binary"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid non-vector operands to %qs"
 msgstr "operan tidak valid ke %%R"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "mode pointer tidak valid %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "tipe tidak cocok dalam ekspresi binary"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, fuzzy, gcc-internal-format
 #| msgid "non-register as LHS of unary operation"
 msgid "non-register as LHS of ternary operation"
 msgstr "bukan register seperti RHS dari operasi unary"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in binary operation"
 msgid "invalid operands in ternary operation"
 msgstr "operan tidak valid dalam operasi binary"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid mask type in %qs"
 msgstr "tipe abstrak tidak valid untuk %q+D"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "'&' not allowed by itself in line %d"
 msgid "not allowed type combination in %qs"
 msgstr "'&' tidak diperboleh dengan sendirinya dalam baris %d"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option argument %qs"
 msgid "invalid position or size in %qs"
 msgstr "pilihan argumen %qs tidak valid"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for %qs"
 msgid "insertion out of range in %qs"
 msgstr "konstanta argumen diluar dari jangkauan untuk %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr ""
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion at assignment"
 msgid "non-trivial conversion in %qs"
 msgstr "konversi bukan trivial di penempatan"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid array assignment"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "assignmen array tidak valid"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "in statement"
 msgid "%qs LHS in clobber statement"
 msgstr "dalam pernyataan"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "operan tidak valid ke %%R"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %qs size argument in load"
 msgstr "tipe argumen tidak valid"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rhs for gimple memory store"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "rhs tidak valid untuk penyimpanan memori gimple"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "non-register as LHS of unary operation"
 msgid "non-register as LHS with vector constructor"
 msgstr "bukan register seperti RHS dari operasi unary"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect sharing of tree nodes"
 msgid "incorrect number of vector %qs elements"
 msgstr "pembagian tidak benar dari titik pohon"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 #| msgid "PHI argument is not a GIMPLE value"
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "argumen PHI bukan sebuah nilai GIMPLE"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "bukan parameter %qs tidak dapat menjadi parameter pack"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "operan tidak valid dalam pernyataan return"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "konversi tidak valid dalam pernyataan return"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "tujuan goto bukan sebuah label ataupun sebuah penunjuk"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "operan tidak valid ke pernyataan switch"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to switch statement"
 msgid "non-integral type switch statement"
 msgstr "operan tidak valid ke pernyataan switch"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "%<default%> label not within a switch statement"
 msgid "invalid default case label in switch statement"
 msgstr "%<default%> label tidak dalam sebuah pernyataan switch"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "invalid case label in switch statement"
 msgstr "label case tidak dalam label pernyataan switch"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to switch statement"
 msgid "invalid case range in switch statement"
 msgstr "operan tidak valid ke pernyataan switch"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type precision mismatch in switch statement"
 msgstr "label case tidak dalam label pernyataan switch"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type mismatch for case label in switch statement"
 msgstr "label case tidak dalam label pernyataan switch"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "case labels not sorted in switch statement"
 msgstr "label case tidak dalam label pernyataan switch"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "label context is not the current function declaration"
 msgstr "nama parameter (tanpa tipe) dalam deklarasi fungsi"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect entry in label_to_block_map.\n"
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "masukan tidak benar dalam label_to_block_map.\n"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, fuzzy, gcc-internal-format
 #| msgid "format string has invalid operand number"
 msgid "incorrect setting of landing pad number"
 msgstr "string format memiliki jumlah operan yang tidak valid"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion in gimple call"
 msgid "invalid comparison code in gimple cond"
 msgstr "konversi tidak valid dalam panggilan gimple"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in gimple comparison"
 msgid "invalid labels in gimple cond"
 msgstr "operan tidak valid dalam perbandingan gimple"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid PHI result"
 msgid "invalid %<PHI%> result"
 msgstr "Hasil PHI tidak valid"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<PHI%> def"
 msgstr "hilang definisi PHI"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid PHI argument"
 msgid "invalid %<PHI%> argument"
 msgstr "argumen PHI tidak valid"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "Incompatible types in PHI argument"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "tipe tidak kompatibel dalam argumen PHI"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_gimple failed"
 msgid "%<verify_gimple%> failed"
 msgstr "verify_gimple gagal"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, fuzzy, gcc-internal-format
 #| msgid "Dead STMT in EH table"
 msgid "dead statement in EH table"
 msgstr "STMT dalam tabel EH mati"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qF throws different exceptions"
 msgid "local declaration from a different function"
 msgstr "deklarasi dari %qF throws exceptions berbeda"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) diset ke blok dasar salah"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, fuzzy, gcc-internal-format
 #| msgid "from this location"
 msgid "PHI node with location"
 msgstr "dari lokasi ini"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "pembagian tidak benar dari titik pohon"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) diset ke blok dasar yang salah"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "pernyataan ditandai untuk throw, tetapi tidak"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "pernyataan ditandai untuk throw di tengah dari blok"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple gagal"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK memiliki IL diasosiasikan dengannya"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK memiliki IL diasosiasikan dengannya"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "fallthru ke keluar dari bb %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "kelebihan grup kurung diakhir dari penginisialisasi"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "kelebihan grup kurung diakhir dari penginisialisasi"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE tidak terinisialisasi"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 #| msgid "Label '%s' at %C doesn't match IF label '%s'"
 msgid "label %qD to block does not match in bb %d"
 msgstr "Label '%s' di %C tidak cocok dengan label IF '%s'"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "kontrol aliran di tengah dari blok dasar %d"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "control flow in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "kontrol aliran di tengah dari blok dasar %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "fallthry edge setelah sebuah pernyataan kontrol dalam bb %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "benar/salah edge setelah sebuah bukan-COND_COND dalam bb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "tanda edge keluar salah diakhir dari bb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "eksplisit goto di akhir dari bb %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "return edge tidak menunjuk ke akhir dalam bb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "ditemukan case baku bukan diawal dari case vektor"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "case label tidak diurutkan: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "kelebihan outgoing edge %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "hilang edge %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<noreturn%> function does return"
 msgid "%<noreturn%> function does return"
 msgstr "%H%<noreturn%> fungsi tidak kembali"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "kontrol mencapai akhir dari fungsi bukan void"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "%H mengabaikan nilai kembali dari %qD, dideklarasikan dengan atribut warn_unused_result"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of function declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -37370,13 +37417,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "tipe vektori tidak valid untuk atribut %qE"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -37915,7 +37962,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -38355,12 +38402,12 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
@@ -38368,19 +38415,19 @@ msgstr ""
 msgid "previous declaration of %qD"
 msgstr "deklarasi sebelumnya dari %q+D"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with previous using declaration %q#D"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D konflik dengan deklarasi sebelumnya menggunakan %q#D"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "collect2 version %s"
 msgid "%qD conflicts for version %qB"
 msgstr "collect2 versi %s"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%Jconflicts with previous declaration here"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -38467,7 +38514,7 @@ msgstr "Tempatkan nol data terinisialisasi dalam daerah bss"
 msgid "no initializers are allowed in section %qs"
 msgstr "tidak dapat menginisialisasi fungsi friend %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "nama register tidak dispesifikasikan untuk %q+D"
@@ -38627,7 +38674,7 @@ msgstr "weakref %q+D secara ultimate mentarget dirinya sendiri"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "weakref %q+D harus memiliki static linkage"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "alias definitions not supported in this configuration"
@@ -38674,62 +38721,62 @@ msgstr "Gunakan packed stack layout"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "template argumen %d tidak valid"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "template argumen %d tidak valid"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "%qE attribute argument has type %qT"
 msgstr "diduga %qT tetapi argumen memiliki tipe %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "argumen baku untuk %q#D memiliki tipe %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta integer"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta integer"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdefault arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "%Hargumen baku hanya diijinkan untuk parameter fungsi"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdefault arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "%Hargumen baku hanya diijinkan untuk parameter fungsi"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdefault arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "%Hargumen baku hanya diijinkan untuk parameter fungsi"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdefault arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -38745,13 +38792,13 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for field of type %qT"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "%qE atribut diabaikan untuk daerah dari tipe %qT"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr ""
@@ -38983,13 +39030,13 @@ msgstr "tidak dapat menggunakan mode %qs untuk tipe enumeral"
 msgid "mode %qs applied to inappropriate type"
 msgstr "mode %qs diaplikasikan ke tipe yang tidak sesuai"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attributes are not supported for this target"
 msgid "section attributes are not supported for this target"
 msgstr "%Jatribut daerah tidak didukung untuk target ini"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "atribut daerah tidak diijinkan untuk %q+D"
@@ -39000,19 +39047,19 @@ msgstr "atribut daerah tidak diijinkan untuk %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta string"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "section attribute cannot be specified for local variables"
 msgstr "%J atribut daerah tidak dapat dispesifikasikan untuk variabel lokal"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "daerah dari %q+D konflik dengan deklarasi sebelumnya"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "daerah dari %q+D tidak dapat dioverridden"
@@ -39112,7 +39159,7 @@ msgstr "membersihkan argumen bukan sebuah identifikasi"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "daerah data dari %q+D konflik dengan deklarasi sebelumnya"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %q+D cannot be declared weak"
 msgid "inline function %q+D declared weak"
@@ -39167,13 +39214,13 @@ msgstr "%qs atribut hanya berlaku ke variabel"
 msgid "%qE attribute is only applicable on functions"
 msgstr "atribut %qs hanya berlaku ke fungsi"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to function types"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "atribut %qs hanya berlaku ke fungsi tipe"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -39185,12 +39232,12 @@ msgstr "%qs atribut hanya berlaku ke variabel"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta string"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -39295,23 +39342,23 @@ msgstr "%qE atribut diabaikan karena %qT telah didefinisikan"
 msgid "visibility argument not a string"
 msgstr "visibility argumen bukan sebuah string"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "%qE attribut diabaikan dalam tipe"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD diredeklarasi dengan visibility berbeda"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD telah dideklarasi %qs yang mengimplikasikan default visibility"
@@ -39329,7 +39376,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applies only to functions"
@@ -39408,7 +39455,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -39497,7 +39544,7 @@ msgstr "%qD tidak dideklarasikan dalam %qD"
 msgid "%qE argument is not a function"
 msgstr "membersihkan argumen bukan sebuah fungsi"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 #| msgid "version attribute is not a string"
 msgid "deprecated message is not a string"
@@ -39570,7 +39617,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "%qE attribut diabaikan dalam tipe"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "%qE attribute requires a string argument"
@@ -39740,16 +39787,16 @@ msgid "requested position is less than zero"
 msgstr "posisi yang diminta lebih kecil dari nol"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected binding attribute at %C"
 msgid "empty string in attribute %<target%>"
 msgstr "Diduga atribut binding di %C"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%qE attribute argument not a string constant"
@@ -40045,7 +40092,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "disarankan parentheses disekitar assignmen digunakan sebagai nilai kebenaran"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "penggunaan tidak valid dari %<restrict%>"
@@ -40235,8 +40282,8 @@ msgstr "tidak cukup variabel argumen yang masuk ke sebuah sentinel"
 msgid "missing sentinel in function call"
 msgstr "hilang sentinel dalam pemanggilan fungsi"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, fuzzy, gcc-internal-format
 #| msgid "Bad option %s to pragma attribute"
 msgid "bad option %qs to attribute %<optimize%>"
@@ -41339,7 +41386,7 @@ msgstr "tidak didukung bukan-standar pemotongan dari string literals"
 msgid "traditional C rejects string constant concatenation"
 msgstr "tradisional C menolak pemotongan konstanta string"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -41395,7 +41442,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "tipe tidak valid untuk iterasi variabel %qE"
@@ -41411,17 +41458,17 @@ msgstr "%Htipe tidak valid untuk iterasi variabel %qE"
 msgid "%qE is not initialized"
 msgstr "%qE tidak terinisialisasi"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "hilang predikat pengontrol"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "predikat pengontrol tidak valid"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "hilang ekspresi peningkatan"
@@ -41431,7 +41478,7 @@ msgstr "hilang ekspresi peningkatan"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "ekspresi peningkatan tidak valid"
@@ -41533,19 +41580,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is not a function argument"
 msgstr "%qD bukan sebuah template fungsi"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -41556,8 +41603,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 #| msgid "%Htoo many %qs clauses"
 msgid "%<_Atomic%> %qE in %qs clause"
@@ -42134,7 +42181,7 @@ msgstr "konstanta tidak valid dalam %<#pragma pack%> - diabaikan"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "salah bentuk %<#pragma message%>, diabaikan"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, fuzzy, gcc-internal-format
 #| msgid "junk at end of #pragma %s"
 msgid "junk at end of %<#pragma %s%>"
@@ -42212,8 +42259,8 @@ msgstr "move insn tidak tertangani"
 msgid "wrong type argument to %s"
 msgstr "tipe argumen salah ke abs"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -42750,17 +42797,17 @@ msgstr "%s dari fungsi %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "lokasi baca-saja %qE digunakan sebagai keluaran %<asm%>"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "penempatan dari lokasi baca-saja %qE"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "peningkatan dari lokasi baca-saja %qE"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "pengurangan dari lokasi baca-saja %qE"
@@ -43045,7 +43092,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "melewatkan argumen %d dari %qE mengabaikan pengkualifikasi dari tipe target penunjuk"
 msgstr[1] "melewatkan argumen %d dari %qE mengabaikan pengkualifikasi dari tipe target penunjuk"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -44054,7 +44101,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -44758,7 +44805,7 @@ msgstr "melewatkan argumen %d dari %qE dari tipe Objective-C berbeda"
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "deleted definition of %qD"
 msgid "duplicate definition of %qs"
@@ -44811,7 +44858,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "tipe %q+D tidak memiliki ukuran yang diketahui"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -44867,7 +44914,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -44971,19 +45018,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "Argumen AltiVec dilewatkan ke fungsi yang tidak berprototipe"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -45030,196 +45077,196 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "%qs atribut diabaikan"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on %<__fpreg%>"
 msgid "invalid format for %<sve_width%>"
 msgstr "operasi di %<__fpreg%> tidak valid"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%H value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "nilai %%H tidak valid"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown spec function '%s'"
 msgid "unknown tuning option (%s)"
 msgstr "fungsi spesifikasi '%s' tidak diketahui"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 #| msgid "Specify the register allocation order"
 msgid "specify a system register with a small string length"
 msgstr "Spesifikasikan pengurutan alokasi register"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs tidak valid untuk %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "argumen ke %<__builtin_frame_address%> tidak valid"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "argumen ke %<__builtin_frame_address%> tidak valid"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march= switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "pilihan -mcpu=%s konflik dengan pilihan -march="
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "%s tidak mendukung %s"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%qs sudah ditinggalkan"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in the %s bit mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "model kode %qs tidak mendukung dalam mode %s bit"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
@@ -45227,25 +45274,25 @@ msgstr ""
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "salah bentuk %<#pragma init%>"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 #| msgid "attribute(target(\"%s\")) is unknown"
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "atribut(target(\"%s\")) tidak diketahui"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -45254,211 +45301,211 @@ msgstr "atribut(target(\"%s\")) tidak diketahui"
 msgid "attribute %<target%> argument not a string"
 msgstr "alias argumen bukan sebuah string"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 #| msgid "attribute(target(\"%s\")) is unknown"
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "atribut(target(\"%s\")) tidak diketahui"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "alias argument not a string"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "alias argumen bukan sebuah string"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qs attribute"
 msgid "missing value in %<target_version%> attribute"
 msgstr "argumen dari atribut %qs tidak valid"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "ekspresi batas stack tidak didukung"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_eh_return not supported on this target"
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "__builtin_eh_return tidak didukung dalam target ini"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D has a previous declaration as %q#D"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+D memiliki sebuah deklarasi sebelumnya sebagai %q#D"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported simdlen %wd"
 msgstr "kombinasi tidak didukung: %s"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support saturating types"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "ISO C tidak mendukung tipe yang bersaturasi"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "unsupported argument type %qT for simd"
 msgstr "argumen yang tidak digunakan dalam $-gaya format"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "pilihan -shared saat ini tidak didukung untuk VAX ELF"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "type attributes ignored after type is already defined"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "tipe atribut diabaikan setelah tipe telah didefinisikan"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q+D defined here"
 msgstr "%q+D dideklarasikan disini"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "melewatkan argumen %d dari %qE dengan lebar berbeda karena ada prototipe"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "melewatkan argumen %d dari %qE dengan lebar berbeda karena ada prototipe"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "melewatkan argumen %d dari %qE dengan lebar berbeda karena ada prototipe"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "melewatkan argumen %d dari %qE dengan lebar berbeda karena ada prototipe"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -45665,12 +45712,12 @@ msgstr "argumen dari atribut %qs bukan \"ilink1\" atau \"ilink2\""
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
@@ -45818,23 +45865,23 @@ msgid "argument of %qE attribute ignored"
 msgstr "%qE atribut diabaikan"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "%qE attribute only applies to variables"
 msgstr "%qs atribut hanya berlaku ke variabel"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr ""
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid type for %<asm%> flag output"
@@ -46426,13 +46473,13 @@ msgstr "-pipe tidak didukung"
 msgid "%<-fPIE%> is not supported"
 msgstr "-pipe tidak didukung"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 #| msgid "-G and -static are mutually exclusive"
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-G dan -static adalah mutually exclusive"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%qs function cannot have arguments"
@@ -46443,7 +46490,7 @@ msgstr "%qD tidak dapat memiliki argumen baku"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "%qs function cannot return a value"
@@ -46808,7 +46855,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "argumen ke fungsi bawaan tidak valid"
@@ -47157,7 +47204,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -47343,190 +47390,190 @@ msgstr "argumen ke %qs harus berupa sebuah 2 bit unsigned literal"
 msgid "parameter to builtin not valid: %s"
 msgstr "Argumen ke -ffpe-trap tidak valid: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt Service Routines cannot be coded in Thumb mode"
 msgid "interrupt service routine cannot be called directly"
 msgstr "Interrupt Sevice Routines tidak dapat dikodekan dalam mode Thumb"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 2 bit immediate"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 #| msgid "the fifth argument must be a 8-bit immediate"
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "argumen kelima harus berupa sebuah 8 bit immediate"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 #| msgid "the third argument must be a 8-bit immediate"
 msgid "the third argument must be an 8-bit immediate"
 msgstr "argumen ketiga harus berupa sebuah 8 bit immediate"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be a 1-bit immediate"
 msgid "the last argument must be an 1-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 1 bit immediate"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be a 4-bit immediate"
 msgid "the last argument must be a 3-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 4 bit immediate"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 4 bit immediate"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 1 bit immediate"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE membutuhkan pilihan isa %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 5 bit immediate"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "argumen selanjutnya ke terakhir harus berupa sebuah 8 bit immediate"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 8 bit immediate"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "the third argument must be comparison constant"
 msgstr "argumen harus berupa sebuah konstanta"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect insn:"
 msgid "incorrect comparison mode"
 msgstr "insn tidak benar:"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect sharing of tree nodes"
 msgid "incorrect rounding operand"
 msgstr "pembagian tidak benar dari titik pohon"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be a 4-bit immediate"
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 4 bit immediate"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be a 5-bit immediate"
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 5 bit immediate"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be an 8-bit immediate"
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 8 bit immediate"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 #| msgid "the fifth argument must be a 8-bit immediate"
 msgid "the fourth argument must be one of enum %qs"
 msgstr "argumen kelima harus berupa sebuah 8 bit immediate"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "pemilih harus berupa sebuah konstanta integer dalam jangkauan 0..%wi"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE membutuhkan pilihan isa tidak diketahui"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE membutuhkan pilihan isa %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "argumen harus berupa sebuah konstanta"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "argumen kedua ke %<__builtin_prefetch%> tidak valid; menggunakan nol"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid third argument"
 msgstr "tipe argumen tidak valid"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "argumen ketiga ke %<__builtin_prefetch%> tidak valid; menggunakan nol"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "argumen ketiga ke %<__builtin_prefetch%> tidak valid; menggunakan nol"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "second argument must be a const"
 msgstr "argumen harus berupa sebuah konstanta"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be a 2-bit immediate"
 msgid "the last argument must be a 32-bit immediate"
 msgstr "argumen terakhir harus berupa sebuah 2 bit immediate"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "argumen terakhir harus berupa sebuah immediate"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be a 4-bit immediate"
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "argumen terakhir harus berupa sebuah 4 bit immediate"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "the next to last argument must be an 8-bit immediate"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -47968,8 +48015,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "%<-march=%s%> is not compatible with the selected ABI"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -48242,7 +48289,7 @@ msgstr "ABI dari melewatkan structure dengan anggota float kompleks telah beruba
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "ABI dari melewatkan structure dengan anggota float kompleks telah berubah dalam GCC 4.4"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -48269,13 +48316,13 @@ msgstr "argumen register SSE dengan SSE tidak aktif"
 msgid "x87 register return with x87 disabled"
 msgstr "x87 register kembali dengan x87 tidak aktif"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, fuzzy, gcc-internal-format
 #| msgid "Calling %qD with attribute sseregparm without SSE/SSE2 enabled"
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "Memanggil %qD dengan atribut sseregparm tanpa mengaktifkan SSE/SSE2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -48286,40 +48333,40 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "ABI dari melewatkan union dengan long double telah berubah dalam GCC 4.4"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "assert: %s adalah assign kompatibel dengan %s"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "batas stact tidak didukung dalam target ini"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "%s not supported for nested functions"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%s tidak didukung untuk fungsi nested"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "%s not supported for nested functions"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -48327,96 +48374,96 @@ msgstr "%s tidak didukung untuk fungsi nested"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr ""
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported operand size for extended register"
 msgid "unsupported size for integer register"
 msgstr "ukuran operan tidak didukung untuk register ekstended"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "register extended tidak memiliki setengah tinggi"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "ukuran operan tidak didukung untuk register ekstended"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr ""
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 #, fuzzy
 #| msgid "the mangling of %<va_list%> has changed in GCC 4.4"
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "mangling dari %<va_list%> telah berubah dalam GCC 4.4"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "tidak ada register bawah yang tersedia unruk popping register atas"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown architecture '%s'"
 msgid "unknown architecture specific memory model"
 msgstr "Arsitektur '%s' tidak dikenal"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -48473,7 +48520,7 @@ msgstr "gp_offset (%ld) atau end_offset (%ld) lebih kecil dari nol"
 msgid "argument %qd is not a constant"
 msgstr "argumen %qd bukan sebuah konstanta"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -48485,7 +48532,7 @@ msgstr "PRINT_OPERAND_ADDRESS, penunjuk kosong"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: Punctuation '%c' tidak diketahui"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -48647,49 +48694,49 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "atribut(target(\"%s\")) tidak diketahui"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "`%s' attribute is not supported for R8C target"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "atribut `%s' tidak didukung untuk target R8C"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "Spe not supported in this target"
 msgid "%qs is not supported in target attribute"
@@ -49508,7 +49555,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "kode bawaan buruk"
@@ -49761,87 +49808,87 @@ msgstr "%s:tidak dapat membuka berkar graphik\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 #| msgid "passing floating point arguments in fp regs not yet supported"
 msgid "not generating patch area, nops not supported"
 msgstr "melewatkan argumen titik pecahan dalam register titik pecahan belum didukung"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute requires a void return type"
 msgstr "%qE attribut diabaikan dalam tipe"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "__BELOW100__ atribut tidak diijinkan dengan class auto storage"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "complement argument must be constant"
 msgstr "argumen harus berupa sebuah konstanta"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "%J definisi alias tidak didukung dalam konfigurasi ini"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -50090,346 +50137,346 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %q+D does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "tipe %q+D tidak memiliki ukuran yang diketahui"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %q+D does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "tipe %q+D tidak memiliki ukuran yang diketahui"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "aritmetik di penunjuk ke sebuah tipe tidak lengkap"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "fields cannot have RVV type %qT"
 msgstr "%qE bukan dari tipe %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "tidak dapat mengalokasikan sebuah objek dari tipe abstrak %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "tidak dapat mengalokasikan sebuah objek dari tipe abstrak %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "tidak dapat mengubah tipe %qT ke tipe %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is disallowed in Java %<throw%> or %<catch%>"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "tipe %qT tidak diijinkan dalam Java %<throw%> atau %<catch%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %<firstprivate%>"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE bukan sebuah variabel dalam clause %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %qs not supported for MIPS16"
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "fungsi bawaan %qs tidak didukung untuk MIPS16"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized gcc debugging option: %c"
 msgid "unrecognized RVV builtin"
 msgstr "pilihan debuggin gcc: %c tidak dikenal"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "fungsi bawaan %q+D dideklarasikan sebagai bukan-fungsi"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "mangling function-style cast with more than one argument"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "mangling function-style cast dengan lebih dari satu argumen"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "unknown value %s for -mfpu"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "nilai %s tidak diketahui untuk pilihan -mfpu"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, fuzzy, gcc-internal-format
 #| msgid "The ABI of passing structure with complex float member has changed in GCC 4.4"
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "ABI dari melewatkan structure dengan anggota float kompleks telah berubah dalam GCC 4.4"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "Argumen AltiVec dilewatkan ke fungsi yang tidak berprototipe"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not \"ilink1\" or \"ilink2\""
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "argumen dari atribut %qs bukan \"ilink1\" atau \"ilink2\""
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE bukan dari tipe %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "atribut %qs membutuhkan sebuah argumen konstanta integer"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support ARM mode"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "target CPU tidak mendukung kode ARM"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in the %s bit mode"
 msgid "code model %qs with %qs"
 msgstr "model kode %qs tidak mendukung dalam mode %s bit"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 tidak mendukung tipe kompleks"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "%spreferred-stack-boundary=%d%s is not between %d and 12"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "%spreferred-stack-boundary=%d%s tidak berada diantara %d dan 12"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs tidak valid untuk %qs"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs tidak valid untuk %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr ""
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -51528,23 +51575,23 @@ msgstr "kebutuhan memori lokal variabel melebihi kapasitas"
 msgid "%<function_profiler%> support"
 msgstr "function_profiler dukungan"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "tidak dapat menggunakan va_start dalam interupsi fungsi"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "pernyataan pilihan dari ukuran %lu masukan terlalu besar"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "%<__BELOW100__%> atribut hanya berlaku ke variabel"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -51796,34 +51843,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D didefinisikan tetapi tidak digunakan"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "register boolean dibutuhkan untuk pilihan titik pecahan"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "-f%s tidak didukung dengan instruksi CONST16"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC dibutuhkan tetapi tidak didukung dengan instruksi CONST16"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "hanya variabel tidak terinisialisasi yang dapat ditempatkan didaerah .bss"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -51919,7 +51966,7 @@ msgstr "%qE atribut membutuhkan prototipe dengan argumen bernama"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "%qE atribut hanya berlaku untuk fungsi variadic"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
@@ -52011,8 +52058,8 @@ msgstr ""
 msgid "could not get size of source file"
 msgstr "tidak dapat menulis ke berkas response %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "nilai void tidak diabaikan karena ini seharusnya"
@@ -52531,7 +52578,7 @@ msgstr "melompat kedalam pernyataan ekspresi"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%H%qE didefinisikan sebagai jenis salah dari tag"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to function types"
 msgid "%qE attribute applied to %qD with void return type"
@@ -52695,7 +52742,7 @@ msgstr "ISO C90 tidak mendukung %<static%> atau tipe kualifier dalam parameter a
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 tidak mendukung %<[*]%> array pendeklarasi"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -52706,7 +52753,7 @@ msgstr "%H%<this%> mungkin tidak digunakan dalam konteks ini"
 msgid "%q+D is usually a function"
 msgstr "%q+D biasanya sebuah fungsi"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 #| msgid "no previous declaration for %q+D"
 msgid "no previous declaration for %qD"
@@ -52790,7 +52837,7 @@ msgstr "tidak dapat meletakan objek dengan bagian volatile kedalam register"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "tidak terinisialisasi const %qD"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -53011,7 +53058,7 @@ msgstr "class penyimpanan dispesifikasikan untuk parameter %qs"
 msgid "storage class specified for unnamed parameter"
 msgstr "class penyimpanan dispesifikasikan untuk parameter %qs"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "class penyimpanan dispesifikasikan untuk nama tipe"
@@ -53212,7 +53259,7 @@ msgstr "%qs dideklarasikan sebagai fungsi yang mengembalikan sebuah array"
 msgid "function definition has qualified void return type"
 msgstr "definisi fungsi memiliki pengkualifikasi tipe kembali void"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "tipe pengkualifikasi diabaikan di tipe kembali fungsi"
@@ -53356,7 +53403,7 @@ msgstr "ISO C melarang tipe fungsi const atau volatile"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "sebuah anggota dari sebuah struktur atau union tidak dapat memiliki sebuah tipe variabel termodifikasi"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "variabel atau field %qE dideklarasikan void"
@@ -53589,7 +53636,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr "field %qE tidak dikenal dispesifikasikan dalam penginisialisasi"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "redeklarasi tidak mendeklarasikan apapun"
@@ -53656,7 +53703,7 @@ msgstr "struct tidak memiliki anggota bernama"
 msgid "struct has no members"
 msgstr "struct tidak memiliki anggota"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "%Jflexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -53728,7 +53775,7 @@ msgstr "redeklarasi dari %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -53790,7 +53837,7 @@ msgstr "ISO C melarang nilai pengenumerasi ke jangkauan dari %<int%>"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C melarang nilai pengenumerasi ke jangkauan dari %<int%>"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %q+D given attribute noinline"
 msgid "inline function %qD given attribute %qs"
@@ -53958,12 +54005,12 @@ msgstr "argumen %qD tidak cocok dengan prototipe bawaan"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "argumen %qD tidak cocok dengan prototipe"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "tidak ada pernyataaan kembali dalam fungsi yang mengembalikan bukan void"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD is initialized"
 msgid "parameter %qD set but not used"
@@ -54055,7 +54102,7 @@ msgstr "%<__thread%> digunakan dengan %<register%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "dua atau lebih tipe data dalam penspesifikasi deklarasi"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> terlalu panjang untuk GCC"
@@ -54169,7 +54216,7 @@ msgstr "ISO C90 tidak mendukung tipe kompleks"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "%s tidak mendukung format %<%%%s%c%> %s"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "%<_Float%d%s%> is not supported on this target"
@@ -54344,12 +54391,12 @@ msgstr "Panjang baris tetap harus paling tidak tujuh."
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C tidak mendukung %<~%> untuk konjugasi kompleks"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -54412,39 +54459,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs harus digunakan dengan %qs"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "jumlah geser kiri negatif"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "jumlah geser kiri negatif"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "jumlah geser kanan negatif"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "jumlah geser kiri >= lebar dari tipe"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "jumlah geser kanan >= lebar dari tipe"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "jumlah geser kiri >= lebar dari tipe"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -54466,7 +54513,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected end of line"
@@ -54477,7 +54524,7 @@ msgstr "Tidak terduga akhir dari modul"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C melarang sebuah satuan terjemahan kosong"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -54526,8 +54573,8 @@ msgid "unknown type name %qE"
 msgstr "nama register: %s tidak dikenal"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "diduga penspesifikasi deklarasi"
@@ -54566,7 +54613,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "diduga pengidentifikasi atau %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "prefix attributes are ignored for methods"
@@ -54584,13 +54631,13 @@ msgstr "atribut diabaikan di template instantiation"
 msgid "unexpected attribute"
 msgstr "Diduga nama atribut bit"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "atribut daerah tidak diijinkan untuk %q+D"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -54638,7 +54685,7 @@ msgstr "penempatan (tidak terinisialisasi) dalam deklarasi"
 msgid "%qs may only be used with a single declarator"
 msgstr "-MG hanya boleh digunakan dengan -M atau -MM"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "diduga %<,%> atau %<,%>"
@@ -54675,7 +54722,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "diduga string literal"
@@ -54709,7 +54756,7 @@ msgstr "ekspresi integral %qE bukan konstan"
 msgid "static assertion failed: %E"
 msgstr "static assertion gagal: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %E"
 msgid "static assertion failed"
@@ -54769,8 +54816,8 @@ msgstr "tidak dapat menggunakan mode %qs untuk tipe enumeral"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "diduga pengidentifikasi"
@@ -54803,12 +54850,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "daerah dari %q+D konflik dengan deklarasi sebelumnya"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "koma di akhir dari daftar pengenumerasi"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -54893,25 +54940,25 @@ msgstr "diduga deklarasi penspesifikasi atau %<...%>"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "parameter pack harus berada di akhir dari daftar parameter"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "Unclassifiable OpenMP directive at %C"
 msgid "expected OpenMP directive name"
 msgstr "Direktif OpenMP tidak terklasifikasi di %C"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "diduga %<none%> atau %<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%qD atribut membutuhkan sebuah argumen NTBS tunggal"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qE attribute does not take any arguments"
@@ -54923,7 +54970,7 @@ msgstr "atribut %qs membutuhkan sebuah argumen konstanta integer"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 tidak mendukung %<[*]%> array pendeklarasi"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -54955,18 +55002,18 @@ msgstr "ISO C90 melarang menspesifikasikan subobjek untuk menginisialisasi"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "penggunaan sudah ditinggalkan dari penginisialisasi yang diberikan tanpa  %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 #| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "daerah terurut harus secara dekat nested didalam sebuah daerah loop dalam sebuah clause terurut"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -54976,44 +55023,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute does not apply to types"
 msgid "%qs attribute does not take any arguments"
@@ -55045,7 +55092,7 @@ msgstr "ISO C90 melarang pencampuran deklarasi dan kode"
 msgid "expected %<}%> before %<else%>"
 msgstr "diduga %<}%> sebelum %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> tanpa sebuah sebelumnya %<if%>"
@@ -55060,7 +55107,7 @@ msgstr "label diakhir dari pernyataan compound"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "diduga pernyataan"
@@ -55097,29 +55144,29 @@ msgstr "ISO C tidak mendukung tipe yang bersaturasi"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "Fungsi '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declaration"
 msgstr "deklarasi kosong"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "disarankan kurung diantara tubuh kosong dalam sebuah pernyataan %<if%>"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "disarankan kurung diantara tubuh kosong dalam sebuah pernyataan %<else%>"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, fuzzy, gcc-internal-format
 #| msgid "%Hsuggest explicit braces to avoid ambiguous %<else%>"
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "%H disarankan kurung eksplisit untuk menghindari ambigu %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -55141,12 +55188,12 @@ msgstr "multiple atribut interupsi tidak diijinkan"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "register tidak valid dalam instruksi"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -55163,8 +55210,8 @@ msgstr "hilang sentinel dalam pemanggilan fungsi"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "%Hduplikasi cv kualifikasi"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -55189,12 +55236,12 @@ msgstr "ISO C melarang mengabaikan term tengah dari sebuah ekspresi ?:"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "first %<sizeof%> operand was declared here"
@@ -55393,7 +55440,7 @@ msgstr "ISO C90 tidak mendukung %<[*]%> array pendeklarasi"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "diduga ekspresi"
@@ -55408,13 +55455,13 @@ msgstr "braced-group didalam eksprsi hanya diijinkan didalam sebuah fungsi"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C melarang grup kurung didalam ekspresi"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "parameter kedua dari %<va_start%> bukan argumen bernama terakhir"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -55579,7 +55626,7 @@ msgstr "kedua argumen ke %<__builtin___clear_cache%> harus berupa penunjuk"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "argumen ketiga ke %<__builtin_prefetch%> harus berupa sebuah konstan"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<__builtin_next_arg%>"
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
@@ -55627,7 +55674,7 @@ msgstr "argumen bukan-konstanta integer %u dalam panggilan ke fungsi %qE"
 msgid "rotate count is negative"
 msgstr "jumlah rotasi kiri negatif"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
@@ -55741,7 +55788,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -55784,12 +55831,12 @@ msgstr "diduga penspesifikasi deklarasi"
 msgid "no type or storage class may be specified here,"
 msgstr "kelas penyimpanan dispesifikasikan untuk %qs"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -55801,62 +55848,62 @@ msgstr "hilang atribut Code"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "Operator tidak dikenal '%s' di %%L"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<}%> before %<else%>"
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "diduga %<}%> sebelum %<else%>"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected %qE selector name"
 msgstr "diduga nama class"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma omp flush%> hanya mungkin digunakan dalam pernyataan compound"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma GCC pch_preprocess%> harus menjadi pertama"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp section%> hanya bisa digunakan dalam %<#pragma omp section%> konstruk"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> hanya bisa digunakan dalam %<#pragma omp section%> konstruk"
@@ -55867,13 +55914,13 @@ msgstr "%<#pragma omp section%> hanya bisa digunakan dalam %<#pragma omp section
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma omp flush%> hanya mungkin digunakan dalam pernyataan compound"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "for, while or do statement expected"
 msgstr "diduga pernyataan for"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> harus menjadi pertama"
@@ -55883,11 +55930,11 @@ msgstr "%<#pragma GCC pch_preprocess%> harus menjadi pertama"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "terlalu banyak %qs clauses"
@@ -55903,66 +55950,66 @@ msgstr "num_threads ekspresi harus integral"
 msgid "%qD is not a variable"
 msgstr "%qD bukan sebuah variabel"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qD is not a pointer variable"
 msgstr "%qD bukan sebuah variabel"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<none%> or %<present%>"
 msgstr "diduga %<none%> atau %<shared%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "diduga %<=%>, %<,%>, %<,%>, %<asm%> atau %<__attribute__%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant logical expression"
 msgstr "diduga ekspresi integer"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<data%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<if%> clauses"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<if%> clauses without modifier"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -55986,25 +56033,25 @@ msgstr "%<num_threads%> nilai harus positif"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<grainsize%> value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<priority%> value must be non-negative"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "diduga ekspresi integer"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, or %<||%>"
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
@@ -56016,112 +56063,112 @@ msgstr "diduga %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, atau %<||%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%qs expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%qs value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<static%> arguments"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected element"
 msgid "unexpected argument"
 msgstr "Elemen tidak diduga"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta integer"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<self%> clauses"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "diduga %<none%> atau %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<concurrent%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "ordered argument needs positive constant integer expression"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, or %<||%>"
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "diduga %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, atau %<||%>"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, fuzzy, gcc-internal-format
 #| msgid "both %<long%> and %<void%> in declaration specifiers"
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "baik %<long%> dan %<void%> dalam penspesifikasi deklarasi"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "jadwal %<runtime%> tidak mengambil sebuah parameter %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "penjadwalan %<auto%> tidak mengambil sebuah parameter %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "chunk size value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "jenis penjadwalan tidak valid"
@@ -56132,42 +56179,42 @@ msgstr "jenis penjadwalan tidak valid"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "diduga %<,%> atau %<,%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "%Hduplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "%Hduplikasi %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
@@ -56184,23 +56231,23 @@ msgstr "diduga %<}%> sebelum %<else%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "multiple inline callers"
 msgid "multiple linear modifiers"
 msgstr "multiple pemanggil inline"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr ""
@@ -56211,7 +56258,7 @@ msgstr ""
 msgid "%<linear%> clause step expression must be integral"
 msgstr "schedule chunk ukuran ekspresi harus integral"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -56228,342 +56275,342 @@ msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "assert: %s adalah assign kompatibel dengan %s"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid depend kind"
 msgstr "jenis penjadwalan tidak valid"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid doacross kind"
 msgstr "jenis penjadwalan tidak valid"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %<fallback%> modifier"
 msgstr "diduga %<(%> atau akhir dari baris"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<always%> modifiers"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<close%> modifiers"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "terlalu banyak berkas masukan"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "terlalu banyak berkas masukan"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "diduga pengidentifikasi atau %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "terlalu banyak berkas masukan"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid map kind"
 msgstr "topeng tidak valid"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "diduga %<none%> atau %<shared%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid dist_schedule kind"
 msgstr "jenis penjadwalan tidak valid"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid proc_bind kind"
 msgstr "jenis penjadwalan tidak valid"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "string literal lebar dalam %<asm%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "nama register: %s tidak dikenal"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "expected string literal or constant integer expression"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "diduga %<,%> atau %<,%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "diduga string literal"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "duplikasi %<restrict%>"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<target%> modifier"
 msgstr "duplikasi %<restrict%>"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "duplikasi %<restrict%>"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected an OpenACC clause"
 msgstr "diduga clause %<#pragma omp%>"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs tidak valid untuk %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 #| msgid "%qs must be used with %qs"
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs harus digunakan dengan %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected an OpenMP clause"
 msgstr "diduga clause %<#pragma omp%>"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<extern%> variable %q+D in %<for%> loop initial declaration"
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "deklarasi dari variabel %<extern%> %q+D dalam %<for> inisial deklarasi loop"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 #| msgid "expected a string after %<#pragma message%>"
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "diduga sebuah string setelah %<#pragma message%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -56580,7 +56627,7 @@ msgstr "%H%qE belum pernah dideklarasikan"
 msgid "expected function name"
 msgstr "diduga nama class"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qD does not refer to a function"
@@ -56591,23 +56638,23 @@ msgstr "%q+D bukan sebuah fungsi,"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma align%> harus muncul sebelum deklarasi dari %D, abaikan"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -56634,7 +56681,7 @@ msgstr ""
 msgid "modified here"
 msgstr "'E' pemodifikasi"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
@@ -56670,119 +56717,119 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "diduga %<:%>, %<,%>, %<,%>, %<}%> atau %<__attribute__%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many atomic clauses"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many memory order clauses"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr ""
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "diduga %<(%> atau akhir dari baris"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operator for %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "operator tidak valid untuk %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "unexpected %<else%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operator for %<#pragma omp atomic%>"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "operator tidak valid untuk %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operator for %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "operator tidak valid untuk %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "operator tidak valid untuk %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "%<depobj%> expression is not lvalue expression"
@@ -56794,30 +56841,30 @@ msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "diduga %<=%>, %<,%>, %<,%>, %<asm%> atau %<__attribute__%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "diduga %<=%>, %<,%>, %<,%>, %<asm%> atau %<__attribute__%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -56827,36 +56874,36 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "diduga %<(%> atau akhir dari baris"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp taskwait%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp taskwait%> hanya  boleh digunakan dalam pernyataan compound"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<}%> before %<else%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "diduga %<}%> sebelum %<else%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<#pragma omp scan%>"
 msgstr "diduga clause %<#pragma omp%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp taskwait%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp taskwait%> hanya  boleh digunakan dalam pernyataan compound"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "diduga pernyataan for"
@@ -56864,71 +56911,71 @@ msgstr "diduga pernyataan for"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "diduga pernyataan for"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "diduga iterasi deklarasi atau inisialisasi"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough perfectly nested loops"
 msgid "not enough nested loops"
 msgstr "tidak cukup secara sempurna nested loops"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "iterasi variabel %qD seharusnya bukan first private"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> hanya mungkin digunakan dalam pernyataan compound"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<for%> after %qs"
@@ -56940,7 +56987,7 @@ msgstr "diduga %<,%> atau %<,%>"
 msgid "expected a function name"
 msgstr "diduga nama class"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "Save registers around function calls"
 msgid "expected target-function call"
@@ -56951,48 +56998,48 @@ msgstr "Simpan register dalam pemanggilan fungsi"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<point%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -57008,63 +57055,63 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma align%> harus muncul sebelum deklarasi dari %D, abaikan"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "Expected attribute bit name"
 msgid "expected trait selector name"
 msgstr "Diduga nama atribut bit"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> hanya dapat dispesifikasikan didalam sebuah kelas"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "last argument must be an immediate"
 msgid "%<score%> argument must be non-negative"
 msgstr "argumen terakhir harus berupa sebuah immediate"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "diduga string literal"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be integer expression"
 msgstr "diduga ekspresi integer"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr ""
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected context selector set name"
@@ -57076,29 +57123,29 @@ msgstr "diduga nama class"
 msgid "variant %qD is not a function"
 msgstr "%q+D bukan sebuah fungsi,"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs declared as a function"
 msgid "variant %qD is the same as base function"
 msgstr "field %qs dideklarasikan sebagai sebuah fungsi"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<match%> clauses"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -57109,7 +57156,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr "%qT bukan sebuah penunjuk-ke-objek tipe"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -57121,18 +57168,18 @@ msgstr "diduga %<none%> atau %<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%H%qs tidak valid untuk %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<interop%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<match%> clause"
@@ -57154,13 +57201,13 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "fungsi nested %qs dideklarasikan %<extern%>"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 #| msgid "first argument of %q+D should be %<int%>"
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "argumen pertama dari %q+D seharusnya %<int%>"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr ""
@@ -57170,7 +57217,7 @@ msgstr ""
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "elements of array %q#D have incomplete type"
 msgid "variant %qD and base %qD have incompatible types"
@@ -57181,7 +57228,7 @@ msgstr "elemen dari array %q#D memiliki tipe tidak lengkap"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -57197,88 +57244,88 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr "implisit deklarasi dari fungsi %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "definisi fungsi tidak mendeklarasikan parameter"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<match%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "diduga %<none%> atau %<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr ""
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_options%>"
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma GCC pop_options%> tanpa sebuah %<#pragma GCC push_options%> yang berhubungan"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<declare%> or %<assumes%>"
@@ -57306,13 +57353,13 @@ msgstr "deklarasi dari %qD sebagai anggota dari %qT"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr ""
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "unexpected clause"
 msgstr "diduga nama class"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "missing open paren"
 msgid "missing %<map%> clause"
@@ -57376,33 +57423,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "diduga %<=%>, %<,%>, %<,%>, %<asm%> atau %<__attribute__%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "diduga %<=%>, %<,%>, %<,%>, %<asm%> atau %<__attribute__%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -57418,171 +57465,171 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "%qE memiliki tipe tidak valid untuk %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<sizes%>"
 msgstr "diduga %<{%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta integer"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %qs or %qs"
 msgstr "diduga %<,%> atau %<,%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> hanya mungkin digunakan dalam pernyataan compound"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected at least one assumption clause"
 msgstr "diduga clause %<#pragma omp%>"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected directive name"
 msgstr "diduga nama class"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown assumption clause %qs"
 msgstr "mode mesin %qs tidak dikenal"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected assumption clause"
 msgstr "diduga clause %<#pragma omp%>"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "nama register: %s tidak dikenal"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE dideklarasikan %<threadprivate%> setelah penggunaan pertama"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "variabel otomatis %qE tidak dapat berupa %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE memiliki tipe tidak lengkap"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -57592,7 +57639,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -57609,7 +57656,7 @@ msgstr "%Hparallel yang melingkupi"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD memiliki tipe tidak lengkap"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "penggunaan tidak valid dari ekspresi void"
@@ -57642,180 +57689,180 @@ msgstr "penggunaan tidak valid dari typedef tidak lengkap %qD"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "%qE atribut hanya berlaku untuk fungsi variadic"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "tipe fungsi tidak benar benar kompatibel dalam ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and vector types"
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "tidak dapat mencampurakan operan dari tipe desimal float dan vektor"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and complex types"
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "tidak dapat mencampurakan operan dari tipe desimal float dan kompleks"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and other float types"
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "tidak dapat mencampurkan operan dari tipe desimal float dan tipe lainnya"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "tipe tidak benar benar kompatibel"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "pointer target types incompatible in C++"
 msgstr "penunjuk ke anggota tipe %qT tidak kompatibel dengan tipe objek %qT"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "tipe kembali fungsi tidak kompatibel karena %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%Jinvalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "%J penggunaan tidak valid dari structure dengan anggota array fleksibel"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT tidak memiliki anggota bernama %qE"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT tidak memiliki anggota bernama %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "meminta untuk anggota %qE dalam sesuatu bukan sebuah struktur atau union"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "dereferensi penunjuk %<void *%>"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "nilai subscripted adalah bukan array ataupun penunjuk"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "array subscrip bukan sebuah integer"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "nilai subscripted adalah penunjuk ke fungsi"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "array subscrip bukan sebuah integer"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C melarang subscripting %<register%> array"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 melarang subscripting array bukan lvalue"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD dideklarasikan sebagai referensi tetapi tidak terinisialisasi"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object %qE is not a function or function pointer"
 msgstr "dipanggil objek %qE bukan sebuah fungsi"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object %qD is not a function or function pointer"
 msgstr "dipanggil objek %qE bukan sebuah fungsi"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object is not a function or function pointer"
@@ -57824,2021 +57871,2021 @@ msgstr "dipanggil objek %qE bukan sebuah fungsi"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "fungsi dipanggil melalui sebuah tipe tidak kompatibel"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 #| msgid "function definition has qualified void return type"
 msgid "function with qualified void return type called"
 msgstr "definisi fungsi memiliki pengkualifikasi tipe kembali void"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "tipe dari parameter format %d tidak lengkap"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai integer daripada pecahan karena ada prototipe"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai integer daripada kompleks kerana ada prototipe"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai kompleks daripada pecahan kerana ada prototipe"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai pecahan daripada integer karena ada prototipe"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai kompleks daripada integer karena ada prototipe"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai pecahan daripada kompleks karena ada prototipe"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai %<float%> daripada %<double%> karena adaprototipe"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai %qT daripada %qT karena ada prototipe"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "melewatkan argumen %d dari %qE dengan lebar berbeda karena ada prototipe"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai unsigned karena ada prototipe"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "melewatkan argumen %d dari %qE sebagai signed karena ada prototipe"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "terlalu banyak argumen ke fungsi %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "terlalu banyak argumen ke fungsi %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "terlalu banyak argumen ke fungsi %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "terlalu sediki argumen ke fungsi %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "terlalu sediki argumen ke fungsi %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "terlalu sediki argumen ke fungsi %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "perbandingan dengan string literal menghasilkan perilaku yang tidak dispesifikasikan"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "perbandingan diantara penunjuk dan integer"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "casting %qT to %qT does not dereference pointer"
 msgid "did you mean to dereference the pointer?"
 msgstr "casting %qT ke %qT tidak medereferensi penunjuk"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "zero as null pointer constant"
 msgstr "array bound bukan sebuah konstanta integer"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "comparison between %qT and %qT"
 msgstr "perbandingan antara %q#T dan %q#T"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "tipe dari penunjuk %<void *%> digunakan dalam pengurangan"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "penunjuk ke sebuah fungsi digunakan dalam pengurangan"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "aritmetik di penunjuk ke sebuah tipe tidak lengkap"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "aritmetik di penunjuk ke sebuah tipe tidak lengkap"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %qT from boolean expression"
 msgid "%<~%> on a boolean expression"
 msgstr "konversi ke %qT dari ekspresi boolean"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C tidak mendukung %<~%> untuk konjugasi kompleks"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "tipe argumen salah ke abs"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "tipe argumen salah ke unary exclamation mark"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %qT from boolean expression"
 msgid "increment of a boolean expression"
 msgstr "konversi ke %qT dari ekspresi boolean"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %qT from boolean expression"
 msgid "decrement of a boolean expression"
 msgstr "konversi ke %qT dari ekspresi boolean"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C tidak mendukung %<++%> dan %<--%> di tipe kompleks"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "tipe argumen salah ke peningkatan"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "tipe argumen salah ke pengurangan"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 #| msgid "cannot increment a pointer to incomplete type %qT"
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "tidak dapat meningkatkan sebuah penunjuk ke tipe tidak lengkap %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decrement a pointer to incomplete type %qT"
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "tidak dapat mengurangi penunjuk ke tipe tidak lengkap %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of expression of type %<void%>"
 msgstr "memakai alamat dari sementara"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "tidak dapat mengambil alamat dari bit-field %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "tidak dapat mengambil alamat dari %<this%>, yang merupakan ekspresi rvalue"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "alamat dari variabel register %qD diminta"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "alamat dari variabel register %qD diminta"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "variabel global register %qD digunakan dalam fungsi nested"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "variabel register %qD digunakan dalam fungsi nested"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "alamat dari variabel global register %qD diminta"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "alamat dari variabel register %qD diminta"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "array bukan lvalue dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral mismatch in conditional expression: %qT vs %qT"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "enumeral tidak cocok dalam ekspresi kondisional: %qT vs %qT"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C melarang kondisional ekspresi dengan hanya satu sisi void"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "tipe penunjuk tidak cocok dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "tipe penunjuk tidak cocok dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "tipe penunjuk tidak cocok dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C melarang kondisional ekpsresi diantara %<void *%> dan penunjuk fungsi"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "tipe penunjuk tidak cocok dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "Diduga tipe ekspresi"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "Diduga tipe ekspresi"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "tipe penunjuk/integer tidak cocok dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "tipe tidak cocok dalam ekspresi kondisional"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "%H mengabaikan nilai kembali dari %qD, dideklarasikan dengan atribut warn_unused_result"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "%H mengabaikan nilai kembali dari %qD, dideklarasikan dengan atribut warn_unused_result"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "%H mengabaikan nilai kembali dari %qD, dideklarasikan dengan atribut warn_unused_result"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "%H mengabaikan nilai kembali dari %qD, dideklarasikan dengan atribut warn_unused_result"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "in call to %qD, declared here"
 msgstr "  %q+#D dideklarasikan disini"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "operan tangan-kiri dari ekspresi koma tidak memiliki efek"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "right-hand operand of comma expression has no effect"
 msgstr "operan tangan-kiri dari ekspresi koma tidak memiliki efek"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 #| msgid "cast adds new qualifiers to function type"
 msgid "cast adds %q#v qualifier to function type"
 msgstr "cast menambahkan kualifier baru ke tipe fungsi"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "cast mengabaikan kualifier dari tipe target penunjuk"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "cast menspesifikasikan tipe array"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "cast menspesifikasikan tipe fungsi"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C melarang casting bukan skalar ke tipe yang sama"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "useless cast to type %qT"
 msgstr "cast ke fungsi tipe %qT tidak valid"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO melarang cast ke tipe union"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "cast ke tipe union dari tipe yang tidak ada dalam union"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "cast meningkatkan alignmen yang dibutuhkan dari tipe target"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "cast dari penunjuk ke integer dari ukuran berbeda"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "cast dari panggilan fungsi dari tipe %qT ke tipe yang tidak cocok %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "cast ke penunjuk dari integer dari ukuran yang berbeda"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C melarang konversi dari fungsi penunjuk ke tipe objek penunjuk"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C melarang konversi dari objek penunjuk ke tipe fungsi penunjuk"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 #| msgid "can't convert from incomplete type %qT to %qT"
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "tidak dapat mengubah dari tipe tidak lengkap %qT ke %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 #| msgid "assignment suppression"
 msgid "assignment to expression with array type"
 msgstr "penekanan penempatan"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(dekat inisialisasi untuk %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "array terinisialisasi dari konstanta string bertanda-petik"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "diduga %qT tetapi argumen memiliki tipe %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "built-in %qD declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "%q+D declared here"
 msgid "%e declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "target penunjuk dalam melewatkan argumen %d dari %qE berbeda dalam signedness"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "diduga %qT tetapi argumen memiliki tipe %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "implicit conversion from %qT to %qT"
 msgstr "konversi dari %qT ke %qT tidak valid"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 #| msgid "passing argument %d of %qE makes qualified function pointer from unqualified"
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "melewatkan argumen %d dari %qE membuat fungsi penunjuk terkualifikasi dari tidak terkualifikasi"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 #| msgid "assignment makes qualified function pointer from unqualified"
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "penempatan membuat fungsi penunjuk terkualifikasi dari tidak terkualifikasi"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 #| msgid "initialization makes qualified function pointer from unqualified"
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "inisialisasi membuat fungsi penunjuk terkualifikasi dari tidak terkualifikasi"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 #| msgid "return makes qualified function pointer from unqualified"
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "return membuat fungsi penunjuk terkualifikasi dari tidak terkualifikasi"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 #| msgid "passing argument %d of %qE discards qualifiers from pointer target type"
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "melewatkan argumen %d dari %qE mengabaikan pengkualifikasi dari tipe target penunjuk"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 #| msgid "assignment discards qualifiers from pointer target type"
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "penempatan mengabaikan pengkualifikasi dari tipe target penunjuk"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 #| msgid "initialization discards qualifiers from pointer target type"
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "inisialisasi mengabaikan pengkualifikasi dari tipe target penunjuk"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 #| msgid "return discards qualifiers from pointer target type"
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "return mengabaikan pengkualifikasi dari tipe target penunjuk"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C melarang konversi argumen ke tipe union"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "melewatkan argumen %d dari %qE dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "cast dari penunjuk ke integer dari ukuran berbeda"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, fuzzy, gcc-internal-format
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "inisialisasi dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "diduga %qT tetapi argumen memiliki tipe %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "argumen %d dari %qE mungkin menjadi sebuah kandidat untuk sebuah format atribut"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "penempatan sisi tangan-kiri mungkin menjadi sebuah kandidat untuk sebuah atribut format"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "inisialisasi sisi tangan kiri mungkin menjadi sebuah kandidat untuk sebuah format atribut"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "tipe kembali mungkin berupa sebuah kandidat untuk sebuah atribut format"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "melewatkan argumen %d dari %qE dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C melarang melewatkan argumen %d dari %qE diantara fungsi penunjuk dan %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C melarang penempatan diantara fungsi penunjuk dan %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C melarang inisialisasi diantara fungsi penunjuk dan %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C melarang kembali diantara fungsi penunjuk dan %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "target penunjuk dalam melewatkan argumen %d dari %qE berbeda dalam signedness"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "target penunjuk dalam assignmen berbeda dalam signedness"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in initialization differ in signedness"
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "target penunjuk dalam inisialisasi berbeda dalam signedness"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "target penunjuk dalam melewatkan argumen %d dari %qE berbeda dalam signedness"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "melewatkan argumen %d dari %qE dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "penempatan dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "penempatan dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "inisialisasi dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "inisialisasi dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "creating pointer to member function of non-class type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "membuat penunjuk ke anggota fungsi dari tipe bukan kelas %qT"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "return from incompatible pointer type"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "kembali dari tipe penunjuk yang tidak kompatibel"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "melewatkan argumen %d dari %qE membuat penunjuk dari integer tanpa sebuah cast"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes pointer from integer without a cast"
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "penempatan membuat penunjuk dari integer tanpa sebuah cast"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes pointer from integer without a cast"
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "inisialisasi membuat penunjuk dari integer tanpa sebuah cast"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "melewatkan argumen %d dari %qE membuat penunjuk dari integer tanpa sebuah cast"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "melewatkan argumen %d dari %qE membuat integer dari penunjuk tanpa sebuah cast"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes integer from pointer without a cast"
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "penempatan membuat integer dari penunjuk tanpa sebuah cast"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes integer from pointer without a cast"
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "inisialisasi membuat integer dari penunjuk tanpa sebuah cast"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "melewatkan argumen %d dari %qE membuat integer dari penunjuk tanpa sebuah cast"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "tipe tidak kompatibel untuk argumen %d dari %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "tipe tidak kompatibel dalam penempatan ke tipe %qT dari tipe %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "tipe tidak kompatibel ketika menginisialisasi tipe %qT menggunakan tipe %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "tipe tidak kompatibel ketika mengembalikan tipe %qT tetapi %qT telah diduga"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "tradisional C menolak inisialisasi otomatis bersama"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "inisialisasi dari sebuah anggota array fleksibel"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "inisialisasi-string untuk array dari karakter terlalu panjang"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "inisialisasi-string untuk array dari karakter terlalu panjang"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "array dari tipe yang tidak sesuai terinisialisasi dari konstanta string"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "penggunaan tidak valid dari bukan-lvalue array"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "penginisialisasi tidak valid"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "elemen penginisialisasi bukan sebuah konstanta"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "array terinisialisasi dari ekspresi array bukan-konstanta"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "initializer element is not a constant expression"
 msgstr "elemen penginisialisasi bukan sebuah konstanta"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "konversi dari %qT ke %qT mengabaikan kualifikasi"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "elemen penginisialisasi tidak dapat dihitung di waktu load"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "tipe vektor opaque tidak dapat diinisialisasi"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "kelebihan grup kurung diakhir dari penginisialisasi"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "kurung disekitar penginisialisasi skalar"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "inisialisasi dari anggota array fleksibel dalam sebuah konteks bertelur"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "hilang kurung disekitar penginisialisasi"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "missing initializer for field %qD of %qT"
 msgstr "hilang penginisialisasi untuk anggota %qD"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "kelebihan elemen dalam penginisialisasi skalar"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "indeks array dalam penginisialisasi bukan-array"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "nama bagian tidak dalam rekaman atau union penginisialisasi"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "indeks array dalam penginisialisasi bukan tipe integer"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer not of integer type"
 msgid "array index in initializer is not an integer constant expression"
 msgstr "indeks array dalam penginisialisasi bukan tipe integer"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "indeks array bukan konstan dalam penginisialisasi"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "indeks array dalam penginisialisasi melebihi batasan array"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "jangkauan indeks kosong dalam penginisialisasi"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "jangkauan indeks array dalam penginisialisasi melebihi batasan array"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "bagian terinisialisasi overwritten"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "bagian terinisialisasi dengan efek-samping overwritten"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, fuzzy, gcc-internal-format
 #| msgid "Perform conversions of switch initializations."
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "Lakukan konversi dari kondisional switch."
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "kelebihan elemen dalam penginisialisasi union"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "kelebihan elemen dalam struktur penginisialisasi"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "inisialisasi tidak statis dari sebuah anggota array fleksibel"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "kelebihan elemen dalam penginisialisasi union"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "tradisional C menolah inisialisasi dari unions"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "kelebihan elemen dalam array penginisialisasi"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "kelebihan elemen dalam penginisialisasi vektor"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "kelebihan elemen dalam penginisialisasi skalar"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C tidak mengijinkan kelebihan %<;%> diluar dari sebuah fungsi"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in output operand outside of a function"
 msgstr "tipe ukuran variabel dideklarasikan diluar dari fungsi apapun"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "keluaran operan %d harus menggunakan batasan %<&%>"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "label %qE referenced outside of any function"
 msgid "%<-%> modifier used inside of a function"
 msgstr "label %qE direferensikan diluar dari fungsi apapun"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in input operand outside of a function"
 msgstr "tipe ukuran variabel dideklarasikan diluar dari fungsi apapun"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD tidak didefinisikan diluar dari jangkauan fungsi"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C melarang %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "computed goto must be pointer type"
 msgstr "tidak dapat mengubah ke sebuah tipe penunjuk"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "fungsi dideklarasikan %<noreturn%> memiliki sebuah pernyataan %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> dengan tidak ada nilai, dalam fungsi mengembalikan bukan void"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> dengan sebuah nilai, dalam fungsi mengembalikan void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C melarang %<return%> dengan ekspresi, dalam fungsi mengembalikan void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of label"
 msgstr "fungsi mengembalikan alamat dari variabel lokal"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "fungsi mengembalikan alamat dari variabel lokal"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch kuantiti bukan sebuah integer"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "pilihan %<long%> ekspresi tidak diubah ke %<int%> dalam ISO C"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "case label is not an integer constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "label case tidak dalam label pernyataan switch"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "%<default%> label tidak dalam sebuah pernyataan switch"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "pernyataan break tidak dalam loop atau switch"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "exit tidak valid dari blok struktur OpenMP"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "pernyataan break digunakan dengan OpenMP untuk loop"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "pernyataan continue tidak dalam sebuah loop"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "pernyataan dengan tidak ada efek"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "ekspresi pernyataan memiliki tipe tidak lengkap"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about comparison of different enum types"
 msgid "comparing vectors with different element types"
 msgstr "Peringatkan mengenai perbandingan dari tipe enum yang berbeda"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "perbandingan diantara tipe %qT dan %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "membandingkan titik pecahan dengan == atau != adalah tidak aman"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "perbandingan dari tipe penunjuk berbeda kurang sebuah cast"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C melarang perbandingan dari %<void *%> dengan fungsi penunjuk"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "perbandingan dari tipe penunjuk berbeda kurang sebuah cast"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "perbandingan diantara penunjuk dan integer"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "perbandingan dari penunjuk lengkap dan tidak lengkap"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C melarang perbandingan terurut dari penunjuk ke fungsi"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with null pointer"
 msgstr "perbandingan terurut dari penunjuk dengan integer nol"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "perbandingan terurut dari penunjuk dengan integer nol"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "menggunakan array yang tidak dapat diubah ke penunjuk dimana skalar dibutuhkan"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "menggunakan nilai tipe struct dimana skalar dibutuhkan"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "menggunaka nilai tipe union dimana skalar dibutuhkan"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "used vector type where scalar is required"
 msgstr "menggunakan nilai tipe struct dimana skalar dibutuhkan"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "diduga clause %<#pragma omp%>"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 #| msgid "%Htoo many %qs clauses"
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%Hterlalu banyak %qs clauses"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "low bound %qE of array section does not have integral type"
 msgstr "ukuran dalam array baru harus memiliki tipe integral"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "length %qE of array section does not have integral type"
 msgstr "ukuran dalam array baru harus memiliki tipe integral"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected single pointer in %qs clause"
 msgstr "diduga string literal"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array %qs is used"
 msgid "zero length array section in %qs clause"
 msgstr "array dengan panjang bervariabel %qs digunakan"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array %qs is used"
 msgid "negative length in array section in %qs clause"
 msgstr "array dengan panjang bervariabel %qs digunakan"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, fuzzy, gcc-internal-format
 #| msgid "Copy array sections into a contiguous block on procedure entry"
 msgid "array section is not contiguous in %qs clause"
 msgstr "Salin bagian array kedalam sebuah blok kontinu dalam masukan prosedur"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE does not have class type"
 msgid "%qE does not have pointer or array type"
 msgstr "%H%qE tidak memiliki tipe kelas"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "melemparkan KOSONG, yang memiliki integral, bukan tipe penunjuk"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qs has invalid type"
 msgid "iterator %qD has const qualified type"
 msgstr "bit-field %qs memiliki tipe tidak valid"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "bit-field %qD dengan tipe bukan integral"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected pointer in %qs clause"
 msgstr "diduga clause %<#pragma omp%>"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in %s clause at %L"
 msgid "zero sized type %qT in %qs clause"
 msgstr "Ukuran array yang diasumsikan '%s' dalam %s clause di %L"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array %qs is used"
 msgid "variable sized type %qT in %qs clause"
 msgstr "array dengan panjang bervariabel %qs digunakan"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE memiliki tipe tidak valid untuk %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "array dengan panjang bervariabel digunakan"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE harus berupa %<threadprivate%> untuk %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE muncul lebih dari sekali dalam clause data"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE bukan sebuah variabel dalam clause %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE bukan sebuah variabel dalam clause %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "tipe dari vektor delete bukan penunjuk ataupun tipe array"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE muncul lebih dari sekali dalam clause data"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE muncul lebih dari sekali dalam clause data"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE muncul lebih dari sekali dalam clause data"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "Nama '%s' tidak dapat digunakan sebagai sebuah operator terdefinisi di %C"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "array must be initialized with a brace-enclosed initializer"
 msgid "traits array must be initialized with constants"
 msgstr "array harus diinisialisasi dengan sebuah kurung melingkupi penginisialisasi"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression in array specification at %C"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "Diduga ekspresi dalam spesifikasi array di %C"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported map expression %qE"
 msgstr "kombinasi tidak didukung: %s"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE muncul lebih dari sekali dalam clause data"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "%s variable %qs is private in outer context"
 msgid "%qs variable is not a pointer"
 msgstr "%s variabel %qs private dalam konteks luar"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "tipe dari vektor delete bukan penunjuk ataupun tipe array"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %qs clauses on a task construct"
 msgstr "terlalu banyak %qs clauses"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD harus mengambil %<void%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qD shall not be const"
 msgstr "%q+D bukan sebuah fungsi,"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE adalah predetermined %qs untuk %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "argumen pertama ke %<va_arg%> bukan dari tipe %<va_list%>"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "argumen pertama ke %<va_arg%> bukan dari tipe %<va_list%>"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "argumen pertama ke %<va_arg%> bukan dari tipe %<va_list%>"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -60142,258 +60189,253 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: invalid file name: %s\n"
 msgid "%s: Invalid field type %s:"
 msgstr "%s: nama berkas tidak valid: %s\n"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "invalid GIMPLE statement"
 msgid "Not valid for ACCEPT statement."
 msgstr "pernyataan GIMPLE tidak valid"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "invalid GIMPLE statement"
 msgid "Not valid for DISPLAY statement."
 msgstr "pernyataan GIMPLE tidak valid"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr ""
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT meresolf ke %qT, yang bukan sebuah tipe class"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -60402,75 +60444,85 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "tipe deklarasi turunan"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unknown dest"
 msgid "Unknown type %d"
 msgstr "Tidak diketahui dest"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "Attempting an assignment of differing types."
 msgstr "target penunjuk dalam assignmen berbeda dalam signedness"
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr ""
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -60480,13 +60532,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "terlalu banyak berkas masukan"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr ""
@@ -60502,68 +60554,68 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr "%s: %s keluar dengan status %d\n"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: wait: %s\n"
 msgid "%s: data item %s #"
 msgstr "%s: tunggu: %s\n"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mask must be an immediate"
 msgid "%s: key must be field"
 msgstr "mask harus berupa sebuah immediate"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "spec '%s' has invalid '%%W%c"
 msgid "%s: %s %s has invalid encoding"
 msgstr "spesifikasi '%s' memiliki '%%W%c' tidak valid"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: would convert file '%s'\n"
 msgid "%s:%d: could not add '%s'"
 msgstr "%s: akan mengubah berkas '%s'\n"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "(%s %s %s %s %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "(%s %s %s %s %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "(%s %s %s %s %s"
 msgid "%s: nbytes %lu %s %lu"
 msgstr "(%s %s %s %s %s"
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling '%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s: mengkompile '%s'\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -61052,7 +61104,7 @@ msgstr "tidak cocok %<operator %s%> untuk %qT"
 msgid "%q#D is private within this context"
 msgstr "dalam konteks ini"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "declared private here"
@@ -61064,7 +61116,7 @@ msgstr "%q+D dideklarasikan disini"
 msgid "%q#D is protected within this context"
 msgstr "dalam konteks ini"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "declared protected here"
@@ -61428,7 +61480,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr "konstruktor tidak dapat dideklarasikan virtual"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI"
@@ -61451,7 +61503,7 @@ msgstr "tidak pasangan fungsi untuk panggilan ke %<%T::%s(%A)%#V%>"
 msgid "call to non-function %qD"
 msgstr "panggilan ke bukan-fungsi %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -62119,7 +62171,7 @@ msgstr "%J anggota array fleksibel dalam sebaliknya struct kosong"
 msgid "next member %q#D declared here"
 msgstr "  %q+#D dideklarasikan disini"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "redefinisi dari %q#T"
@@ -62129,7 +62181,7 @@ msgstr "redefinisi dari %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -62270,7 +62322,7 @@ msgstr "tipe kembali abstrak tidak valid untuk fungsi %q+#D"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
@@ -62324,7 +62376,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -62361,341 +62413,341 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "%H eksepsi dari tipe %qT tidak akan ditangkap"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qD tidak boleh memiliki argumen dengan jumlah bervariabel"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D dideklarasikan dengan spesifikasi eksepsi"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "ekspresi integral %qE bukan konstan"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D dideklarasikan dengan spesifikasi eksepsi"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s tidak mendukung %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr ""
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<va_start%>"
 msgid "wrong number of arguments to %qs call"
 msgstr "jumlah dari argumen ke fungsi %<va_start%> salah"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma message: %s"
 msgid "constexpr message: %.*s"
 msgstr "pesan #pragma: %s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%q+E is not a constant expression"
 msgstr "%s tidak dapat muncul dalam sebuah konstanta ekspresi"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "panggilan ke bukan-fungsi %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer"
 msgstr "dereferensi penunjuk %<void *%>"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to internal function %qE"
 msgstr "panggilan ke bukan-fungsi %qD"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr ""
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "tipe %qT bukan sebuah basis tipe untuk tipe %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr ""
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an ambiguous base of %qT"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT adalah sebuah dasar ambigu dari %qT"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "tidak dapat memanggil anggota fungsi %qD tanpa objek"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "tidak dapat menjalankan '%s': %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr ""
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "operan 'o' bukan sebuah konstanta"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr ""
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, fuzzy, gcc-internal-format
 #| msgid "Attempting to allocate already allocatedarray"
 msgid "deallocation of already deallocated storage"
 msgstr "Mencoba untuk mengalokasikan array yang telah dialokasikan"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "deklarasi dari %qD membayangi sebuah lokal sebelumnya"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 #| msgid "PARAMETER '%s' is used at %L before its definition is complete"
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "PARAMTER '%s' digunakan di %L sebelum definisinya lengkap"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD called in a constant expression"
 msgstr "%qD tidak dapat muncul dalam sebuah ekspresi konstan"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D was used with no prototype before its definition"
 msgid "%qD used before its definition"
 msgstr "%q+D telah digunakan dengan tidak ada prototipe sebelum definisinya"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, fuzzy, gcc-internal-format
 #| msgid "protocol %qs has circular dependency"
 msgid "call has circular dependency"
 msgstr "protokol %qs memiliki ketergantungan circular"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "kedalaman template instantiation melebihi maksimal dari %d (gunakan -ftemplate-depth-NN untuk meningkatkan maksimal) instantiating %qD"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "reference to %qD is not a constant expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "overflow dalam konstanta ekspresi"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is negative"
 msgstr "jumlah geser kanan negatif"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "operan tangan-kiri dari ekspresi koma tidak memiliki efek"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "shift expression %q+E overflows"
 msgstr "ekspresi integral %qE bukan konstan"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 #| msgid "%Harray subscript is outside array bounds"
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "%H array subscript diluar dari cakupan array"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 #| msgid "%Harray subscript is outside array bounds"
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "%H array subscript diluar dari cakupan array"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized array element"
 msgstr "hilang penginisialisasi untuk anggota %qD"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "dereferensi penunjuk %<void *%>"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
@@ -62703,581 +62755,581 @@ msgstr "dereferensi penunjuk %<void *%>"
 msgid "%qE is not a constant expression"
 msgstr "%s tidak dapat muncul dalam sebuah konstanta ekspresi"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%qD tidak dapat muncul dalam sebuah ekspresi konstan"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized member %qD"
 msgstr "hilang penginisialisasi untuk anggota %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT karena ini adalah sebuah penunjuk"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "parameter template %qD dari tipe %qT tidak diijinkan dalam sebuah ekspresi konstanta integral karena ini bukan tipe integral atau enumerasi"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%s tidak digunakan dalam asm disini"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qT object created here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q#D declared here"
 msgstr "%q+D dideklarasikan disini"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "allocated here"
 msgstr "dipanggil dari sini"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not initialized"
 msgid "%qD used in its own initializer"
 msgstr "%qE tidak terinisialisasi"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%q#D is not const"
 msgstr "%q#T bukan sebuah kelas"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D is private"
 msgid "%q#D is volatile"
 msgstr "%q+#D adalah private"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD tidak dapat muncul dalam sebuah ekspresi konstan"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD belum pernah dideklarasikan dalam lingkup ini"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 #| msgid "%Hexpression in new-declarator must have integral or enumeration type"
 msgid "%qD does not have integral or enumeration type"
 msgstr "%Hekspresi dalam pendeklarasi new harus memiliki integral atau tipe enumerasi"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "deklarasi dari %q#D diluar dari kelas bukan sebuah definisi"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "inline assembly is not a constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "penggunaan tidak valid dari %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D dideklarasikan dengan spesifikasi eksepsi"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral and non-enumeral type in conditional expression"
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "tipe enumeral dan bukan enumeral dalam ekspresi kondisional"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "%s tidak dapat muncul dalam sebuah konstanta ekspresi"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 #| msgid "cast from type %qT to type %qT casts away constness"
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "cast dari tipe %qT ke tipe %qT menghilangkan constness"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "parameter template %qD dari tipe %qT tidak diijinkan dalam sebuah ekspresi konstanta integral karena ini bukan tipe integral atau enumerasi"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr ""
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr ""
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%s tidak dapat muncul dalam sebuah konstanta ekspresi"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "expression %qE is not a constant expression"
 msgstr "ekspresi integral %qE bukan konstan"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "%<goto%> is not a constant expression"
 msgstr "overflow dalam konstanta ekspresi"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "statement is not a constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unexpected expression %qE of kind %s"
 msgstr "diduga ekspresi"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "operan 'B' bukan sebuah konstanta"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "contract predicate is false in constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "%Hbreak statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "%Hpernyataan break tidak dalam loop atau switch"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcontinue statement not within a loop"
 msgid "%<continue%> outside of a loop"
 msgstr "%Hpernyataan continue tidak dalam sebuah loop"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "%Jjump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "%J lompat ke pernyataan ekspresi"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "cast tidak valid dari sebuah ekspresi rvalue dari tipe %qT ke tipe %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from type %qT to type %qT casts away constness"
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "reinterpret_cast dari tipe %qT ke tipe %qT menghilangkan constness"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "fungsi virtual tidak dapat menjadi friend"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "division by zero is not a constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "%<delete[]%> is not a constant expression"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "overflow dalam konstanta ekspresi"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "non-constant array initialization"
 msgstr "indeks array bukan konstan dalam penginisialisasi"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected end of file in '%s'"
 msgid "unexpected AST of kind %s"
@@ -63424,410 +63476,410 @@ msgstr "operan tidak valid dalam instruksi"
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD bukan sebuah variabel"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not nothrow default constructible"
 msgstr "tipe %qs tidak memiliki konstruktor baku untuk memanggil"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qD bukan sebuah variabel"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not trivially default constructible"
 msgstr "tipe %qs tidak memiliki konstruktor baku untuk memanggil"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qT is not trivially copy constructible"
 msgstr "%qs bukan sebuah berkas keluaran yang valid"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qT is not trivially destructible"
 msgstr "%qs bukan sebuah berkas keluaran yang valid"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr ""
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "base class %q#T has a non-virtual destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "kelas dasar %q#T memiliki desktruktor tidak virtual"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an abstract class"
 msgstr "%q#T bukan sebuah kelas"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an aggregate"
 msgstr "%qT bukan sebuah tipe kumpulan"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an array"
 msgstr "%qT bukan sebuah tipe kumpulan"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT bukan sebuah basis dari %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a bounded array"
 msgstr "%qT bukan sebuah namespace"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T bukan sebuah kelas"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a const type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not default constructible, because"
 msgstr "tipe %qs tidak memiliki konstruktor baku untuk memanggil"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D hides constructor for %q#T"
 msgid "%qT is not constructible from %qT, because"
 msgstr "%q#D menyembunyikan konstruktor untuk %q#T"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not destructible, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an empty class"
 msgstr "%q#T bukan sebuah kelas"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT mungkin bukan sebuah template"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a final class"
 msgstr "%q#T bukan sebuah kelas"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qT is not a function"
 msgstr "%q+D bukan sebuah fungsi,"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not invocable, because"
 msgstr "%q#T bukan sebuah kelas"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qT bukan sebuah basis dari %qT"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a literal type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD bukan sebuah anggota dari fungsi template"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT bukan sebuah anggota dari %qT"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT bukan sebuah anggota dari %qT"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "tipe %qs tidak memiliki konstruktor baku untuk memanggil"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT bukan sebuah penunjuk-ke-objek tipe"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a POD type"
 msgstr "%qD bukan sebuah tipe"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not a pointer"
 msgstr "%qT mungkin bukan sebuah template"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT bukan sebuah namespace"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT bukan sebuah basis dari %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "%qT bukan sebuah namespace"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a trivial type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not trivially copyable"
 msgstr "%qT mungkin bukan sebuah template"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not trivially destructible, because"
 msgstr "%qT bukan sebuah dasar yang bisa diakses dari %qT"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an unbounded array"
 msgstr "%qT bukan sebuah tipe kumpulan"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qT is not a union"
 msgstr "%q+D bukan sebuah fungsi,"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT bukan sebuah basis dari %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
-msgid "%qT is not consteval-only"
+msgid "%qT is not a structural type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "%q+#D tidak dapat dideklarasikan"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not destructurable"
 msgstr "%qD bukan sebuah variabel"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not declared in %qD"
 msgid "%qD is not deducible from %qT"
 msgstr "%qD tidak dideklarasikan dalam %qD"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid constraints"
 msgstr "batasan untuk operan tidak valid"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "alamat dari %qD akan selalu dievaluasi sebagai %<true%>"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "trampolines not supported"
 msgid "constraints not satisfied"
 msgstr "trampolines tidak didukung"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -63862,52 +63914,52 @@ msgstr "deklarasi asm diabaikan karena konflik dengan pengubahan nama sebelumnya
 msgid "previous declaration with fewer contracts here"
 msgstr "deklarasi sebelumnya dari %q+D ada disini"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "parameter declared %<auto%>"
 msgid "parameter declared here"
 msgstr "parameter dideklarasikan %<auto%>"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "deklarasi dari %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "first declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "constructor does not return a value to test"
 msgstr "Fungsi tidak mengembalikan sebuah nilai"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "destructor does not return a value to test"
 msgstr "Fungsi tidak mengembalikan sebuah nilai"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "function does not return a value to test"
@@ -63984,7 +64036,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "no member named %qE in %qT"
@@ -64068,91 +64120,91 @@ msgstr "tipe kualifikasi %qT tidak cocok dengan nama destruktor ~%qT"
 msgid "awaitable type %qT is not a structure"
 msgstr "tipe kualifikasi %qT tidak cocok dengan nama destruktor ~%qT"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%s tidak digunakan dalam asm disini"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "fungsi dideklarasikan %<noreturn%> memiliki sebuah pernyataan %<return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "argumen ketiga ke %<__builtin_prefetch%> harus berupa sebuah konstan"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "argumen ketiga ke %<__builtin_prefetch%> harus berupa sebuah konstan"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %q+D"
 msgid "no suspend point info for %qD"
 msgstr "tidak ada prototipe sebelumnya untuk %q+D"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "duplikasi %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "penunjuk tidak diijinkan sebagai nilai case"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array %qs is used"
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "array dengan panjang bervariabel %qs digunakan"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -64179,77 +64231,83 @@ msgstr "%qD bukan sebuah fungsi template"
 msgid "%qs used outside of constant expressions"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declaration specifiers"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "diduga penspesifikasi deklarasi"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static member function %qD"
 msgid "taking address of an immediate function %qD"
 msgstr "penggunaan tidak valid dari anggota fungsi %qD bukan statis"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "alamat dari %qD akan selalu dievaluasi sebagai %<true%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "mengabaikan atribut yang diaplikasikan ke %qT setelah definisi"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qs attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "argumen dari atribut %qs tidak valid"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "%Hparse error in template argument list"
 msgid "use fold expression in the attribute argument instead"
 msgstr "%Hparse error dalam daftar argumen template"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD bukan sebuah tipe"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qD is not a class type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE does not have class type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "%H%qE tidak memiliki tipe kelas"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE does not have class type"
 msgid "%qD does not have integral type"
 msgstr "%H%qE tidak memiliki tipe kelas"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -64302,7 +64360,7 @@ msgstr "inisialisasi dari referensi bukan const dari tipe %qT dari sebuah tipe s
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "konversi dari %qT ke %qT mengabaikan kualifikasi"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "casting %qT ke %qT tidak medereferensi penunjuk"
@@ -64739,7 +64797,7 @@ msgstr "dari deklarasi sebelumnya %q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "deklarasi friend %qD dalam kelas lokal tanpa deklarasi sebelumnya"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D"
 msgid "previous declaration %qD"
@@ -64994,13 +65052,13 @@ msgstr "argumen baku diberikan untuk parameter %d dari %q#D"
 msgid "previous specification in %q#D here"
 msgstr "setelah spesifikasi sebelumnya dalam %q+#D"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "konflik deklarasi %q#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr ""
@@ -65227,7 +65285,7 @@ msgstr "  melewati inisialisasi dari %q+#D"
 msgid "  enters %<template for%> statement"
 msgstr "diduga deklarasi atau pernyataan"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -65278,596 +65336,596 @@ msgstr "%<typename %T::%D%> nama %q#T, yang bukan sebuah tipe"
 msgid "template parameters do not match template %qD"
 msgstr "parameter template tidak cocok dengan template"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "alignmen yang diminta bukan kelipatan dari 2"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D invalid; an anonymous union can only have non-static data members"
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q+#D tidak valid; sebuah anonymous union hanya dapat mempunnya anggota data tidak statis"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "anonymous struct tidak didalam tipe bernama"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "anggota %q+#D dengan konstruktor tidak diijinkan dalam kumpulan anonymous"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "anggota %q+#D dengan desktruktor tidak diijinkan dalam kumpulan anoymous"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "anggota %q+#D dengan operator penempatan salin tidak diperbolehkan dalam kumpulan anonymous"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attribute ignored in declaration of %q#T"
 msgstr "atribut diabaikan dalam deklarasi dari %q+#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, fuzzy, gcc-internal-format
 #| msgid "attribute for %q+#T must follow the %qs keyword"
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "atribut untuk %q+#T harus mengikuti kata kunci %qs"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "multiple tipe dalam satu deklarasi"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "redeklarasi dari C++ tipe bawaan %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%qs hanya dapat dispesifikasikan untuk fungsi"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "hilang nama-tipe dalam typedef-deklarasi"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ menghambat struct anonymous"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "%qs hanya dapat dispesifikasikan untuk fungsi"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%qs hanya dapat dispesifikasikan untuk fungsi"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> hanya dapat dispesifikasikan didalam sebuah kelas"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> hanya dapat dispesifikasikan untuk konstruktor"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "sebuah kelas penyimpanan hanya dapat dispesifikasikan untuk objek dan fungsi"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "kualifier hanya dapat dispesifikasikan untuk objek dan fungsi"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "kualifier hanya dapat dispesifikasikan untuk objek dan fungsi"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "kualifier hanya dapat dispesifikasikan untuk objek dan fungsi"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "a storage class can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "sebuah kelas penyimpanan hanya dapat dispesifikasikan untuk objek dan fungsi"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> telah diabaikan dalam deklarasi ini"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qs cannot be used for type declarations"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "atribut diabaikan di template instantiation"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "%qE atribut hanya dapat diaplikasikan ke definisi class"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
 msgid "attribute ignored"
 msgstr "%qE atribut diabaikan"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "mengabaikan atribut yang diaplikasikan ke tipe kelas %qT diluar dari definisi"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "mengabaikan atribut yang diaplikasikan ke tipe dependen %qT tanpa sebuah deklarasi yang berasosiasi"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %qD is initialized (use decltype instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD diinisialisasi (lebih baik gunakan decltype)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "deklarasi dari %q#D memiliki %<extern%> dan terinisialisasi"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "definisi dari %q#D ditandai %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q#D bukan sebuah anggota data bukan-statis dari %qT"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member-template declaration of %qD"
 msgstr "template deklarasi dari %q#D"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member template declaration %qD"
 msgid "does not match member template declaration here"
 msgstr "deklarasi anggota template %qD tidak valid"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ tidak mengijinkan %<%T::%D%> untuk didefinisikan sebagai %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "duplikasi inisialisasi dari %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "deklarasi dari %q#D diluar dari kelas bukan sebuah definisi"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "variabel %q#D memiliki penginisialisasi tetapi tipe tidak lengkap"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "elemen dari array %q#D memiliki tipe tidak lengkap"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "kumpulan %q#D memiliki tipe tidak lengkap dan tidak dapat didefinisikan"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD dideklarasikan sebagai referensi tetapi tidak terinisialisasi"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "nama digunakan dalam sebuah gaya GNU diperuntukan penginisialisasi untuk sebuah array"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "nama %qD digunakan dalam sebuah gaya GNU didesign penginisialisasi untuk sebuah array"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "bukan trivial designated penginisialisasi tidak didukung"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "penginisialisasi gagal untuk menentukan ukuran dari %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "ukuran array hilang dalam %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "array berukuran-nol %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of %q+D isn%'t known"
 msgid "storage size of %qD isn%'t known"
 msgstr "ukuran penyimpanan dari %q+D tidak diketahui"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of %q+D isn%'t constant"
 msgid "storage size of %qD isn%'t constant"
 msgstr "ukuran penyimpanan dari %q+D bukan konstant"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "maaf: semantik dari fungsi inline data statis %q+#D salah (anda akan berputar putar dengan beberap salinan)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "maaf: semantik dari fungsi inline data statis %q+#D salah (anda akan berputar putar dengan beberap salinan)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 #| msgid "%J  you can work around this by removing the initializer"
 msgid "you can work around this by removing the initializer"
 msgstr "%J  anda dapat memperbaiki ini dengan menghapus penginisialisasi"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "tidak terinisialisasi const %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "variabel register %qD digunakan dalam fungsi nested"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 #| msgid "%Juninitialized member %qD with %<const%> type %qT"
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "%J anggota tidak terinisialisasi %qD dengan %<const%> tipe %qT"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has a user-defined constructor"
 msgid "%q#T has no user-provided default constructor"
 msgstr "tipe %qs memiliki sebuah konstruktor yang didefinisikan pengguna"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "tipe tidak valid %qT sebagai penginisialisasi untuk sebuah vektor dari tipe %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "penginisialisasi untuk %qT harus berupa kurung dilingkupi"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, fuzzy, gcc-internal-format
 #| msgid "name %qD used in a GNU-style designated initializer for an array"
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "nama %qD digunakan dalam sebuah gaya GNU didesign penginisialisasi untuk sebuah array"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "permintaan untuk anggota %qD adalah ambigu"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT memiliki anggota data tidak statis bernama %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD bukan sebuah anggota dari %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer for %q#D"
 msgstr "penginisialisasi tidak valid"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "terlalu banyak penginisialisasi untuk %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "kurung disekitar penginisialisasi skalar untuk tipe %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "kurung disekitar penginisialisasi skalar untuk tipe %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "hilang kurung diantara penginisialisasi untuk %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %P has incomplete type %qT"
 msgid "structured binding has incomplete type %qT"
 msgstr "parameter %P memiliki tipe tidak lengkap %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "elemen dari array %q#T memiliki tipe tidak lengkap"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "ukuran-variabel compound literals"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has incomplete type"
 msgid "%q#D has incomplete type"
 msgstr "%qD memiliki tipe tidak lengkap"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "objek skalar %qD membutuhkan satu elemen dalam penginisialisasi"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "dalam C++98 %qD harus diinisialisasi dengan konstruktor, bukan dengan %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "array %qD diinisialisasi dengan tanda kurung string literal %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "penginisialisasi tidak valid untuk anggota statis  dengan konstruktor"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "ISO C++ melarang dalam kelas inisialisasi dari anggota statis bukan const %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "ISO C++ melarang dalam kelas inisialisasi dari anggota statis bukan const %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(diluar dari kelas inisialisasi dibutuhkan)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "alamat dari variabel eksplisit register %qD diminta"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD is initialized"
 msgid "reference %qD is initialized with itself"
 msgstr "parameter %qD dinisialisasi"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "Aktual argumen untuk '%s' harus berupa sebuah penunjuk di %L"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "could not find variant declaration"
 msgstr "%<[*]%> tidak dalam sebuah deklarasi"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "redeklarasi dari enumerator %q+D"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "%<declare variant%> on destructor %qD"
 msgstr "redeklarasi dari enumerator %q+D"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "deklarasi dari template %q#D"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "%<declare variant%> on deleted %qD"
 msgstr "deklarasi dari template %q#D"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%<declare variant%> on virtual %qD"
 msgstr "%qD dideklarasikan sebagai sebuah %<virtual%> %s"
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "penempatan (tidak terinisialisasi) dalam deklarasi"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ tidak mengijinkan designated penginisialisasi"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %qs"
 msgid "%<register%> storage class specifier used"
 msgstr "kelas penyimpanan dispesifikasikan untuk %qs"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "deklarasi dari %q#D tidak memiliki penginisialisasi"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -65875,131 +65933,131 @@ msgstr "tipe kembali %q#T tidak lengkap"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be defaulted"
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD tidak dapat dibakukan"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "membayangi tipe deklarasi sebelumnya dari %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr ""
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "fungsi %q#D telah dinisialisasi seperti sebuah variabel"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decompose address"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "tidak dapat menguraikan alamat"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "lambda declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at %q+D because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "  tidak dapat menggunakan obsolete binding di %q+D karena ini memiliki sebuah desktruktor"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an inaccessible base of %qT"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "%qT adalah sebuah dasar tidak dapat diakses dari %qT"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT bukan sebuah nested class dari %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 #| msgid "cannot increment a pointer to incomplete type %qT"
 msgid "structured binding refers to incomplete type %qT"
 msgstr "tidak dapat meningkatkan sebuah penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD includes %s to array of unknown bound %qT"
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "parameter %qD includes %s ke array dari ikatan tidak dikenal %qT"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable length array %qs"
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 melarang array dengan panjang bervariabel %qs"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot decompose variable length vector %qT"
 msgstr "tidak dapat mendeklarasikan penunjuk ke %q#T"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %s to qualified function type %qT"
 msgid "cannot decompose union type %qT"
 msgstr "tidak dapat mendeklarasikan %s untuk fungsi yang dikualifikasikan dengan tipe %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "membuat penunjuk ke anggota dari tipe bukan kelas %qT"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "cannot increment a pointer to incomplete type %qT"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "tidak dapat meningkatkan sebuah penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Hinitializer provided for function"
 msgid "%u name provided for structured binding"
@@ -66007,1928 +66065,1939 @@ msgid_plural "%u names provided for structured binding"
 msgstr[0] "%Hpenginisialisasi disediakan untuk fungsi"
 msgstr[1] "%Hpenginisialisasi disediakan untuk fungsi"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr ""
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 #| msgid "initialization string truncated to match variable at %L"
 msgid "in initialization of structured binding variable %qD"
 msgstr "inisialisasi dari string terpotong untuk mencocokan dengan variabel di %L"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to static data member %qD"
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "tidak dapat menjalankan %<offsetof%> ke anggota data statis %qD"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 #| msgid "initializer fails to determine size of %qD"
 msgid "initializer fails to determine size of %qT"
 msgstr "penginisialisasi gagal untuk menentukan ukuran dari %qD"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 #| msgid "array size missing in %qD"
 msgid "array size missing in %qT"
 msgstr "ukuran array hilang dalam %qD"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 #| msgid "zero-size array %qD"
 msgid "zero-size array %qT"
 msgstr "array berukuran-nol %qD"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "desktruktor untuk alien kelas %qT tidak dapat berupa sebuah anggota"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "konstruktor untuk alien kelas %qT tidak dapt berupa sebuah anggota"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD dideklarasikan sebagai sebuah %<virtual%> %s"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "%<const%> dan %<volatile%> fungsi penspesifikasi di %qD tidak valid dalam %s deklarasi"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD dideklarasikan sebagai sebuah %<virtual%> %s"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD dideklarasikan sebagai sebuah %<inline%> %s"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "%<const%> dan %<volatile%> fungsi penspesifikasi di %qD tidak valid dalam %s deklarasi"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD dideklarasikan sebagai sebuah %<virtual%> %s"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD dideklarasikan sebagai sebuah %<inline%> %s"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "%<const%> dan %<volatile%> fungsi penspesifikasi di %qD tidak valid dalam %s deklarasi"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD dideklarasikan sebagai sebuah %<virtual%> %s"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD dideklarasikan sebagai sebuah %<inline%> %s"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "%<const%> dan %<volatile%> fungsi penspesifikasi di %qD tidak valid dalam %s deklarasi"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D dideklarasikan sebagai sebuah friend"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D dideklarasikan dengan spesifikasi eksepsi"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "definisi dari %qD tidak dalam namespace melingkupi %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "anggota fungsi statis %q#D dideklarasikan dengan tipe pengkualifikasi"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnamed return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "%Hnilai kembali bernama tidak lagi didukung"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD bukan sebuah fungsi template"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "deklarasi friend tidak dalam definisi kelas"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "mendifinisikan eksplisit spesialisasi %qD dalam deklarasi friend"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "penggunaan tidak valid dari template-id %qD dalam deklarasi dari primary template"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "argumen baku tidak diijinkan dalam deklarasi dari spesialisasi template friend %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> tidak diijinkan dalam deklarasi dari spesialisasi template friend %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "deklarasi dari %q#D diluar dari kelas bukan sebuah definisi"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "tidak dapat mendeklarasikan %<::main%> untuk menjadi sebuah template"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "tidak dapat mendeklarasikan %<::main%> untuk menjadi inline"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "tidak dapat mendeklarasikan %<::main%> untuk menjadi statis"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "tidak dapat mendeklarasikan %<::main%> untuk menjadi statis"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "tidak dapat mendeklarasikan %<::main%> untuk menjadi sebuah template"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "fungsi bukan-anggota %qD tidak dapat memiliki cv-kualifier"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "anggota fungsi statis %qD tidak dapat memiliki cv kualifier"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "anggota fungsi statis %qD tidak dapat memiliki cv kualifier"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 #| msgid "non-member function %qD cannot have cv-qualifier"
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "fungsi bukan-anggota %qD tidak dapat memiliki cv-kualifier"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "anggota fungsi statis %qD tidak dapat memiliki cv kualifier"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "anggota fungsi statis %qD tidak dapat memiliki cv kualifier"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "explicit object parameter declared here"
 msgstr "tipe parameter template %qT dideklarasikan %<friend%>"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "  declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding '%s'"
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "Binding di %C harus memiliki akses sama seperti telah didefinisikan binding '%s'"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "deklarasi dari %qD sebagai bukan fungsi"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate with C linkage"
 msgid "literal operator with C linkage"
 msgstr "%Htemplate dengan C linkage"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option argument %qs"
 msgid "%qD has invalid argument list"
 msgstr "pilihan argumen %qs tidak valid"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-member function"
 msgstr "%qD harus berupa sebuah anggota fungsi tidak statis"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> harus kembali %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "definisi dari secara implisit dideklarasikan %qD"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "definition of implicitly-declared %qD"
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "definisi dari secara implisit dideklarasikan %qD"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "%q#D explicitly defaulted here"
 msgstr "%q+#D sebelumnya didefinisikan disini"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "bukan %q#D anggota fungsi dideklarasikan dalam kelas %qT"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "tidak dapat mendeklarasikan %<::main%> untuk menjadi sebuah template"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 #| msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "variabel otomatis %qE tidak dapat berupa %<threadprivate%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "strong using only meaningful at namespace scope"
 msgid "concept must be defined at namespace scope"
 msgstr "strong using hanya berarti di lingkup namespace"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnamed return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "%Hnilai kembali bernama tidak lagi didukung"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "tidak valid dalam kelas penginisialisasian dari anggota data statis dari tipe bukan integral %qT"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "tidak valid dalam kelas penginisialisasian dari anggota data statis dari tipe bukan integral %qT"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "tidak valid dalam kelas penginisialisasian dari anggota data statis dari tipe bukan integral %qT"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "tidak valid dalam kelas penginisialisasian dari anggota data statis dari tipe bukan integral %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ melarang dalam kelas inisialisasi dari anggota statis bukan const %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ melarang inisialisasi dari anggota constant %qD dari bukan integral tipe %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "ukuran dari array %qD memiliki tipe bukan integral %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "ukuran dari array memiliki tipe %qT bukan integral"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "ukuran dari array %qD bukan sebuah integral konstan-ekspresi"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "ukuran dari array bukan sebuah integral konstan ekspresi"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ melarang array berukuran-nol %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ melarang array berukuran-nol"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ melarang array dengan variabel panjang %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ melarang array dengan variabel panjang"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "array dengan panjang bervariabel  %qD digunakan"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "array dengan panjang bervariabel digunakan"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "overflow dalam dimensi array"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "membuat penunjuk ke anggota referensi tipe %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of voids"
 msgid "declaration of %qD as array of void"
 msgstr "deklarasi dari %qs sebagai dari voids"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of void"
 msgstr "membuat array dari %qT"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of functions"
 msgstr "deklarasi dari %qs sebagai array dari fungsi"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of functions"
 msgstr "membuat array dari %qT"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of references"
 msgstr "deklarasi dari %qs sebagai array dari fungsi"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of references"
 msgstr "membuat array dari %qT"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of function members"
 msgstr "deklarasi dari %qs sebagai array dari fungsi"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "creating array of function members"
 msgstr "deklarasi dari %qs sebagai array dari fungsi"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "deklarasi dari %qD sebagai array multidimensi harus memiliki batasan untuk seluruh dimensi kecuali yang pertama"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "array multidimensi harus memiliki batasan untuk seluruh dimensi kecuali yang pertama"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "array dengan panjang bervariabel digunakan"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "spesifikasi tipe kembali untuk konstruktor tidak valid"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "kualifier tidak diijinkan dalam deklarasi dari %<operator %T%>"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "spesifikasi tipe kembali untuk desktruktor tidak valid"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "kualifier tidak diijinkan dalam deklarasi dari %<operator %T%>"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "tipe kembali yang dispesifikasikan untuk %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "kualifier tidak diijinkan dalam deklarasi dari %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "spesifikasi tipe kembali untuk desktruktor tidak valid"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "kualifier tidak diijinkan dalam deklarasi dari %<operator %T%>"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 #| msgid "too many template parameter lists in declaration of %qD"
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "terlalu banyak daftar parameter template dalam deklarasi dari %qD"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "penspesifikasi konflik dalam deklarasi dari %qs"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "variabel tidak bernama atau field dideklarasikan void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "variabel atau field dideklarasikan void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "%<inline%> penspesifikasi tidak valid untuk fungsi %qs dideklarasikan diluar dari lingkup global"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "%qE tidak berada di awal dari deklarasi"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "desktruktor mungkin berupa cv-kualified"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together for %qs"
 msgid "%e and %e specified together"
 msgstr "%<signed%> dan %<unsigned%> dispesifikasikan bersama untuk %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "penggunaan tidak valid dari nama kualifikasi %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "penggunaan tidak valid dari nama kualifikasi %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "penggunaan tidak valid dari nama kualifikasi %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT bukan sebuah class atau namespace"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "deklarasi dari %qD sebagai bukan fungsi"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "deklarasi dari %qD sebagai bukan anggota"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "id pendeklarasi hilang; menggunaka kata reserved %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "definisi fungsi tidak mendeklarasikan parameter"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "deklarasi dari %qD sebagai bukan fungsi"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as %s"
 msgid "declaration of %qD as %<typedef%>"
 msgstr "deklarasi dari %qD sebagai %s"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q+D shadows a parameter"
 msgid "declaration of %qD as parameter"
 msgstr "deklarasi dari %q+D membayangi sebuah parameter"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "missing type-name in typedef-declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "hilang nama-tipe dalam typedef-deklarasi"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "dua atau lebih tipe data dalam deklarasi dari %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain %<complex%> meaning %<double complex%>"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C tidak mendukung plain %<complex%> yang berarti %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ melarang deklarasi dari %qs dengan tidak ada tipe"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_saveregs not supported by this target"
 msgid "%<__int%d%> is not supported by this target"
 msgstr "__builtin_saveregs tidak didukung oleh target ini"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ 1998 does not support %<long long%>"
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ 1998 tidak mendukung %<long long%>"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "no class name specified with %qs"
 msgid "%qs specified with %qT"
 msgstr "tidak ada nama class dispesifikasikan dengan %qs"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr ""
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 #| msgid "%qs not specified in enclosing parallel"
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs tidak dispesifikan dalam parallel yang melingkupi"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qs specified with %<typeof%>"
 msgstr "%<__thread%> digunakan dengan %<typedef%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "kompleks tidak valid untuk %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "anggota %qD tidak dapat dideklarasikan baik virtual dan statis"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "anggota %qD tidak dapat dideklarasikan baik virtual dan statis"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "type deklarasi tidak valid dalam parameter deklarasi"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter %qs"
 msgid "storage class specified for template parameter %qs"
 msgstr "class penyimpanan dispesifikasikan untuk parameter %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "class penyimpanan dispesifikasikan untuk parameter %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "a parameter cannot be declared %qs"
 msgstr "parameter template tidak dapat berupa friends"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> diluar deklarasi kelas"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "structured binding declaration cannot be %qs"
 msgstr "atribut diabaikan dalam deklarasi dari %q+#T"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "structured binding declaration cannot have type %qT"
 msgstr "atribut diabaikan dalam deklarasi dari %q+#T"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "multiple storage kelas dalam deklarasi dari %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "kelas penyimpanan dispesifikasikan untuk %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "fungsi nested %qs dideklarasikan %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "top-level deklarasi dari %qs menspesifikasikan %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "lingkup-fungsi %qs secara implisit auto dan dideklarasikan %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "spesifikasi kelas penyimpanan tidak valid dalam deklarasi fungsi friend"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "multiple storage kelas dalam deklarasi dari %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "Diduga parenthesis kiri"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot have an initializer"
 msgid "a function type cannot have an explicit object parameter"
 msgstr "Fungsi '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to member function used in arithmetic"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "penunjuk ke anggota fungsi digunakan dalam aritmetik"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function uses %<auto%> type specifier without late return type"
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "%qs fungsi menggunakan penspesifikasi tipe %<auto%> tanpa tipe kembali late"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "fungsi virtual tidak dapat menjadi friend"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with late return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "%qs fungsi dengan tipe kembali late memiliki %qT sebagai tipenya daripada plain %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with late return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "%qs fungsi dengan tipe kembali late memiliki %qT sebagai tipenya daripada plain %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "penggunaan tidak valid dari %<auto%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with late return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "%qs fungsi dengan tipe kembali late memiliki %qT sebagai tipenya daripada plain %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "penggunaan tidak valid dari %<auto%>"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "tipe pengkualifikasi diabaikan di tipe kembali fungsi"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with late return type not declared with %<auto%> type specifier"
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "%qs fungsi dengan tipe kembali late tidak dideklarasikan dengan penspesifikasi tipe %<auto%>"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs dideklarasikan sebagai fungsi yang mengembalikan sebuah fungsi"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs dideklarasikan sebagai fungsi yang mengembalikan sebuah array"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "%<noreturn%> function returns non-void value"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<noreturn%> fungsi mengembalikan nilai bukan-void"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "desktruktor tidak dapat berupa anggota statis fungsi"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, fuzzy, gcc-internal-format
 #| msgid "destructor cannot be static member function"
 msgid "constructor cannot be static member function"
 msgstr "desktruktor tidak dapat berupa anggota statis fungsi"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "desktruktor mungkin berupa cv-kualified"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "constructors may not be cv-qualified"
 msgstr "desktruktor mungkin berupa cv-kualified"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "destructors may not be ref-qualified"
 msgstr "desktruktor mungkin berupa cv-kualified"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "constructors may not be ref-qualified"
 msgstr "desktruktor mungkin berupa cv-kualified"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "konstruktor tidak dapat dideklarasikan virtual"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "fungsi virtual tidak dapat menjadi friend"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "deklarasi friend tidak dalam definisi kelas"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 #| msgid "can't define friend function %qs in a local class definition"
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "tidak dapat mendefinisikan fungsi friend %qs dalam sebuah definisi lokal kelas"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "non-member function %qD cannot have cv-qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "fungsi bukan-anggota %qD tidak dapat memiliki cv-kualifier"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "anggota fungsi statis %qD tidak dapat memiliki cv kualifier"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD harus berupa sebuah anggota fungsi tidak statis"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "destruktor mungkin tidak memiliki parameter"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "tidak dapat mendeklarasikan penunjuk ke %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "tidak dapat mendeklarasikan referensi ke %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "tidak dapat mendeklarasikan penunjuk ke %q#T anggota"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %s to qualified function type %qT"
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "tidak dapat mendeklarasikan %s untuk fungsi yang dikualifikasikan dengan tipe %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %s to qualified function type %qT"
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "tidak dapat mendeklarasikan %s untuk fungsi yang dikualifikasikan dengan tipe %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "tidak dapat mendeklarasikan referensi ke %q#T, yang bukan sebuah typedef atau sebuah argumen tipe template"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "template-id %qD digunakan sebagai sebuah pendeklarasi"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "anggota fungsi secara implisit friends dari kelasnya"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "ekstra kualifikasi %<%T::%> di anggota %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot define member function %<%T::%s%> within %<%T%>"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "tidak dapat mendefinisikan anggota fungsi %<%T::%s%> dalam %<%T%>"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member %<%T::%s%> within %qT"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "tidak dapat mendeklarasikan anggota %<%T::%s%> dalam %qT"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "tidak dapat mendeklarasikan anggota %<%T::%s%> dalam %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "bukan parameter %qs tidak dapat menjadi parameter pack"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "anggota member tidak boleh memiliki tipe variabel termodifikasi %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "parameter mungkin tidak memiliki tipe variabel termodifikasi %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 #| msgid "%<virtual%> outside class declaration"
 msgid "%<explicit%> outside class declaration"
 msgstr "%<virtual%> diluar deklarasi kelas"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%> dalam deklarasi kosong"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 #| msgid "only declarations of constructors can be %<explicit%>"
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "hanya deklarasi dari konstruktor yang dapan berupa %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "bukan-anggota %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "anggota bukan-objek %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "fungsi %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "statis %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "const %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 #| msgid "function %qs cannot be declared %<mutable%>"
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "fungsi %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "%Hattributes are not allowed on a function-definition"
 msgid "typedef may not be a function definition"
 msgstr "%Hatribut tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "destructor cannot be static member function"
 msgid "typedef may not be a member function definition"
 msgstr "desktruktor tidak dapat berupa anggota statis fungsi"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<[*]%> not allowed in other than a declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%H%<[*]%> tidak diijinkan selain dalam sebuah deklarasi"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 #| msgid "parameter declared %<auto%>"
 msgid "typedef declared %<auto%>"
 msgstr "parameter dideklarasikan %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, fuzzy, gcc-internal-format
 #| msgid "%Jtypedef name may not be a nested-name-specifier"
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "%J typedef nama mungkin berupa sebuah nested-name-specifier"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ melarang tipe nested %qD dengan nama sama seperti kelas yang melingkupi"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> dispesifikan untuk deklarasi kelas friend"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "parameter template tidak dapat berupa friends"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "deklarasi friend membutuhkan kunci kelas, i.e. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "deklarasi friend membutuhkan class-key, i.e. %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "mencoba untuk membuat kelas %qT sebuah friend dari lingkup global"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "kualifier tidak valid di tipe fungsi bukan anggota"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "deklarasi abstrak %qT digunakan sebagai deklarasi"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of C++ built-in type %qT"
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "redeklarasi dari C++ tipe bawaan %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "tidak dapat menggunakan %<::%> dalam parameter deklarasi"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter %q+D to be of abstract type %qT"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "tidak dapat mendeklarasikan parameter %q+D untuk menjadi tipe abstrak %qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<this%> may not be used in this context"
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%H%<this%> mungkin tidak digunakan dalam konteks ini"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "parameter dideklarasikan %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid use of template-name %qE without an argument list"
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "%Hpenggunaan tidak vlaid dari nama template %qE tanpa sebuah daftar argumen"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "non-static data member declared with placeholder %qT"
 msgstr "anggota statis %qD dideklarasikan %<register%>"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array %qD"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ melarang array berukuran-nol %qD"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 tidak mendukung keanggotaan array fleksibel"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "penggunaan tidak valid dari %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of C function %q#D conflicts with"
 msgid "declaration of function %qD in invalid context"
 msgstr "deklarasi dari C fungsi %q#D konflik dengan"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "fungsi %qD dideklarasikan virtual didalam sebuah union"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be declared virtual, since it is always static"
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD tidak dapat dideklarasikan virtual, karena itu selalu statis"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "diduga nama yang dikualifikasikan dalam deklarasi friend untuk destruktor %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "deklarasi dari %qD sebagai anggota dari %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "a destructor cannot be %qs"
 msgstr "desktruktor mungkin berupa cv-kualified"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "diduga kualifikasi nama dalam deklarasi friend untuk konstruktor %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "a constructor cannot be %<concept%>"
 msgstr "konstruktor tidak dapat dideklarasikan virtual"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 #| msgid "destructor cannot be static member function"
 msgid "a concept cannot be a member function"
 msgstr "desktruktor tidak dapat berupa anggota statis fungsi"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "tidak dapat membuka %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of implicitly-declared special member function"
 msgid "specialization of variable template %qD declared as function"
 msgstr "spesialisasi dari anggota fungsi spesial secara implist dideklarasikan"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "variable template declared here"
 msgstr "variabel atau field dideklarasikan void"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "field %qD has incomplete type %qT"
 msgstr "field %qD memiliki tipe tidak lengkap"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "nama %qT memiliki tipe tidak lengkap"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE bukan fungsi atau anggota fungsi; tidak dapat dideklarasikan sebagai friend"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE bukan fungsi atau anggota fungsi; tidak dapat dideklarasikan sebagai friend"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "mendifinisikan eksplisit spesialisasi %qD dalam deklarasi friend"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "static data member %qE declared %qs"
 msgstr "anggota statis %qD dideklarasikan %<register%>"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member %qD has Java class type"
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "anggota data bukan statis %qD memiliki tipe kelas Java"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "non-static data member %qE declared %qs"
 msgstr "anggota statis %qD dideklarasikan %<register%>"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "kelas penyimpanan %<auto%> tidak valid untuk fungsi %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "kelas penyimpanan %<register%> tidak valid untuk fungsi %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "kelas penyimpanan %<__thread%> tidak valid untuk fungsi %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %<__thread%> invalid for function %qs"
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "kelas penyimpanan %<__thread%> tidak valid untuk fungsi %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "%<inline%> penspesifikasi tidak valid untuk fungsi %qs dideklarasikan diluar dari lingkup global"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 #| msgid "%Han asm-specification is not allowed on a function-definition"
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "%Hsebuah spesifikasi asm tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "%<static%> specified invalid for function %qs declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "%<static%> dispesifikasikan tidak valid untuk fungsi %qs dideklarasikan diluar lingkup global"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "%<inline%> penspesifikasi tidak valid untuk fungsi %qs dideklarasikan diluar dari lingkup global"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "virtual bukan kelas fungsi %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs didefinisikan dalam sebuah lingkup bukan kelas"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 #| msgid "%qs defined in a non-class scope"
 msgid "%qs declared in a non-class scope"
 msgstr "%qs didefinisikan dalam sebuah lingkup bukan kelas"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "tidak dapat mendeklarasikan anggota fungsi %qD untuk memiliki linkage statis"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "tidak dapat mendeklarasikan fungsi statis didalam fungsi lainnya"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> mungkin tidak digunakan ketika mendefinisikan (terbalik untuk deklarasi) sebuah anggota data statis"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "anggota statis %qD dideklarasikan %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "tidak dapat secara eksplisit mendeklarasikan anggota %q#D untuk memiliki extern linkage"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<extern%> variable %q+D in %<for%> loop initial declaration"
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "deklarasi dari variabel %<extern%> %q+D dalam %<for> inisial deklarasi loop"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "statis %qs tidak dapat dideklarasikan %<mutable%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs diinisialisasi dan dideklarasi %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs keduanya memiliki %<extern> dan penginisialisasi"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 #| msgid "default argument %qE uses local variable %qD"
 msgid "default argument %qE uses %qD"
 msgstr "argumen baku %qE menggunakan variabel lokal %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "argumen baku %qE menggunakan variabel lokal %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "penspesifikasi kelas penyimpanan dalam parameter deklarasi"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use %<::%> in parameter declaration"
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "tidak dapat menggunakan %<::%> dalam parameter deklarasi"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "parameter %qD secara tidak valid dideklarasikan tipe metode"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD includes %s to array of unknown bound %qT"
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "parameter %qD includes %s ke array dari ikatan tidak dikenal %qT"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD includes %s to array of unknown bound %qT"
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "parameter %qD includes %s ke array dari ikatan tidak dikenal %qT"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "konstruktor tidak valid; anda mungkin bermaksud %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD mungkin tidak dideklarasikan dalam sebuah namespace"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD tidak boleh dideklarasikan sebagai statis"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD harus berupa sebuah anggota fungsi tidak statis"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a member function"
 msgstr "%qD harus berupa sebuah anggota fungsi tidak statis"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD harus baik sebuah anggota fungsi tidak statis atau bukan anggota fungsi"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD harus memiliki sebuah argumen dari kelas atau tipe enumerasi"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ melarang overloading operator ?:"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD tidak boleh memiliki argumen dengan jumlah bervariabel"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD harus mengambil baik nol atau satu argumen"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD harus mengambil baik satu atau dua argumen"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "postfix %qD harus mengambil %<int%> sebagai argumennya"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "postfix %qD harus mengambil %<int%> sebagai argumen keduanya"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD harus mengambil secara tepat dua argumen"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD harus mengambil secara tepat satu argumen"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD harus mengambil secara tepat dua argumen"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD tidak dapat memiliki argumen baku"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "konversi ke %s%s tidak akan pernah menggunakan sebuah tipe operator konversi"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "konversi ke %s%s tidak akan pernah menggunakan sebuah tipe operator konversi"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "konversi ke %s%s tidak akan pernah menggunakan sebuah tipe operator konversi"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "konversi ke %s%s tidak akan pernah menggunakan sebuah tipe operator konversi"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "konversi ke %s%s tidak akan pernah menggunakan sebuah tipe operator konversi"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "definisi-pengguna %qD selalu mengevaluasikan kedua argumen"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "prefix %qD seharusnya mengembalikan %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "postfix %qD seharusnya mengembalikan %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD seharusnya kembali dengan nilai"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "menggunakan parameter tipe template %qT setelah %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous template specialization %qD for %q+D"
 msgid "using alias template specialization %qT after %qs"
 msgstr "spesialisasi template ambigu %qD untuk %q+D"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "menggunakan typedef-name %qD setelah %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D has a previous declaration here"
 msgid "%qD has a previous declaration here"
 msgstr "%q+D telah dideklarasikan sebelumnya disini"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT mereferensikan sebagai %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%qT has a previous declaration here"
 msgstr "%q+T telah dideklarasikan sebelumnya disini"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT direferensikan sebagai enum"
@@ -67940,103 +68009,103 @@ msgstr "%qT direferensikan sebagai enum"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "argumen template dibutuhkan untuk %<%s %T%>"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "referensi ke %qD adalah ambigu"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfunction template %qD redeclared as a class template"
 msgid "class template %qD redeclared as non-template"
 msgstr "%Htemplate fungsi %qD redeklarasikan sebagai sebuah template kelas"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD memiliki nama sama seperti kelas yang telah dideklarasikan"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT mungkin bukan sebuah template"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "penggunaan dari enum %q#D tanpa deklarasi sebelumnya"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "redeklarasi dari %qT sebagai bukan-template"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "union turunan %qT tidak valid"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct or virtual base of %qT"
 msgid "%qT defined with direct virtual base"
 msgstr "tipe %qT tidak sebuah langsung atau virtual base dari %qT"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "tipe base %qT gagal untuk menjadi sebuah struct atau tipe kelas"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "tipe rekursif %qT tidak terdefinisi"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "duplikasi tipe dasar %qT tidak valid"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "previous definition here"
 msgstr "%J definisi sebelumnya disini"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 #| msgid "underlying type %<%T%> of %<%T%> must be an integral type"
 msgid "underlying type %qT of %qT must be an integral type"
@@ -68046,95 +68115,101 @@ msgstr "tipe yang digaris bawahi %<%T%> dari %<%T%> harus berupa sebuah tipe int
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "tidak ada tipe integral yang dapat merepresentasikan seluruh dari nilai enumerasi untuk %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qD is not an integer constant"
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "nilai enumerasi untuk %qD bukan sebuah konstanta integer"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "nilai enumerasi untuk %qD bukan sebuah konstanta integer"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value %E is too large for underlying type %<%T%>"
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "nilai pengenumerasi untuk %E terlalu besar untuk tipe yang digaris bawahi %<%T%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value %E is too large for underlying type %<%T%>"
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "nilai pengenumerasi untuk %E terlalu besar untuk tipe yang digaris bawahi %<%T%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "overflow dalam nilai enumerasi di %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value %E is too large for underlying type %<%T%>"
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "nilai pengenumerasi untuk %E terlalu besar untuk tipe yang digaris bawahi %<%T%>"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "multiple definisi dari %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "tipe kembali %q#T tidak lengkap"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> seharusnya mengembalikan referensi ke %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statements in function returning %qT"
 msgstr "tidak ada pernyataaan kembali dalam fungsi yang mengembalikan bukan void"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 #| msgid "function return types not compatible due to %<volatile%>"
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "tipe kembali fungsi tidak kompatibel karena %<volatile%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "tidak ada pernyataaan kembali dalam fungsi yang mengembalikan bukan void"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD telah didefinisikan dalam kelas %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "try using %qE instead"
 msgid "using %qs"
 msgstr "lebih baik coba gunakan %qE"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D digunakan sebelum ke deklarasi"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -68606,383 +68681,383 @@ msgstr "insn tidak memenuhi batasannya:"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "menggunakan %<typename%> diluar dari template"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %s:%d:%d"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    inlined dari %qs di %s:%d:%d"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %s:%d"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    inlined dari %qs di %s:%d"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    inlined dari %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In static member function %qD"
 msgstr "Dalam anggota fungsi %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr ""
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "%d constructor(s) found\n"
 msgid "In constructor %qD"
 msgstr "%d konstruktor ditemukan\n"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "In destructor %qD"
 msgstr "tidak ada argumen baku untuk %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In lambda function"
 msgstr "Dalam anggota fungsi %qs"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "Dalam anggota fungsi %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "Dalam anggota fungsi %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "Dalam fungsi %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "but %qE is a type"
 msgstr "%qD bukan sebuah tipe"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "  in thrown expression"
 msgid "but %qE is an expression"
 msgstr "  dalam ekspresi thrown"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD bukan sebuah variabel"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr ""
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "but %qE is a function"
 msgstr "%q+D bukan sebuah fungsi,"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "but %qE is a data member"
 msgstr "%q#T memiliki anggota data penunjuk"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD bukan sebuah template fungsi"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE is not a template"
 msgid "but %qE is a class template"
 msgstr "%H%qE bukan sebuah template"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE is not a template"
 msgid "but %qE is a variable template"
 msgstr "%H%qE bukan sebuah template"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%H%qD adalah sebuah namespace"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr ""
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "  dalam instantiation dari template %qT"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr ""
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of %q#D"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "eksplisit instantiation dari %q#D"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "required from %q#D\n"
 msgstr "disediakan untuk %q+D"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr ""
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "required from here\n"
 msgstr "dipanggil dari sini"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr ""
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr ""
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "tidak ada argumen"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "tidak ada argumen"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, fuzzy, gcc-internal-format
 #| msgid "%Hincomplete type %qT used in nested name specifier"
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "%Htipe %qT tidak lengkap digunakan dalam nama penspesifikasi nested"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, fuzzy, gcc-internal-format
 #| msgid "%Hreference to %<%T::%D%> is ambiguous"
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "%Hreferensi ke %<%T::%D%> adalah ambigu"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD bukan sebuah anggota dari %qT"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD bukan sebuah anggota dari %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD is not a member of %qD"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%H%qD bukan sebuah anggota dari %qD"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD is not a member of %qD"
 msgid "%qD is not a member of %qD"
 msgstr "%H%qD bukan sebuah anggota dari %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%H%<::%D%> belum pernah dideklarasikan"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared"
@@ -69224,7 +69299,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "anggota %qD referensi tidak terinisialisasi"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "array harus diinisialisasi dengan sebuah kurung melingkupi penginisialisasi"
@@ -69352,7 +69427,7 @@ msgstr "tipe %qT tidak sebuah langsung atau virtual base dari %qT"
 msgid "type %qT is not a direct base of %qT"
 msgstr "tipe %qT bukan sebuah dasar langsung dari %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -69557,45 +69632,45 @@ msgstr "kemungkinan masalah terdeteksi dalam penggunaan dari operator delete:"
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "bukan destruktor ataupu class-specific operator delete yang akan dipanggil, meskipun mereka dideklarasikan ketika kelas didefinisikan."
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "penginisialisasi berakhir secara prematur"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "ukuran array tidak diketahui dalam delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "tipe kembali adalah sebuah tipe tidak lengkap"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "kemungkinan masalah terdeteksi dalam penggunaan dari operator delete:"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined."
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "bukan destruktor ataupu class-specific operator delete yang akan dipanggil, meskipun mereka dideklarasikan ketika kelas didefinisikan."
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "tipe dari vektor delete bukan penunjuk ataupun tipe array"
@@ -69633,90 +69708,98 @@ msgstr "tidak dapat meningkatkan sebuah penunjuk ke tipe tidak lengkap %qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> tidak tersedia untuk anggota fungsi static"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "nama mangled dari %qD tidak akan berubah dalam versi yang akan datang dari GCC"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "nama mangled dari %qD tidak akan berubah dalam versi yang akan datang dari GCC"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "#pragma %s tidak valid"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable tidak lagi didukung"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "#pragma implementasi untuk %qs muncul setelah berkas dimasukan"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD tidak didefinisikan"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD belum pernah dideklarasikan dalam lingkup ini"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD belum pernah dideklarasikan dalam lingkup ini"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "tidak ada argumen ke %qD yang tergantung di sebuah parameter template, jadi sebuah deklarasi dari %qD harus tersedia"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(jika anda menggunakan %<-fpermissive%>, G++ akan menerima kode anda, tetapi mengijinkan penggunaan dari sebuah nama tidak dideklarasikan sudah ditinggalkan)"
@@ -69726,66 +69809,58 @@ msgstr "(jika anda menggunakan %<-fpermissive%>, G++ akan menerima kode anda, te
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, fuzzy, gcc-internal-format
 #| msgid "mangling typeof, use decltype instead"
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "mangling typeof, lebih baik gunakan decltype"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, fuzzy, gcc-internal-format
-#| msgid "mangling typeof, use decltype instead"
-msgid "mangling type pack index"
-msgstr "mangling typeof, lebih baik gunakan decltype"
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "mangling %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "diabaikan operan tengah ke %<?:%> operan tidak dapat mangled"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -70204,7 +70279,7 @@ msgstr "redeklarasi dari %q+D dengan tidak ada sambungan"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "penspesifikasi konflik dalam deklarasi dari %qs"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting type for imported declaration %#qD"
@@ -70222,461 +70297,461 @@ msgstr "penspesifikasi konflik dalam deklarasi dari %qs"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "tipe konfliks untuk fungsi bawaan %q+D"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "penspesifikasi konflik dalam deklarasi dari %qs"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for %q+#D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "tipe kembali konflik dispesifikasikan untuk %q+#D"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "penspesifikasi konflik dalam deklarasi dari %qs"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "konflik deklarasi %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "dalam deklarasi %q+D"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "tidak ada argumen baku untuk %qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "existing default declared here"
 msgstr "%J%qD telah dideklarasikan disini"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "argumen baku diberikan untuk parameter %d dari %q#D"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of %q#D doesn't match"
 msgid "definition of %qD does not match"
 msgstr "deklarasi extern dari %q#D tidak cocok"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "hilang definisi"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "enumerator %qD does not match ..."
 msgstr "argumen dari tipe %qT tidak cocok dengan %qT"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "redeklarasi dari enumerator %q+D"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE bukan dari tipe %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "spesialisasi eksplisit dari bukan-template %qT"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%H%qD redeklarasi dengan akses berbeda"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD mungkin tidak dideklarasikan dalam sebuah namespace"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "%s of function %qD"
 msgid "%qD refers to TU-local function %qD"
 msgstr "%s dari fungsi %qD"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 #| msgid "instantiation of %q+D as type %qT"
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "instantiation dari %q+D sebagai tipe %qT"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "module %qs declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "  from definition of %q+#D"
 msgid "macro definitions of %qE corrupted"
 msgstr "  dari definisi dari %q+#D"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "inconsistent imported macro definition %qE"
 msgstr "spesifikasi variabel instance tidak konsisten"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 #| msgid "Can't delete module file '%s': %s"
 msgid "compiled module file is %qs"
 msgstr "tidak dapat menghapus berkas modul '%s': %s"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s"
 msgid "compiled module is %sversion %s"
 msgstr "collect2 versi %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 versi %s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs not found"
 msgid "module %qs found"
 msgstr "field %qs tidak ditemukan"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr ""
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "ekspresi batas stack tidak didukung"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "declaration %qD conflicts with builtin"
 msgstr "deklarasi dari namespace %qD konflik dengan"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "deklarasi dari namespace %qD konflik dengan"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %qD in local class without prior declaration"
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "deklarasi friend %qD dalam kelas lokal tanpa deklarasi sebelumnya"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "konflik deklarasi %q#D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting declaration of %qD in global module"
 msgstr "konflik deklarasi %q#D"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of %qs"
 msgid "previously declared in module %qs"
 msgstr "deklarasi sebelumnya dari %qs"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of %qs"
 msgid "previously declared in global module"
 msgstr "deklarasi sebelumnya dari %qs"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %q#D declares a non-template function"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "deklarasi friend %q#D mendeklarasikan fungsi bukan template"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "redeklarasi dari %q+D dengan tidak ada sambungan"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "creating %s"
 msgid "reading CMI %qs"
 msgstr "membuat %s"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "definisi metode tidak dalam conteks @implementation"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "module declared here"
@@ -70689,114 +70764,114 @@ msgstr "%q+D dideklarasikan disini"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' already declared"
 msgid "module already declared"
 msgstr "Simbol '%s' telah terdeklarasi"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr ""
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr ""
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown compiled module interface: %s"
 msgstr "mode mesin %qs tidak dikenal"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing"
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Aktifkan preprosesing tradisional"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "invalid header name %qs"
 msgstr "parameter %qs tidak valid"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "%s: invalid file name: %s\n"
 msgid "invalid module name %qs"
 msgstr "%s: nama berkas tidak valid: %s\n"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "error menulis %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "first error in %qD appeared here"
 msgstr "  %q+#D dideklarasikan disini"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown header kind %qs"
@@ -70813,7 +70888,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "fungsi %q+D redeklarasi dengan atribut noinline"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
@@ -70865,288 +70940,299 @@ msgstr "deklarasi dari %q#D membayangi sebuah parameter"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "deklarasi dari %qD sebagai anggota dari %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %q+D but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "deklarasi untuk parameter %q+D tetapi tidak ada parameter seperti itu"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %qD in local class without prior declaration"
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "deklarasi friend %qD dalam kelas lokal tanpa deklarasi sebelumnya"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s(%E) %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "%q#D declared here with no linkage"
 msgstr "%qD dideklarasikan sebagai referensi tetapi tidak terinisialisasi"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD redeclared with different access"
 msgid "%q#D declared here with internal linkage"
 msgstr "%H%qD redeklarasi dengan akses berbeda"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "%q#D declared here with module linkage"
 msgstr "  %q+#D dideklarasikan disini"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> names desktruktor"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "using-declaration untuk bukan-anggota di class scope"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT bukan sebuah class atau namespace"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "using-declaration untuk bukan-anggota di class scope"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "tipe %qT bukan sebuah dasar langsung dari %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not declared in %qD"
 msgid "%qD has not been declared in %qD"
 msgstr "%qD tidak dideklarasikan dalam %qD"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD not in a namespace surrounding %qD"
 msgid "using-declaration may not name namespace %qD"
 msgstr "deklarasi dari %qD bukan dalam sebuah lingkup namespace %qD"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> names konstruktor dalam %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "deklarasi dari %qD bukan dalam sebuah lingkup namespace %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "eksplisit kualifikasi dalam deklarasi dari %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD seharusnya telah dideklarasikan didalam %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not declared in %qD"
 msgid "%qD has not been declared within %qD"
 msgstr "%qD tidak dideklarasikan dalam %qD"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D dideklarasikan sebagai sebuah friend"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%qD atribut membutuhkan sebuah argumen NTBS tunggal"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "%qD atribut tidak berarti karena anggota dari anonymous namespace memperoleh simbol lokal"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "atribut %qD direktif diabaikan"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D"
 msgid "  %qE"
 msgstr "  %q+#D"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<this%> tidak tersedia untuk anggota fungsi static"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr ""
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "it was later defined here"
 msgstr "%J%qD telah dideklarasikan disini"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnamed return values are no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "%Hnilai kembali bernama tidak lagi didukung"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%H%<this%> mungkin tidak digunakan dalam konteks ini"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "cannot nest more than %d namespaces"
 msgstr "%qD mungkin tidak dideklarasikan dalam sebuah namespace"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "'%s' di %L adalah ambigu"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "namespace alias %qD tidak diijinkan disini, diasumsikan %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "redeklarasi dari %q+D dengan tidak ada sambungan"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD mungkin tidak dideklarasikan dalam sebuah namespace"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "Formal namespace"
 msgid "exporting unnamed namespace"
 msgstr "Ruang nama formal"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "address area of %q+D conflicts with previous declaration"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "daerah alamat dari %q+D konflik dengan deklarasi sebelumnya"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "reachable %s definition here"
 msgstr "%J definisi sebelumnya disini"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX memasuki pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -71181,7 +71267,7 @@ msgstr "pengidentifikasi %<%s%> akan menjadi sebuah kata kunci dalam C++0x"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -71232,7 +71318,7 @@ msgstr "%H%<::%E%> belum pernah dideklarasikan"
 msgid "request for member %qE in non-class type %qT"
 msgstr "%Hpermintaan untuk anggota %qE dalam tipe bukan kelas %qT"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<%T::%E%> has not been declared"
 msgid "%<%T::%E%> has not been declared"
@@ -71315,7 +71401,7 @@ msgstr "(mungkin sebuah semikolom hilang setelah definisi dari %qT)"
 msgid "%qE is not a class template"
 msgstr "%H%qE bukan sebuah template"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE is not a template"
 msgid "%qE is not a template"
@@ -71672,1908 +71758,1919 @@ msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "fungsi media ini hanya tersedia di fr500"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type"
 msgstr "diduga deklarasi atau pernyataan"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD bukan sebuah template fungsi"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfixed-point types not supported in C++"
 msgid "fixed-point types not supported in C++"
 msgstr "%Htipe titik tetap tidak didukung dalam C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ melarang braced-groups didalam ekspresi"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, fuzzy, gcc-internal-format
 #| msgid "%Hstatement-expressions are not allowed outside functions nor in template-argument lists"
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "%Hpernyataan ekspresi tidak diijinkan diluar fungsi atau didalam daftar template argumen"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected primary-expression"
 msgstr "diduga ekspresi"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<this%> may not be used in this context"
 msgid "%<this%> may not be used in this context"
 msgstr "%H%<this%> mungkin tidak digunakan dalam konteks ini"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 #| msgid "Objective-C declarations may only appear in global scope"
 msgid "a template declaration cannot appear at block scope"
 msgstr "deklarasi Objective-C mungkin hanya muncul dalam lingkup global"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "%Hlocal variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "%Hvariabel lokal %qD mungkin tidak muncul dalam konteks ini"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, fuzzy, gcc-internal-format
 #| msgid "%Hlocal variable %qD may not appear in this context"
 msgid "local variable %qD may not appear in this context"
 msgstr "%Hvariabel lokal %qD mungkin tidak muncul dalam konteks ini"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "fungsi media ini hanya tersedia di fr500"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected id-expression"
 msgstr "diduga ekspresi"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, fuzzy, gcc-internal-format
 #| msgid "%Hscope %qT before %<~%> is not a class-name"
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "%Hlingkup %qT sebelum %<~%> bukan sebuah class-name"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdeclaration of %<~%T%> as member of %qT"
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "%Hdeklarasi dari %<~%T%> sebagai anggota dari %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, fuzzy, gcc-internal-format
 #| msgid "%Htypedef-name %qD used as destructor declarator"
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "%Htypedef-nama %qD digunakan sebagai desktruktor deklarator"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, fuzzy, gcc-internal-format
 #| msgid "expected specifier-qualifier-list"
 msgid "expected unqualified-id"
 msgstr "diduga specifier-qualifier-list"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD bukan sebuah template"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%qT meresolf ke %qT, yang bukan sebuah tipe enumerasi"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "%Hincomplete type %qT used in nested name specifier"
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "%Htipe %qT tidak lengkap digunakan dalam nama penspesifikasi nested"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "%Hincomplete type %qT used in nested name specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "%Htipe %qT tidak lengkap digunakan dalam nama penspesifikasi nested"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 #| msgid "%Hincomplete type %qT used in nested name specifier"
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "%Htipe %qT tidak lengkap digunakan dalam nama penspesifikasi nested"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected nested-name-specifier"
 msgstr "diduga penspesifikasi deklarasi"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in casts"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<__builtin_next_arg%>"
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "jumlah dari argumen ke fungsi %<__builtin_next_arg%> salah"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<__builtin_next_arg%>"
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "jumlah dari argumen ke fungsi %<__builtin_next_arg%> salah"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<__builtin_next_arg%>"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "jumlah dari argumen ke fungsi %<__builtin_next_arg%> salah"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<__builtin_next_arg%>"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "jumlah dari argumen ke fungsi %<__builtin_next_arg%> salah"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 #| msgid "nested function %qs declared %<extern%>"
 msgid "selected function declared here"
 msgstr "fungsi nested %qs dideklarasikan %<extern%>"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ melarang compound literals"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "penggunaan tidak valid dari %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 #| msgid "%<%D::%D%> is not a member of %qT"
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> bukan sebuah anggota dari %qT"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "%Jtypedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%J typedef nama mungkin berupa sebuah nested-name-specifier"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new tidak dapat diaplikasikan untuk mereferensikan sebuah tipe"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "new tidak dapat diaplikasikan ke sebuah fungsi tipe"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ tidak mengijinkan designated penginisialisasi"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD tidak dapat memiliki argumen baku"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in %qs expressions"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in a new-expression"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, fuzzy, gcc-internal-format
 #| msgid "%Harray bound forbidden after parenthesized type-id"
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "%Harray bound dilarang setelah parenthesized tipe id"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "mencoba menghapus tanda kurung disekitar tipe-id"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected expression-list or type-id"
 msgstr "Diduga tipe ekspresi"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in a new-type-id"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "atribut diabaikan di template instantiation"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, fuzzy, gcc-internal-format
 #| msgid "%Hexpression in new-declarator must have integral or enumeration type"
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "%Hekspresi dalam pendeklarasi new harus memiliki integral atau tipe enumerasi"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "penggunaan dari gaya-lama cast"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<>>%> operator will be treated as two right angle brackets in C++0x"
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "%H%<>>%> operator akan diperlakukan sebagai dua sudut brackets dalam C++0x"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "disarankan tanda kurung disekeliling ekspresi %<>>%>"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C tidak mengijinkan kelebihan %<;%> diluar dari sebuah fungsi"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected end of capture-list"
 msgstr "Tidak terduga akhir dari modul"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in unary expression"
 msgid "already captured %qD in lambda expression"
 msgstr "operan tidak valid dalam ekspresi unary"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a reference type"
 msgid "%<this%> cannot be captured by reference"
 msgstr "new tidak dapat diaplikasikan untuk mereferensikan sebuah tipe"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 #| msgid "increment of read-only variable %qD"
 msgid "capture of non-variable %qE"
 msgstr "peningkatan dari variabel baca-saja %qD"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "default argument specified for lambda parameter"
 msgstr "argumen baku diberikan untuk parameter %d dari %q#D"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here"
+msgid "%q#E declared here"
+msgstr "%q+D dideklarasikan disini"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 #| msgid "attributes after parenthesized initializer ignored"
 msgid "attributes at the beginning of statement are ignored"
 msgstr "atribut setelah tanda kurung penginisialisasi diabaikan"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected labeled-statement"
 msgstr "diduga pernyataan"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcase label %qE not within a switch statement"
 msgid "case label %qE not within a switch statement"
 msgstr "%Hlabel case %qE tidak dalam sebuah pernyataan switch"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class, struct, or union type"
 msgid "%qE names the constructor, not the type"
 msgstr "%qT bukan sebuah tipe class, struct, atau union"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "lvalue required in asm statement"
 msgid "%<if consteval%> requires compound statement"
 msgstr "lvalue dibutuhkan dalam pernyataan asm"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected selection-statement"
 msgstr "diduga deklarasi atau pernyataan"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "fungsi mengembalikan sebuah array"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs declared as a function"
 msgid "condition declares a function"
 msgstr "field %qs dideklarasikan sebagai sebuah fungsi"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in conditions"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected initializer"
 msgstr "diduga pengidentifikasi"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "non-local variable %q#D uses local type %qT"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "variabel bukan-lokal %q#D menggunakan tipe lokal %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "ekspresi pernyataan memiliki tipe tidak lengkap"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected iteration-statement"
 msgstr "diduga deklarasi atau pernyataan"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in vector initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "kelebihan elemen dalam penginisialisasi vektor"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "deklarasi friend tidak dalam definisi kelas"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ melarang gotos yang sudah dihitung"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected jump-statement"
 msgstr "diduga pernyataan"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected module-partition"
 msgstr "diduga ekspresi"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "Expected name"
 msgid "expected module-name"
 msgstr "Diduga nama"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "metode deklarasi tidak dalam context @interface"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "using-declaration untuk bukan-anggota di class scope"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "used here"
 msgid "scope opened here"
 msgstr "digunakan disini"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr ""
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "using-declaration untuk bukan-anggota di class scope"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%qE may only occur once in an export declaration"
 msgstr "%<inline%> dalam deklarasi kosong"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C tidak mengijinkan kelebihan %<;%> diluar dari sebuah fungsi"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C tidak mengijinkan kelebihan %<;%> diluar dari sebuah fungsi"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr ""
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "attributes are not permitted in this position"
 msgstr "atribut %qE tidak didukung di platform ini"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr ""
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "spesialisasi eksplisit dari bukan-template %qT"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "instantiation eksplisit dari bukan-template %q#D"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "export-declarations are not permitted here"
 msgstr "penunjuk tidak diijinkan sebagai nilai case"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<__label__%> not at the beginning of a block"
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%H%<__label__%> tidak berada diawal dari sebuah blok"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, fuzzy, gcc-internal-format
 #| msgid "%Hmixing declarations and function-definitions is forbidden"
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "%Hpencampuran deklarasi dan definisi fungsi dilarang"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in a for-range-declaration"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 #| msgid "using %<typename%> outside of template"
 msgid "structured binding pack outside of template"
 msgstr "menggunakan %<typename%> diluar dari template"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "multiple types in one declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "multiple tipe dalam satu deklarasi"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "empty structured binding declaration"
 msgstr "deklarasi kosong"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member function declaration"
 msgid "invalid initializer for structured binding declaration"
 msgstr "deklarasi anggota fungsi tidak valid"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of %qs"
 msgid "for-range-declaration cannot be %qs"
 msgstr "deklarasi sebelumnya dari %qs"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "penspesifikasi kelas penyimpanan dalam parameter deklarasi"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<friend%> used outside of class"
 msgid "%<friend%> used outside of class"
 msgstr "%H%<friend%> digunakan diluar dari kelas"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "Atribut di %L tidak diijinkan dalam sebuah definisi TIPE"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "  conflict with %q+D"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "  konflik dengan %q+D"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<auto%> will change meaning in C++0x; please remove it"
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%H%<auto%> akan mengubah arti dalam C++0x; mohon hapus itu"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in condition"
 msgstr "%q+D tidak valid dalam %q#T"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in lambda"
 msgstr "%q+D tidak valid dalam %q#T"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "type-specifier invalid in lambda"
 msgstr "penspesifikasi kelas penyimpanan dalam parameter deklarasi"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, fuzzy, gcc-internal-format
 #| msgid "%Hclass definition may not be declared a friend"
 msgid "class definition may not be declared a friend"
 msgstr "%Hdefinisi kelas mungkin tidka dideklarasikan sebagai friend"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplates may not be %<virtual%>"
 msgid "templates may not be %<virtual%>"
 msgstr "%Htemplate mungkin bukan %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in explicit-specifier"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid linkage-specification"
 msgstr "spesifikasi kelas dasar tidak valid"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in a conversion-type-id"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "penggunaan tidak valid dari %<auto%> dalam operator konversi"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "penggunaan tidak valid dari %<auto%> dalam operator konversi"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 #| msgid "%Honly constructors take base initializers"
 msgid "only constructors take member initializers"
 msgstr "%Hhanya konstruktor yang mengambil penginisialisasi dasar"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcannot expand initializer for member %<%D%>"
 msgid "cannot expand initializer for member %qD"
 msgstr "%Htidak dapat mengekspand penginisialisasi untuk anggota %<%D%>"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 #| msgid "static declaration of %q+D follows non-static declaration"
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "deklarasi statis dari %q+D mengikuti deklarasi bukan statis"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "anachronistic gaya-lama kelas dasar penginisialisasi"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, fuzzy, gcc-internal-format
 #| msgid "%Hkeyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "%Hkata kunci %<typename%> tidak diijinkan dalam konteks ini (sebuah anggota terkualifikasi secara implisit adalah sebuah tipe)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected suffix identifier"
 msgstr "diduga pengidentifikasi"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, fuzzy, gcc-internal-format
 #| msgid "expected a string after %<#pragma message%>"
 msgid "expected empty string after %<operator%> keyword"
 msgstr "diduga sebuah string setelah %<#pragma message%>"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in binary operation"
 msgid "invalid encoding prefix in literal operator"
 msgstr "operan tidak valid dalam operasi binary"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected operator"
 msgstr "operan tidak terduga"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "kata kunci %<export%> tidak terimplementasi, dan akan diabaikan"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "kata kunci %<export%> tidak terimplementasi, dan akan diabaikan"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid constrained type parameter"
 msgstr "batasan untuk operan tidak valid"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "cv-qualified type parameter"
 msgstr "tipe argumen tidak valid"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "penggunaan tidak valid dari %<auto%> dalam operator konversi"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate parameter pack %qD cannot have a default argument"
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "%Htemplate parameter pack %qD tidak dapat memiliki sebuah argumen baku"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate parameter packs cannot have default arguments"
 msgid "template parameter packs cannot have default arguments"
 msgstr "%Htemplate parameter pack tidak dapat memiliki argumen baku"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-id"
 msgstr "diduga pernyataan"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> tidak dapat berawal sebuah daftar template argumen"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> adalah sebuah penyebutan alternatif untuk %<[%>. Masukan spasi diantara %<<%> dan %<::%>"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 #| msgid "(if you use %<-fpermissive%> G++ will accept your code)"
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(jika anda menggunakan %<-fpermissive%> G++ akan menerima kode anda)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid template-argument-list"
 msgstr "tipe argumen tidak valid"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "%<<::%> cannot begin a template-argument list"
 msgid "expected %<(%> after template-argument-list"
 msgstr "%<<::%> tidak dapat berawal sebuah daftar template argumen"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, fuzzy, gcc-internal-format
 #| msgid "%Hparse error in template argument list"
 msgid "parse error in template argument list"
 msgstr "%Hparse error dalam daftar argumen template"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-name"
 msgstr "diduga pernyataan"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnon-template %qD used as template"
 msgid "non-template %qD used as template"
 msgstr "%Hbukan-template %qD digunakan sebagai template"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "gunakan %<%T::template %D%> untuk mengindikasikan bahwa ini adalah template"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, fuzzy, gcc-internal-format
 #| msgid "%Hexpected parameter pack before %<...%>"
 msgid "expected parameter pack before %<...%>"
 msgstr "%Hdiduga parameter pack sebelum %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-argument"
 msgstr "diduga pernyataan"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid non-type template argument"
 msgstr "tipe argumen tidak valid"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr ""
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "eksplisit instantiation dari tipe bukan template %qT"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "eksplisit instantiation dari tipe bukan template %qT"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "eksplisit instantiation dari tipe bukan template %qT"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate specialization with C linkage"
 msgid "template specialization with C linkage"
 msgstr "%Hspesialisasi template dengan C linkage"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected type specifier"
 msgstr "diduga penspesifikasi deklarasi"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "use of %qs in template"
 msgid "use of %<auto%> in template argument"
 msgstr "penggunaan dari %qs dalam template"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected template-id for type"
 msgstr "Diduga tipe ekspresi"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 #| msgid "Expected name"
 msgid "expected type-name"
 msgstr "Diduga nama"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%H%qE tidak bernama sebuah tipe"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "Recognize GNU-defined keywords"
 msgid "concept defined here"
 msgstr "Kenali kata kunci didefinisikan GNU"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "penggunaan tidak valid dari %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<}%> before %<else%>"
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "diduga %<}%> sebelum %<else%>"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "deklarasi %qD tidak mendeklarasikan apapun"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "atribut diabaikan di tipe uninstantiasi"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "atribut diabaikan di template instantiation"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "atribut diabaikan di elaborated type penspesifikasi yang tidak memforward sebuah deklarasi"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is an enumeration template"
 msgstr "%qD bukan sebuah template fungsi"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD bukan sebuah anggota dari %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<namespace%> definition is not allowed here"
 msgid "unnamed scoped enum is not allowed"
 msgstr "%H%<namespace%> definisi tidak diijinkan disini"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in enum-base"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<;%> or %<{%>"
 msgstr "diduga %<,%> atau %<,%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 #| msgid "Enable automatic template instantiation"
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "Aktifkan instantiation template otomatis"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfriend declaration does not name a class or function"
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "%Hdeklarasi friend tidak bernama sebuah kelas atau fungsi"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdeclaration of %qD in namespace %qD which does not enclose %qD"
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "%Hdeklarasi dari %qD dalam namespace %qD yang tidak dilingkupi %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdeclaration of %qD in %qD which does not enclose %qD"
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "%Hdeklarasi dari %qD dalam %qD yang tidak dilingkup %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, fuzzy, gcc-internal-format
 #| msgid "%Hextra qualification not allowed"
 msgid "extra qualification not allowed"
 msgstr "%Hekstra pengkualifikasi diabaikan"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids incrementing an enum"
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ melarang menaikkan sebuah enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD is not a namespace-name"
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%H%qD bukan sebuah nama namespace"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD is not a namespace-name"
 msgid "%qD is not a namespace-name"
 msgstr "%H%qD bukan sebuah nama namespace"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected namespace-name"
 msgstr "diduga nama class"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<namespace%> definition is not allowed here"
 msgid "a nested namespace definition cannot have attributes"
 msgstr "%H%<namespace%> definisi tidak diijinkan disini"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "a nested namespace definition cannot be inline"
 msgstr "Peringatkan ketika sebuah fungsi inline tidak dapat diinline"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "namespace %qD entered"
 msgstr "penggunaan dari namespace %qD  sebagai ekspresi"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<namespace%> definition is not allowed here"
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%H%<namespace%> definisi tidak diijinkan disini"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, fuzzy, gcc-internal-format
 #| msgid "%Ha template-id may not appear in a using-declaration"
 msgid "a template-id may not appear in a using-declaration"
 msgstr "%Hsebuah template-id mungkin tidak muncul dalam sebuah using deklarasi"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "membentuk %s ke tipe referensi %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "%Jcase value %qs not in enumerated type %qT"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%J nilai case %qs tidak dalam tipe enumerasi %qT"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete typedef %qD"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "penggunaan tidak valid dari typedef tidak lengkap %qD"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "opaque-enum-declaration here"
 msgstr "deklarasi sebelumnya %q+#D disini"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in alias template declarations"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "%Hduplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "%Hduplikasi cv kualifikasi"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%qD tidak didefinisikan diluar dari jangkauan fungsi"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT bukan sebuah namespace"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%qD tidak didefinisikan diluar dari jangkauan fungsi"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "atribut diabaikan dalam deklarasi dari %q+#T"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "nama parameter (tanpa tipe) dalam deklarasi fungsi"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "nama parameter (tanpa tipe) dalam deklarasi fungsi"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "cast adds new qualifiers to function type"
 msgid "cannot handle qualified name for variant function"
 msgstr "cast menambahkan kualifier baru ke tipe fungsi"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "konversi baku tidak diijinkan dalam konteks ini"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cleanup argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "membersihkan argumen bukan sebuah identifikasi"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "%s: declaration of function '%s' not converted\n"
 msgid "no declaration of base function %qs in this scope"
 msgstr "%s: deklarasi dari fungsi '%s' tidak diubah\n"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "referensi ke %qD adalah ambigu"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "%Hattributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "%Hatribut tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "%Hattributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "%Hatribut tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "%Hattributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "%Hatribut tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "%Hattributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "%Hatribut tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<namespace%> definition is not allowed here"
 msgid "a function-definition is not allowed here"
 msgstr "%H%<namespace%> definisi tidak diijinkan disini"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "%Han asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "%Hsebuah spesifikasi asm tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, fuzzy, gcc-internal-format
 #| msgid "%Hattributes are not allowed on a function-definition"
 msgid "attributes are not allowed on a function-definition"
 msgstr "%Hatribut tidak diijinkan dalam sebuah definisi fungsi"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinitializer provided for function"
 msgid "initializer provided for function"
 msgstr "%Hpenginisialisasi disediakan untuk fungsi"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "atribut setelah tanda kurung penginisialisasi diabaikan"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared as inline"
 msgid "non-function %qD declared as implicit template"
 msgstr "fungsi %q+D redeklarasi sebagai inline"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "array bound bukan sebuah konstanta integer"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "cannot define member of dependent typedef %qT"
 msgstr "membuat penunjuk ke anggota referensi tipe %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<%T::%E%> is not a type"
 msgid "%<%T::%E%> is not a type"
@@ -73583,318 +73680,318 @@ msgstr "%H%<%T::%E%> bukan sebuah tipe"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "invalid declarator"
 msgstr "deklarasi fungsi tidak valid"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid use of constructor as a template"
 msgid "invalid use of constructor as a template"
 msgstr "%Hpenggunaan tidak valid dari konstruktor sebagai sebuah template"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "penggunaan %<%T::%D%> daripada %<%T::%D%> untuk menamai konstruktor dalam sebuah nama berkualifikasi"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "qualified-id in declaration"
 msgstr "deklarasi fungsi tidak valid"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected declarator"
 msgstr "diduga penspesifikasi deklarasi"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD is a namespace"
 msgid "%qD is a namespace"
 msgstr "%H%qD adalah sebuah namespace"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "membuat penunjuk ke anggota dari tipe bukan kelas %qT"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected ptr-operator"
 msgstr "operan tidak terduga"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, fuzzy, gcc-internal-format
 #| msgid "%Hduplicate cv-qualifier"
 msgid "duplicate cv-qualifier"
 msgstr "%Hduplikasi cv kualifikasi"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 #| msgid "multiple inline callers"
 msgid "multiple ref-qualifiers"
 msgstr "multiple pemanggil inline"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 #| msgid "%Hduplicate cv-qualifier"
 msgid "duplicate virt-specifier"
 msgstr "%Hduplikasi cv kualifikasi"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 #| msgid "missing makefile target after %qs"
 msgid "missing template arguments after %qE"
 msgstr "hilang target makefile setelah %qs"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "%Hparse error in template argument list"
 msgid "%qT not permitted in template argument"
 msgstr "%Hparse error dalam daftar argumen template"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of %qT"
 msgstr "penggunaan tidak valid dari %qD"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in template arguments"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "invalid use of %<auto%> in template argument"
 msgstr "penggunaan tidak valid dari %<auto%> dalam operator konversi"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected type-specifier"
 msgstr "diduga pengidentifikasi"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected %<,%> or %<...%>"
 msgstr "diduga %<:%> atau %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in parameter types"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "penspesifikasi kelas penyimpanan dalam parameter deklarasi"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "bukan parameter %qs tidak dapat menjadi parameter pack"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdefault arguments are only permitted for function parameters"
 msgid "default arguments are only permitted for function parameters"
 msgstr "%Hargumen baku hanya diijinkan untuk parameter fungsi"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 #| msgid "%H%sparameter pack %qD cannot have a default argument"
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "%H%s parameter pack %qD tidak dapat memiliki sebuah argumen baku"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate parameter pack cannot have a default argument"
 msgid "template parameter pack cannot have a default argument"
 msgstr "%Htemplate parameter pack tidak dapat memiliki sebuah argumen baku"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 #| msgid "%H%sparameter pack cannot have a default argument"
 msgid "parameter pack cannot have a default argument"
 msgstr "%H%s parameter pack tidak dapat memiliki sebuah argumen baku"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate parameter pack cannot have a default argument"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "%Htemplate parameter pack tidak dapat memiliki sebuah argumen baku"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ tidak mengijinkan designated penginisialisasi"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ tidak mengijinkan designated penginisialisasi"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ tidak mengijinkan designated penginisialisasi"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected class-name"
 msgstr "diduga nama class"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "expected %<;%> after class definition"
 msgstr "%q+D dideklarasikan inline setelah definisinya"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "expected %<;%> after struct definition"
 msgstr "%q+D dideklarasikan inline setelah definisinya"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "expected %<;%> after union definition"
 msgstr "Tidak terduga sampah setelah deklarasi fungsi di %C"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "%Hduplicate %qs"
 msgid "duplicate %qD specifier"
 msgstr "%Hduplikasi %qs"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<{%> or %<:%>"
 msgstr "diduga %<,%> atau %<,%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfriend declaration does not name a class or function"
 msgid "qualified name does not name a class"
 msgstr "%Hdeklarasi friend tidak bernama sebuah kelas atau fungsi"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 #| msgid "%Hkeyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "%Hkata kunci %<typename%> tidak diijinkan diluar dari templates"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid class name in declaration of %qD"
 msgid "invalid class name in declaration of %qD"
 msgstr "%Hnama kelas tidak valid dalam deklarasi dari %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "mendifinisikan eksplisit spesialisasi %qD dalam deklarasi friend"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, fuzzy, gcc-internal-format
 #| msgid "%Han explicit specialization must be preceded by %<template <>%>"
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "%Hsebuah eksplisit spesialisasi harus diawali oleh %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfunction template %qD redeclared as a class template"
 msgid "function template %qD redeclared as a class template"
 msgstr "%Htemplate fungsi %qD redeklarasikan sebagai sebuah template kelas"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "%Hprevious definition of %q+#T"
 msgid "previous definition of %q#T"
@@ -73903,305 +74000,305 @@ msgstr "%Hdefinisi sebelumnya dari %q+#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected class-key"
 msgstr "diduga nama class"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<class%> or %<typename%>"
 msgstr "diduga %<,%> atau %<,%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, fuzzy, gcc-internal-format
 #| msgid "%Ha class-key must be used when declaring a friend"
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "%Hsebuah class-key harus digunakan ketikan mendeklarasikan sebuah friend"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfriend declaration does not name a class or function"
 msgid "friend declaration does not name a class or function"
 msgstr "%Hdeklarasi friend tidak bernama sebuah kelas atau fungsi"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "bit-field %qD dengan tipe bukan integral"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, fuzzy, gcc-internal-format
 #| msgid "%Hpure-specifier on function-definition"
 msgid "pure-specifier on function-definition"
 msgstr "%Hpenspesifikasi pure di definisi fungsi"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "stray %<,%> at end of member declaration"
 msgstr "%<[*]%> tidak dalam sebuah deklarasi"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %<;%> at end of member declaration"
 msgstr "diduga %<(%> atau akhir dari baris"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, fuzzy, gcc-internal-format
 #| msgid "invalid AE type specified (%s)\n"
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "tipe AE yang dispesifikasikan (%s) tidak valid\n"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<namespace%> definition is not allowed here"
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "%H%<namespace%> definisi tidak diijinkan disini"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "attributes in parameter array declarator ignored"
 msgid "attributes on base specifiers are ignored"
 msgstr "atribut dalam parameter pendeklarasi array diabaikan"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, fuzzy, gcc-internal-format
 #| msgid "%Hkeyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "%Hkata kunci %<typename%> tidak diijinkan dalam konteks ini (kelas dasar  adalah sebuah tipe implisit)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in an exception-specification"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 #| msgid "due to different exception specifications"
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "karena perbedaan eksepsi spesifikasi"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "penggunaan tidak valid dari %<auto%> dalam operator konversi"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in exception-declarations"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> dalam deklarasi kosong"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD tidak dapat memiliki argumen baku"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "diduga %qT tetapi argumen memiliki tipe %qT"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "%s atribut konflik dengan %s atribut di %L"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected an identifier for the attribute name"
 msgstr "diduga pengidentifikasi atau %<(%>"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 #| msgid "%Hexpected parameter pack before %<...%>"
 msgid "expected attribute before %<...%>"
 msgstr "%Hdiduga parameter pack sebelum %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "atribut bukan null tanpa argumen di sebuah bukan prototipe"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected conditional-expression"
 msgstr "diduga ekspresi"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qs is only available with %qs"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "%qE atribut diabaikan untuk %qE"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "atribut diabaikan di tipe uninstantiasi"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only available for 64-bit"
 msgid "contracts are only available with %qs"
 msgstr "%qs atribut hanya tersedia untuk 64 bit"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "expression must be enclosed in parentheses"
 msgstr "ekspresi pernyataan memiliki tipe tidak lengkap"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "posisi yang diminta bukan sebuah konstanta integer"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "alignmen yang diminta bukan sebuah konstanta"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 #| msgid "invalid redeclaration of %q+D"
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "redeklarasi tidak valid dari %q+D"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, fuzzy, gcc-internal-format
 #| msgid "%Htoo few template-parameter-lists"
 msgid "too few template-parameter-lists"
@@ -74211,500 +74308,500 @@ msgstr "%Hterlalu sedikit template-parameter-list"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, fuzzy, gcc-internal-format
 #| msgid "%Htoo many template-parameter-lists"
 msgid "too many template-parameter-lists"
 msgstr "%Hterlalu banyak template-parameter-lists"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnamed return values are no longer supported"
 msgid "named return values are no longer supported"
 msgstr "%Hnilai kembali bernama tidak lagi didukung"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid declaration of member template in local class"
 msgid "invalid declaration of member template in local class"
 msgstr "%Hdeklarasi tidak valid dari anggota template dalam kelas lokal"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate with C linkage"
 msgid "template with C linkage"
 msgstr "%Htemplate dengan C linkage"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid explicit specialization"
 msgstr "spesifikasi kelas dasar tidak valid"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "template declaration of %<typedef%>"
 msgstr "template deklarasi dari %q#D"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "redeklarasi tidak mendeklarasikan apapun"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 #| msgid "%Hexplicit template specialization cannot have a storage class"
 msgid "explicit template specialization cannot have a storage class"
 msgstr "%Heksplisit template spesialisasi tidak dapat memiliki sebuah kelas penyimpanan"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<>>%> should be %<> >%> within a nested template argument list"
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%H%<>>%> seharusnya %<> >%> didalam sebuah daftar argumen template nested"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, fuzzy, gcc-internal-format
 #| msgid "%Hspurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "%Hspurious %<>>%>, gunakan %<>%> untuk mengakhiri sebuah daftar argumen template"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "%Hspurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%Hspurious %<>>%>, gunakan %<>%> untuk mengakhiri sebuah daftar argumen template"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid use of %qD in linkage specification"
 msgid "invalid use of %qD in linkage specification"
 msgstr "%Hpenggunaan tidak valid dari %qD dalam spesifikasi linkage"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "  conflict with %q+D"
 msgid "%qD specifier conflicts with %qs"
 msgstr "  konflik dengan %q+D"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<__thread%> before %qD"
 msgid "%<__thread%> before %qD"
 msgstr "%H%<__thread%> sebelum %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 tidak mendukung %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 #| msgid "both %<_Sat%> and %<char%> in declaration specifiers"
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "baik %<_Sat%> dan %<char%> dalam penspesifikasi deklarasi"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate %qD"
 msgstr "duplikasi %qE"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, fuzzy, gcc-internal-format
 #| msgid "%Hduplicate %qs"
 msgid "duplicate %qs"
 msgstr "%Hduplikasi %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<new%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<delete%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<return%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<extern%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected %<static_assert%>"
 msgstr "diduga pernyataan"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<decltype%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<operator%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<class%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<template%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<namespace%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<using%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<asm%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<try%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<catch%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<throw%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<auto%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<__label__%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@try%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@synchronized%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@throw%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<__transaction_relaxed%>"
 msgstr "diduga %<none%> atau %<shared%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<co_yield%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<::%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<...%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<*%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<~%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected %<:%> or %<::%>"
 msgstr "diduga %<:%> atau %<...%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<:]%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "%qs tag digunakan dalam penamaan %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%q#T was previously declared here"
 msgstr "%q+T telah dideklarasikan sebelumnya disini"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "tidak dapat mendeklarasikan referensi ke %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared with greater visibility than its base %qT"
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT dideklarasikan dengan visibility lebih besar dari basenya %qT"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 #| msgid "template class without a name"
 msgid "replace the class-key with %qs"
 msgstr "template kelas tanpa sebuah nama"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "%qT referred to as %qs"
 msgid "%qT defined as %qs here"
 msgstr "%qT mereferensikan sebagai %qs"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "%qT first declared as %qs here"
 msgstr "%J%qD telah dideklarasikan disini"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qD redeclared with different access"
 msgid "%qD redeclared with different access"
 msgstr "%H%qD redeklarasi dengan akses berbeda"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<template%> (as a disambiguator) is only allowed within templates"
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "%H%<template%> (sebagai sebuah disambiguator) hanya diijinkan dalam templates"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfile ends in default argument"
 msgid "file ends in default argument"
 msgstr "%Hberkas berakhir dalam argumen baku"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, fuzzy, gcc-internal-format
 #| msgid "%Hmisplaced %<@%D%> Objective-C++ construct"
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "%Hsalah tempat %<@%D%> Objective-C++ konstruk"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<@encode%> must specify a type as an argument"
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%H%<@encode%> harus menspesifikasikan sebuah tipe sebagai sebuah argumen"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid Objective-C++ selector name"
 msgid "invalid Objective-C++ selector name"
 msgstr "%Hpemilih nama Objective-C++ tidak valid"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "objective-c++ method declaration is expected"
 msgstr "diduga penspesifikasi deklarasi"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "method attributes must be specified at the end"
 msgstr "%J atribut daerah tidak dapat dispesifikasikan untuk variabel lokal"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "invalid type for instance variable"
 msgstr "tipe tidak valid untuk iterasi variabel %qE"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, fuzzy, gcc-internal-format
 #| msgid "%Hidentifier expected after %<@protocol%>"
 msgid "identifier expected after %<@protocol%>"
 msgstr "%Hpengidentifikasi diduga setelah %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "%qE atribut diabaikan untuk %qE"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid type for property"
 msgstr "tipe argumen tidak valid"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr ""
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected integer expression list"
 msgstr "diduga ekspresi integer"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<wait%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "diduga %<,%>, %<,%> atau %<}%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid reduction-identifier"
 msgstr "penginisialisasi tidak valid"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in iterator type"
@@ -74714,191 +74811,191 @@ msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable tidak lagi didukung"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "inisialisasi berkurung tidak diijinkan dalam loop OpenMP %<for%>"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "iterasi variabel %qD seharusnya bukan reduksi"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp section%> hanya bisa digunakan dalam %<#pragma omp section%> konstruk"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not a C pointer"
 msgstr "%qD bukan sebuah tipe"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<target%>"
 msgstr "diduga %<{%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "penginisialisasi tidak valid"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected id-expression (arguments)"
 msgstr "diduga ekspresi"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined in declare reduction type list"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "%Hnew types may not be defined in a return type"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "%Htipe baru mungkin tidak didefinisikan dalam sebuah tipe kembali"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "diduga %<=%>, %<,%>, %<,%>, %<asm%> atau %<__attribute__%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD bukan sebuah anggota dari fungsi template"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "OpenMP directives at %C may not appear in PURE or ELEMENTAL procedures"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "Direktif OpenMP di %C tidak boleh muncul dalam prosedur PURE atau ELEMENTAL"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "%Hjunk at end of %<#pragma GCC pch_preprocess%>"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "%Hsampah diakhir dari %<#pragma GCC pch_preprocess%>"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%> hanya mungkin digunakan dalam pernyataan compound"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp flush%> hanya mungkin digunakan dalam pernyataan compound"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC option is not allowed inside functions"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "#pragma GCC option tidak diijinkan didalam fungsi"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "inter-module optimisasi tidak diimplementasikan untuk C++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "konversi baku tidak diijinkan dalam konteks ini"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplates may not be %<virtual%>"
 msgid "implicit templates may not be %<virtual%>"
 msgstr "%Htemplate mungkin bukan %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -75418,17 +75515,23 @@ msgstr "gunakan template<> untuk spesialisasi eksplisit"
 msgid "redeclaration of %qD with different constraints"
 msgstr "deklarasi dari %qF throws exceptions berbeda"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "%Htoo many template-parameter-lists"
+msgid "local class in lambda in template parameter list"
+msgstr "%Hterlalu banyak template-parameter-lists"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "penspesifikasi template tidak dispesifikasikan dalam deklarasi dari %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "redeclared with %d template parameter(s)"
 msgid "redeclared with %d template parameter"
@@ -75436,7 +75539,7 @@ msgid_plural "redeclared with %d template parameters"
 msgstr[0] "redeklarasikan dengan %d parameter template"
 msgstr[1] "redeklarasikan dengan %d parameter template"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D used %d template parameter(s)"
 msgid "previous declaration %qD used %d template parameter"
@@ -75444,528 +75547,528 @@ msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "deklarasi sebelumnya %q+D digunakan %d parameter template"
 msgstr[1] "deklarasi sebelumnya %q+D digunakan %d parameter template"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "parameter template %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "redeklarasikan disini sebagai %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here as %q#D"
 msgid "redeclared here"
 msgstr "redeklarasikan disini sebagai %q#D"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qF throws different exceptions"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "deklarasi dari %qF throws exceptions berbeda"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 #| msgid "%Joriginal definition appeared here"
 msgid "original declaration appeared here"
 msgstr "%J definisi asli muncul disini"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qF throws different exceptions"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "deklarasi dari %qF throws exceptions berbeda"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "ini harus berupa alamat dari sebuah fungsi dengan hubungan eksternal"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, fuzzy, gcc-internal-format
 #| msgid "it must be the address of a function with external linkage"
 msgid "it must be the name of a function with external linkage"
 msgstr "ini harus berupa alamat dari sebuah fungsi dengan hubungan eksternal"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT karena objek %qD bukan eksternal linkage"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE bukan sebuah argumen template yang valid dari tipe %qT karena %qD tidak memiliki eksternal linkage"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "(sebuah penunjuk ke anggota hanya dapat dibentuk dengan %<&%E%>)"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qT bukan sebuah anggota dari %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "got %d template parameters for %q#D"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "diperoleh %d parameter template untuk %q#D"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %qT and %qT"
 msgid "  mismatched types %qT and %qT"
 msgstr "perbandingan diantara tipe %qT dan %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, fuzzy, gcc-internal-format
 #| msgid "%Htemplate parameter pack %qD cannot have a default argument"
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "%Htemplate parameter pack %qD tidak dapat memiliki sebuah argumen baku"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 #| msgid "template arguments to %qD do not match original template %qD"
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "template argumen ke %qD tidak cocok dengan template asli %qD"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "  %qE is not equivalent to %qE"
 msgstr "%qs tidak valid untuk %qs"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "partial spesialisasi %qT tidak menspesialisasikan argumen template apapun"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "  member function type %qT is not a valid template argument"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "tidak dapat mengubah tipe %qT ke tipe %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an ambiguous base of %qT"
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "%qT adalah sebuah dasar ambigu dari %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "  %qT is not derived from %qT"
 msgstr "tipe %qT tidak diturunkan dari tipe %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decrement a pointer to incomplete type %qT"
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "tidak dapat mengurangi penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "  template argument %qE does not match %qE"
 msgstr "argumen dari tipe %qT tidak cocok dengan %qT"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE bukan sebuah argumen template yang valid dari tipe %qT karena %qE bukan sebuah variabel"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE bukan sebuah argumen template yang valid dari tipe %qT karena %qD tidak memiliki eksternal linkage"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE bukan sebuah argumen template yang valid dari tipe %qT karena %qE bukan sebuah variabel"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "the address of %qD is not a valid template argument"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qE bukan sebuah argumen template yang valid dari tipe %qT karena %qD tidak memiliki eksternal linkage"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD bukan sebuah template argumen yang valid karena %qD bukan sebuah variabel, bukan alamat dari sebuah variabel"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qD bukan sebuah template argumen yang valid karena %qD bukan sebuah variabel, bukan alamat dari sebuah variabel"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT karena string literal tidak dapat digunakan dalam konteks ini"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "in template argument for type %qT"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "argumen dari atribut %qs bukan sebuah konstanta string"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE bukan sebuah template argumen yang valid untuk tipe %qT karena konflik dalam cv kualifikasi"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT karena ini bukan sebuah lvalue"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a non-constant expression"
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%qE bukan sebuah template argumen yang valid untuk tipe %qT karena ini bukan sebuah ekspresi konstan"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT karena ini adalah sebuah penunjuk"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "lebih baik coba gunakan %qE"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE bukan sebuah argumen template yang valid untuk tipe %qT karena ini dari tipe %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 #| msgid "Conflict in attributes of function argument at %C"
 msgid "ignoring attributes on template argument %qT"
 msgstr "Konflik dalam atribut dari argumen fungsi di %C"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "ignoring attributes in template argument %qE"
 msgstr "mengabaikan atribut yang diaplikasikan ke %qT setelah definisi"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, fuzzy, gcc-internal-format
 #| msgid "name of class shadows template template parameter %qD"
 msgid "injected-class-name %qD used as template template argument"
 msgstr "nama dari template kelas bayangan parameter template %qD"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid use of destructor %qD as a type"
 msgid "invalid use of destructor %qE as a type"
 msgstr "%Hpenggunaan tidak valid dari desktruktor %qD memiliki sebuah tipe"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "merefer ke sebuah anggota tipe dari sebuah parameter template, gunakan %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "tipe/nilai tidak cocok di argumen %d dalam daftar parameter template untuk %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  diduga sebuah konstanta dari tipe %qT, diperoleh %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  diduga sebuah template kelas, diperoleh %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  diduga sebuah tipe, diperoleh %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  diduga sebuah tipe, diperoleh %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  diduga sebuah template kelas, diperoleh %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a template of type %qD, got %qD"
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  diduga sebuah template dari tipe %qD, diperoleh %qD"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "tipe/nilai tidak cocok di argumen %d dalam daftar parameter template untuk %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "  expected %qD but got %qD"
 msgstr "  diduga sebuah tipe, diperoleh %qE"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument %qE to %qT"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "tidak dapat mengubah argumen template %qE ke %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "template argumen %d tidak valid"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "jumlah dari argumen template salah (%d, seharusnya %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "jumlah dari argumen template salah (%d, seharusnya %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "disediakan untuk %q+D"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "argumen baku diberikan untuk parameter %d dari %q#D"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%q#D is not a function template"
 msgstr "%qD bukan sebuah template fungsi"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "tipe bukan template %qT digunakan sebuah sebuah template"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "untuk deklarasi template %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "template constraint failure for %qD"
 msgstr "template deklarasi dari %q#D"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "use of %qs in template"
 msgid "use of invalid variable template %qE"
 msgstr "penggunaan dari %qs dalam template"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "kedalaman template instantiation melebihi maksimal dari %d (gunakan -ftemplate-depth-NN untuk meningkatkan maksimal) instantiating %qD"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "score argument must be constant integer expression"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "last argument must be an immediate"
 msgid "score argument must be non-negative"
 msgstr "argumen terakhir harus berupa sebuah immediate"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "property must be constant integer expression or string literal"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "property must be constant integer expression"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "instantiating erroneous template"
 msgstr "  dalam instantiation dari template %qT"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "%Joriginal definition appeared here"
 msgid "first error appeared here"
 msgstr "%J definisi asli muncul disini"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 #| msgid "%Jflexible array member in union"
 msgid "flexible array member %qD in union"
 msgstr "%J anggota array fleksibel dalam union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE tidak berada di awal dari deklarasi"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%T%>"
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "panjang argumen pack tidak cocok akan diekspan %<%T%>"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%E%>"
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "panjang argumen pack tidak cocok ketika mengekspan %<%E%>"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find 'nm'"
 msgid "cannot index an empty pack"
 msgstr "tidak dapat menemukan 'nm'"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for %q#D"
 msgid "  when instantiating default argument for call to %qD"
 msgstr "redefinisi dari argumen baku untuk %q#D"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "membuat penunjuk ke anggota fungsi dari tipe bukan kelas %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%T%>"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -75984,132 +76087,132 @@ msgstr "panjang argumen pack tidak cocok akan diekspan %<%T%>"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "variabel %qD memiliki tipe fungsi"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "tipe parameter %qT tidak valid"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "dalam deklarasi %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "fungsi mengembalikan sebuah array"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "fungsi mengembalikan sebuah fungsi"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice type"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE bukan sebuah variabel dalam clause %qs"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "membentuk referensi ke void"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forming pointer to reference type %qT"
 msgstr "membentuk %s ke tipe referensi %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forming reference to reference type %qT"
 msgstr "membentuk %s ke tipe referensi %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %s to qualified function type %qT"
 msgid "forming pointer to qualified function type %qT"
 msgstr "tidak dapat mendeklarasikan %s untuk fungsi yang dikualifikasikan dengan tipe %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %s to qualified function type %qT"
 msgid "forming reference to qualified function type %qT"
 msgstr "tidak dapat mendeklarasikan %s untuk fungsi yang dikualifikasikan dengan tipe %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "membuat penunjuk ke anggota dari tipe bukan kelas %qT"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "membuat penunjuk ke anggota referensi tipe %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "membuat penunjuk ke anggota dari tipe void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "membuat array dari %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "array %q+D diasumsikan memiliki sebuah elemen"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT bukan sebuah tipe class, struct, atau union"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT meresolf ke %qT, yang bukan sebuah tipe enumerasi"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT meresolf ke %qT, yang bukan sebuah tipe class"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT meresolf ke %qT, yang bukan sebuah tipe enumerasi"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type template"
 msgstr "diduga deklarasi atau pernyataan"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "penggunaan dari %qs dalam template"
@@ -76117,219 +76220,219 @@ msgstr "penggunaan dari %qs dalam template"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdeclaration of %<~%T%> as member of %qT"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "%Hdeklarasi dari %<~%T%> sebagai anggota dari %qT"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 #| msgid "qualified type %qT does not match destructor name ~%qT"
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "tipe kualifikasi %qT tidak cocok dengan nama destruktor ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "dependent-name %qE diparse sebagai sebuah bukan-tipe, tetapi instantiation menghasilkan sebuah tipe"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "katakan %<typename %E%> jika sebuah tipe adalah berarti"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands in comparison expression"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "operan tidak valid dalam ekspresi perbandingan"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "penggunaan tidak valid dari ekspresi ekspansi pack"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "gunakan %<...%> untuk mengekspan argumen pack"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE undeclared here (not in a function)"
 msgid "%qD declared here, later in the translation unit"
 msgstr "%H%qE tidak dideklarasikan disini (bukan dalam sebuah fungsi)"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to function %<__builtin_next_arg%>"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "jumlah dari argumen ke fungsi %<__builtin_next_arg%> salah"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "jumlah dari argumen salah dispesifikasikan untuk atribut %qs"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT bukan sebuah class atau namespace"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD bukan sebuah class atau namespace"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "menggunakan field tidak valid %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is/uses anonymous type"
 msgid "%qT is/uses unnamed type"
 msgstr "%qT adalah/menggunakan tipe anonymous"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "argumen template untuk %qD menggunakan tipe lokal %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT adalah sebuah tipe variabel termodifikasi"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "ekspresi integral %qE bukan konstan"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  mencoba untuk instantiate %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#T"
 msgstr "template class instantiation ambigu untuk %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#D"
 msgstr "template class instantiation ambigu untuk %q#T"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %+#D"
 msgid "%s %#qS"
 msgstr "%s %+#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "instantiation eksplisit dari bukan-template %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD bukan sebuah anggota data statis dari sebuah template class"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "template tidak cocok untuk %qD yang ditemukan"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "tipe %qT untuk instantiation eksplisit %qD tidak cocok dengan tipe yang dideklarasikan %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "eksplisit instantiation dari %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "duplikasi eksplisit instantiation dari %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ 1998 melarang penggunaan dari %<extern%> di instantiation eksplisit"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "class penyimpanan %qD diaplikasikan ke template instantiation"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiation of non-class template %qD"
 msgstr "instantiation eksplisit dari bukan-template %q#D"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "eksplisit instantiation dari tipe bukan template %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "eksplisit instantiation dari %q#T sebelum definisi dari template"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ melarang penggunaan dari %qE di instantiasi eksplisit"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "duplikasi instansiasi eksplisit dari %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "spesisialisasi eksplisit dari %qD setelah penggunaan pertama"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "%Han asm-specification is not allowed on a function-definition"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -76342,176 +76445,176 @@ msgstr "%Hsebuah spesifikasi asm tidak diijinkan dalam sebuah definisi fungsi"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "eksplisit instansiasi dari %qD tetapi tidak ada definisi yang tersedia"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth-NN to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "kedalaman template instansiasi melebihi maksimal dari %d instantiating %q+D, kemungkinan dari pembuatan tabel virtual (gunakan -ftemplate-depth-NN untuk meningkatkan maksimal)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template constant parameter"
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T bukan sebuah tipe valid untuk sebuah parameter template konstan"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "invalid template non-type parameter"
 msgstr "menggunakan parameter tipe template %qT setelah %qs"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template constant parameter"
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T bukan sebuah tipe valid untuk sebuah parameter template konstan"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 #| msgid "%Hkeyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "%Hkata kunci %<typename%> tidak diijinkan diluar dari templates"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "opaque vector types cannot be initialized"
 msgid "a concept cannot be constrained"
 msgstr "tipe vektor opaque tidak dapat diinisialisasi"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT bukan sebuah namespace"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "definisi dari %q#T didalam daftar parameter template"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, fuzzy, gcc-internal-format
 #| msgid "deducing auto from brace-enclosed initializer list requires #include <initializer_list>"
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "deduksi auto dari daftar penginisialisasi dikurung membutuhkan #include <daftar_penginisialisasi>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "%qD digunakan tanpa parameter template"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 #| msgid "%s only available with -std=c++0x or -std=gnu++0x"
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%s hanya tersedia dengan -std=c++0x atau -std=gnu++0x"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "use #include instead"
 msgid "use %qD directly instead"
 msgstr "lebih baik gunakan #include"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "class template argument deduction failed:"
 msgstr "template argumen %d tidak valid"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "fungsi tidak dipertimbangkan untuk inlining"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 #| msgid "explicit qualification in declaration of %qD"
 msgid "explicit deduction guide declared here"
 msgstr "eksplisit kualifikasi dalam deklarasi dari %qD"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 #| msgid "unable to deduce %qT from %qE"
 msgid "unable to deduce lambda return type from %qE"
 msgstr "tidak dapat mendeduksi %qT dari %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "tidak dapat mendeduksi %qT dari %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "insn tidak memenuhi batasannya:"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "insn tidak memenuhi batasannya:"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -76519,379 +76622,442 @@ msgstr "insn tidak memenuhi batasannya:"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new tidak dapat diaplikasikan untuk mereferensikan sebuah tipe"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new tidak dapat diaplikasikan ke sebuah fungsi tipe"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 #| msgid "name of class shadows template template parameter %qD"
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "nama dari template kelas bayangan parameter template %qD"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "new tidak dapat diaplikasikan ke sebuah fungsi tipe"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new tidak dapat diaplikasikan ke sebuah fungsi tipe"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new tidak dapat diaplikasikan ke sebuah fungsi tipe"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of %qE"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "tipe tidak kompatibel untuk argumen %d dari %qE"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qT bukan sebuah namespace"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "tidak dapat menjalankan '%s': %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "operan tidak terduga"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "tidak dapat menjalankan '%s': %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  diduga sebuah tipe, diperoleh %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT bukan sebuah penunjuk-ke-objek tipe"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT must be a function type"
 msgstr "%qD bukan sebuah template fungsi"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr ""
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "tidak dapat mendeklarasikan bit-field %qD dengan tipe fungsi"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr ""
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %<access_context%> argument"
 msgstr "tipe argumen tidak valid"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr ""
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "unexpected argument to %qs"
 msgstr "Diduga daftar argumen di %C"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of %qE"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "tipe tidak kompatibel untuk argumen %d dari %qE"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "tipe kembali konflik dispesifikasikan untuk %q+#D"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "tipe kembali konflik dispesifikasikan untuk %q+#D"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function '%s'"
 msgid "unknown metafunction %qD"
 msgstr "fungsi spesifikasi '%s' tidak diketahui"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "splice argument must be an expression of type %qs"
 msgstr "argumen ke decltype harus berupa sebuah ekspresi"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "%qE cannot be used as a function"
+msgid "cannot splice a null reflection"
+msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "tidak dapat menggunakan %<::%> dalam parameter deklarasi"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "add %<constexpr%>"
 msgstr "duplikasi %<const%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "konversi baku tidak diijinkan dalam konteks ini"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr ""
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected a reflection of an expression"
 msgstr "diduga ekspresi integer"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "%Hkeyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "%Hkata kunci %<typename%> tidak diijinkan diluar dari templates"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "penggunaan dari namespace %qD  sebagai ekspresi"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "tidak dapat secara eksplisit mendeklarasikan anggota %q#D untuk memiliki extern linkage"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "Enforce class member access control semantics"
+msgid "invalid class member access of type template %qE"
+msgstr "Paksa anggota kelas mengakses sematics kontrol"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can't use '%s' as a %s register"
+msgid "cannot use %qE to access a class member"
+msgstr "tidak dapat menggunakan '%s' sebagai sebuah register %s"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD bukan sebuah template fungsi"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -77250,646 +77416,646 @@ msgstr "definisi tidak valid dari tipe pengkualifikasi %qT"
 msgid "invalid base-class specification"
 msgstr "spesifikasi kelas dasar tidak valid"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 #| msgid "protected member %q+#D in anonymous union"
 msgid "cannot capture member %qD of anonymous union"
 msgstr "anggota terproteksi %q+#D dalam union anonymous"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not captured"
 msgstr "%qD bukan sebuah tipe"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of local variable with automatic storage from containing function"
 msgstr "penggunaan dari variabel %<auto%> dari fungsi yang berisi"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of parameter from containing function"
 msgstr "penggunaan dari variabel %<auto%> dari fungsi yang berisi"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "alloc_size parameter outside range"
 msgid "use of parameter outside function body"
 msgstr "alloc_size parameter diluar dari jangkauan"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched arguments"
 msgid "missing template arguments"
 msgstr "argumen tidak cocok"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "parameter template %qD dari tipe %qT tidak diijinkan dalam sebuah ekspresi konstanta integral karena ini bukan tipe integral atau enumerasi"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "penggunaan dari template class %qT sebagai ekspresi"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "permintaan untuk anggota %qD adalah ambigu dalam multiple inheritance lattice"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD tidak dapat muncul dalam sebuah ekspresi konstan"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "tipe dari %qE tidak dikenal"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an enumeration type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "ukuran dari array memiliki tipe %qT bukan integral"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "pack index is not an integral constant"
 msgstr "array bound bukan sebuah konstanta integer"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qs is negative"
 msgid "pack index %qE is negative"
 msgstr "ukuran dari array %qs adalah negatif"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "penspesifikasi kelas penyimpanan dalam parameter deklarasi"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "tidak dapat mengaplikasikan %<offsetof%> ke destruktor %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "tidak dapat mengaplikasikan %<offsetof%> ke anggota fungsi %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "tidak dapat mengaplikasikan %<offsetof%> ke anggota fungsi %qD"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "tidak dapat mengaplikasikan %<offsetof%> ke anggota fungsi %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "constructor priorities are not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "prioritas konstruktor tidak didukung"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "user defined reduction lookup is ambiguous"
 msgstr "referensi ke %qD adalah ambigu"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %+#D"
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has invalid type for %<reduction%>"
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE memiliki tipe tidak valid untuk %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "Expected initialization expression at %C"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "Diduga ekspresi inisialisasi di %C"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "linear step expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD bukan sebuah variabel dalam clause %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD bukan sebuah variabel dalam clause %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<gang%> static expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<gang%> static value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<gang%> num expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<vector%> length expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<worker%> num expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<gang%> num value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<vector%> length value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<worker%> num value must be positive"
 msgstr "%<num_threads%> nilai harus positif"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "schedule chunk ukuran ekspresi harus integral"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%qs length expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<async%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<thread_limit%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<device%> id must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "schedule chunk ukuran ekspresi harus integral"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "schedule chunk ukuran ekspresi harus integral"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD bukan sebuah variabel dalam clause %qs"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD muncul lebih dari sekali dalam data clauses"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "Nama '%s' tidak dapat digunakan sebagai sebuah operator terdefinisi di %C"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length traits arrays are not supported"
 msgstr "array dengan panjang bervariabel digunakan"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 #| msgid "reimplementation of class %qs"
 msgid "template %qE in clause %qs"
 msgstr "reimplementasi dari class %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<grainsize%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<priority%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<hint%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<filter%> expression must be integral"
 msgstr "num_threads ekspresi harus integral"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "nilai subscripted adalah bukan array ataupun penunjuk"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "%<tree%> is not defined as a pointer type"
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tree%> tidak didefinisikan sebagai sebuah tipe pointer"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD bukan berkas, namespace atau blok scope variabel"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%<threadprivate%> %qE direktif tidak dalam definisi %qT"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, fuzzy, gcc-internal-format
 #| msgid "%Hdifference between %qE and %qD does not have integer type"
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "%Hperbedaan antara %qE dan %qD tidak memiliki tipe integer"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid type for iteration variable %qE"
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%Htipe tidak valid untuk iterasi variabel %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr ""
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %E"
 msgid "static assertion failed: %.*s"
 msgstr "static assertion gagal: %E"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "kondisi bukan konstan untuk assertion static"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "argumen ke decltype harus berupa sebuah ekspresi"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%s tidak dapat meresolf alamat dari fungsi overloaded"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT bukan sebuah tipe kelas"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_next_arg%> dipanggil tanpa sebuah argumen"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_next_arg%> dipanggil tanpa sebuah argumen"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr ""
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a class or namespace"
 msgid "%qD is not a class or alias template"
 msgstr "%qD bukan sebuah class atau namespace"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "operan tangan-kiri dari ekspresi koma tidak memiliki efek"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "template argumen %qE melibatkan parameter template"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "both arguments to %<__builtin___clear_cache%> must be pointers"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -77898,382 +78064,382 @@ msgstr "kedua argumen ke %<__builtin___clear_cache%> harus berupa penunjuk"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr ""
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV kualifier tidak dapat diaplikasikan ke %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid " declared here"
 msgstr "%q+D dideklarasikan disini"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "Use 32-bit floating-point registers"
 msgid "%qT is a floating-point type"
 msgstr "Gunakan 32 bit register titik pecahan"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "%qT bukan sebuah tipe template"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT bukan sebuah basis dari %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T memiliki anggota data penunjuk"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "padding occurs between %qD and %qD"
 msgstr "perbandingan antara %q#T dan %q#T"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs bukan sebuah berkas data gcov"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class %qT has cv qualifiers"
 msgid "base class %qT is not public"
 msgstr "kelas dasar %qT memiliki cv pengkualifikasi"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not public"
 msgstr "%qD bukan sebuah tipe"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qD is mutable"
 msgstr "%qD bukan sebuah variabel"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has an incomplete type"
 msgid "%qD has a non-structural type"
 msgstr "%qD memiliki tipe tidak lengkap"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "%qE atribut hanya dapat diaplikasikan ke definisi class"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "argumen atribut %qs bukan sebuah konstanta string"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "%qE atribut hanya dapat diaplikasikan ke definisi class"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "%qE atribut hanya dapat diaplikasikan ke definisi class"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "%qE atribut hanya dapat diaplikasikan ke definisi class"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute takes no arguments"
 msgstr "atribut %J%qE berlaku hanya untuk fungsi"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr ""
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "deklarasi fungsi tidak valid"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%Jcase value %qs not in enumerated type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%J case value %qs tidak dalam tipe enumerasi"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> diaplikasikan ke sebuah bit-field"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %q+D but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "deklarasi untuk parameter %q+D tetapi tidak ada parameter seperti itu"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "permintaan init_priority bukan sebuah konstanta integer"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "hanya dapat menggunakan atribut %qE di definisi lingkup-berkas dari objek dari tipe class"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "permintaan init_priority diluar dari jangkauan"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "permintaan init_priority disimpan untuk penggunaan internal"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as %s"
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "deklarasi dari %qD sebagai %s"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 #| msgid "%qD attribute requires a single NTBS argument"
 msgid "the %qE attribute requires arguments"
 msgstr "%qD atribut membutuhkan sebuah argumen NTBS tunggal"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "argumen dari atribut %qs bukan sebuah konstanta string"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "argumen dari atribut %qs bukan sebuah konstanta string"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%T::%D%> bukan sebuah deklarator yang valid"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%T::%D%> bukan sebuah deklarator yang valid"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "%qE atribut diabaikan dalam tipe bukan-class"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "mengabaikan atribut yang diaplikasikan ke %qT setelah definisi"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "mengabaikan atribut yang diaplikasikan ke %qT setelah definisi"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes applied to %qT after definition"
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "mengabaikan atribut yang diaplikasikan ke %qT setelah definisi"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "atribut %J%qE berlaku hanya untuk fungsi"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute applied to %s %s at %L"
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "%s atribut diaplikasikan ke %s %s di %L"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr ""
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "%qs atribut hanya berlaku ke variabel"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "annotation on void parameter"
 msgstr "parameter %qs tidak valid"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "fungsi tidak mengembalikan tipe string"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -78494,884 +78660,890 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT tidak memiliki anggota bernama %qE"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> bukan sebuah anggota dari %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD bukan sebuah anggota dari %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD bukan sebuah anggota dari fungsi template"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT bukan sebuah penunjuk-ke-objek tipe"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of array indexing on pointer to member"
 msgstr "penggunaan tidak valid dari %qs di penunjuk ke anggota"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "penggunaan tidak valid dari %qs di penunjuk ke anggota"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "penggunaan tidak valid dari %qs di penunjuk ke anggota"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "subscrip hilang dalam referensi array"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "subscripting array dideklarasikan %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "nilai subscripted adalah bukan array ataupun penunjuk"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "objek hilang dalam penggunaan dari %qE"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "Generate default single-precision SH4 code"
 msgid "no default version in scope"
 msgstr "Hasilkan kode baku presisi tunggal SH4"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ melarang pemanggilan %<::main%> dari dalam aplikasi"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "harus menggunakan %<.*%> atau %<->*%> untuk memanggil penunjuk-ke-anggota fungsi dalam %<%E (...)%>, contoh %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qD cannot be used as a function"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "expression cannot be used as a function"
 msgstr "%qE tidak dapat digunakan sebagai sebuah fungsi"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "too many arguments to constructor %q#D"
 msgstr "terlalu banyak argumen ke %s %q+#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "too few arguments to constructor %q#D"
 msgstr "terlalu sedikit argumen ke %s %q+#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to member function %q#D"
 msgstr "terlalu banyak argumen ke fungsi %qE"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to member function %q#D"
 msgstr "terlalu sediki argumen ke fungsi %qE"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %q#D"
 msgstr "terlalu banyak argumen ke fungsi %qE"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %q#D"
 msgstr "terlalu sediki argumen ke fungsi %qE"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "too many arguments to method %q#D"
 msgstr "terlalu banyak argumen ke %s %q+#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "too few arguments to method %q#D"
 msgstr "terlalu sedikit argumen ke %s %q+#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "terlalu banyak argumen ke fungsi"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "terlalu sedikit argumen ke fungsi"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "parameter %P dari %qD memiliki tipe tidak lengkap %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "parameter %P memiliki tipe tidak lengkap %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "alamat dari %qD tidak akan pernah menjadi KOSONG"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "alamat dari %qD tidak akan pernah menjadi KOSONG"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "alamat dari %qD tidak akan pernah menjadi KOSONG"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "alamat dari %qD tidak akan pernah menjadi KOSONG"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "operan ke ?: memiliki tipe berbeda %qT dan %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types when returning type %qT but %qT was expected"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "tipe tidak kompatibel ketika mengembalikan tipe %qT tetapi %qT telah diduga"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "same canonical type node for different types %T and %T"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "tipe titik kanonikal sama untuk tipe berbeda %T dan %T"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "%s diantara tipe penunjuk berbeda %qT dan %qT kurang sebuah cast"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "cast dari panggilan fungsi dari tipe %qT ke tipe yang tidak cocok %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "cast dari panggilan fungsi dari tipe %qT ke tipe yang tidak cocok %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types when assigning to type %qT from type %qT"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "tipe tidak kompatibel dalam penempatan ke tipe %qT dari tipe %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "mengasumsikan cast ke tipe %qT dari fungsi overloaded"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL digunakan dalam aritmetik"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ melarang perbandingan diantara penunjuk dan integer"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %qT and %qT"
 msgid "operand types are %qT and %qT"
 msgstr "perbandingan diantara tipe %qT dan %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "perbandingan terurut dari penunjuk dengan integer nol"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "perbandingan tidak berurut di argumen bukan titik pecahan"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "meminta untuk konversi implisit dari %qT ke %qT tidak diijinkan dalam C++"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "operang tidak valid untuk tipe %qT dan %qT ke binari %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ melarang menggunakan penunjuk dari tipe %<void *%> dalam pengurangan"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ melarang menggunakan penunjuk ke sebuah fungsi  dalam pengurangan"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ melarang menggunakan penunjuk ke sebuah metoda  dalam pengurangan"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "penggunaan tidak valid dari sebuah penunjuk ke sebuah tipe tidak lengkap dalam aritmetik penunjuk"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of constructor %qD"
 msgstr "memakai alamat dari sementara"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of destructor %qD"
 msgstr "memakai alamat dari sementara"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "penggunaan tidak valid dari %qE untuk membentuk sebuah penunjuk ke anggota fungsi"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  sebuah kualified-id dibutuhkan"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "tanda kurung disekitar %qE tidak dapat digunakan untuk membentuk sebuah penunjuk-ke-anggota-fungsi"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ melarang mengambil alamat dari tidak terkualifikasi atau bertanda kurun anggota bukan statis fungsi untuk membentuk sebuah penunjuk ke anggota fungsi. Katakan %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 #| msgid "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%>"
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ melarang mengambil alamat dari tidak terkualifikasi atau bertanda kurun anggota bukan statis fungsi untuk membentuk sebuah penunjuk ke anggota fungsi. Katakan %<&%T::%D%>"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ melarang mengambil alamat dari sebuah anggota fungsi terikat ke sebuah bentuk penunjuk ke anggota fungsi. Katakan %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ melarang mengambil alamat dari sebuah anggota fungsi terikat ke sebuah bentuk penunjuk ke anggota fungsi. Katakan %<&%T::%D%>"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(sebuah penunjuk ke anggota hanya dapat dibentuk dengan %<&%E%>)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "memakai alamat dari sementara"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ melarang mengambil alamat dari fungsi %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "tidak dapat membuat penunjuk ke anggota referensi %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field %qD"
 msgid "attempt to take address of bit-field"
 msgstr "tidak dapat mengambil alamat dari bit-field %qD"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ melarang menaikkan sebuah enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ melarang mengurangi sebuah enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "tidak dapat meningkatkan sebuah penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "tidak dapat mengurangi penunjuk ke tipe tidak lengkap %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ melarang meningkatkan sebuah penunjuk dari tipe %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ melarang mengurangi sebuah penunjuk dari tipe %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "tidak dapat mengambil alamat dari %<this%>, yang merupakan ekspresi rvalue"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "alamat yang diminta untuk %qD, yang dideklarasikan %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 #| msgid "initializer for %qT must be brace-enclosed"
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "penginisialisasi untuk %qT harus berupa kurung dilingkupi"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in initializer"
 msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in functional cast"
 msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "%s daftar ekspresi diperlakukan sebagai ekspresi compound"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 #| msgid "cast from type %qT to type %qT casts away constness"
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "cast dari tipe %qT ke tipe %qT menghilangkan constness"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 #| msgid "static_cast from type %qT to type %qT casts away constness"
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "static_cast dari tipe %qT ke tipe %qT menghilangkan constness"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from type %qT to type %qT casts away constness"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "reinterpret_cast dari tipe %qT ke tipe %qT menghilangkan constness"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "useless cast to type %q#T"
 msgstr "cast ke fungsi tipe %qT tidak valid"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "tipe pengkualifikasi diabaikan di tipe kembali fungsi"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "tidak valid static_cast dari tipe %qT ke tipe %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "class type %qT is incomplete"
 msgstr "tipe kembali %q#T tidak lengkap"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "mengubah dari %qT ke %qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "cast tidak valid dari sebuah ekspresi rvalue dari tipe %qT ke tipe %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "cast dari %qT ke %qT kehilangan presisi"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 #| msgid "%s between distinct pointer-to-member types %qT and %qT lacks a cast"
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "%s diantara penunjuk-ke-anggota tipe berbeda %qT dan %qT kurang sebuah cast"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "cast dari %qT ke %qT menaikan alignmen yang dibutuhkan dari tipe target"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ melarang casting diantara penunjuk ke fungsi dan penunjuk ke objek"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "cast dari tipe %qT ke tipe %qT tidak valid"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "penggunaan tidak valid dari const_cast dengan tipe %qT, yang bukan sebuah penunjuk, referensi, ataupun sebuah tipe penunjuk-ke-anggota-data"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "penggunaan tidak valid dari const_cast dengan tipe %qT, yang merupakan sebuah penunjuk atau referensi ke sebuah tipe fungsi"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "const_cast tidak valid dari sebuah rvalue dari tipe %qT ke tipe %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "const_cast dari tipe %qT ke tipe %qT tidak valid"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ melarang casting ke sebuah tipe array %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "cast ke fungsi tipe %qT tidak valid"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "tidak dapat mengubah %qE dari tipe %qT ke tipe %qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  dalam evaluasi dari %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "assigning to an array from an initializer list"
 msgstr "indeks array bukan konstan dalam penginisialisasi"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "tipe tidak kompatibel dalam assignmen dari %qT ke %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "array digunakan sebagai penginisialisasi"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "assignmen array tidak valid"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   dalam penunjuk ke anggota fungsi konversi"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "penunjuk ke anggota konversi melalui basis maya %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   dalam penunjuk ke anggota konversi"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "konversi tidak valid ke tipe %qT dari tipe %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 #| msgid "cannot convert %qT to %qT for argument %qP to %qD"
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "tidak dapat mengubah %qT ke %qT untuk argumen %qP ke %qD"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "tidak dapat mengubah %qT ke %qT dalam %s"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "tidak dapat mengubah %qT ke %qT dalam %s"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in return"
 msgstr "tidak dapat mengubah %qT ke %qT dalam %s"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "tidak dapat mengubah %qT ke %qT dalam %s"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE might be a candidate for a format attribute"
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "argumen %d dari %qE mungkin menjadi sebuah kandidat untuk sebuah format atribut"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 #| msgid "return type might be a candidate for a format attribute"
 msgid "parameter might be a candidate for a format attribute"
 msgstr "tipe kembali mungkin berupa sebuah kandidat untuk sebuah atribut format"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 #| msgid "argument of function call might be a candidate for a format attribute"
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "argumen dari fungsi panggilan mungkin menjadi sebuah kandidat untuk sebuah atribut format"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 #| msgid "argument of function call might be a candidate for a format attribute"
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "argumen dari fungsi panggilan mungkin menjadi sebuah kandidat untuk sebuah atribut format"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 #| msgid "assignment left-hand side might be a candidate for a format attribute"
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "penempatan sisi tangan-kiri mungkin menjadi sebuah kandidat untuk sebuah atribut format"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of %q+D"
 msgid "in passing argument %P of %qD"
 msgstr "dalam melewatkan argumen %P dari %q+D"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "mengembalikan referensi ke sementara"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "mengembalikan referensi ke sementara"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable %q+D returned"
 msgid "reference to local variable %qD returned"
 msgstr "referensi ke variabel lokal %q+D dikembalikan"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of label %qD returned"
 msgstr "alamat dari variabel lokal %q+D dikembalikan"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of local variable %qD returned"
 msgstr "alamat dari variabel lokal %q+D dikembalikan"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in return statement"
 msgid "redundant move in return statement"
 msgstr "operan tidak valid dalam pernyataan return"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "<During initialization>\n"
 msgid "redundant move in initialization"
 msgstr "<Selama inisialisasi>\n"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "mengembalikan sebuah nilai dari sebuah destruktor"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "tidam dapat kembali dari sebuah penanganan dari sebuah fungsi-coba-blok dari sebuah konstruktor"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "mengembalikan sebuah nilai dari sebuah konstruktor"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "pernyataan-kembali dengan tidak ada nilai, dalam fungsi mengembalikan %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "returning initializer list"
 msgstr "hilang penginisialisasi"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with no value, in function returning %qT"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "pernyataan-kembali dengan tidak ada nilai, dalam fungsi mengembalikan %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> harus tidak mengembalikan KOSONG kecuali ini dideklarasikan %<throw()%> (atau ada dalam pengaruh -fcheck-new )"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr ""
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s value"
 msgid "using rvalue as lvalue"
@@ -79822,19 +79994,19 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown attribute %qs"
 msgstr "mode mesin %qs tidak dikenal"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after being called"
 msgid "%q+D declared weak after being used"
 msgstr "%q+D dideklarasikan inline setelah dipanggil"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -79863,47 +80035,47 @@ msgstr "hilang penginisialisasi untuk anggota %qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "alamat dari %qD tidak akan pernah menjadi KOSONG"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "tidak dapat mendeklarasikan penunjuk ke %q#T"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "Simpan nama fungsi dalam kode objek"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qE bukan fungsi atau anggota fungsi; tidak dapat dideklarasikan sebagai friend"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qs used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "variabel register %qs digunakan dalam fungsi nested"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has reference type for %qs"
 msgid "forward reference to frame of %qs"
@@ -79991,36 +80163,36 @@ msgstr "nilai (%s) buruk untuk pilihan %scmodel=%s %s"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "terlalu banyak argumen ke fungsi %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "tidak dapat membuka %s untuk menulis: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "membuka berkas keluaran %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "tidak dapat membuka %s untuk menulis: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "membuka berkas  ketergantungan %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -80126,7 +80298,7 @@ msgstr ""
 msgid "%qs is not an associative array"
 msgstr "%qT bukan sebuah tipe kumpulan"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -80143,25 +80315,25 @@ msgstr "%q+D secara normal sebuah fungsi bukan-statis"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs tidak valid untuk %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "recursive reference %qs"
 msgstr "tidak dapat mendeklarasikan referensi ke %q#T"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "overflow dalam konstanta ekspresi"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "  in thrown expression"
 msgid "%qs is not an expression"
 msgstr "  dalam ekspresi thrown"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in not expression"
 msgid "type %qs is not an expression"
@@ -80261,18 +80433,18 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "tidak dapat menggunaka typeid dengan -fno-rtti"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -80622,8 +80794,8 @@ msgstr "Referensi array di %C tidak dapat memiliki lebih dari %d dimensi"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -80921,7 +81093,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "argumen dari atribut %qs bukan sebuah konstanta string"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad kind for logical constant at %C"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -81011,7 +81183,7 @@ msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa REAL atau KOMPLEKS"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa INTEGER atau PROSEDUR"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -81175,7 +81347,7 @@ msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah subprogram te
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "'%s' dan '%s' argumen dari '%s' intrinsik di %L harus memiliki tipe yang sama"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different type kinds at %L"
@@ -81193,7 +81365,7 @@ msgstr "Penunjuk KOSONG di %L tidak diijinkan sebagai argumen aktual dari '%s' f
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "'%s' argumen dari '%s' instrinsik di %L harus berupa sebuah PENUNJUK"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
@@ -81351,8 +81523,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -81456,9 +81628,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah subprogram terkontain"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' intrinsic with KIND argument at %L"
 msgid "%qs intrinsic with KIND argument at %L"
@@ -81476,13 +81648,13 @@ msgstr "'dim' argumen dari %s intrinsik di %L bukan sebuah dimensi indeks valid"
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "argumen SHIFT di %L dari CHIFT harus memiliki tingkat %d atau berupa sebuah skalar"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa numerik atau LOGIKAL"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 #| msgid "Argument types of '%s' intrinsic at %L must match (%s/%s)"
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
@@ -81591,688 +81763,688 @@ msgstr "'%s' argumen dari '%s' instrinsik di %L harus berupa sebuah konstanta"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Intrinsik '%s' di %L harus memiliki paling tidak dua argumen"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Hilang argumen ke %s intrinsik di %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Hilang argumen ke %s intrinsik di %L"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Hilang argumen ke %s intrinsik di %L"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different character kinds at %L"
 msgstr "Ekstensi: Jenis tipe berbeda di %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "'a%d' argumen dari '%s' intrinsik di %L harus berupa %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' intrinsic with CHARACTER argument at %L"
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "Fortran 2003: '%s' intrinsik dengan argumen KARAKTER di %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "'a1' argumen dari '%s' intrinsik di %L harus berupa INTEGER, REAL, atau KARAKTER"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "'a1' argumen dari '%s' intrinsik di %L harus berupa INTEGER, REAL, atau KARAKTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 #| msgid "Different shape on dimension 1 for arguments '%s' and '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Bentuk berbeda dalam dimensi 1 untuk argumen '%s' dan '%s' di %L untuk intrinsik matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 #| msgid "Different shape on dimension 2 for argument '%s' and dimension 1 for argument '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Bentuk berbeda dalam dimensi 2 untuk argumen '%s' dan dimensi 1 untuk argumen '%s' di %L untuk intrinsik matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2"
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa tingkat 1 atau 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa tipe yang sama dan jenis sebagai '%s'"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa INTEGER atau REAL"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "'%s' argumen dari '%s' instrinsik di %L harus berupa sebuah PENUNJUK"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Argumen kedua dari NEAREST di %L tidak boleh berupa nol"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Argumen kedua dari NEAREST di %L tidak boleh berupa nol"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "'%s' dan '%s' argumen dari '%s' intrinsik di %L harus memiliki tingkat yang sama %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "'%s' dan '%s' argumen dari '%s' intrinsik di %L harus memiliki tingkat yang sama %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "Argumen kedua dari NEAREST di %L tidak boleh berupa nol"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa DAPAT-DIALOKASIKAN"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah jenis tidak lebih lebar dari jenis baku (%d)"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah variabel dummy"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah variabel dummy OPSIONAL"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must not be a subobject of '%s'"
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "'%s' argumen dari '%s' intrinsik di %L tidak boleh berupa subobjek dari '%s'"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a variable"
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah variabel"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SHIFT argument at %L of CSHIFT must have rank %d or be a scalar"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "argumen SHIFT di %L dari CHIFT harus memiliki tingkat %d atau berupa sebuah skalar"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "BOUNDARY argument at %L of EOSHIFT must have rank %d or be a scalar"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "argumen BOUNDARY di %L dari EOSHIFT harus memiliki tingkat %d atau berupa sebuah skalar"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "'shape' argumen dari 'reshape' intrinsik di %L harus berupa sebuah array dari konstantaukuran"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa %s"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "'shape' argumen dari 'reshape' intrinsik di %L memiliki lebih dari %d elemen"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "'a%d' argumen dari '%s' intrinsik di %L harus berupa %s(%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus dari tingkat %d"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "'dim' argumen dari %s intrinsik di %L bukan sebuah dimensi indeks valid"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "'dim' argumen dari %s intrinsik di %L bukan sebuah dimensi indeks valid"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Tanpa padding, disana tidak cukup elemen dalam sumber intrinsik RESHAPE di %L untuk cocok dengan shape"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a numeric type"
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa tipe numerik"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' intrinsic with KIND argument at %L"
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "Fortran 2003: '%s' intrinsik dengan JENIS argumen di %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "'source' argumen dari 'shape' intrinsik di %L tidak boleh sebuah ukuran arrayyang diasumsikan"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah skalar"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)"
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "'%s' argumen dari '%s' intrinsik di %L tidak dapat berupa INTENT(IN)"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "'source' argumen dari 'shape' intrinsik di %L tidak boleh sebuah ukuran arrayyang diasumsikan"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa tipe bukan-turunan"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FIELD argument at %L of UNPACK must have the same rank as MASK or be a scalar"
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "argumen FIELD di %L dari UNPACK harus memiliki tingkat sama seperti MASK atau berupa sebuah skalar"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FIELD argument at %L of UNPACK must have the same rank as MASK or be a scalar"
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "argumen FIELD di %L dari UNPACK harus memiliki tingkat sama seperti MASK atau berupa sebuah skalar"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment to non-POINTER at %L"
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Penempatan penunjuk ke bukan-PENUNJUK di %L"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L has no IMPLICIT type"
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "Hasil fungsi '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Prosedur operator pengguna '%s' di %L harus berupa sebuah FUNGSI"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "Argumen kedua dari NEAREST di %L tidak boleh berupa nol"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "Komponen di %C harus memiliki sebuah atribut PENUNJUK"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "Hilang argumen ke %s intrinsik di %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus lebih kecil dari tingkat %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "'dim' argumen dari %s intrinsik di %L bukan sebuah dimensi indeks valid"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus lebih kecil dari tingkat %d"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "Aktual argumen untuk '%s' harus berupa sebuah penunjuk di %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Terlalu banyak argumen ke %s di %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Terlalu banyak argumen ke %s di %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "'MOLD' argumen dari 'TRANSFER' intrinsik di %L tidak boleh berupa %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "'MOLD' argumen dari 'TRANSFER' intrinsik di %L tidak boleh berupa %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 #| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "'MOLD' argumen dari 'TRANSFER' intrinsik di %L tidak boleh berupa %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 #, fuzzy
 #| msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld"
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "Intrinsik TRANSFER di %L memiliki hasil tidak terdefinisi sebagian: ukuran sumber %ld < ukuran hasil %ld"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same kind as '%s'"
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa jenis sama dengan '%s'"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "'%s' dan '%s' argumen dari '%s' intrinsik di %L harus memiliki tipe yang sama"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Argumen dari ATANH di %L harus berada didalam jangkauan -1 ke 1"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 #| msgid "Size of '%s' argument of '%s' intrinsic at %L too small (%i/%i)"
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Ukuran dari '%s' argumen dari '%s' intrinsik di %L terlalu kecil (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Terlalu banyak argumen ke %s di %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "jumlah dari argumen template salah (%d, seharusnya %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah jenis tidak lebih lebar dari jenis baku (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa sebuah skalar"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa INTEGER atau LOGIKAL"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -82345,12 +82517,12 @@ msgstr "inisialisasi dari string terpotong untuk mencocokan dengan variabel di %
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "inisialisasi dari string terpotong untuk mencocokan dengan variabel di %L"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Indeks awal substring di %L lebih kecil dari satu"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "Indeks akhir substring di %L melebihi panjang string"
@@ -82405,2268 +82577,2268 @@ msgstr "Variabel '%s' di %C dengan sebuah penginisialisasi telah muncul dalam se
 msgid "Simplification error"
 msgstr "gimplification gagal"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 #| msgid "Host associated variable '%s' may not be in the DATA statement at %C"
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Host berasosiasi variabel '%s' mungkin tidak berada dalam peryataan DATA di %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 #| msgid "Extension: initialization of common block variable '%s' in DATA statement at %C"
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Ekstensi: inisialisasi dari blok umum variabel '%s' dalam pernyataan DATA di %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C"
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Simbol '%s' harus berupa sebuah PARAMETER dalam pernyataan DATA di %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid initializer %s in Data statement at %C"
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Penginisialisasi %c tidak valid dalam pernyataan DATA di %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%s tidak dapat muncul dalam sebuah konstanta ekspresi"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "inisialisasi di %C tidak diperbolehkan dalam sebuah prosedur PURE"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah ANTAR-MUKA"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid initializer %s in Data statement at %C"
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Penginisialisasi %c tidak valid dalam pernyataan DATA di %C"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "pernyataan DATA di %C tidak diperbolehkan dalam sebuah prosedur PURE"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Empty old style initializer list at %C"
 msgstr "Ekstensi: Gaya-lama inisialisasi di %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array component of structure at %C must have an explicit shape"
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Struktur komponen array di %C harus memiliki sebuah bentuk eksplisit"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "kelebihan elemen dalam penginisialisasi skalar"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C must be an integer"
 msgid "Repeat spec must be an integer at %C"
 msgstr "Penunjuk Cray di %C harus berupa sebuah integer"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Diduga alternatif label kembali di %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "End of scalar initializer expected at %C"
 msgstr "Didugak ekspresi inisialisasi skalar di %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "kelebihan elemen dalam array penginisialisasi"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "kelebihan elemen dalam array penginisialisasi"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in OpenMP variable list at %C"
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Sintaks error dalam daftar variabel OpenMP di %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Spesifikasi INTENT buruk di %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "deferred type parameter at %C"
 msgstr "menggunakan parameter tipe template %qT setelah %qs"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Old-style character length at %C"
 msgstr "Karakter tidak valid dalam nama di %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Sintaks error dalam spesifikasi panjang karakter di %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Prosedur '%s' di %C telah terdefinisi di %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Prosedur '%s' di %C telah terdefinisi di %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is already defined as a generic interface at %L"
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Nama '%s' di %C telah terdefinisi sebagai sebuah antar-muka umum di %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Prosedur '%s' di %C memiliki sebuah antar-muka eksplisit dan tidak boleh memiliki atribut terdeklarasi di %L"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L must have the BIND(C) attribute to be C interoperable"
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Prosedur '%s' di %L harus memiliki atribut BIND(C) supaya C interoperable"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, fuzzy, gcc-internal-format
 #| msgid "Type '%s' at %L is a parameter to the BIND(C)  procedure '%s' but is not C interoperable because derived type '%s' is not C interoperable"
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "Tipe '%s' di %L adalah sebuah parameter ke BIND(C) prosedur '%s' tetapi bukan C interoperable karena tipe turunan '%s' bukan C interoperable"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is a parameter to the BIND(C) procedure '%s' but may not be C interoperable"
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "Variabel '%s' di %L adalah sebuah parameter ke prosedur BIND(C) '%s' tetapi mungkintidak C interoperable"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is a parameter to the BIND(C) procedure '%s' but may not be C interoperable"
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Variabel '%s' di %L adalah sebuah parameter ke prosedur BIND(C) '%s' tetapi mungkintidak C interoperable"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the OPTIONAL attribute because procedure '%s' is BIND(C)"
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "Variabel '%s' di %L tidak dapat memiliki atribut OPSIONAL karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Argumen karakter '%s' di %L harus memiliki panjang 1 karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Argumen karakter '%s' di %L harus memiliki panjang 1 karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "Argumen karakter '%s' di %L harus memiliki panjang 1 karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the ALLOCATABLE attribute because procedure '%s' is BIND(C)"
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Variabel '%s' di %L tidak dapat memiliki atribut ALLOCATABLE karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the POINTER attribute because procedure '%s' is BIND(C)"
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Variabel '%s' di %L tidak dapat memiliki atribut PENUNJUK karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the OPTIONAL attribute because procedure '%s' is BIND(C)"
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "Variabel '%s' di %L tidak dapat memiliki atribut OPSIONAL karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the OPTIONAL attribute because procedure '%s' is BIND(C)"
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Variabel '%s' di %L tidak dapat memiliki atribut OPSIONAL karena prosedur '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed-shape array '%s' at %L cannot be an argument to the procedure '%s' at %L because the procedure is BIND(C)"
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Bentuk-diasumsikan array '%s' di %L tidak dapat berupa sebuah argumen ke prosedur '%s' di %L karena prosedur adalah BIND(C)"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L cannot have a type"
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Simbol '%s' di %L tidak dapat memiliki sebuah tipe"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is BIND(C)"
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "Variabel '%s' dalam blok umum '%s' di %C harus terdeklarasi dengan sebuah jenis C interoperable karena blok umum '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument must be a constant"
 msgid "CHARACTER length must be a constant at %L"
 msgstr "argumen harus berupa sebuah konstanta"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CHARACTER expression at %L is being truncated (%d/%d)"
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "ekspresi KARAKTER di %L terpotong (%d/%d)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The CHARACTER elements of the array constructor at %L must have the same length (%d/%d)"
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Elemen KARAKTER dari konstruktor array di %L harus memiliki panjang yang sama (%d/%d)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 #| msgid "Initializer not allowed for PARAMETER '%s' at %C"
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Penginisialisasi tidak diperbolehkan untuk PARAMETER '%s' di %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "PARAMETER di %L hilang sebuah penginisialisasi"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C with an initializer already appears in a DATA statement"
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Variabel '%s' di %C dengan sebuah penginisialisasi telah muncul dalam sebuah pernyataan DATA"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Tingkat tidak cocok dalam referensi array di %L (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize multi-dimensional array with initializer"
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "tidak dapat menginisialisasi array multidimensi dengan penginisialisasi"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' at %L already is initialized at %L"
 msgid "Bad shape of initializer at %L"
 msgstr "'%s' di %L telah terinisialisasi di %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "tidak dapat mendeklarasikan penunjuk ke %q#T"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Sintaks error dalam deklarasi data di %C"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "Fungsi '%s' di %L adalah INTRINSIK tetapi tidak kompatibel dengan sebuah intrinsik"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Komponen di %C harus memiliki sebuah atribut PENUNJUK"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Komponen array dari struktur di %C harus memiliki bentuk eksplisit atau deffered"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "Component %qs at %C already declared at %L"
 msgstr "Komponen '%s' di %C telah dideklarasikan di %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Komponen penunjuk array dari struktur di %C harus memilki sebuah bentuk deffered"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Komponen dapat dialokasikan dari struktur di %C harus memiliki sebuah bentuk deffered"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Struktur komponen array di %C harus memiliki sebuah bentuk eksplisit"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "sebuah daftar parameter dengan sebuah ellipsis tidak dapat cocok dengan sebuah parameter kosong deklarasi daftar nama"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "inisialisasi NULL() di %C adalah ambigu"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NULL() initialization at %C is ambiguous"
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "inisialisasi NULL() di %C adalah ambigu"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Inisialisasi dari pointer di %C tidak diperbolehkan dalam prosedur PURE"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Error in pointer initialization at %C"
 msgstr "Ekstensi: Gaya-lama inisialisasi di %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "non-NULL pointer initialization at %C"
 msgstr "Ekstensi: Gaya-lama inisialisasi di %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%s atribut konflik dengan %s atribut di %L"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Karakter tidak valid dalam nama di %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat bernilai-penunjuk"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be of INTEGER type, found %s"
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Indeks array di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Dummy '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Duplikasi spesifikasi array untuk Cray pointee di %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set pointee array spec."
 msgstr "tidak dapat mengubah ke sebuah tipe penunjuk"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Old-style initialization at %C"
 msgstr "Ekstensi: Gaya-lama inisialisasi di %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid value-initialization of reference types"
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "nilai-inisialisasi dari referensi tidak valid"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Ekstensi: Gaya-lama inisialisasi di %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Inisialisasi di %C bukan sebuah variabel penunjuk"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Inisialisasi dari penunjuk di %C membutuhkan '=>', bukan '='"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Diduga sebuah ekspresi inisialisasi di %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Inisialisasi dari variabel di %C tidak diperbolehkan alam prosedur PURE"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Inisialisasi dari komponen dapat dialokasikan di %C tidak diperbolehkan"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of allocatable component at %C is not allowed"
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "Inisialisasi dari komponen dapat dialokasikan di %C tidak diperbolehkan"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The pointer component '%s' of '%s' at %L is a type that has not been declared"
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Komponen penunjuk '%s' dari '%s' di %L adalah sebuah tipe yang belum pernah dideklarasikan"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Eksternal '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Tipe deklarasi gaya-lama %s*%d tidak didukung di %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Tipe deklarasi tidak-baku %s*%d di %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Hilang paranthesis kanan di %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Diduga ekspresi inisialisasi di %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Didugak ekspresi inisialisasi skalar di %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Jenis %d tidak didukung untuk tipe %s di %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Jenis tipe parameter C adalah untuk tipe %s tetapi tipe di %L adalah %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Hilang paranthesis kanan atau koma di %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Jenis %d tidak didukung untuk KARAKTER di %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Sintaks error dalam deklarasi KARAKTER di %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 #| msgid "the first parameter of %<operator new%> cannot have a default argument"
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "parameter pertama dari %<operator new%> tidak dapat memiliki sebuah argumen baku"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Ekspresi di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "Ekspresi di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "Array '%s' di %L bukan sebuah variabel, yang tidak mereduksi ke sebuah ekspresi konstanta"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "referensi ke %qD adalah ambigu"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: BYTE type at %C"
 msgid "BYTE type at %C"
 msgstr "Ekstensi: BYTE tipe di %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "tipe BYTE digunakan di %C tidak tersedia dalam mesin target"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L is not allowed in this context"
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Argumen dengan nilai di %L tidak diperbolehkan dalam konteks ini"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "malformed spec function name"
 msgid "Malformed type-spec at %C"
 msgstr "spesifikasi nama fungsi salah format"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C is ambiguous"
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Tipe nama '%s' di %C adalah ambigu"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected CASE statement at %C"
 msgid "CLASS statement at %C"
 msgstr "Diduga pernyataan CASE di %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Duplikasi pernyataan IMPLISIT NONE di %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate IMPLICIT NONE statement at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "Duplikasi pernyataan IMPLISIT NONE di %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Hilang jangkauan karakter dalam IMPLISIT di %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Huruf harus dalam urutan alphabet dalam pernyataan IMPLISIT di %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE statement at %C follows blanket SAVE statement"
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "pernyataan SAVE di %C mengikuti blanket pernyataan SAVE"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Pernyataan IMPLISIT kosong di %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "pernyataan IMPOR di %C hanya diijinkan di sebuah tubuh ANTAR-MUKA"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "pernyataan IMPOR di %C hanya diijinkan di sebuah tubuh ANTAR-MUKA"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "IMPORT statement at %C"
 msgstr "Pernyataan IMPLISIT kosong di %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot IMPORT '%s' from host scoping unit at %C - does not exist."
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "Tidak dapat IMPOR '%s' dari satuan host scoping di %C - tidak ada."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is already IMPORTed from host scoping unit at %C."
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "'%s' telah ter-IMPOR dari satuan host scoping di %C."
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Sintaks error dalam pernyataan IMPOR di %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Diduga daftar dari entiti bernama di %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing dimension specification at %C"
 msgid "Missing codimension specification at %C"
 msgstr "Hilang spesifikasi dimensi di %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Hilang spesifikasi dimensi di %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Duplikasi %s atribut di %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Fortran 2003: atribut DAPAT DIALOKASIKAN di %C dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003: atribut DAPAT DIALOKASIKAN di %C dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Fortran 2003: Atribut %s di %L dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003: Atribut %s di %L dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Fortran 2003: atribut DAPAT DIALOKASIKAN di %C dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003: atribut DAPAT DIALOKASIKAN di %C dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Components in TYPE at %C must precede CONTAINS"
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "Komponen dalam TYPE di %C harus mengawali CONTAINS"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Atribut di %L tidak diijinkan dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Atribut di %L tidak diijinkan dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Fortran 2003: Atribut %s di %L dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%s atribut di %L tidak diperbolehka diluar dari bagian spesifikasi dari sebuah modul"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "Atribut di %L tidak diijinkan dalam sebuah definisi TIPE"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "TERPROTEKSI di %C hanya diperbolehkan dalam bagian spesifikasi dari modul"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: PROTECTED attribute at %C"
 msgid "PROTECTED attribute at %C"
 msgstr "Fortran 2003: atribut TERPROTEKSI di %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VALUE attribute at %C"
 msgid "VALUE attribute at %C"
 msgstr "Fortran 2003: atribut NILAI di %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VOLATILE attribute at %C"
 msgid "VOLATILE attribute at %C"
 msgstr "Fortran 2003: atribut VOLATILE di %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Multiple pengidentifikasi disediakan dengan penspesifikasi NAMA= tunggal di %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, fuzzy, gcc-internal-format
 #| msgid "Implicitly declared BIND(C) function '%s' at %L may not be C interoperable"
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "secara implisit terdeklarasi fungsi BIND(C) '%s' di %L mungkin tidak C interoperable"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' in common block '%s' at %L may not be a C interoperable kind though common block '%s' is BIND(C)"
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "Variabel '%s' dalam blok umum '%s' di %L mungkin tidak berupa jenis C dapat berinteroperasi melalui blok umum '%s' adalah BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, fuzzy, gcc-internal-format
 #| msgid "Type declaration '%s' at %L is not C interoperable but it is BIND(C)"
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "Tipe deklarasi '%s' di %L bukan C interoperable tetapi ini adalah BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L may not be a C interoperable kind but it is bind(c)"
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "Variabel '%s' di %L mungkin bukan sebuah jenis C interoperable tetapi ini adalah bind(c)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' in common block '%s' at %L cannot be declared with BIND(C) since it is not a global"
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "Variabel '%s' dalam blok umum '%s' di %L tidak dapat dideklarasikan dengan BIND(C)karena ini bukan sebuah global"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut PENUNJUK dan BIND(C)"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut DAPAT DIALOKASIKAN dan BIND(C)"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 #| msgid "Return type of BIND(C) function '%s' at %L cannot be an array"
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Tipe kembali dari fungsi BIND(C) '%s' di %L tidak dapat berupa sebuah array"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "Return type of BIND(C) function '%s' at %L cannot be a character string"
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Tipe kembali dari fungsi BIND(C) '%s' di %L tidak dapat berupa string karakter"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is marked PRIVATE but has been given the binding label '%s'"
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "Simbol '%s' di %L ditandai PRIVATE tetapi telah diberikan level binding '%s'"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Dibutuhkan baik entiti atau nama blok umum untuk pernyataan spesifikasi atribut di %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Hilang entiti atau nama blok umum untuk pernyataan spesifikasi atribut di %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "missing number"
 msgid "Missing symbol"
 msgstr "hilang angka"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "BIND(C) statement at %C"
 msgstr "Pernyataan IMPLISIT kosong di %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "Komponen di %C harus memiliki sebuah atribut PENUNJUK"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Tipe turunan di %C belum pernah didefinisikan sebelumnya jadi tidak dapat muncul dalam sebuah tipe definisi turunan"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Sintaks error dalam deklarasi data di %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Sintaks error dalam deklarasi data di %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "PROSEDUR MODUL di %C harus dalam sebuah antar-muka modul umum"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "procedure name = %s"
 msgid "IMPURE procedure at %C"
 msgstr "nama prosedur = %s"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer expression required at %C"
 msgid "A type parameter list is required at %C"
 msgstr "Ekspresi integer dibutuhkan di %C"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Alternate-return argument at %C"
 msgstr "Diduga alternatif label kembali di %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unused parameter '%s' declared at %L"
 msgid "A parameter name is required at %C"
 msgstr "Parameter '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Nama '%s' di %C adalah nama dari prosedur"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Diduga dimensi lain dalam deklarasi array di %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Tidak teduga sampah dalam daftar argumen formal di %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Duplikasi simbol '%s dalam daftar argumen formal di %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Duplikasi simbol '%s dalam daftar argumen formal di %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with SAVE attribute in '%s' at %L"
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "atribut PROSEDUR konflik dengan atribut SAVE dalam '%s' di %L"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "variabel RESULT di %C harus berbeda dari nama fungsi"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Tidak terduga sampah setelah deklarasi fungsi di %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: BIND(C) attribute at %L may not be specified for an internal procedure"
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Fortran 2008: BIND(C) atribut di %L mungkin tidak dispesifikasikan untuk sebuah prosedur internal"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "atribut BIND(C) di %C membutuhkan sebuah antar-muka dengan BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "prosedur BIND(C) dengan NAMA mungkin tidak memiliki atribut PENUNJUK di %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Prosedur dummy di %C mungkin tidak memiliki atribut BIND(C) dengan NAMA"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Nama tipe turunan '%s' di %C telah memiliki sebuah tipe dasar dari %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Sintaks error dalam pernyataan PROSEDUR di %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '::' after binding-attributes at %C"
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Diduga '::' setelah atribut binding di %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid procedure pointer assignment at %L"
 msgid "Procedure pointer component at %C"
 msgstr "Penempatan penunjuk prosedur tidak valid di %L"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in structure constructor at %C"
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Sintaks error dalam struktur konstruktor di %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROSEDUR di %C harus berupa sebuah antar-muka umum"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in PROCEDURE statement at %C"
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "Sintaks error dalam pernyataan PROSEDUR di %C"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: PROCEDURE statement at %C"
 msgid "PROCEDURE statement at %C"
 msgstr "Fortran 2003: pernyataan PROSEDUR di %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Diduga daftar argumen formal dalam definisi fungsi di %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "atribut BIND(C) di %L hanya dapat digunakan untuk variabel atau blok umum"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "ENTRY statement at %C"
 msgstr "Pernyataan IMPLISIT kosong di %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah APLIKASI"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah MODUL"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah MODUL"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah DATA BLOK"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah ANTAR-MUKA"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok SELECT"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok TIPE TURUNAN"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok IF-THEN"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "pernnyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok DO"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok SELECT"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok FORALL"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok WHERE"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul didalam sebuah subprogram terkontain"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Tidak terduga pernyataan END di %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah prosedur terkontain"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Hilang parantheses yang dibutuhkan sebelum BIND(C) di %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "pernyataan MASUKAN di %C tidak dapat muncul dalam sebuah prosedur terkontain"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Alternate return cannot appear in operator interface at %L"
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "Kembali alternatif tidak dapat muncul dalam antar-muka operator di %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid C name in NAME= specifier at %C"
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Nama C tidak valid dalam penspesifikasi NAMA= di %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Sintaks error dalam penspesifikasi NAMA= untuk binding label di %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "ASYNCHRONOUS= penspesifikasi di %L harus berupa ekspresi inisialisasi"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Hilang penutup paren untuk binding label di %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Tidak ada nama binding diijinkan dalam BIND(C) di %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "Untuk prosedur dummy %s, tidak ada nama binding diijinkan dalam BIND(C) di %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "NAMA tidak diijinkan dalam BIND(C) untuk ANTAR-MUKA ABSTRAK di %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Tidak terduga pernyataan END di %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s statement at %C cannot follow %s statement at %L"
 msgid "END statement instead of %s statement at %L"
 msgstr "pernyataan %s di %C tidak dapat mengikuti pernyataan %s di %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "pernyataan %s tidak terduga di %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting %s statement at %L"
 msgstr "Diduga pernyataan %s di %C"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Diduga nama blok dari '%s' dalam pernyataan %s di %C"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Diduga nama berakhir di %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 #| msgid "Expected label '%s' for %s statement at %C"
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Diduga label '%s' untuk pernyataan %s di %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Hilang spesifikasi array di %L dalam pernyataan DIMENSI"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dimensions specified for %s at %L after its initialisation"
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Dimensi dipesifikasikan untuk %s di %L setelah inisialisasinya"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing array specification at %L in DIMENSION statement"
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Hilang spesifikasi array di %L dalam pernyataan DIMENSI"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Spesifikasi array harus deferred di %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Karakter tidak terduda dalam daftar variabel di %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<(%> at %C"
 msgstr "Diduga '(' di %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Diduga nama variabel di %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Penunjuk Cray di %C harus berupa sebuah integer"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Penunjuk Cray di %C memiliki %d bytes ketelitian; alamat memori membutuhkan %d bytes"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Diduga \",\" di %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
 msgstr "tidak dapat mengubah ke sebuah tipe penunjuk"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Duplikasi spesifikasi array untuk Cray pointee di %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Diduga \")\" di %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" or end of statement at %C"
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "Diduga \",\" atau akhir dari pernyataan di %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer declaration at %C requires -fcray-pointer flag"
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Deklarasi penunjuk cray di %C membutuhkan pilihan -fcray-pointer"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "CONTIGUOUS statement at %C"
 msgstr "Pernyataan IMPLISIT kosong di %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "Spesifikasi akses dari operator %s di %C telah dispesifikasikan"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "Spesifikasi akses dari operator .%s.  di %C telah dispesifikasikan"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: PROTECTED statement at %C"
 msgid "PROTECTED statement at %C"
 msgstr "Fortran 2003: pernyataan TERPROTEKSI di %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Sintaks error dalam pernyataan TERPROTEKSI di %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "pernyataan PRIVATE di %C hanya diperbolehkan dalam bagian spesifikasi dari sebuah modul"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "pernyataan PUBLIK di %C hanya diperbolehkan dalam bagian spesifikasi dari sebuah modul"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Nama variabel diduga di %C dalam pernyataan PARAMETER"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Diduga tanda = dalam pernyataan PARAMETER di %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Diduga ekspresi di %C dalam pernyataan PARAMETER"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Inisialisasi variabel  yang telah diinisialisasi di %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Karakter tidak terduga dalam pernyataan PARAMETER di %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Diduga variabel dalam pernyataan BACA di %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in VOLATILE statement at %C"
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Sintaks error dalam pernyataan VOLATILE di %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Diduga variabel dalam pernyataan BACA di %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Sintaks error dalam pernyataan SAVE di %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Blanket pernyataan SAVE di %C mengikuti pernyataan SAVE sebelumnya"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "pernyataan SAVE di %C mengikuti blanket pernyataan SAVE"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Sintaks error dalam pernyataan SAVE di %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VALUE statement at %C"
 msgid "VALUE statement at %C"
 msgstr "Fortran 2003: pernyataan NILAI di %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Sintaks error dalam pernyataan NILAI di %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: VOLATILE statement at %C"
 msgid "VOLATILE statement at %C"
 msgstr "Fortran 2003: pernyataan VOLATILE di %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Sintaks error dalam pernyataan VOLATILE di %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate SEQUENCE statement at %C"
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Duplikasi pernyataan SEQUENCE di %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in VALUE statement at %C"
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Sintaks error dalam pernyataan NILAI di %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after PROCEDURE declaration at %C"
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "Sampah setelah deklarasi PROCEDURE di %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "PROSEDUR MODUL di %C harus dalam sebuah antar-muka modul umum"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Intrinsic procedure '%s' not allowed in PROCEDURE statement at %C"
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "Prosedur intrinsik '%s' tidak diperbolehkan dalam pernyataan PROSEDUR di %C"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Ambigu simbol dalam definisi TIPE di %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Simbol '%s' di %C telah diassosiasikan host"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in EXTENDS expression at %C is not a derived type"
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "'%s' dalam ekspresi EXTENDS di %C bukan sebuah tipe turunan"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' cannot be extended at %C because it is BIND(C)"
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "'%s' tidak dapat diekstensikan di %C karena ini adalah BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' cannot be extended at %C because it is a SEQUENCE type"
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "'%s' tidak dapat diekstensikan di %C karena ini adalah tipe SEQUENCE"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Tipe turunan di %C hanya dapat berupa PRIVATE dalam bagian spesifikasi dari sebuah modul"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Tipe turunan di %C hanya dapat berupa PUBLIK dalam bagian spesifikasi dari sebuah modul"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ABSTRACT type '%s' used at %L"
 msgid "ABSTRACT type at %C"
 msgstr "tipe ABSTRAK '%s' digunakan di %L"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate construct label '%s' at %C"
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Duplikasi konstruksi label '%s' di %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Definisi tipe turunan dari '%s' di %C telah terdefinisi"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Junk after MAP statement at %C"
 msgstr "Tidak terduga sampah setelah pernyataan ELSE di %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Junk after UNION statement at %C"
 msgstr "Tidak terduga sampah setelah pernyataan ELSE di %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Tidak terduga sampah setelah deklarasi fungsi di %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected CASE statement at %C"
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Diduga pernyataan CASE di %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Nama tipe '%s' di %C tidak dapat sama seperti sebuah tipe intrinsic"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Diduga :: dalam definisi TIPE di %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003:  CONTAINS block in derived type definition at %C"
 msgid "Mangled derived type definition at %C"
 msgstr "Fortran 2003: blok CONTAINS dalam definisi turunan di %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Nama tipe '%s' di %C tidak dapat sama seperti sebuah tipe intrinsic"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Nama tipe turunan '%s' di %C telah memiliki sebuah tipe dasar dari %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Nama tipe turunan '%s' di %C telah memiliki sebuah tipe dasar dari %s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Dummy argumen '%s' di %L tidak dapat berupa OPSIONAL"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "Definisi tipe turunan dari '%s' di %C telah terdefinisi"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after PROCEDURE declaration at %C"
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Sampah setelah deklarasi PROCEDURE di %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Cray Pointee di %C tidak dapat diasumsikan bentuk array"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: ENUM and ENUMERATOR at %C"
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "Fortran 2003: ENUM dan ENUMERATOR di %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Enumerator melebihi tipe integer C di %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L tidak diinisialisasi dengan ekspresi integer"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "pernyataan definisi ENUM diduga sebelum %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Sintaks error dalam definisi ENUMERATOR di %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Duplikasi penspesifikasi akses di %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Binding atribut telah menspesifikasikan passing, tidak legal NOPASS di %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Binding atribut telah menspesifikasikan passing, tidak legal PASS di %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s attribute at %L"
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Duplikasi %s atribut di %L"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Duplikasi NON_OVERRIDABLE di %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate NON_OVERRIDABLE at %C"
 msgid "Duplicate DEFERRED at %C"
 msgstr "Duplikasi NON_OVERRIDABLE di %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Diduga penspesifikasi akses di %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Diduga atribut binding di %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "%<)%> expected at %C"
 msgstr "Diduga '(' di %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in NAME= specifier for binding label at %C"
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Sintaks error dalam penspesifikasi NAMA= untuk binding label di %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE(interface) at %C is not yet implemented"
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDUR(antar-muka) di %C belum diimplementasikan"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Diduga nama binding di %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after PROCEDURE declaration at %C"
 msgid "PROCEDURE list at %C"
 msgstr "Sampah setelah deklarasi PROCEDURE di %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, fuzzy, gcc-internal-format
 #| msgid "'::' needed in PROCEDURE binding with explicit target at %C"
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "'::' diperlukan dalam binding PROCEDUR dengan target eksplisit di %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 #| msgid "Expected binding target after '=>' at %C"
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Diduga binding target setelah '=>' di %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a procedure with binding name '%s' for the derived type '%s' at %C"
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Telah ada sebuah prosedur dengan nama binding '%s' untuk tipe turunan '%s' di %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '::' at %C"
 msgid "Expected %<::%> at %C"
 msgstr "Diduga '::' di %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected generic name at %C"
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Diduga nama generik di %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Malformed GENERIC statement at %C"
 msgstr "Form tidak valid dari pernyataan APLIKASI di %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<=>%> at %C"
 msgstr "Diduga '(' di %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Shape specification at %L cannot be negative"
 msgid "The access specification at %L not in a module"
 msgstr "Spesifikasi bentuk di %L tidak dapat negatif"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a non-generic procedure with binding name '%s' for the derived type '%s' at %C"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Telah ada sebuah prosedur bukan generik dengan nama binding '%s' untuk tipe turunan '%s' di %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "Spesifikasi akses dari operator %s di %C telah dispesifikasikan"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "Spesifikasi akses dari operator %s di %C telah dispesifikasikan"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding '%s'"
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "Binding di %C harus memiliki akses sama seperti telah didefinisikan binding '%s'"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected module procedure name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Diduga nama prosedur modul di %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' already defined as specific binding for the generic '%s' at %C"
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "'%s' telah didefinisikan sebagai binding spesifik untuk generik '%s' di %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after GENERIC binding at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Sampah setelah binding GENERIC di %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "GENERIC di %C harus berada didalam sebuah tipe turunan CONTAINS"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a non-generic procedure with binding name '%s' for the derived type '%s' at %C"
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Telah ada sebuah prosedur bukan generik dengan nama binding '%s' untuk tipe turunan '%s' di %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding '%s'"
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "Binding di %C harus memiliki akses sama seperti telah didefinisikan binding '%s'"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Diduga nama binding spesifik di %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' already defined as specific binding for the generic '%s' at %C"
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "'%s' telah didefinisikan sebagai binding spesifik untuk generik '%s' di %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Sampah setelah binding GENERIC di %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "deklarasi FINAL di %C harus berada didalam sebuah tipe turunan daerah CONTAINS"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "Deklarasi tipe turunan dengan FINAL di %C harus berada dalam spesifikasi dari sebuah MODULE"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "Kosong FINAL di %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Diduga nama prosedur modul di %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" at %C"
 msgid "Expected %<,%> at %C"
 msgstr "Diduga \",\" di %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown procedure name \"%s\" at %C"
 msgid "Unknown procedure name %qs at %C"
 msgstr "Nama prosedur tidak dikenal \"%s\" di %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is already defined as FINAL procedure!"
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "'%s' di %C telah didefinisikan sebagai prosedur FINAL!"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected characters in PARAMETER statement at %C"
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Karakter tidak terduga dalam pernyataan PARAMETER di %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in VALUE statement at %C"
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Sintaks error dalam pernyataan NILAI di %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Sintaks error dalam iterasi FORALL di %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Sintaks error dalam deklarasi KARAKTER di %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Sintaks error dalam deklarasi KARAKTER di %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in ENUMERATOR definition at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -84817,454 +84989,454 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr ""
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "argumen fungsi elemen di %C tidak komplian"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Operan numerik atau KARAKTER dibutuhkan dalam ekspresi di %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Operator konkatenasi dalam ekspresi di %L harus memiliki dua operan KARAKTER"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Operator konkatenasi di %L harus konkatenasi string dari tipe yang sama"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "operator .NOT. dalam ekspresi di %L harus memiliki sebuah operan LOGIKAL"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "operan LOGICAL dibutuhkan dalam ekspresi di %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Hanya intrinsik operator yang dapat digunakan dalam ekspresi di %L"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Operan numerik dibutuhkan dalam ekspresi di %L"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 #| msgid "No initializer for component '%s' given in the structure constructor at %C!"
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Tidak ada penginisialisasi untuk komponen '%s' yang diberikan dalam struktur konstruktor di %C"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed character length variable '%s' in constant expression at %L"
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Diasumsikan panjang karakter variabel '%s' dalam ekspresi konstanta di %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "intrinsik transformational '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Evaluation of nonstandard initialization expression at %L"
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Ekstensi: Evaluasi dari ekspresi inisialisasi ekpresi tidak baku di %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' in initialization expression at %L must be an intrinsic or a specification function"
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "Fungsi '%s' dalam ekspresi inisialisasi di %L harus berupa sebuah intrinsik atau sebuah spesifikasi fungsi"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic function '%s' at %L is not permitted in an initialization expression"
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "Fungsi intrinsik '%s' di %L tidak diperbolehkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 #| msgid "PARAMETER '%s' is used at %L before its definition is complete"
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "PARAMTER '%s' digunakan di %L sebelum definisinya lengkap"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "Diasumsikan ukuran array '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Diasumsikan bentuk array '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Diasumsikan bentuk array '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "Deferred array '%s' at %L is not permitted in an initialization expression"
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "Deferred array '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Array '%s' di %L bukan sebuah variabel, yang tidak mereduksi ke sebuah ekspresi konstanta"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "Diasumsikan bentuk array '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Parameter '%s' di %L belum terdeklarasi atau sebuah variabel, yang tidak mereduksi ke sebuah ekspresi konstan"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_init_expr(): Unknown expression type"
 msgstr "Diduga tipe ekspresi"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Fungsi spesifikasi '%s' di %L tidak dapat berupa sebuah pernyataan fungsi"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be an internal function"
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Spesifikasi fungsi '%s' di %L tidak dapat berupa sebuah internal fungsi"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Spesifikasi fungsi '%s' di %L harus berupa PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be RECURSIVE"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Spesifikasi fungsi '%s' di %L tidak dapat REKURSIF"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' not allowed in expression at %L"
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Dummy argumen '%s' tidak diijinkan dalam ekspresi di %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Dummy argumen '%s' di %L tidak dapat berupa OPSIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Dummy argumen '%s' di %L tidak dapat berupa INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Variabel '%s' tidak dapat muncul dalam ekspresi di %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_restricted(): Unknown expression type"
 msgstr "Diduga tipe ekspresi"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Ekspresi di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L must be PURE"
 msgid "Function %qs at %L must be PURE"
 msgstr "Fungsi '%s' di %L harus berupa PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Ekspresi di %L harus berupa skalar"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Tingkat tidak kompatibel dalam %s (%d dan %d) di %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Bentuk berbeda untuk %s di %L dalam dimensi %d (%d dan %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "menggunakan parameter tipe template %qT setelah %qs"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a VALUE"
 msgid "%qs at %L is not a VALUE"
 msgstr "'%s' di %L bukan sebuah NILAI"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Tidak legal stride dari nol di %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Tingkat tidak kompatibel %d dan %d dalam penempatan di %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Tipe variabel adalah TIDAK DIKETAHUI dalam penempatan di %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL muncul di sisi kanan dalam penempatan di %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "POINTER valued function appears on right-hand side of assignment at %L"
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "fungsi dinilai POINTER muncul di sisi kanan dari penempatan di %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Tipe tidak kompatibel dalam pernyataan DATA di %L; dicoba mengubah %s ke %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Penempatan target penunjuk bukan sebuah PENUNJUK di %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "'%s' dalam penempatan penunjuk di %L tidak dapat berupa sebuah nilai-kiri karena iniadalah sebuah prosedur"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 #| msgid "Expected bounds specification for '%s' at %L"
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Diduga spesifikasi terikat untuk '%s' di %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: Bounds specification for '%s' in pointer assignment at %L"
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Fortran 2003: Spesifikasi terikat untuk '%s' dalam penempatan penunjuk di %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "stack size must not be greater than 64k"
 msgid "Stride must not be present at %L"
 msgstr "ukuran stack harus lebih besar  dari 64k"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Objek eksternal '%s' di %L tidak boleh memiliki sebuah penginisialisasi"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Penempatan penunjuk prosedur tidak valid di %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Diduga sebuah prosedur untuk argumen '%s' di %L"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate interface declaration for class %qs"
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "duplikasi deklarasi antar-muka untuk class %qs"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid procedure pointer assignment at %L"
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Penempatan penunjuk prosedur tidak valid di %L"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Penempatan target penunjuk bukan sebuah PENUNJUK di %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Tipe berbeda dalam penempatan penunjuk di %L; mencoba penempatan dari %s ke %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Jenis parameter berbeda dalam penempatan penunjuk di %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Tingkat berbeda dalam penempatan penunjuk di %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Penempatan target penunjuk bukan sebuah PENUNJUK di %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -85272,210 +85444,210 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data target at %L shall not have a coindex"
 msgstr "Elemen pemindahan data di %L tidak dapat memiliki komponen PENUNJUK"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "Pemilihan ekspresi dalam pernyataan GOTO yang terhitung di %L harus berupa sebuah ekspresi integer skalar"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "Target penempatan penunjuk memiliki atribut PROTECTED di %L"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Argumen dari pernyataan SELECT di %L harus berupa sebuah ekspresi skalar"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Target penempatan penunjun baik bukan TARGET ataupun PENUNJUN di %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Target buruk dalam penempatan penunjuk dalam prosedur PURE di %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Penempatan penunjuk dengan subscrip vektori di rhs di %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Target penempatan penunjuk memiliki atribut PROTECTED di %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "Argumen dari prosedur FINAL di %L harus berupa DAPAT-DIALOKASIKAN"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "Komponen di %C harus memiliki sebuah atribut PENUNJUK"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Komponen di %C harus memiliki sebuah atribut PENUNJUK"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 #| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Antarmuka abstrak '%s' tidak valid dalam penempatan penunjuk prosedur di %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2003: Noninteger exponent in an initialization expression at %L"
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2003: eksponen bukan integer dalam sebuah ekspresi inisialisasi di %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 #| msgid "Argument to '%s' at %L is not a variable"
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "Argumen ke '%s' di %L bukan sebuah variabel"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Variabel '%s' tidak dapat muncul dalam ekspresi di %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %s cannot be assigned in PURE procedure at %C"
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Variabel %s tidak dapat ditempatkan dalam prosedur PURE di %C"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -85498,7 +85670,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -85565,46 +85737,46 @@ msgstr "Variabel '%s' di %C tidak dapat diredefinisi didalam loop berawal di %L"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "Variabel '%s' di %C tidak dapat diredefinisi didalam loop berawal di %L"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "Referensi array di %L diluar dari jangkauan (%ld < %ld) dalam dimensi %d"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "Referensi array di %L diluar dari jangkauan (%ld > %ld) dalam dimensi %d"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "Variabel '%s' di %C tidak dapat diredefinisi didalam loop berawal di %L"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "Variabel '%s' di %C tidak dapat diredefinisi didalam loop berawal di %L"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "%s between %L and %L"
@@ -85738,12 +85910,12 @@ msgstr "Argumen pertama dari penempatan yang didefinisikan di %L harus berupa IN
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Argumen kedua dari penempatan didefinisikan di %L harus berupa INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Argumen pertama dari antar-muka operator di %L harus berupa INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Argumen kedua dari antar-muka operator di %L harus berupa INTENT(IN)"
@@ -86221,350 +86393,355 @@ msgstr "Aktual argumen untuk '%s' harus DAPAT DIALOKASIKAN di %L"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr "Aktual argumen di %L harus dapat didefinisikan sebagai sebuah dummy argumen '%s' adalah INTENT = OUT/INOUT"
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, fuzzy, gcc-internal-format
 #| msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT) or VOLATILE attribute of the dummy argument '%s'"
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "Daerah array aktual argumen dengan vektor subscript di %L adalah tidak kompatibel dengan INTENT(OUT), INTENT(INOUT) atau VOLATILE atribut dari argumen dummy'%s'"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Bentuk-diasumsikan aktual argumen di %L adalah tidak kompatibel dengan bentuk tidak diasumsikan dummy argumen '%s' karena atribut VOLATILE"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, fuzzy, gcc-internal-format
 #| msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Daerah array aktual argumen di %L adalah tidak kompatibel dengan tidak-diasumsikanbentuk dummy argumen '%s' karena atribut VOLATILE"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument '%s' due to VOLATILE attribute"
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "Penunjuk array aktual argumen di %L membutuhkan sebuah bentuk diasumsikan ataupenunjuk array dummy argumen '%s' karena atribut VOLATILE"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Hilang alternatif spesifikasi kembali dalam pemanggilan subroutine di %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 #| msgid "Missing actual argument for argument '%s' at %L"
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Hilang aktual argumen untuk argumen '%s' di %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, fuzzy, gcc-internal-format
 #| msgid "Same actual argument associated with INTENT(%s) argument '%s' and INTENT(%s) argument '%s' at %L"
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Aktual argumen sama berasosiasi dengan INTENT(%s) argumen '%s' dan INTENT(%s) argumen '%s' di %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Prosedur argumen di %L adalah lokal ke sebuah prosedur PURE dan memiliki atribut PENUNJUK"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Prosedur argumen di %L adalah lokal ke sebuah prosedur PURE dan adalah dilewatkan ke sebuah argumen INTENT(%s)"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Prosedur argumen di %L adalah lokal ke sebuah prosedur PURE dan adalah dilewatkan ke sebuah argumen INTENT(%s)"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Prosedur '%s' dipanggil dengan sebuah antar-muka implisit di %L"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L has no explicit interface"
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Prosedur '%s' dalam %s di %L tidak memiliki antar-muka eksplisit"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Prosedur '%s' dipanggil dengan sebuah antar-muka implisit di %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic character length function '%s' at %L must have an explicit interface"
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Otomatis panjang fungsi karakter '%s' di %L harus memiliki sebuah antar-muka eksplisit"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Diduga sebuah prosedur untuk argumen '%s' di %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Kata kunci argumen membutuhkan antar-muka eksplisit untuk prosedur '%s' di %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Simbol '%s' di %L telah memiliki sebuah antar-muka eksplisit"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Kata kunci argumen membutuhkan antar-muka eksplisit untuk prosedur '%s' di %L"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "MOLD argument to NULL required at %L"
 msgstr "Hilang argumen ke %s intrinsik di %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Kata kunci argumen membutuhkan antar-muka eksplisit untuk prosedur '%s' di %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Prosedur '%s' dipanggil dengan sebuah antar-muka implisit di %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "Kata kunci argumen membutuhkan antar-muka eksplisit untuk prosedur '%s' di %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D aliased to undefined symbol %qs"
 msgid "Unable to find symbol %qs"
 msgstr "%q+D teraliasi ke simbol tidak terdefinisi %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 #| msgid "Entity '%s' at %C is already present in the interface"
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Entiti '%s' di %C telah ada dalam sebuah antar-muka"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 #| msgid "Can't overwrite GENERIC '%s' at %L"
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "Tidak dapat overwrite GENERIC '%s' di %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "'%s' di %L overrides sebuah prosedur binding dideklarasikan NON_OVERRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a PURE procedure and must also be PURE"
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "'%s' di %L overrides sebuah prosedur PURE dan juga harus berupa PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "'%s' di %L overrides sebuah prosedur ELEMENTAL dan juga harus berupa ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "'%s' di %L overrides sebuah prosedur bukan ELEMENTAL dan tidak harus berupa ELEMENTAL juga"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "'%s' di %L overrides sebuah SUBROUTINE dan juga harus berupa sebuah SUBROUTINE"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a FUNCTION and must also be a FUNCTION"
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "'%s' di %L overrides sebuah FUNGSI dan juga harus berupa sebuah FUNGSI"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "'%s' di %L overrides sebuah prosedur PUBLIK dah tidak harus berupa PRIVATE"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' of '%s' at %L should be named '%s' as to match the corresponding argument of the overridden procedure"
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "Argumen dummy '%s' dari '%s' di %L seharusnya bernama '%s' untuk mencocokan dengan argumen yang berhubungan dengan prosedur overridden"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have the same number of formal arguments as the overridden procedure"
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "'%s' di %L harus memiliki jumlah sama dari argumen formal seperti prosedur overridden"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a NOPASS binding and must also be NOPASS"
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "'%s' di %L overrides sebuah binding NOPASS dan juga harus berupa NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L overrides a binding with PASS and must also be PASS"
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "'%s' di %L overrides sebuah pengikatan dengan PASS dan juga harus berupa PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, fuzzy, gcc-internal-format
 #| msgid "Passed-object dummy argument of '%s' at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "Argumen dummy objek yang dilewatkan dari '%s' di %L harus berada di posisi yang sama sebagai argumen dumy objek yang dilewatkan dari prosedur overridden"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "%s tag di %L harus berupa tipe %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "Argumen dim di %L harus berupa tipe INTEGER"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Nilai-karakter fungsi internal '%s' di %L tidak boleh dengan panjang diasumsikan"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "Dummy argumen '%s' di %L tidak dapat berupa INTENT(OUT)"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "pernyataan DATA di %C tidak diperbolehkan dalam sebuah prosedur PURE"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "Deleted feature: %s at %L must be integer"
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "Featur terhapus: %s di %L harus berupa integer"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Terlalu banyak argumen dalam panggilan ke '%s' di %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -86777,7 +86954,7 @@ msgstr "Konversi dari %s ke %s di %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -87398,7 +87575,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' in namelist '%s' at %L cannot have ALLOCATABLE components"
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
@@ -87585,12 +87762,12 @@ msgstr "Integer overflow"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -88153,7 +88330,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "Penunjuk Cray di %C harus berupa sebuah integer"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -88714,102 +88891,102 @@ msgstr "Diduga nama dari SELECT CASE konstruk di %C"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "pernnyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok DO"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in PROTECTED statement at %C"
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Sintaks error dalam pernyataan TERPROTEKSI di %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "SELECT RANK statement at %C"
 msgstr "Pernyataan IMPLISIT kosong di %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Sintaks error dalam pernyataan SAVE di %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Diduga pernyataan CASE di %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in CASE specification at %C"
 msgstr "Sintaks error dalam spesifikasi CASE di %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Tidak terduga pernyataan END di %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Sintaks error dalam spesifikasi CASE di %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Sintaks error dalam spesifikasi CASE di %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "Tidak terduga pernyataan END di %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "FORALL stride ekspresi di %L harus berupa sebuah skalar %s"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "Sintaks error dalam spesifikasi CASE di %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "pernyataan ELSEWHERE di %C tidak terenklose dalam blok WHERE"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 #| msgid "Label '%s' at %C doesn't match WHERE label '%s'"
 msgid "Label %qs at %C doesn't match WHERE label %qs"
@@ -89887,7 +90064,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
@@ -89925,12 +90102,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Tidak terduga sampah setelah pernyataan ELSE di %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -90450,7 +90627,7 @@ msgstr "Tidak terduga sampah setelah pernyataan ELSE di %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "NUM_THREADS clause di %L membutuhkan sebuah ekspresi skalar INTEGER"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be of type %s"
 msgid "INTEGER expression of %s clause at %L must be positive"
@@ -90473,7 +90650,7 @@ msgstr "Cray penunjuk '%s' dalam clause %s di %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Cray pointee '%s' dalam %s clause di %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
@@ -90509,19 +90686,19 @@ msgstr "Ukuran array yang diasumsikan '%s' dalam %s clause di %L"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "objek PENUNJUK '%s' dalam %s clause di %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Cray penunjuk '%s' dalam clause %s di %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointee '%s' in %s clause at %L"
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Cray pointee '%s' dalam %s clause di %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "ALLOCATABLE object %qs in %s clause at %L"
@@ -90644,8 +90821,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "IF clause di %L membutuhkan sebuah ekspresi skalara LOGIKAL"
@@ -90730,7 +90907,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' is not a variable at %L"
 msgid "Object %qs is not a variable at %L"
@@ -90754,7 +90931,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' present on multiple clauses at %L"
 msgid "Symbol %qs present on multiple clauses at %L"
@@ -90797,7 +90974,7 @@ msgstr "Simbol '%s' ada dalam multiple clause di %L"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE muncul lebih dari sekali dalam clause data"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -91138,638 +91315,648 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 #| msgid "%s REDUCTION variable '%s' must be INTEGER at %L"
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "%s REDUKSI variabel '%s' harus berupa INTEGER di %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 #| msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "IF clause di %L membutuhkan sebuah ekspresi skalara LOGIKAL"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr ""
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "SCHEDULE clause chunk_size di %L membutuhkan sebuah ekspresi skalar INTEGER"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Tingkat tidak kompatibel dalam %s (%d dan %d) di %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "SIZES requires constant expression at %L"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Didugak ekspresi inisialisasi skalar di %C"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC pernyataan harus diset ke sebuah variabel skalar dari tipe intrinsik di %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "!$OMP ATOMIC pernyataan harus diset ke sebuah variabel skalar dari tipe intrinsik di %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC pernyataan harus diset ke sebuah variabel skalar dari tipe intrinsik di %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr dalam !$OMP ATOMIC assignment var = var op expr harus berupa skalar dan tidak dapat bereferensi var di %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC pernyataan harus diset ke sebuah variabel skalar dari tipe intrinsik di %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC pernyataan harus diset ke sebuah variabel skalar dari tipe intrinsik di %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr dalam !$OMP ATOMIC assignment var = var op expr harus berupa skalar dan tidak dapat bereferensi var di %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC assignment operator must be +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "!$OMP ATOMIC assignmen operator harus berupa +, *, -, /, .AND., .OR., .EQV. atau .NEQV. di %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "!$OMP ATOMIC assignmen harus berupa var = var op expr atau var = expr op var di %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP ATOMIC var = var op expr tidak seacra matematik sama ekuivalen ke var = var op (expr) di %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "expr dalam !$OMP ATOMIC assignment var = var op expr harus berupa skalar dan tidak dapat bereferensi var di %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "!$OMP ATOMIC assignmen intrinsik IAND, IOR, atau IEOR harus memiliki dua argumen di %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "!$OMP ATOMIC assignmen intrinsik harus berupa MIN, MAX, IAND, IOR atau IEOR di %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, fuzzy, gcc-internal-format
 #| msgid "!$OMP ATOMIC intrinsic arguments except one must not reference '%s' at %L"
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "!$OMP ATOMIC intrinsik argumen kecuali satu tidak boleh mereferensi '%s' di %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "!$OMP ATOMIC intrinsik argumen harus berupa skalar di %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, fuzzy, gcc-internal-format
 #| msgid "First or last !$OMP ATOMIC intrinsic argument must be '%s' at %L"
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Pertama atau terakhir !$OMP ATOMIC intrinsik argumen harus berupa '%s' di %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "!$OMP ATOMIC assignmen harus memiliki sebuah operator atau instrinsik di tangan sebelah kanan di %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected exponent in expression at %C"
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Diduga eksponen dalam ekspresi di %C"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP DO tidak dapat berupa sebuah DO WHILE atau DO tanpa pengontrol loop di %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "!$OMP DO variabel iterasi harus berupa tipe integer di %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must not be THREADPRIVATE at %L"
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "!$OMP DO variabel iterasi tidak boleh berupa THREADPRIVATE di %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "!$OMP DO variabel iterasi ada dalam clause selain dari PRIVATE atau LASTPRIVATE di %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "!$OMP DO variabel iterasi ada dalam clause selain dari PRIVATE atau LASTPRIVATE di %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "!$OMP DO variabel iterasi harus berupa tipe integer di %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Hiteration variable %qE is unsigned"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "%H variabel iterasi %qE unsigned"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad kind expression for function '%s' at %L"
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "Jenis ekspresi buruk untuk fungsi '%s' di %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "not enough DO loops for collapsed !$OMP DO at %L"
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "tidak cukup DO loops untuk kolaps !$OMP DO di %L"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "kolaps !$OMP DO loops tidak secara sempurna nested di %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcollapse argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "%Hkolaps argumen membutuhkan konstanta positif integer ekspresi"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "Aktual argumen untuk '%s' harus berupa sebuah penunjuk di %L"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "property must be a logical expression at %L"
 msgstr "argumen ke decltype harus berupa sebuah ekspresi"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be an integer expression at %L"
 msgstr "diduga ekspresi integer"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Character length of component '%s' needs to be a constant specification expression at %L"
 msgid "property must be a constant logical expression at %L"
 msgstr "Panjang karakter dari komponen '%s' butuh untuk menjadi sebuah ekspresi spesifikasi konstan di %L"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "property must be a constant integer expression at %L"
 msgstr "argumen collapes membutuhkan konstanta positif ekspresi integer"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP DO tidak dapat berupa sebuah DO WHILE atau DO tanpa pengontrol loop di %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "!$OMP DO variabel iterasi harus berupa tipe integer di %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO collapsed loops don't form rectangular iteration space at %L"
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "!$OMP DO collapsed loops tidak membentuk iterasi ruang rectangular di %L"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "kolaps !$OMP DO loops tidak secara sempurna nested di %L"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "not enough DO loops for collapsed !$OMP DO at %L"
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "tidak cukup DO loops untuk kolaps !$OMP DO di %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOGICAL operands are required in expression at %L"
 msgid "TILE requires constant expression at %L"
 msgstr "operan LOGICAL dibutuhkan dalam ekspresi di %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected an initialization expression at %C"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Diduga sebuah ekspresi inisialisasi di %C"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COLLAPSE clause argument not constant positive integer at %C"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "COLLAPSE clause argumeb bukan konstanta positif integer di %C"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -92492,69 +92679,69 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %C is already ambiguous"
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Prosedur berisi '%s' di %C telah ambigu"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Tidak terduga pernyataan %s dalam daerah CONTAINS di %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Fortran 2008: CONTAINS statement without FUNCTION or SUBROUTINE statement at %C"
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Fortran 2008: pernyataan CONTAINS tanpa pernyataan FUNCTION atau SUBROUTINE di %C"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s statement at %C cannot follow %s statement at %L"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "pernyataan %s di %C tidak dapat mengikuti pernyataan %s di %L"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "pernyataan CONTAINS di %C telah berada dalam satuan aplikasi terisi"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Nama global '%s' di %L telah digunakan sebuah sebuah %s di %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Nama global '%s' di %L telah digunakan sebuah sebuah %s di %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Nama global '%s' di %L telah digunakan sebuah sebuah %s di %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Nama global '%s' di %L telah digunakan sebuah sebuah %s di %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "BLOK DATA kosong di %C konflik dengan BLOK DATA sebelumnya di %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Tidak terduga pernyataan %s dalam BLOK DATA di %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Tidak terduga pernyataan %s dalam MODUL di %C"
@@ -92562,7 +92749,7 @@ msgstr "Tidak terduga pernyataan %s dalam MODUL di %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Dua APLIKASI utama di %L dan %C"
@@ -93066,139 +93253,139 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr "'%s' di %C bukan sebuah variabel"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is of the ABSTRACT type '%s'"
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "'%s' di %L adalah tipe ABSTRACT '%s'"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, fuzzy, gcc-internal-format
 #| msgid "ABSTRACT type '%s' used at %L"
 msgid "ABSTRACT type %qs used at %L"
 msgstr "tipe ABSTRAK '%s' digunakan di %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s', used by procedure '%s' at %L, is declared in a later PROCEDURE statement"
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "Antar-muka '%s', digunakan oleh prosedur '%s' di %L, dideklarasikan dalam pernyataan PROSEDUR kemudian"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' at %C may not be generic"
 msgid "Interface %qs at %L may not be generic"
 msgstr "Antar-muka '%s' di %C mungkin bukan umum"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' at %C may not be a statement function"
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Antar-muka '%s' di %C mungkin bukan sebuah pernyataan fungsi"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic procedure '%s' not allowed in PROCEDURE statement at %C"
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Prosedur intrinsik '%s' tidak diperbolehkan dalam pernyataan PROSEDUR di %C"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
 msgid "Interface %qs at %L must be explicit"
 msgstr "Antar-muka '%s' dari prosedur '%s' di %L harus berupa eksplisit"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE at %C must be in a generic interface"
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROSEDUR di %C harus berupa sebuah antar-muka umum"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in elemental subroutine '%s' at %L is not allowed"
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Alternatif return penspesifikasi dalam subroutine elemental '%s' di %L tidak diperbolehkan"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in function '%s' at %L is not allowed"
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Alternatif return penspesifikasi dalam fungsi '%s' di %L tidak diperbolehkan"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L is not allowed in this context"
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Argumen dengan nilai di %L tidak diperbolehkan dalam konteks ini"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Prosedur dummy '%s' dari prosedur PURE di %L harus juga PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Argumen '%s' dari fungsi pure '%s' di %L harus berupa INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "Argumen '%s' dari fungsi pure '%s' di %L harus berupa INTENT(IN)"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified"
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Argumen '%s' dari subroutine pure '%s' di %L harus memiliki spesifikasi INTENT-nya"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified"
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Argumen '%s' dari subroutine pure '%s' di %L harus memiliki spesifikasi INTENT-nya"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "Argumen '%s' dari prosedur elemental di %L harus berupa skalar"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Kata kunci argumen '%s' di %L tidak dalam prosedur"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Argumen '%s' dari prosedur elemental di %L harus berupa skalar"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Argumen '%s' dari prosedur elemental di %L tidak dapat memiliki atribut POINTER"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Argumen '%s' dari prosedur elemental di %L tidak dapat memiliki atribut POINTER"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' not allowed in elemental procedure '%s' at %L"
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "Prosedur dummy '%s' tidak diperbolehkan dalam elemtal prosedur '%s' di %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
@@ -93206,1092 +93393,1092 @@ msgstr "Argumen '%s' dari prosedur elemental di %L tidak dapat memiliki atribut
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Argumen '%s' dalam pernyataan fungsi di %L harus berupa skalar"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued argument '%s' of statement function at %L must have constant length"
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Nilai-karakter argumen '%s' dari pernyataan fungsi di %L harus memiliki panjang konstan"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "prosedur ANTAR-MUKA '%s' di %L memiliki nama sama dengan prosedur yang melingkupinya"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 #| msgid "Contained function '%s' at %L has no IMPLICIT type"
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Fungsi yang berisi '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 #| msgid "Result '%s' of contained function '%s' at %L has no IMPLICIT type"
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Hasil '%s' dari fungsi yang berisi '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Nilai-karakter fungsi internal '%s' di %L tidak boleh dengan panjang diasumsikan"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Nilai-karakter fungsi internal '%s' di %L tidak boleh dengan panjang diasumsikan"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Fungsi %s di %L memiliki masukan dengan spesifikasi array tidak cocok"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function %s at %L has entries with mismatched array specifications"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "Fungsi %s di %L memiliki masukan dengan spesifikasi array tidak cocok"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Function %s at %L with entries returning variables of different string lengths"
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "Ekstensi: Fungsi %s di %L dengan masukan mengembalikan variabel dari panjang string berbeda"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Hasil FUNGSI %s tidak dapat berupa sebuah array dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Hasil MASUKAN %s tidak dapat berupa sebuah array dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Hasil FUNGSI %s tidak dapat berupa sebuah PENUNJUK dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Hasil MASUKAN %s tidak dapat berupa sebuah PENUNJUK dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Hasil FUNGSI %s tidak dapat berupa sebuah PENUNJUK dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Hasil MASUKAN %s tidak dapat berupa sebuah PENUNJUK dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Hasil FUNGSI %s tidak dapat tipe %s dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Hasil MASUKAN %s tidak dapat tipe %s dalam FUNGSI %s di %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a DO block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "pernnyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok DO"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a DO block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "pernnyataan MASUKAN di %C tidak dapat muncul didalam sebuah blok DO"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COMMON block /%s/ not found at %C"
 msgid "COMMON block at %L"
 msgstr "blok COMMON /%s/  tidak ditemukan di %C"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "Variabel '%s' di %L adalah dalam COMMON tetapi hanya dalam inisialisasi BLOK DATA yang diperbolehkan"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, fuzzy, gcc-internal-format
 #| msgid "Initialized variable '%s' at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "variabel terinisialisasi '%s' di %L adalah dalam sebuah kosong COMMON tetapi inisialisasi hanya diperbolehkan dalam blok umum bernama"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Array otomatis '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "Tipe variabel turunan '%s' dalam COMMON di %L memiliki bukan SEQUENCE ataupun atribut BIND(C)"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' in COMMON at %L has an ultimate component that is allocatable"
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "Tipe variabel turunan '%s' dalam COMMON di %L memiliki sebuah komponen ultimate yang dapat dialokasikan"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' in COMMON at %L may not have default initializer"
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "Tipe variabel turunan '%s' dalam COMMOND di %L tidak boleh memiliki penginisialisasi baku"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "blok COMMON '%s' di %L digunakan sebagai PARAMETER di %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "blok COMMON '%s' di %L digunakan sebagai PARAMETER di %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut PENUNJUK dan BIND(C)"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is also an intrinsic procedure"
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "blok COMMON '%s' di %L juga sebuah prosedur intrinsik"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: COMMON block '%s' at %L that is also a function result"
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "Fortran 2003: blok common '%s' di %L yang juga sebuah hasil fungsi"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: COMMON block '%s' at %L that is also a global procedure"
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "Fortran 2003: blok COMMON '%s' di %L yang juga sebuah prosedur global"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The rank of the element in the derived type constructor at %L does not match that of the component (%d/%d)"
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Tingkat dari elemen dalam tipe konstruktor turunan di %L tidak cocok dengan komponen (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Elemen dalam tipe konstruktor turunan di %L, untuk komponen penunjuk '%s', adalah %s tetapi seharusnya berupa %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "Unequal character lengths (%ld/%ld) in %s at %L"
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Panjang karakter tidak sama (%ld/%ld) dalam %s di %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, fuzzy, gcc-internal-format
 #| msgid "The NULL in the derived type constructor at %L is being applied to component '%s', which is neither a POINTER nor ALLOCATABLE"
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "NULL dalam tipe konstruktor turunan di %L, sedang diaplikasikan untuk komponen '%s', yang bukan sebuah PENUNJUK atau sebuah ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %C!"
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Terlalu banyak komponen dalam struktur konstruktor di %C!"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %C!"
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Terlalu banyak komponen dalam struktur konstruktor di %C!"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 #| msgid "The rank of the element in the derived type constructor at %L does not match that of the component (%d/%d)"
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Tingkat dari elemen dalam tipe konstruktor turunan di %L tidak cocok dengan komponen (%d/%d)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s' should be a POINTER or a TARGET"
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Elemen dalam tipe konstruktor turunan di %L, untuk komponen penunjuk '%s' seharusnya berupa sebuah PENUNJUK atau sebuah TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Penempatan penunjuk dengan subscrip vektori di rhs di %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Elemen dalam tipe konstruktor turunan di %L, untuk komponen penunjuk '%s', adalah %s tetapi seharusnya berupa %s"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, fuzzy, gcc-internal-format
 #| msgid "The upper bound in the last dimension must appear in the reference to the assumed size array '%s' at %L"
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Batas atas dalam dimensi terakhir harus muncul dalam referensi ke ukuran array yang diasumsikan '%s' di %L"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is ambiguous"
 msgid "%qs at %L is ambiguous"
 msgstr "'%s' di %L adalah ambigu"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "prosedur UMUM '%s' tidak diperbolehkan sebagai sebuah argumen aktual di %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 #| msgid "Type specified for intrinsic function '%s' at %L is ignored"
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Tipe dispesifikasikan untuk fungsi intrinsik '%s' di %L diabaikan"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic subroutine '%s' at %L shall not have a type specifier"
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Intrinsik subroutine '%s' di %L tidak boleh memiliki sebuah penspesifikasi tipe"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' declared INTRINSIC at %L does not exist"
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "'%s' dideklarasikan INTRINSIC di %L tidak ada"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, fuzzy, gcc-internal-format
 #| msgid "The intrinsic '%s' declared INTRINSIC at %L is not available in the current standard settings but %s.  Use an appropriate -std=* option or enable -fall-intrinsics in order to use it."
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "Intrinsik '%s' dideklarasikan INTRINSIC di %L tidak tersedia dalam konfigurasi baku sekarang tetapi %s. Gunakan sebuah pilihan -std=* yang sesuai atau aktifkan -fall-intrinsics untuk menggunakan itu."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, fuzzy, gcc-internal-format
 #| msgid "Non-RECURSIVE procedure '%s' at %L is possibly calling itself recursively.  Declare it RECURSIVE or use -frecursive"
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Bukan prosedur REKURSIF '%s' di %L mungkin memanggil dirinya sendiri secara rekursif. Deklarasikan itu secara RECURSIVE atau gunakan -frecursive"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, fuzzy, gcc-internal-format
 #| msgid "Non-RECURSIVE procedure '%s' at %L is possibly calling itself recursively.  Declare it RECURSIVE or use -frecursive"
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Bukan prosedur REKURSIF '%s' di %L mungkin memanggil dirinya sendiri secara rekursif. Deklarasikan itu secara RECURSIVE atau gunakan -frecursive"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Label %d direferensikan di %L tidak pernah terdefinisi"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Prosedur internal '%s' tidak diperbolehkan sebagai sebuah argumen aktual di %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Pernyataan fungsi '%s' di %L tidak diperbolehkan sebagai argumen aktual"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not allowed as an actual argument"
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Intrinsik '%s' di %L tidak diperbolehkan sebagai sebuah argumen aktual"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Prosedur internal '%s' tidak diperbolehkan sebagai sebuah argumen aktual di %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL bukan INTRINSIK prosedur '%s' tidak diperbolehkan sebagai sebuah argumen aktual di %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to find a specific INTRINSIC procedure for the reference '%s' at %L"
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Tidak dapat menemukan sebuah prosedur INTRINSIK spesifik untuk referensi '%s' di %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Simbol '%s' di %L adalah ambigu"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Argumen dengan nilai di %L adalah bukan tipe numerik"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "Argumen dengan nilai di %L tidak dapat berupa sebuah array atau sebuah daerah array"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Argumen dengan nilai di %L tidak diperbolehkan dalam konteks ini"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Melewati prosedur internal di %L dengan lokasi tidak diperbolehkan"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL bukan INTRINSIK prosedur '%s' tidak diperbolehkan sebagai sebuah argumen aktual di %L"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (12.4.1.5)"
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "'%s' di %L adalah sebuah array dan OPSIONAL; JIKA INI HILANG, ini tidak dapat berupa argumen aktual dari sebual prosedur ELEMENTAL kecuali disana ada sebuah tidak pilihanonal argumen dengan tingkat sama (12.4.1.5)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument at %L for INTENT(%s) dummy '%s' of ELEMENTAL subroutine '%s' is a scalar, but another actual argument is an array"
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "Argumen aktual di %L untuk INTENT(%s) dummy '%s' dari subroutine ELEMENTAL '%s' adalah sebuah skalar, tetapi argumen aktual lain adalah sebuah array"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 #| msgid "Return value of function '%s' at %L not set"
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Nilai kembali dari fungsi '%s' di %L tidak diset"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Antar-muka '%s' dari prosedur '%s' di %L harus berupa eksplisit"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific function for the generic '%s' at %L"
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "Disana tidak ada fungsi spesifik untuk umum '%s' di %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 #| msgid "Generic function '%s' at %L is not consistent with a specific intrinsic interface"
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Fungsi umum '%s' di %L tidak konsisten dengan sebuah antar-muka spesifik intrinsik."
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Fungsi '%s' di %L adalah INTRINSIK tetapi tidak kompatibel dengan sebuah intrinsik"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Tidak dapat meresolf fungsi spesifik '%s'di %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Fungsi '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Fungsi '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "referensi ke fungsi bukan-PURE '%s' di %L didalam sebuah FORALL %s"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 #| msgid "reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "referensi ke fungsi bukan-PURE '%s' di %L didalam sebuah FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, fuzzy, gcc-internal-format
 #| msgid "reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "referensi ke fungsi bukan-PURE '%s' di %L didalam sebuah FORALL %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot write to internal file unit '%s' at %C inside a PURE procedure"
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Tidak dapat menulis ke internal berkas satuan '%s' di %C didalam prosedur PURE"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Unexpected junk after %qs at %L"
 msgstr "Tidak terduga sampah setelah pernyataan ELSE di %C"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "%qs at %L is not a function"
 msgstr "'%s' di %L bukan sebuah fungsi"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, fuzzy, gcc-internal-format
 #| msgid "ABSTRACT INTERFACE '%s' must not be referenced at %L"
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ANTAR-MUKA ABSTRAK '%s' tidak boleh direferensikan di %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "Fungsi '%s' adalah dideklarasikan KARAKTER(*) dan tidak dapat digunakan di %L karena ini bukan sebuah argumen dummy"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Hilang daftar argumen dalam fungsi '%s' di %C"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, fuzzy, gcc-internal-format
 #| msgid "User defined non-ELEMENTAL function '%s' at %L not allowed in WORKSHARE construct"
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "Fungsi bukan-ELEMENTAL definisi pengguna '%s' di %L tidak diperbolehkan dalam WORKSHAREkonstruksi"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L cannot be called recursively, as function '%s' is not RECURSIVE"
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "MASUKAN '%s' di %L tidak dapat dipanggil secara rekursif, karena fungsi '%s' tidak REKURSIF"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot be called recursively, as it is not RECURSIVE"
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Fungsi '%s' di %L tidak dapat dipanggil secara rekursif, karena ini bukan REKURSIF"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function at %L is recursive"
 msgid "Using function %qs at %L is deprecated"
 msgstr "Pernyataan fungsi di %L adalah rekursif"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "Prosedur dummy di %L tidak diperbolehkan dalam prosedur ELEMENTAL"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Panggilan subroutine ke '%s' dalam blok FORALL di %L tidak PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Panggilan subroutine ke '%s' dalam blok FORALL di %L tidak PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Panggilan subroutine ke '%s' dalam blok FORALL di %L tidak PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' at %L is not PURE"
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Panggilan subroutine ke '%s' di %L bukan PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific subroutine for the generic '%s' at %L"
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Disana tidak ada subroutine spesifik untuk umum '%s' di %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "Generic subroutine '%s' at %L is not consistent with an intrinsic subroutine interface"
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Subroutine umum '%s' di %L tidak konsisten dengan sebuah anta-muka subroutine intrinsik"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Subroutine '%s' di %L adalah INTRINSIK tetapi tidak kompatibel dengan sebuah intrinsik"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific subroutine '%s' at %L"
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Tidak dapat meresolf subroutine spesifik '%s' di %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "'%s' di %L memiliki sebuah tipe, yang tidak konsisten dengan CALL di %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L cannot be called recursively, as subroutine '%s' is not RECURSIVE"
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "MASUKAN '%s' di %L tidak dapat dipanggil secara rekursif, karena subroutine '%s' tidak REKURSIF"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 #| msgid "SUBROUTINE '%s' at %L cannot be called recursively, as it is not RECURSIVE"
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "SUBROUTINE '%s' di %L tidak dapat dipanggil secara rekursif, karena ini bukan REKURSIF"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Bentuk untuk operan di %L dan %L tidak konformant"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat bernilai-penunjuk"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Shape specification at %L cannot be negative"
 msgid "Impure function at %L might not be evaluated"
 msgstr "Spesifikasi bentuk di %L tidak dapat negatif"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "Argumen dengan nilai di %L tidak dapat berupa sebuah array atau sebuah daerah array"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "perbandingan dari ekspresi unsigned >= 0 adalah selalu benar"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Konteks tidak valid untuk penunjuk NULL() di %%L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator '%s' at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Operan dari operator numerik unary '%s' di %%L adalah %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Operan dari operan binari numerik '%s' di %%L adalah %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Tingkat tidak konsisten untuk operator di %%L dan %%L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Operan dari string operator konkatenasi di %%L adalah %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator '%s' at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Operan dari operator logikal '%s' di %%L adalah %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .not. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Operan dari operator .not. di %%L adalah %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "kuantitas KOMPLEKS tidak dapat dibandingkan di %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Tingkat tidak konsisten untuk operator di %%L dan %%L"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "Jenis tidak valid untuk %s di %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "Jenis tidak valid untuk %s di %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Logikal di %%L harus dibandingkan dengan %s daripada %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Operan dari operator perbandingan '%s' di %%L adalah %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator '%s' at %%L"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "Operator tidak dikenal '%s' di %%L"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator '%s' at %%L"
 msgid "Unknown operator %qs at %L"
 msgstr "Operator tidak dikenal '%s' di %%L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator '%s' at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Operan dari operator pengguna '%s' di %%L adalah %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator '%s' at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Operan dari operator pengguna '%s' di %%L adalah %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Referensi array di %L diluar dari jangkauan (%ld < %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Referensi array di %L diluar dari jangkauan (%ld < %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Referensi array di %L diluar dari jangkauan (%ld > %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Referensi array di %L diluar dari jangkauan (%ld > %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Tidak legal stride dari nol di %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Referensi array bawah di %L diluar dari jangkauan (%ld < %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Referensi array bawah di %L diluar dari jangkauan (%ld > %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Referensi array atas di %L diluar dari jangkauan (%ld < %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Referensi array atas di %L diluar dari jangkauan (%ld > %ld) dalam dimensi %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "subscrip hilang dalam referensi array"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Jangkauan paling kanan ats dari daerah ukuran array yang diasumsikan tidak dispesifikasikan di %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Tingkat tidak cocok dalam referensi array di %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Tingkat tidak cocok dalam referensi array di %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "index in dimension %d is out of bounds at %L"
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "indeks dalam dimensi %d diluar dari jangkauan di %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Indeks array di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Indeks array di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: REAL array index at %L"
 msgid "REAL array index at %L"
 msgstr "Ekstensi: indeks array RIL di %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Argumen dim di %L harus berupa tipe INTEGER"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Format dari referensi array tidak valid di %C"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Indeks array di %L adalah sebuah array dari tingkat %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Ekspresi di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Ekspresi di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT tag in %s statement at %L must be a variable"
 msgid "STAT's expression at %L must be a variable"
 msgstr "STAT tag dalam pernyataan %s di %L harus berupa sebuah variabel"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Indeks awal substring di %L harus berupa tipe INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Indeks awal substring di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "Indeks akhir substring di %L harus berupa tipe INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "Indeks akhir substring di %L harus berupa skalar"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L must be scalar"
 msgid "Substring end index at %L is too large"
 msgstr "Indeks akhir substring di %L harus berupa skalar"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "resolve_ref(): Bad array reference"
 msgstr "Referensi array buruk di %L"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Komponen ke bagian kanan dari referensi dengan tingkat bukan-nol harus tidak memiliki atribut PENUNJUK di %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Komponen ke bagian kanan dari referensi dengan tingkat bukan-nol harus tidak memiliki atribut DAPAT DIALOKASIKAN di %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Dua atau lebih referensi bagian dengan tingkat bukan-nol tidak boleh dispesifikasikan di %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
@@ -94301,12 +94488,12 @@ msgstr "Bentuk array yang diasumsikan di %L harus berupa sebuah argumen dummy"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
@@ -94316,442 +94503,442 @@ msgstr "Bentuk array yang diasumsikan di %L harus berupa sebuah argumen dummy"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Intrinsic subroutine '%s' at %L shall not have a type specifier"
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "Intrinsik subroutine '%s' di %L tidak boleh memiliki sebuah penspesifikasi tipe"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Intrinsic subroutine '%s' at %L shall not have a type specifier"
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "Intrinsik subroutine '%s' di %L tidak boleh memiliki sebuah penspesifikasi tipe"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "Referensi array buruk di %L"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s', used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "Variabel '%s', digunakan dalam sebuah ekspresi spesifikasi, direferensikan di %L sebelum pernyataan MASUKAN dimana ini adalah sebuah parameter"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' is used at %L before the ENTRY statement in which it is a parameter"
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "Variabel '%s' digunakan di %L sebelum pernyataan MASUKAN dimana ini adalah sebuah parameter"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared %s"
 msgid "Using variable %qs at %L is deprecated"
 msgstr "instance variabel %qs dideklarasikan %s"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "Referensi array buruk di %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Objek yang dilewatkan di %L harus berupa skalar"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Argumen '%s' dari prosedur elemental di %L harus berupa skalar"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, fuzzy, gcc-internal-format
 #| msgid "Found no matching specific binding for the call to the GENERIC '%s' at %L"
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "Tidak ditemukan pengikatan spesifik yang cocok untuk panggilan ke GENERIC '%s' di %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L should be a SUBROUTINE"
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "'%s' di %L seharusnya berupa sebuah SUBROUTINE"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L should be a FUNCTION"
 msgid "%qs at %L should be a FUNCTION"
 msgstr "'%s' di %L seharusnya berupa sebuah FUNGSI"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "Diduga tipe ekspresi"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s di %L harus berupa sebuah skalar"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Deleted feature: %s at %L must be integer"
 msgid "%s at %L must be integer"
 msgstr "Featur terhapus: %s di %L harus berupa integer"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s di %L harus berupa INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "Ekspresi step dalam loop DO di %L tidak dapat berupa nol"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Diduga nama variabel di %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Variabel '%s' di %L belum ditempatkan sebuah label format"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "atribut SAVE di %L tidak dapat dispesifikasikan dalam sebuah prosedur PURE"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in %s clause at %L"
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Ukuran array yang diasumsikan '%s' dalam %s clause di %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Cray penunjuk '%s' dalam clause %s di %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr ""
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "FORALL nama-indeks di %L harus berupa sebuah skalar INTEGER"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "FORALL awal ekspresi di %L harus berupa sebuah skalar INTEGER"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "FORALL akhir ekspresi di %L harus berupa sebuah skalar INTEGER"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "FORALL stride ekspresi di %L harus berupa sebuah skalar %s"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "FORALL stride ekspresi di %L tidak dapat berupa nol"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 #| msgid "FORALL index '%s' may not appear in triplet specification at %L"
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "FORALL indeks '%s' mungkin tidak muncul dalam spesifikasi triplet di %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in ALLOCATE statement at %L must be ALLOCATABLE or a POINTER"
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Ekspresi dalam pernyataan ALOKASI di %L harus berupa DAPAT DIALOKASIKAN atau sebuah PENUNJUK"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Hanya intrinsik operator yang dapat digunakan dalam ekspresi di %L"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Spesifikasi array dibutuhkan dalam pernyatan ALOKASI di %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Spesifikasi array dibutuhkan dalam pernyatan ALOKASI di %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Spesifikasi array dibutuhkan dalam pernyatan ALOKASI di %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array specification in ALLOCATE statement at %L"
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Spesifikasi array buruk dalam pernyataan ALOKASI di %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Spesifikasi array buruk dalam pernyataan ALOKASI di %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "'%s' tidak boleh muncul dalam spesifikasi array di %L dalam pernyataan ALOKASI yang sama dimana ini sendiri dialokasikan"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array specification in ALLOCATE statement at %L"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "Spesifikasi array buruk dalam pernyataan ALOKASI di %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "pernyataan ASSIGN di %L membutuhkan sebuah skalar baku variabel INTEGER"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Label di %L tidak dalam blok yang sama seperti pernyataan GOTO di %L"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "pernyataan ASSIGN di %L membutuhkan sebuah skalar baku variabel INTEGER"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -94760,343 +94947,343 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "CASE label di %L overlaps dengan CASE label di %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "Ekspresi dalam pernyataan CASE di %L harus berupa tipe %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Ekspresi dalam pernyataan CASE di %L harus berupa tipe %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Ekspresi dalam pernyataan CASE di %L harus berupa skalar"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Pemilihan ekspresi dalam pernyataan GOTO yang terhitung di %L harus berupa sebuah ekspresi integer skalar"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Argumen dari pernyataan SELECT di %L tidak dapat berupa %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Argumen dari pernyataan SELECT di %L harus berupa sebuah ekspresi skalar"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be of type %s"
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Ekspresi dalam pernyataan CASE di %L harus berupa tipe %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "KASUS BAKU di %L tidak dapat diikuti oleh sebuah KASUS BAKU kedua di %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Jangkauan logikal dalam pernyataan CASE di %L tidak diperbolehkan"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "constant logical value in CASE statement is repeated at %L"
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "nilai logikan konstan dalam pernyataan CASE diulang di %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Spesifikasi jangkauan di %L tidak pernah cocok"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Logikal SELECT CASE blok di %L memiliki lebih dari dua kasus"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "Tidak dapat meresolf fungsi spesifik '%s'di %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Nama '%s' tidak dapat digunakan sebagai sebuah operator terdefinisi di %C"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Selector at %L cannot be NULL()"
 msgstr "Langkah iterasi di %L tidak dapat nol"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Selector at %L has no type"
 msgstr "Fungsi '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Sintaks error dalam pernyataan EKUIVALEN di %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Deleted feature: %s at %L must be integer"
 msgid "Selector at %L must not be coindexed"
 msgstr "Featur terhapus: %s di %L harus berupa integer"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CASE label at %L overlaps with CASE label at %L"
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "CASE label di %L overlaps dengan CASE label di %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L is empty"
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Tipe turunan '%s' di %L adalah kosong"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L is empty"
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Tipe turunan '%s' di %L adalah kosong"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected %s statement at %C"
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Tidak terduga pernyataan %s di %C"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Konteks tidak valid untuk penunjuk NULL() di %%L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "Antar-muka '%s' dari prosedur '%s' di %L harus berupa eksplisit"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "Elemen pemindahan data di %L tidak dapat memiliki komponen PENUNJUK"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "Elemen pemindahan data di %L tidak dapat memiliki komponen PENUNJUK"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have ALLOCATABLE components"
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "Elemen pemindahan data di %L tidak dapat memiliki komponen DAPAT DIALOKASIKAN"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "Elemen pemindahan data di %L tidak dapat memiliki komponen PRIVATE"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have PRIVATE components"
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "Elemen pemindahan data di %L tidak dapat memiliki komponen PRIVATE"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Elemen pemindahan data di %L tidak dapat berupa sebuah referensi lengkap ke sebuah array yang ukurannya diasumsikan"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "FORALL nama-indeks di %L harus berupa sebuah skalar INTEGER"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "Argumen dengan nilai di %L tidak dapat berupa sebuah array atau sebuah daerah array"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "Argumen dengan nilai di %L tidak dapat berupa sebuah array atau sebuah daerah array"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "pernyataan ASSIGN di %L membutuhkan sebuah skalar baku variabel INTEGER"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "pernyataan ASSIGN di %L membutuhkan sebuah skalar baku variabel INTEGER"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "Argumen dim di %L harus berupa skalar"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "NUM_THREADS clause di %L membutuhkan sebuah ekspresi skalar INTEGER"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "!$OMP ATOMIC pernyataan harus diset ke sebuah variabel skalar dari tipe intrinsik di %L"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa jenis %d"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Argumen dari pernyataan SELECT di %L harus berupa sebuah ekspresi skalar"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ACOS at %L must be between -1 and 1"
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Argumen dari ACOS di %L harus berada diantara -1 dan 1"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Pernyataan di %L bukan sebuah pernyataan pencabangan target yang valid untuk sebuah pernyataan percabangan di %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Cabang di %L bisa menyebabkan sebuah loop tak terhingga"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -95104,222 +95291,222 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Label di %L tidak dalam blok yang sama seperti pernyataan GOTO di %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "DIMANA mask di %L memiliki bentuk tidak konsisten"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "penempatan target WHERE di %L memiliki bentuk tidak konsisten"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "penempatan bukan-ELEMEN didefinisikan-pengguna dalam WHERE di %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Pernyataan didalam WHERE di %L tidak didukung"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Penempatan ke sebuah indeks variabel FORALL di %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, fuzzy, gcc-internal-format
 #| msgid "The FORALL with index '%s' is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "FORALL dengan indeks '%s' tidak digunakan di sisi kiri dari penempatan di %L dan jadi mungkin menyebabkan penempatan berulang di objek ini"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "FORALL nama-indeks di %L harus berupa sebuah skalar INTEGER"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Sebuah konstruks FORALL luar telah memiliki sebuah indeks dengan nama ini %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Diduga nama variabel di %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "WHERE/ELSEWHERE clause di %L membutuhkan sebuah array LOGIKAL"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "Tidak dapat mengubah %s ke %s di %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER expression will be truncated in assignment (%d/%d) at %L"
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "Ekspresi KARAKTER akan dipotong dalam penempatan (%d/%d) di %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The impure variable at %L is assigned to a derived type variable with a POINTER component in a PURE procedure (12.6)"
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Variabel impure di %L ditempatkan ke sebuah tipe variabel turunan dengan sebuah komponen PENUNJUK dalam sebuah prosedur PURE (12.6)"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Penempatan ke sebuah indeks variabel FORALL di %L"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Penempatan ke sebuah indeks variabel FORALL di %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid procedure pointer assignment at %L"
 msgid "Pointer procedure assignment at %L"
 msgstr "Penempatan penunjuk prosedur tidak valid di %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "pernyataan GOTO ASSIGNED di %L membutuhkan sebuah variabel INTEGER"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' has not been assigned a target label at %L"
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Variabel '%s' belum pernah ditempatkan sebuah label target di %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Pernyataan RETURN alternatif di %L membutuhkan sebuah SKALAR-INTEGER return penspesifikasi"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Diduga ekspresi inisialisasi dalam CASE di %C"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "pernyataan ASSIGN di %L membutuhkan sebuah skalar baku variabel INTEGER"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "Jenis tidak valid untuk %s di %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Arithmetic IF statement at %L requires a numeric expression"
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Pernyataan aritmetik IF di %L membutuhkan sebuah ekspresi numerik"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Kondisi keluar dari loop DO WHILE di %L harus berupa sebuah ekspresi skalar LOGIKAL"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL mask clause at %L requires a LOGICAL expression"
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "FORALL mask clause di %L membutuhkan sebuah ekspresi LOGIKAL"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_trans_code(): Pernyataan kode buruk"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter '%s' declared at %L"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Parameter '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, fuzzy, gcc-internal-format
 #| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
@@ -95327,7 +95514,7 @@ msgstr "Binding label '%s' di %L collides dengan global entity '%s' di %L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -95335,69 +95522,69 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, fuzzy, gcc-internal-format
 #| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Binding label '%s' di %L collides dengan global entity '%s' di %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array %qs is too large"
 msgid "String length at %L is too large"
 msgstr "ukuran dari array %qs adalah terlalu besar"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Array dapat dialokasikan '%s' di %L harus memiliki sebuah bentuk deferred"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 #| msgid "Scalar object '%s' at %L may not be ALLOCATABLE"
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Objek skalar '%s' di %L mungkin tidak dapat DIALOKASIKAN"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Penunjuk array '%s' di %L harus memiliki sebuah bentuk deffered"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L cannot have a deferred shape"
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Array '%s' di %L tidak dapat memiliki sebuah bentuk deferred"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, fuzzy, gcc-internal-format
 #| msgid "The type '%s' cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Tipe '%s' tidak dapat host assosiasi di %L karena ini diblok dengan sebuah objek tidak kompatibel dari nama sama yang dideklarasikan di %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -95405,1021 +95592,1021 @@ msgstr "Array otomatis '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "The module or main program array '%s' at %L must have constant shape"
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Modul atau array aplikasi utama '%s' di %L harus memiliki bentuk konstan"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "Entity dengan panjang karakter diasumsikan di %L harus berupa sebuah argumen dummy atau sebuah PARAMETER"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "%qs at %L must have constant character length in this context"
 msgstr "'%s' di %L harus memiliki panjang karakter konstan dalam konteks ini"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "'%s' di %L harus memiliki panjang karakter konstan dalam konteks ini"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Dapat dialokasikan '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Eksternal '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Dummy '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Intrinsik '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Hasil fungsi '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Array otomatis '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "in %s, at %s:%d"
 msgid "%s at %L"
 msgstr "dalam %s, di %s:%d"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued statement function '%s' at %L must have constant length"
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Pernyataan fungsi nilai-karakter '%s' di %L harus memiliki panjang konstant"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: '%s' is of a PRIVATE type and cannot be a dummy argument of '%s', which is PUBLIC at %L"
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003: '%s' adalah sebuah tipe PRIVATE dan tidak dapat berupa sebuah argumen dummy dari '%s', yang mana ini adalah PUBLIK di %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: Procedure '%s' in PUBLIC interface '%s' at %L takes dummy arguments of '%s' which is PRIVATE"
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Fortran 2003: Prosedur '%s' dalam antar-muka PUBLIK '%s' di %L memakai argumen dummy dari '%s' dimana ini adalah PRIVATE"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot have an initializer"
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Fungsi '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Objek eksternal '%s' di %L tidak boleh memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL function '%s' at %L must have a scalar result"
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "Fungsi ELEMEN '%s' di %L harus memiliki sebuah hasil skalar"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "Pernyataan fungsi '%s' di %L tidak diperbolehkan sebagai argumen aktual"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat bernilai-array"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat bernilai-penunjuk"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat pure"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be recursive"
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat rekursif"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "Fungsi KARAKTER(*) '%s' di %L tidak dapat pure"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L has no explicit interface"
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "Prosedur '%s' dalam %s di %L tidak memiliki antar-muka eksplisit"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' at %C cannot have a generic interface"
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Prosedur dummy '%s' di %C tidak dapat memiliki sebuah antar-muka umum"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with SAVE attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut SAVE dalam '%s' di %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut INTENT dalam '%s' di %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut NAMELIST dalam '%s' di %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L"
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut INTENT dalam '%s' di %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Antar-muka '%s' dari prosedur '%s' di %L harus berupa eksplisit"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, fuzzy, gcc-internal-format
 #| msgid "FINAL procedure '%s' at %L is not a SUBROUTINE"
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "Prosedur FINAL '%s' di %L bukan sebuah SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "Prosedur FINAL di %L harus memiliki tepat satu argumen"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of FINAL procedure at %L must be of type '%s'"
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Argumen dari prosedur FINAL di %L harus berupa tipe '%s'"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "argumen dari prosedur FINAL di %L harus berupa sebuah PENUNJUK"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "Argumen dari prosedur FINAL di %L harus berupa DAPAT-DIALOKASIKAN"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "Argumen dari prosedur FINAL di %L tidak boleh berupa OPSIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "Argumen dari prosedur FINAL di %L harus berupa INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Prosedur FINAL bukan skalar di %L seharusnya memiliki diasumsikan argumen bentuk"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 #| msgid "FINAL procedure '%s' declared at %L has the same rank (%d) as '%s'"
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "prosedur FINAL '%s' dideklarasikan di %L memiliki tingkat yang sama (%d) seperti '%s'"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, fuzzy, gcc-internal-format
 #| msgid "Only array FINAL procedures declared for derived type '%s' defined at %L, suggest also scalar one"
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Hanya array prosedur FINAL dideklarasikan untuk tipe turunan '%s' didefinisikan di %L, disarankan juga skalar satu"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' can't be mixed FUNCTION/SUBROUTINE for GENERIC '%s' at %L"
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "'%s' dan '%s' tidak dapat dicampurkan FUNCTION/SUBROUTINE untuk GENERIC '%s' di %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' for GENERIC '%s' at %L are ambiguous"
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "'%s' dan '%s' untuk GENERIC '%s' di %L adalah ambigu"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, fuzzy, gcc-internal-format
 #| msgid "Undefined specific binding '%s' as target of GENERIC '%s' at %L"
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "Tidak terdefinisi pengikatan spesifik '%s' sebagai target dari GENERIC '%s' di %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC '%s' at %L must target a specific binding, '%s' is GENERIC, too"
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "GENERIC '%s' di %L harus target sebuah pengikatan spesifik, '%s' adalah GENERIC, juga"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC '%s' at %L can't overwrite specific binding with the same name"
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "GENERIC '%s' di %L tidak dapat overwrite pengikatan spesifik dengan nama sama"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Langkah iterasi di %L tidak dapat nol"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' must be a module procedure or an external procedure with an explicit interface at %L"
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "'%s' harus berupa sebuah prosedur modul atau sebuah prosedur eksternal dengan sebuah antar-muka eksplisit di %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' with PASS(%s) at %L has no argument '%s'"
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Prosedur '%s' dengan PASS(%s) di %L tidak memiliki argumen '%s'"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' with PASS at %L must have at least one argument"
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Prosedur '%s' dengan PASS di %L harus memiliki paling tidak satu argumen"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, fuzzy, gcc-internal-format
 #| msgid "Polymorphic entities are not yet implemented, non-polymorphic passed-object dummy argument of '%s' at %L accepted"
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "entiti polymorphic belum diimplementasikan, bukan polymorphic objek argumen dummy dilewatkan dari '%s' di %L diterima"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Argumen '%s' dari '%s' dengan PASS(%s) di %L harus berupa tipe turunan '%s'"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Argumen '%s' dari '%s' dengan PASS(%s) di %L harus berupa tipe turunan '%s'"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "Passed-object at %L must be scalar"
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Objek yang dilewatkan di %L harus berupa skalar"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa DAPAT-DIALOKASIKAN"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "'%s' argumen dari '%s' instrinsik di %L harus berupa sebuah PENUNJUK"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L has the same name as a component of '%s'"
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Prosedur '%s' di %L memiliki nama sama sebagai sebuah komponen dari '%s'"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L has the same name as an inherited component of '%s'"
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Prosedur '%s' di %L memiliki nama sama seperti sebuah komponen turunan dari '%s'"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Penunjuk array '%s' di %L harus memiliki sebuah bentuk deffered"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Argumen dari ICHAR di %L harus berupa panjang satu"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' with PASS(%s) at %L has no argument '%s'"
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Prosedur '%s' dengan PASS(%s) di %L tidak memiliki argumen '%s'"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' with PASS at %L must have at least one argument"
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Prosedur '%s' dengan PASS di %L harus memiliki paling tidak satu argumen"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Argumen '%s' dari '%s' dengan PASS(%s) di %L harus berupa tipe turunan '%s'"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Argumen '%s' dari '%s' dengan PASS(%s) di %L harus berupa tipe turunan '%s'"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Argumen '%s' dari prosedur elemental di %L tidak dapat memiliki atribut POINTER"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus berupa DAPAT-DIALOKASIKAN"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' of '%s' at %L has the same name as an inherited type-bound procedure"
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Komponen '%s' dari '%s' di %L memiliki nama sama dengan prosedur yang melingkupinya"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, fuzzy, gcc-internal-format
 #| msgid "Character length of component '%s' needs to be a constant specification expression at %L"
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Panjang karakter dari komponen '%s' butuh untuk menjadi sebuah ekspresi spesifikasi konstan di %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Ekspresi di %L harus berupa tipe INTEGER, ditemukan %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: the component '%s' is a PRIVATE type and cannot be a component of '%s', which is PUBLIC at %L"
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003: Komponen '%s' adalah sebuah tipe PRIVATE dan tidak dapat berupa sebuah komponen dari '%s', yang mana adalah PUBLIK di %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Komponen %s dari tipe URUTAN dideklarasikan di %L tidak dapat memiliki atribut URUTAN"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Conflict in attributes of function argument at %C"
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Konflik dalam atribut dari argumen fungsi di %C"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, fuzzy, gcc-internal-format
 #| msgid "Non-extensible derived-type '%s' at %L must not be ABSTRACT"
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Bukan ekstensible tipe turunan '%s' di %L tidak boleh berupa ABSTRACT"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE has not been declared"
 msgid "Derived type %qs at %L has not been declared"
 msgstr "%H%qE belum pernah dideklarasikan"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s' at %C is not allowed"
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Ukuran array yang diasumsikan '%s' dalam daftar nama '%s' di %C tidak diperbolehkan"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST array object '%s' must not have assumed shape in namelist '%s' at %L"
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "NAMELIST array objek '%s' tidak boleh memiliki bentuk yang diasumsikan dalam daftar-nama '%s' di %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST array object '%s' must have constant shape in namelist '%s' at %L"
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "NAMELIST array objek '%s' harus memiliki bentuk konstan dalam daftar-nama '%s' di %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST array object '%s' must have constant shape in namelist '%s' at %L"
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "NAMELIST array objek '%s' harus memiliki bentuk konstan dalam daftar-nama '%s' di %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' was declared PRIVATE and cannot be member of PUBLIC namelist '%s' at %L"
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST objek '%s' telah dideklarasikan PRIVATE dan tidak dapat berupa anggota dari PUBLIK namelist '%s' di %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' has use-associated PRIVATE components and cannot be member of namelist '%s' at %L"
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "NAMELIST objek '%s' memiliki use-associated komponen PRIVATE dan tidak dapat berupa anggota dari daftar-nama '%s' di %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' has PRIVATE components and cannot be a member of PUBLIC namelist '%s' at %L"
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST objek '%s' meemiliki komponen PRIVATE dan tidak dapat berupa anggota dari PUBLIK daftar-nama '%s' di %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut NAMELIST dalam '%s' di %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter array '%s' at %L cannot be automatic or of deferred shape"
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Parameter array '%s' di %L tidak dapat berupa otomatis atau bentuk deferred"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, fuzzy, gcc-internal-format
 #| msgid "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type"
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Tipe PARAMETER secara implisit '%s' di %L tidak cocok dengan tipe IMPLISIT kemudian"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Tipe turunan tidak kompatibel dalam PARAMETER di %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut PENUNJUK dan BIND(C)"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Expecting constant expression near %L"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L"
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut INTENT dalam '%s' di %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "atribut PROSEDUR konflik dengan atribut INTENT dalam '%s' di %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad specification for assumed size array at %C"
 msgid "Bad specification for assumed size array at %L"
 msgstr "Spesifikasi buruk untuk diasumsikan ukuran array di %C"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Ukuran array yang diasumsikan di %L harus berupa sebuah argumen dummy"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Bentuk array yang diasumsikan di %L harus berupa sebuah argumen dummy"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Bentuk array yang diasumsikan di %L harus berupa sebuah argumen dummy"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Simbol di %L bukan sebuah variabel DUMMY"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "'%s' di %L tidak dapat memiliki VALUE atribut karena ini bukan sebuah argumen dummy"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 #| msgid "Character dummy variable '%s' at %L with VALUE attribute must have constant length"
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Karakter dummy variabel '%s' di %L dengan atribut NILAI harus memiliki panjang konstant"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, fuzzy, gcc-internal-format
 #| msgid "C interoperable character dummy variable '%s' at %L with VALUE attribute must have length one"
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "C interoperable karakter dummy variabel '%s' di %L dengan atribut NILAI harus memiliki panjang satu"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, fuzzy, gcc-internal-format
 #| msgid "The derived type '%s' at %L is of type '%s', which has not been defined"
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Tipe turunana '%s' di %L adalah tipe '%s',  yang mana belum didefinisikan"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut DAPAT DIALOKASIKAN dan BIND(C)"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut PENUNJUK dan BIND(C)"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "Diasumsikan bentuk array '%s' di %L tidak diijinkan dalam sebuah ekspresi inisialisasi"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut DAPAT DIALOKASIKAN dan BIND(C)"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut PENUNJUK dan BIND(C)"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "Variabel '%s' di %L tidak dapat berupa BIND(C) karena ini bukan sebuah blok UMUM atau dideklarasikan dalam tingkat cakupan modul"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "Argumen dari %s di %L harus berupa panjang satu"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 #| msgid "Fortran 2003: PUBLIC %s '%s' at %L of PRIVATE derived type '%s'"
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "Fortran 2003: PUBLIK %s '%s' di %L dari tipe turunan '%s' PRIVATE"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, fuzzy, gcc-internal-format
 #| msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "INTENT(OUT) dummy argumen '%s' di %L adalah UKURAN DIASUMSIKAN dan jadi tidak dapat memiliki sebuah penginisialisasi baku"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Dummy argumen '%s' di %L tidak dapat berupa INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Dummy argumen '%s' di %L tidak dapat berupa INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Argumen dengan nilai di %L tidak dapat berupa sebuah array atau sebuah daerah array"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Array dapat dialokasikan '%s' di %L harus memiliki sebuah bentuk deferred"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Prosedur dummy di %L tidak diperbolehkan dalam prosedur ELEMENTAL"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist %s cannot be renamed by USE association to %s"
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Daftar-nama %s tidak dapat diubah namanya dengan assosiasi USE ke %s"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Threadprivate di %L bukan SAVEd"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "Komponen di %C harus memiliki sebuah atribut PENUNJUK"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Dapat dialokasikan '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting list of named entities at %C"
 msgid "Expecting definable entity near %L"
 msgstr "Diduga daftar dari entiti bernama di %C"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 #| msgid "BLOCK DATA element '%s' at %L must be in COMMON"
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "DATA BLOK elemen '%s' di %L harus berupa dalam COMMON"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, fuzzy, gcc-internal-format
 #| msgid "DATA array '%s' at %L must be specified in a previous declaration"
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "DATA array '%s' di %L harus dispesifikasikan dalam sebuah deklarasi sebelumnya"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "Dummy '%s' di %L tidak dapat memiliki sebuah penginisialisasi"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Variabel '%s' di %L tidak dapat memiliki dua atribut DAPAT DIALOKASIKAN dan BIND(C)"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Daerah array tidak konstant di %L dalam pernyataan DATA"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "pernyataan DATA di %L memiliki lebih variabel daripada nilai"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Daerah array tidak konstant di %L dalam pernyataan DATA"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "Ekspresi step dalam loop DO di %L tidak dapat berupa nol"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "pernyataan DATA di %L memiliki lebih banyak nilai daripada variabel"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Label %d di %L didefinisikan tetapi tidak digunakan"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Label %d di %L didefinisikan tetapi tidak dapat digunakan"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Tipe variabel turunan '%s' di %L harus memiliki atribut URUTAN untuk menjadi sebuah objek EKUIVALEN"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Tipe variabel turunan '%s' di %L tidak dapat memiliki komponen DAPAT DIALOKASIKAN untuk menjadi sebuah objek EKUIVALEN"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Tipe variabel turunan '%s' di %L dengan inisialisasi baku tidak dapat berada dalam EKUIVALEN dengan sebuah variabel dalam COMMON"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Tipe variabel turunan '%s' di %L dengan komponen penunjuk tidak dapat berupa sebuah objek EKUIVALEN"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Sintaks error dalam pernyataan EKUIVALEN di %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Baik semua atau kosong dari objek dalam EKUIVALEN set di %L yang memiliki atribut TERPROTEKSI"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 #| msgid "Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure procedure '%s'"
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "Anggota blok umum '%s' di %L tidak dapat berupa sebuah objek EKUIVALEN dalam prosedur pure '%s'"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, fuzzy, gcc-internal-format
 #| msgid "Named constant '%s' at %L cannot be an EQUIVALENCE object"
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
@@ -96427,96 +96614,96 @@ msgstr "Konstanta bernama '%s' di %L tidak dapat berupa sebuah objek EKUIVALEN"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Sintaks error dalam pernyataan EKUIVALEN di %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Array '%s' di %L dengan cakupan tidak-konstan tidak dapat berupa sebuah objek EKUIVALEN"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, fuzzy, gcc-internal-format
 #| msgid "Structure component '%s' at %L cannot be an EQUIVALENCE object"
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Komponen struktur '%s' di %L tidak dapat berupa sebuah objek EKUIVALEN"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Substring di %L memiliki panjang nol"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Panjang karakter berbeda dalam penempatan penunjuk di %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 #| msgid "PUBLIC function '%s' at %L cannot be of PRIVATE type '%s'"
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "Fungsi PUBLIK '%s' di %L tidak dapat berupa tipe PRIVATE '%s'"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L has no IMPLICIT type"
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "MASUKAN '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Prosedur operator pengguna '%s' di %L harus berupa sebuah FUNGSI"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L cannot be assumed character length"
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Prosedur operator pengguna '%s' di %L tidak dapat berupa panjang karakter diasumsikan"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Prosedur operator pengguna '%s' di %L harus memiliki paling tida satu argumen"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Argumen pertama dari antar-muka operator di %L tidak dapat berupa pilihanonal"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Argumen kedua dari antar-muka operator di %L tidak dapat berupa pilihanonal"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Antar-muka operator di %L harus memiliki, paling tidak, dua argumen"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
@@ -96539,108 +96726,108 @@ msgstr "mengabaikan direktori tidak ada \"%s\"\n"
 msgid "%qs is not a directory"
 msgstr "%qD bukan sebuah tipe"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP di %C berawal sebuah baris berkomentar yang tidak diikuti sebuah spasi atau sebuah baris kelanjutan"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP di %C berawal sebuah baris berkomentar yang tidak diikuti sebuah spasi atau sebuah baris kelanjutan"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Line truncated at %C"
 msgid "Line truncated at %L"
 msgstr "Baris terpotong di %C"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Batas dari %d kelanjutan dilampaui dalam pernyataan di %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 #| msgid "Missing '&' in continued character constant at %C"
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Hilang '&' dalam konstanta karakter kelanjutan di %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Karakter tab tidak konforman di %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character 0x%s at %C"
 msgstr "Karakter tidak valid dalam nama di %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, fuzzy, gcc-internal-format
 #| msgid "'&' not allowed by itself in line %d"
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "'&' tidak diperboleh dengan sendirinya dalam baris %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Karakter tab tidak konforman dalam kolom %d dari baris %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: file %s left but not entered"
 msgid "file %qs left but not entered"
 msgstr "%s:%d: berkas %s tertinggal tetapi tidak dimasukan"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Illegal preprocessor directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s:%d: Direktif preprosesor tidak legal"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, fuzzy, gcc-internal-format
 #| msgid "File '%s' is being included recursively"
 msgid "File %qs is being included recursively"
 msgstr "Berkas '%s' sedang dimasukan secara rekursif"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file '%s'"
 msgid "Cannot open file %qs"
 msgstr "Tidak dapat membuka berkas '%s'"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open included file %qs"
 msgstr "Tidak dapat membuka berkas termasuk '%s'"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "Tidak dapat membuka berkas termasuk '%s'"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "Included file %qs is not a regular file"
@@ -96816,230 +97003,230 @@ msgstr "Jika argumen pertama dari ATAN2 %L adalah nol, maka argumen kedua tidak
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Argumen dari IACHAR di %L harus berupa panjang satu"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Argumen dari fungsi IACHAR di %L diluar dari jangkauan 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "Jumlah dari argumen kedua dan ketiga dari IBITS melampaui ukuran bit di %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Argumen dari ICHAR di %L harus berupa panjang satu"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of IBCLR exceeds bit size at %L"
 msgid "Second argument of %s is negative at %L"
 msgstr "Argume kedua dari IBCLR melampaui ukuran bit di %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFT exceeds bit size at %L"
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "Besar dari argumen kedua dari ISHFT melampaui ukuran bit di %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %L"
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "Besar dari argumen kedua dari ISHFTC melampaui BIT_SIZE dari argumen pertama di %L"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "DIM argumen di %L diluar dari cakupan"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "Argumen dari LOG di %L tidak dapat lebih kecil atau sama dengan nol"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "Kompleks argumen dari LOG di %L tidak dapat berupa nol"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "Argumen dari LOG10 di %L tidak dapat lebih kecil atau sama dengan nol"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "Argumen kedua dari NEAREST di %L tidak boleh berupa nol"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_trans_code(): Pernyataan kode buruk"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Argumen kedua dari NEAREST di %L tidak boleh berupa nol"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Hasil dari NEAREST adalah NaN di %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "Argumen NCOPIES dari REPEAT intrinsik adalah negatif di %L"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "Argumen NCOPIES dari REPEAT intrinsik adalah terlalu besar di %L"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer too large at %C"
 msgid "Reshaped array too large at %C"
 msgstr "Integer terlalu besar di %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Hasil dari overflow SKALA jenisnya di %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "'%s' argumen dari '%s' intrinsik di %L harus dari tingkat %d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Tipe buruk dalam ekspresi konstanta"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, fuzzy, gcc-internal-format
 #| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "Jumlah dari elemen dalam konstruktor array di %L membutuhkan sebuah peningkatan dari batas atas %d yang diijinkan. Lihat pilihan -fmax-array-constructor"
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Finalization at %L is not yet implemented"
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Finalisasi di %L belum diimplementasikan"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Argumen dari SQRT di %L memiliki sebuah nilai negatif"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid second argument of IBSET at %L"
 msgid "invalid argument of SQRT at %L"
 msgstr "Argumen kedua dari IBSET di %L tidak valid"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, fuzzy, gcc-internal-format
 #| msgid "Character '%s' in string at %L cannot be converted into character kind %d"
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
@@ -97412,85 +97599,85 @@ msgstr "Diduga nama berakhir di %C"
 msgid "Labeled DO statement at %L"
 msgstr "Tidak terduga pernyataan END di %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'"
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Nama '%s' di C adalah sebuah referensi ambigu ke '%s' dari module '%s'"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from current program unit"
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Nama '%s' di %C adalah sebuah referensi ambigu ke '%s' dari satuan aplikasi sekarang"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Simbol '%s' di %C telah diassosiasikan host"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' declared at %L must have the BIND attribute to be C interoperable"
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Tipe turunan '%s' dideklarasikan di %L harus memiliki atribut BIND ke Cinteroperable"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L has PRIVATE components"
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Tipe turunan '%s' di %L memiliki komponen PRIVATE"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponen '%s' di %L tidak dapat memiliki atribut PENUNJUK karena ini sebuah anggota tari BIND(C) tipe turunan '%s' di %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponen '%s' di %L tidak dapat memiliki atribut PENUNJUK karena ini sebuah anggota tari BIND(C) tipe turunan '%s' di %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponen '%s' di %L tidak dapat memiliki atribut DAPAT DIALOKASIKAN karena ini sebuah anggota dari tipe turunan BIND(C) '%s' di %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' in derived type '%s' at %L may not be C interoperable, even though derived type '%s' is BIND(C)"
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "Komponen '%s' dalam tipe turunan '%s' di %L mungkin tidak C interoperabel, walaupun melalui tipe turunan '%s' adalah BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' in derived type '%s' at %L may not be C interoperable"
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "Komponen '%s' dalam tipe turunan '%s' di %L mungkin tidak C interoperabel"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Tipe turunan '%s' di %L tidak dapat memiliki urutan atribut karena ini adalah BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' is used before it is typed at %L"
 msgid "Symbol %qs is used before it is typed at %L"
@@ -97523,31 +97710,37 @@ msgstr "Overlapping tidak sama penginisialisasi dalam EKUIVALEN di %L"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Overlapping tidak sama penginisialisasi dalam EKUIVALEN di %L"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "Array '%s' di %L bukan sebuah variabel, yang tidak mereduksi ke sebuah ekspresi konstanta"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, fuzzy, gcc-internal-format
 #| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "Jumlah dari elemen dalam konstruktor array di %L membutuhkan sebuah peningkatan dari batas atas %d yang diijinkan. Lihat pilihan -fmax-array-constructor"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 #| msgid "Creating array temporary at %L for argument '%s'"
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Membuat array sementara di %L untuk argumen '%s'"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "tipe ekspresi buruk selama walk (%d)"
@@ -97661,128 +97854,128 @@ msgstr "Menempatkan nilai selain dari 0 atau 1 ke LOGICAL bisa menghasilkan hasi
 msgid "non-constant initialization expression at %L"
 msgstr "Diduga sebuah ekspresi inisialisasi di %C"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY '%s' at %L has no IMPLICIT type"
 msgid "%s at %L has no default type"
 msgstr "MASUKAN '%s' di %L tidak memiliki tipe IMPLISIT"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "variabel instrinsic yang bukan sebuah prosedur"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 #| msgid "Return value of function '%s' at %L not set"
 msgid "Return value of function %qs at %L not set"
 msgstr "Nilai kembali dari fungsi '%s' di %L tidak diset"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Deferred type parameter not yet supported"
 msgstr "Jenis parameter berbeda dalam penempatan penunjuk di %L"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, fuzzy, gcc-internal-format
 #| msgid "backend decl for module variable %s already exists"
 msgid "backend decl for module variable %qs already exists"
 msgstr "backend deklarasi untuk variabel modul %s telah ada"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable '%s' declared at %L"
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Variabel '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "'%s' di %L tidak dapat memiliki VALUE atribut karena ini bukan sebuah argumen dummy"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L was declared INTENT(OUT) but was not set"
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Dummy argumen '%s' di %L telah dideklarasikan INTENT(OUT) tetapi belum diset"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L was declared INTENT(OUT) but was not set"
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "Dummy argumen '%s' di %L telah dideklarasikan INTENT(OUT) tetapi belum diset"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 #| msgid "Unused dummy argument '%s' at %L"
 msgid "Unused dummy argument %qs at %L"
 msgstr "Argumen dummy tidak digunakan '%s' di %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable '%s' declared at %L"
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Variabel '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable '%s' declared at %L"
 msgid "Unused variable %qs declared at %L"
 msgstr "Variabel '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter '%s' declared at %L"
 msgid "Unused parameter %qs declared at %L"
 msgstr "Parameter '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter '%s' declared at %L"
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Parameter '%s' tidak digunakan dideklarasikan di %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 #| msgid "Return value '%s' of function '%s' declared at %L not set"
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Nilai kembali dari fungsi '%s' dideklarasikan di %L tidak diset"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "Finalization at %L is not yet implemented"
 msgid "Unsigned not yet implemented"
 msgstr "Finalisasi di %L belum diimplementasikan"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -97813,12 +98006,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "Instrinsik op tidak diketahui"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Daftar fungsi argumen tidak diketahui di %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -97836,12 +98029,12 @@ msgstr "Fungsi instrinsik %s(%d) tidak dikenal"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "'dim' argumen dari %s intrinsik di %L bukan sebuah dimensi indeks valid"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "environment variable \"%s\" not defined"
 msgid "The event variable at %L shall not be coindexed"
@@ -97869,200 +98062,200 @@ msgstr "-fprefetch-loop-array tidak didukung untuk target ini"
 msgid "implicit mapping of assumed size array %qD"
 msgstr "Spesifikasi buruk untuk diasumsikan ukuran array di %C"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "optional class parameter"
 msgstr "parameter %qs tidak valid"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "Diduga tipe ekspresi"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "diduga ekspresi"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "used here"
 msgid "Used here"
 msgstr "digunakan disini"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_code(): Pernyataan kode buruk"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Nama '%s' di %C adalah nama dari prosedur"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Interface '%s' at %C may not be generic"
 msgid "The base name at %L must not be a generic name"
 msgstr "Antar-muka '%s' di %C mungkin bukan umum"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Parameter '%s' to '%s' at %L must be a procedure"
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "Paramter '%s' ke '%s' di %L harus berupa sebuah prosedur"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure '%s' in %s at %L has no explicit interface"
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "Prosedur '%s' dalam %s di %L tidak memiliki antar-muka eksplisit"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find class %qs"
 msgid "Cannot find symbol %qs at %L"
 msgstr "tidak dapat menemukan class %qs"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "Prosedur '%s' dalam %s di %L bukan sebuah fungsi atau subrutin"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "variant %qs at %L is the same as base function"
 msgstr "'%s' di %L bukan sebuah fungsi"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "Diduga daftar argumen di %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L exceeds the string length"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Indeks akhir substring di %L melebihi panjang string"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Sebuah alternatif return di %L tanpa sebuah * dummy argumen"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Argumen '%s' dalam pernyataan fungsi di %L harus berupa skalar"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Argumen '%s' dari prosedur elemental di %L tidak dapat memiliki atribut POINTER"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%qs at %L is specified more than once"
 msgstr "%qs hanya dapat dispesifikasikan untuk fungsi"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr ""
@@ -98439,7 +98632,7 @@ msgstr "fclose %s"
 msgid "two or more sections for %s"
 msgstr "dua atau lebih tipe data dalam deklarasi dari %qs"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -98802,32 +98995,32 @@ msgstr "array digunakan sebagai penginisialisasi"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "alignmen yang diminta bukan sebuah konstanta"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "alignmen yang diminta bukan kelipatan dari 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "alignmen yang diminta terlalu besar"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -103973,10 +104166,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "metode tidak statis %q+D overrides metode static"
 
-#, gcc-internal-format
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D digunakan sebelum ke deklarasi"
-
 #, gcc-internal-format
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "Dalam %+D: variabel overlapped dan jangkauan eksepsi di %d"
--- a/src/gcc/po/ja.po
+++ b/src/gcc/po/ja.po
@@ -21,7 +21,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 11.1.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2021-05-11 22:47+0900\n"
 "Last-Translator: Hiroshi Takekawa <sian@big.or.jp>\n"
 "Language-Team: Japanese <translation-team-ja@lists.sourceforge.net>\n"
@@ -1290,12 +1290,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "-mveclibabi= スイッチ用の不明なベクトルライブラリ ABI 型 (%s) です"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "ターゲット CPU の名前を指定する"
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 msgid "Initialize ptx registers."
 msgstr "浮動小数点レジスタを利用する"
@@ -2114,13 +2114,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2568,7 +2568,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "ターゲット CPU がビックエンディアンとして設定されているとみなす"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "ターゲット CPU がリトルエンディアンとして設定されているとみなす"
@@ -2643,7 +2643,7 @@ msgstr "関数プロローグとエピローグ用にサブルーチンを使用
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 msgid "Specify the code model."
@@ -2680,7 +2680,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "末端の関数ではフレームポインタを省略する"
@@ -2790,7 +2790,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2836,7 +2836,7 @@ msgstr "  -fsched-verbose=<number> スケジューラの饒舌レベルを設定
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5099,7 +5099,7 @@ msgstr "BMI 組み込み関数とコード生成をサポートする"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5454,7 +5454,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "分岐命令用のコストを設定する"
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5759,212 +5759,217 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "スレッドポインタへのアクセス方法を指定する"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "レジスタ確保順を指定する"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "即値 TLS オフセットのビットサイズを指定する"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "-mcpu=\t与えられた CPU 用の機能とスケジュールコードを使用する"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "-mcpu=\t与えられた CPU 用の機能とスケジュールコードを使用する"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, fuzzy, no-c-format
 msgid "Optimize for CPU."
 msgstr "速度よりもサイズを重視した最適化を行う"
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "-mabi=ABI\t与えられた ABI に準拠したコードを生成する"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, fuzzy, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "  -fsched-verbose=<number> スケジューラの饒舌レベルを設定する\n"
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "noreturn 関数が return するとき abort の呼び出しを生成する"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 msgid "This option is deprecated."
 msgstr "このスイッチは廃止されました。代わりに -Wextra を使用してください"
@@ -11289,7 +11294,7 @@ msgstr "SSA 最適化を有効にする"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18211,88 +18216,88 @@ msgstr "ISO 1998 C++ 標準に準拠させる"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "ISO 201X C 標準ドラフト版に準拠させる (実験的かつ不完全なサポート)"
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 msgid "argument must be passed by copying"
 msgstr "引数は定数でなければいけません"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 msgid "callee does not return"
 msgstr "左シフト回数が負の数です"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 msgid "volatile function type"
 msgstr "sizeof が関数型に適用されました"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "関数が予期されます"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "different number of parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "引数の数が異なります"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s は support split_block をサポートしていません"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 msgid "variable size arguments"
 msgstr "無効な PHI 引数です"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 msgid "hidden string length argument passed on stack"
 msgstr "%qs への引数がありません"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 msgid "tail call production failed"
 msgstr "静的アサーションに失敗しました: %E"
@@ -18410,12 +18415,12 @@ msgstr "'%%l' 被演算子が label ではありません"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "浮動小数定数を使い損ねました"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19733,12 +19738,12 @@ msgstr ""
 msgid "this is the insn:"
 msgstr ""
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 msgid "unable to reload address in "
 msgstr "無効なアドレスです"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr ""
 
@@ -19959,7 +19964,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr ""
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<無名>"
@@ -20344,20 +20349,20 @@ msgstr "コード '%c' に対する無効な被演算子です"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "コード '%c' に対する無効な被演算子です"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "無効なベクトル定数です"
@@ -20403,84 +20408,84 @@ msgstr "無効な被演算子コード '%c' です"
 msgid "invalid address mode"
 msgstr "無効なアドレスモードです"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "%<bfloat16_t%> からの無効な変換です"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "%<bfloat16_t%> への無効な変換です"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "pointers are not permitted as case values"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "case の値としてポインタは許可されていません"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 msgid "negation operation not permitted on svbool_t"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 #, fuzzy
 msgid "plus operation not permitted on svbool_t"
 msgstr "case の値としてポインタは許可されていません"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 #, fuzzy
 msgid "minus operation not permitted on svbool_t"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 #, fuzzy
 msgid "multiply operation not permitted on svbool_t"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 #, fuzzy
 msgid "divide operation not permitted on svbool_t"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 msgid "subscript operation not supported on svbool_t"
 msgstr "-fstack-usage はこのターゲットではサポートされていません"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 #, fuzzy
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "GNU と SVE ベクタの二項演算はできません"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20497,13 +20502,13 @@ msgid "invalid %%r value"
 msgstr "無効な %%r 値"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "無効な %%R 値"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "無効な %%N 値"
@@ -20518,7 +20523,7 @@ msgstr "無効な %%P 値"
 msgid "invalid %%h value"
 msgstr "無効な %%h 値"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "無効な %%L 値"
@@ -20533,7 +20538,7 @@ msgstr "無効な %%m 値"
 msgid "invalid %%M value"
 msgstr "無効な %%M 値"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "無効な %%U 値"
@@ -20872,7 +20877,7 @@ msgstr "サポートされていない演算子"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21117,134 +21122,134 @@ msgstr "無効な浮動小数点定数です"
 msgid "Expected register or constant integer."
 msgstr "インターフェースまたはインターフェースへのポインタが予期されます"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "被演算子として無効な UNSPEC です"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "'%s' の誤った用法です"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 msgid "invalid use of asm flag output"
 msgstr "無効な型の使用法です"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "演算子コード '%c' に対する無効な被演算子サイズです"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "演算子コード '%c' に対する無効な被演算子サイズです"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "被演算子コード '%c' に無効な被演算子型が使用されました"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "演算子コード '%c' に対する無効な被演算子サイズです"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'Y' です"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "被演算子は条件コードではありません。無効な被演算子コード 'D' です"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "無効な被演算子コード '%c' です"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "演算子に対する無効な制約です"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr "無効なベクトル直接表記"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "不明な命令モード"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "%<bfloat16_t%> からの無効な変換です"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "%<bfloat16_t%> からの無効な変換です"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "%<bfloat16_t%> への無効な変換です"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "%<bfloat16_t%> への無効な変換です"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21323,9 +21328,9 @@ msgstr "'%%%c' は有効な被演算子接頭辞ではありません"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "'%%%c' の無効な使用法です"
@@ -21390,7 +21395,7 @@ msgid "insn contains an invalid address !"
 msgstr "命令に無効なアドレスが含まれています!"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "無効なアドレスです"
 
@@ -21465,7 +21470,7 @@ msgstr "無効な再配置です"
 msgid "invalid %%H value"
 msgstr "無効な %%H 値"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "無効な %%d 値です"
@@ -21515,33 +21520,33 @@ msgstr "サポートされていない定数アドレス:"
 msgid "unsupported memory expression:"
 msgstr "固定小数変換内で無効な型です"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 msgid "invalid vector operand"
 msgstr "無効な %%P 被演算子です"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "'b' 修飾子に対する無効な被演算子"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr ""
@@ -21603,7 +21608,7 @@ msgstr "誤った 128 ビット move"
 msgid "invalid %%A value"
 msgstr "無効な %%A 値"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "無効な %%D 値です"
@@ -21643,7 +21648,7 @@ msgstr "無効な %%J コードです"
 msgid "invalid %%k value"
 msgstr "無効な %%k 値です"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "無効な %%K 値です"
@@ -21673,17 +21678,17 @@ msgstr "無効な %%T 値です"
 msgid "invalid %%u value"
 msgstr "無効な %%u 値です"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "無効な %%v 値です"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "無効な %%V 値"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "無効な %%x 値です"
@@ -21899,28 +21904,28 @@ msgstr "無効な %%s 被演算子です"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "浮動小数定数は有効な即値被演算子ではありません"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "'B' 被演算子が定数ではありません"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "'o' 被演算子が定数ではありません"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "'B' 被演算子が定数ではありません"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: 不明なコードです"
@@ -21982,24 +21987,24 @@ msgstr "不正な被演算子が検出されました"
 msgid "Unable to load DLL."
 msgstr "DLL 用のコードを生成する"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "誤った test です"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "無効なマスクです"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "無効な %%t/%%b 値です"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "アドレスオフセットが定数ではありません"
 
@@ -22033,7 +22038,7 @@ msgstr "{無名}"
 msgid "aka"
 msgstr "aka"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({無名})"
 
@@ -22058,8 +22063,8 @@ msgstr "({無名})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "%<;%> が予期されます"
@@ -22087,7 +22092,7 @@ msgstr "%<,%> または %<)%> が予期されます"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "%<)%> が予期されます"
@@ -22095,7 +22100,7 @@ msgstr "%<)%> が予期されます"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "%<]%> が予期されます"
@@ -22115,13 +22120,13 @@ msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "%<(%> が予期されます"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "%<[%> が予期されます"
@@ -22130,7 +22135,7 @@ msgstr "%<[%> が予期されます"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22147,13 +22152,13 @@ msgstr "%<{%> が予期されます"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "%<:%> が予期されます"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "%<while%> が予期されます"
@@ -22163,7 +22168,7 @@ msgstr "%<while%> が予期されます"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "%<,%> が予期されます"
@@ -22173,18 +22178,18 @@ msgid "expected %<.%>"
 msgstr "%<.%> が予期されます"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "%<@end%> が予期されます"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "%<>%> が予期されます"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "%<,%> または %<)%> が予期されます"
@@ -22194,46 +22199,46 @@ msgstr "%<,%> または %<)%> が予期されます"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "%<=%> が予期されます"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "%<,%> または %<)%> が予期されます"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "%<}%> が予期されます"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<else%>"
 msgstr "%<delete%> が予期されます"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "%<#pragma omp section%> または %<}%> が予期されます"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(無名)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "%<<%> が予期されます"
@@ -22262,7 +22267,7 @@ msgstr "候補:"
 msgid "  after user-defined conversion:"
 msgstr "利用者定義命令を有効にする"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "候補:"
@@ -22361,7 +22366,7 @@ msgstr "<テンプレートパラメータエラー>"
 msgid "<statement>"
 msgstr "<文>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<不明>"
@@ -22388,303 +22393,344 @@ msgstr "<ラムダ"
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<式エラー>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<不明な演算子>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "大域スコープ:"
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "initializer element is not a constant expression"
-msgid "array element not a constant integer"
-msgstr "初期化子の要素が定数式ではありません"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 msgid "reflect_constant failed"
 msgstr "文が予期されます"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "initializer element is not a constant expression"
+msgid "array element not a constant integer"
+msgstr "初期化子の要素が定数式ではありません"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "関数が文字列型を返しません"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 msgid "reflection does not have template arguments"
 msgstr "strftime フォーマットは引数をフォーマットできません"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 msgid "reflection does not represent a function or function type"
 msgstr "呼び出されたオブジェクト %qE は関数ではありません"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 msgid "operators argument is not a valid operator"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not have a type"
 msgstr "関数が文字列型を返しません"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "関数が文字列型を返しません"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "cannot set interrupt attribute: no current function"
 msgid "reflection does not represent parameter of current function"
 msgstr "interrupt 属性を設定できません: 現在の関数がありません"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "呼び出されたオブジェクト %qE は関数ではありません"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 msgid "non-constant offset for offset_of"
 msgstr "%qs 用の定数引数が範囲外です"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "conversion to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "不完全型への変換です"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 msgid "reflection not suitable for alignment_of"
 msgstr "書き込み可能データ整列を調整しない"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "assignment of function %qD"
 msgid "alignment_of on function type"
 msgstr "関数 %qD への代入です"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 msgid "reflect_function failed"
 msgstr "関数が予期されます"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr ""
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 msgid "unexpected value of value member"
 msgstr "クラス名が予期されます"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "関数が文字列型を返しません"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "関数が文字列型を返しません"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 msgid "reflection represents non-integral or bool type"
 msgstr "非整数型のビットフィールド %qD です"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "関数が文字列型を返しません"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qE attribute"
 msgid "invalid argument to can_substitute"
 msgstr "%qE 属性の無効な引数です"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "target is not pointer or reference"
 msgid "type is not object or reference type"
 msgstr "ターゲットはポインタまたは参照ではありません"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 #, fuzzy
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "%qT への %qT からの変換はその値が変更になるかもしれません"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 msgid "name is not a valid identifier"
 msgstr "%<%T::%D%> は有効な宣言子ではありません"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "レジスタ名が %q+D 用に指定されていません"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "%q+D 用の整列が指定されていないようです"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "フィールド幅指定"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "右シフト回数が負です"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+msgid "name unspecified and type is const"
+msgstr "型名用に記憶域クラスが指定されました"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+msgid "name unspecified and type is volatile"
+msgstr "型名用に記憶域クラスが指定されました"
+
+#: cp/reflect.cc:6038
 #, fuzzy
 msgid "alignment is not power of two"
 msgstr "要求された整列が 2 の累乗ではありません"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 msgid "alignment is negative"
 msgstr "右シフト回数が負の数です"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "%qD の整列は元の宣言より大きいです"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+msgid "reflection does not have non-array object type"
+msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+msgid "current scope does not represent a function"
+msgstr "メンバ関数の名前を欠いています"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+msgid "current scope does not represent a class nor a member function"
+msgstr "デストラクタを静的メンバ関数とすることはできません"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 msgid "incomplete parent class"
 msgstr "クラス `%s' の実装が不完全です"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 msgid "neither complete class type nor namespace"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 msgid "not a complete class type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 msgid "value cannot be extracted"
 msgstr "複雑なパラメタをもつ関数は inline にできません"
@@ -22729,52 +22775,52 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "候補:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "単項マイナスへの引数の型が間違っています"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "単項プラスへの引数の型が間違っています"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "ビット反転への引数の型が間違っています"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "abs への引数の型が間違っています"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "複素共役(~)への引数の型が間違っています"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr ""
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -22792,68 +22838,68 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "浮動小数定数が 0 に切り詰められました"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 msgid "NULL() is not interoperable"
 msgstr "%qD は変数ではありません"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "無効な定数"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "expression statement has incomplete type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "式の中の文に不完全型があります"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 msgid "Procedure unexpected as argument"
 msgstr "packed 属性は必要ありません"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 msgid "Type shall have a character length of 1"
 msgstr "無効な文字定数が #if にあります"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "型は全く互換がありません"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -22927,7 +22973,7 @@ msgstr "演算子が予期されます"
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "配列代入"
 
@@ -22936,17 +22982,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -23139,11 +23185,11 @@ msgstr ""
 msgid "implied END DO"
 msgstr ""
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "代入"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 #, fuzzy
 msgid "pointer assignment"
 msgstr "代入"
@@ -23152,137 +23198,137 @@ msgstr "代入"
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 msgid "allocatable argument"
 msgstr "引数がありません"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 msgid "asynchronous argument"
 msgstr "十分な引数がありません"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 msgid "optional argument"
 msgstr "無効な PHI 引数です"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 msgid "pointer argument"
 msgstr "代入"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 msgid "target argument"
 msgstr "引数がありません"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 msgid "value argument"
 msgstr "無効な PHI 引数です"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 msgid "volatile argument"
 msgstr "引数がありません"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 msgid "assumed-shape argument"
 msgstr "合っていない引数です"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 msgid "assumed-rank argument"
 msgstr "合っていない引数です"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 msgid "coarray argument"
 msgstr "配列代入"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 msgid "polymorphic argument"
 msgstr "引数がありません"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 msgid "assumed-type argument"
 msgstr "合っていない引数です"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr ""
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "DEALLOCATE オブジェクト"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "ALLOCATE オブジェクト"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "STAT 変数"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "ERRMSG 変数"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -23291,31 +23337,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -23378,27 +23424,27 @@ msgstr "関数呼び出しが集合体の値を持っています"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, fuzzy, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "関数 `%s' への引数が少なすぎます"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, fuzzy, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "関数 `%s' への引数が少なすぎます"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, fuzzy, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "関数 `%s' への引数が少なすぎます"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23497,7 +23543,7 @@ msgid "expected boolean type"
 msgstr "整数または真偽型が予期されます"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 msgid "expected integer"
 msgstr "ポインタが予期されます"
@@ -23563,7 +23609,7 @@ msgstr "十分な引数がありません"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "引数が多すぎます"
@@ -23987,7 +24033,7 @@ msgstr "VxWorks 用のプロファイルサポート"
 msgid "target OS does not support unaligned accesses"
 msgstr "ターゲット形式は無限大をサポートしません"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr ""
@@ -24232,13 +24278,13 @@ msgstr "認識できないオプション %<-%s%> です"
 msgid "Global declarative %s for %s"
 msgstr "無効な宣言です"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24403,12 +24449,12 @@ msgstr "-mxl_stack_check は廃止されました。-fstack-check を使用し
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "-mno-clearbss は廃止されました。-fno-zero-initialized-in-bss を使用してください"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "不明なスタック検査パラメータ \"%s\" です"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -24850,8 +24896,8 @@ msgstr "%qE 属性は %s 属性と競合します"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "前方での `%s' の宣言"
@@ -24868,7 +24914,7 @@ msgstr "%qE 属性指示が無視されました"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%qE 属性指示が無視されました"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "%qE 属性用に間違った数の引数が指定されました"
@@ -24878,7 +24924,7 @@ msgstr "%qE 属性用に間違った数の引数が指定されました"
 msgid "expected %i or more, found %i"
 msgstr "%<(%> またはファイル終端 (EOF) が予期されます"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "%<(%> またはファイル終端 (EOF) が予期されます"
@@ -24961,12 +25007,12 @@ msgstr "型が既に定義されているため型属性が無視されました
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25083,133 +25129,133 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, fuzzy, gcc-internal-format
 msgid "location of the second call"
 msgstr "前に %qD 用の定義がありません"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "location is after end of function"
 msgstr "`%s' の宣言は関数の配列"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "%<.%> が予期されます"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "入力ファイル %s を close できません"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "型 %qT の引数が %qT と一致しません"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "friend 関数 `%s' を初期化できません"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "friend 関数 `%s' を初期化できません"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "クラス %s 用のファイルを見つけられません。"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "クラス %s 用のファイルを見つけられません。"
@@ -25219,7 +25265,7 @@ msgstr "クラス %s 用のファイルを見つけられません。"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "オフセットが定数文字列の境界の外にあります"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qD はここで宣言されています"
@@ -25322,7 +25368,7 @@ msgstr "%qs 用の定数引数が範囲外です"
 msgid "illegal argument 0 to %qs"
 msgstr "%qs への有効な引数は次の通りです: %s"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -25399,12 +25445,12 @@ msgstr "%K %D の最後の引数が 0 から 3 の間の整数定数ではあり
 msgid "cannot tail-call: %s"
 msgstr "[%s が見つかりません]"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "関数呼び出しが集合体の値を持っています"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "%qs への引数がありません"
@@ -26048,343 +26094,343 @@ msgstr "基本ブロックが連続的に番号付けられていません"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "命令連鎖中の bb の数 (%d) が n_basic_blocks (%d) と違います"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "左シフト回数が負の数です"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "オーバーロードされた関数 %s への不十分な引数です"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "制御投機を使用する"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "初期化子の要素が定数ではありません"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "シンボルが有効であると見なす"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "戻り型が void の関数で、`return' に値があります"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "sanitizer function attribute mismatch"
 msgid "semantic interposition mismatch"
 msgstr "sanitizer関数属性が合いません"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "-mno-fentry は SEH と互換性がありません"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "-mno-fentry は SEH と互換性がありません"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "セクションポインタを欠いています"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, fuzzy, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "重複する `virtual' 指定子"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr ""
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "左シフト回数が負の数です"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr ""
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr ""
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, fuzzy, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "`%s' は宣言よりも先に使用されました"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "文が予期されます"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "不完全型のポインタへの間接参照"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node に失敗しました"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr ""
@@ -27150,17 +27196,17 @@ msgstr "局所オブジェクトの総サイズが大きすぎます"
 msgid "impossible constraint in %<asm%>"
 msgstr "%<asm%> 内で制約を行うことは出来ません"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "変数 %q+D が %<longjmp%> または %<vfork%> によって破壊されるかもしれません"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "引数 %q+D が %<longjmp%> または %<vfork%> によって破壊されるかもしれません"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "関数が集合体を返します"
@@ -27838,7 +27884,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "構造体の最後ではない所に可変配列メンバがあります"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -27878,7 +27924,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 msgid "%qD defined here"
 msgstr "ラベル %qD はここで定義されています"
@@ -27898,24 +27944,24 @@ msgstr "NULL ポインタ"
 msgid "function may return address of local variable"
 msgstr "関数が局所変数のアドレスを返します"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "関数が局所変数のアドレスを返します"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -28792,7 +28838,7 @@ msgstr "配列 %qE のサイズが負です"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 msgid "returned from %qD"
 msgstr "ここから呼び出されました"
@@ -28862,210 +28908,210 @@ msgstr "インライン関数 %q+D を弱いとして宣言できません"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "不明なアーキテクチャ %qs です"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "%d 番目の %qE の引数用の互換性がない型です"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "%d 番目の %qE の引数用の互換性がない型です"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 msgid "valid models are %e"
 msgstr "%qs への有効な引数は次の通りです: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "%d 番目の %qE の引数用の互換性がない型です"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, fuzzy, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "%qs への有効な引数は次の通りです: %s"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "%qE 属性は名前付き引数があるプロトタイプが必要です"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "右シフト回数が負の数です"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "引数 %d 個の `%s' を渡します"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "インライン関数 %q+D を弱いとして宣言できません"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "%qs 属性用の無効なエレメント型です"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "組み込み関数への無効な引数です"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "%qs 属性用の無効なエレメント型です"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, fuzzy, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr "%s を開けません"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 msgid "assigned here"
 msgstr "共用体がここで定義されています"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "メンバ関数の名前を欠いています"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "値をベクトルには変換できません"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "値をベクトルには変換できません"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "%q+D 用の整列が指定されていないようです"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "仮引数 %q+D が未使用です"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 msgid "call to %qD here"
 msgstr "`%s' は前にここで宣言されました"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "無効なポインタモード %qs です"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "メンバ %qD へのポインタと見なしています"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "無効なポインタモード %qs です"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD はここで宣言されています"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "共用体がここで定義されています"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "非関数 %qD の呼び出しです"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "非関数 %qD の呼び出しです"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to %qD"
 msgstr "非関数 %qD の呼び出しです"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "要求された大域レジスタ変数 `%s' のアドレス"
@@ -29862,340 +29908,340 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "無効な %<auto%> の使用です"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "非仮想関数 %q+D 用の初期化子が指定されています"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "列挙型がここで定義されています"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "配列参照が範囲外です"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "<戻り値> "
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "型が前方の外部宣言と一致しません"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "引数の型が異なります"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "型 %qT の引数が %qT と一致しません"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "<戻り値> "
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "ラベル %qD はここで定義されています"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 msgid "mismatching definition"
 msgstr "定義がありません"
@@ -30215,7 +30261,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "call 文内で無効な関数です"
@@ -30450,12 +30496,12 @@ msgstr "SCoP 内のパラメータの最大数"
 msgid "unable to find a register to spill"
 msgstr "PIC レジスタ用に '%s' を使用できません"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "%<asm%> 内の被演算子制約に一貫性がありません"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -30826,7 +30872,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "結果の数が値の数と一致しません"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -32224,22 +32270,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr "出力被演算子 %d は %<&%> 制約を使用しなければいけません"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -33186,168 +33232,168 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "ADDR_EXPR が変更されたときに定数が再計算されません"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "ADDR_EXPR が変更されたときに副作用が計算されません"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "非スカラー型"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "BIT_FIELD_REF への無効な位置またはサイズ被演算子です"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, fuzzy, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr "整数結果の型精度が BIT_FIELD_REF のフィールドサイズに適合しません"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, fuzzy, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "非整数結果のモード精度が BIT_FIELD_REF のフィールドサイズに適合しません"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "被演算子が非整数型のシフト演算です"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, fuzzy, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "BIT_FIELD_REF への無効な位置またはサイズ被演算子です"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "配列参照内で型不一致です"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "%qT から %qT への変換が曖昧です"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "NaN から整数への変換です"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "%%R への無効な被演算子です"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "型が前方の外部宣言と一致しません"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "無効なシフト被演算子"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "MEM_REF 内で無効なアドレス被演算子です"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "MEM_REF 内で無効なオフセット被演算子です"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "無効な %qD の使用です"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr "INDIRECT_REF が gimple IL 内にあります"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "スカラーが必要な場所で構造体型の値が使用されています"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr ""
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "gimple 呼び出し内で無効な関数です"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "gimple 呼び出し内で非関数です"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr ""
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "gimple 呼び出し内で無効な LHS です"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "gimple 呼び出し内で無効な変換ですcall"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -33358,600 +33404,600 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_next_arg%> が引数無しで呼び出されました"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "gimple 呼び出しへの無効な引数です"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "gimple 比較内で無効な被演算子です"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "比較式内で型不一致です"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, fuzzy, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "gimple 比較内で無効な被演算子です"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "無効なベクトル順列定数です"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "異なる列挙型の比較に関して警告する"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "単項演算子内で無効な被演算子です"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "nop 変換内で無効な型です"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "nop 変換内で無効な型です"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "アドレス空間変換内で無効な型です"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "固定小数変換内で無効な型です"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "浮動小数点への変換内で無効な型です"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "整数への変換内で無効な型です"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "アドレス式内で型不一致です"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "`%s' に対するレジスタ名として無効です"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "`%s' に対するレジスタ名として無効です"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "二進演算内で無効な被演算子です"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "ベクトル値加算への無効な非ベクトル被演算子です"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "無効なポインタモード %qs です"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "整数式が予期されます"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "二進式内で型不一致です"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "整数式が予期されます"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "異なる列挙型の比較に関して警告する"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "無効な回転 (rotate) 命令です"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "サポートされていない組み合わせです: %s"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "BIT_FIELD_REF への無効な位置またはサイズ被演算子です"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "被演算子が非整数型のシフト演算です"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "%qs 用の定数引数が範囲外です"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "無効なバージョン番号 %qs です"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "CPU \"%s\" は %s\"%s\"%s 用には無効です"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "式内"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "式内"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "%%R への無効な被演算子です"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "無効な %qD の使用です"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "左シフト回数 >= 型の幅となっています"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "関数 %qE へ十分な引数がありません"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "PHI 引数が GIMPLE 値ではありません"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "異なる列挙型の比較に関して警告する"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "return 文内で無効な被演算子です"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "return 文内で無効な変換です"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "goto の先がラベルでもポインタでもありません"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "switch 文への無効な被演算子です"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "switch 文への無効な被演算子です"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "switch 文の外にある %<default%> ラベルです"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "switch 文の外にある case ラベルです"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "switch 文への無効な被演算子です"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "switch 文の外にある case ラベルです"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "switch 文の外にある case ラベルです"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "switch 文の外にある case ラベルです"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "関数宣言中に（型の無い）仮引数名があります"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, fuzzy, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "label_to_block_map 内に間違ったエントリがあります"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "gimple 条件内で無効な比較コードです"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "gimple 条件内で無効なラベルです"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "無効な PHI 結果です"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "PHI 定義がありません"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "無効な PHI 引数です"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "PHI 引数 %u 内で互換性のない型です"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "verify_gimple に失敗しました"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, fuzzy, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "EH 表内に不要な (dead) STMT があります"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "`%s' の宣言は関数の配列"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) が間違った基本ブロックに設定されています"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) が間違った基本ブロックに設定されています"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "文が throw とマークされていますが、 throw しません"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple に失敗しました"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "初期化子の終わりに余分なブレースのグループ"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "初期化子の終わりに余分なブレースのグループ"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "-mno-fentry は SEH と互換性がありません"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE は初期化されていません"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-mno-fentry は SEH と互換性がありません"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "ラベル `%s' が定義されましたが使われていません"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "領域 `%s' は不完全な型です"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr "NOTE_INSN_BASIC_BLOCK %d が基本ブロック %d の中ほどにあります"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "明示的な goto が基本ブロック %d の末尾にあります"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr ""
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr ""
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%> 関数が戻り (return) ます"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "制御が非 void 関数の終りに到達しました"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "warn_unused_result 属性付きで宣言されている %qD の戻り値を無視しています"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "warn_unused_result 属性付きで宣言されている関数の戻り値を無視しています"
@@ -34132,12 +34178,12 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "%qs 属性用の無効なエレメント型です"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "無効な %<auto%> の使用です"
@@ -34641,7 +34687,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -35068,29 +35114,29 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "前方での `%s' の宣言"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "`%s' のセクションは前方でに宣言されたものと衝突します"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 msgid "%qD conflicts for version %qB"
 msgstr "`%s' のセクションは前方でに宣言されたものと衝突します"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "`%s' のセクションは前方でに宣言されたものと衝突します"
@@ -35165,7 +35211,7 @@ msgstr "0 で初期化されるデータを bss セクション内に配置す
 msgid "no initializers are allowed in section %qs"
 msgstr "0 で初期化されるデータを bss セクション内に配置する"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "レジスタ名が %q+D 用に指定されていません"
@@ -35314,7 +35360,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "弱い参照 %q+D は静的リンクされなければいけません"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "この設定では別名定義はサポートされていません"
@@ -35359,53 +35405,53 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "マクロ引数 \"%s\" は文字列化されます"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "マクロ引数 \"%s\" は文字列化されます"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "%qE 属性は %qT 型のフィールド用としては無視されます"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "%qE 属性は %qT 型のフィールド用としては無視されます"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "%qE 属性の引数が整数定数ではありません"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "%qE 属性の引数が整数定数ではありません"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "%qE 属性は関数型にのみ適用できます"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "%qE 属性は関数型にのみ適用できます"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "メソッドは関数ポインタに変換できません"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "メソッドは関数ポインタに変換できません"
@@ -35420,12 +35466,12 @@ msgstr "%qE 属性は名前付き引数があるプロトタイプが必要で
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "%qE 属性は名前付き引数があるプロトタイプが必要です"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "%qE 属性は型に関しては無視されます"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "%qE 属性は型に関しては無視されます"
@@ -35634,12 +35680,12 @@ msgstr "モード %qs を列挙型用に使用できません"
 msgid "mode %qs applied to inappropriate type"
 msgstr "モード %qs が適切でない型に適用されています"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "セクション属性はこのターゲットでは実装されていません"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "セクション属性は %q+D 用には許可されていません"
@@ -35649,18 +35695,18 @@ msgstr "セクション属性は %q+D 用には許可されていません"
 msgid "section attribute argument not a string constant"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "section 属性は局所変数用には指定できません"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "%q+D のセクションが前の宣言と競合しています"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "%q+D のセクションは上書きできません"
@@ -35750,7 +35796,7 @@ msgstr "%qE 属性の引数が整数定数ではありません"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "%q+D のデータ領域が前の宣言と競合しています"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "インライン関数 %q+D を弱いとして宣言できません"
@@ -35796,12 +35842,12 @@ msgstr "非インライン (noinline) 属性が与えられたインライン関
 msgid "%qE attribute is only applicable on functions"
 msgstr "%qE 属性は関数へのみ適用されます"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "%qs 属性は関数へのみ適用出来ます"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "%qE 属性は関数へのみ適用されます"
@@ -35811,12 +35857,12 @@ msgstr "%qE 属性は関数へのみ適用されます"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -35907,23 +35953,23 @@ msgstr "%qE 属性は %qT が既に定義されているため無視されます
 msgid "visibility argument not a string"
 msgstr "可視性の引数が文字列ではありません"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "%qE 属性は型に関しては無視されます"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "属性 %qE の引数が文字列ではありません"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD が別の可視性で再宣言されました"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD は %qs として宣言されていて、暗黙的にデフォルトの可視性になります"
@@ -35940,7 +35986,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "%qE 属性は関数にのみ適用できます"
@@ -36011,7 +36057,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "%<void%> を返す関数の結果を使用しています"
@@ -36086,7 +36132,7 @@ msgstr "%qD は %qD 内では宣言されていません"
 msgid "%qE argument is not a function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "廃止された (deprecated) メッセージが文字列ではありません"
@@ -36153,7 +36199,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "%qE 属性は型に関しては無視されます"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "%qE 属性は文字列定数引数を必要とします"
@@ -36314,15 +36360,15 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "%qE 属性の引数が文字列定数ではありません"
@@ -36590,7 +36636,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "真偽値として使われる代入のまわりでは、丸括弧の使用をお勧めします"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "%<restrict%> の誤った使用法です"
@@ -36761,8 +36807,8 @@ msgstr ""
 msgid "missing sentinel in function call"
 msgstr ""
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, fuzzy, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "pragma 属性への間違ったオプション %s です"
@@ -37780,7 +37826,7 @@ msgstr "サポートされていない非標準の文字列リテラルの連結
 msgid "traditional C rejects string constant concatenation"
 msgstr "伝統的な C では文字列定数の連結を拒否します"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -37835,7 +37881,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "唯一の仮引数となる %<void%> には修飾子がつきません"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr ""
@@ -37850,17 +37896,17 @@ msgstr "%qs が自動変数 %qE 用に指定されています"
 msgid "%qE is not initialized"
 msgstr "%qE は初期化されていません"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "増分式がありません"
@@ -37870,7 +37916,7 @@ msgstr "増分式がありません"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "無効な増分式です"
@@ -37967,18 +38013,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD は関数テンプレートではありません"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -37988,8 +38034,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%qs 句が多すぎます"
@@ -38510,7 +38556,7 @@ msgstr ""
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "間違った形式の %<#pragma %s%> です。無視されました"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "%<#pragma %s%> の末尾にゴミがあります"
@@ -38582,8 +38628,8 @@ msgstr ""
 msgid "wrong type argument to %s"
 msgstr "%s への間違った型の引数です"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -39069,17 +39115,17 @@ msgstr "関数 %qD の減分です"
 msgid "function %qD used as %<asm%> output"
 msgstr "関数 %qD が %<asm%> の出力として使用されています"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "読み取り専用位置 %qE への代入です"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "読み取り専用位置 %qE の増分です"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "読み取り専用位置 %qE の減分です"
@@ -39344,7 +39390,7 @@ msgid "passing argument %i to %qs-qualified parameter aliases with argument %Z"
 msgid_plural "passing argument %i to %qs-qualified parameter aliases with arguments %Z"
 msgstr[0] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -40277,7 +40323,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -40950,7 +40996,7 @@ msgstr "passing argument %d 番目の %qE の引数を渡すときにポイン
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "重複した初期化子"
@@ -40997,7 +41043,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "%qE 属性は %qT が既に定義されているため無視されます"
@@ -41049,7 +41095,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -41143,19 +41189,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "プロトタイプが無い関数に AltiVec 引数が渡されました"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41201,209 +41247,209 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "%qs 属性が無視されました"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "無効な #pragma %s です"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "無効な %%h 値"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "不明な spec 関数 %qs です"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, fuzzy, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, fuzzy, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "%qs への有効な引数は次の通りです: %s"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, fuzzy, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr "組み込み関数への無効な引数です"
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "組み込み関数への無効な引数です"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "-mcpu=%s スイッチが -march=%s スイッチと競合しています"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "multilib はサポートしません"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%qE は廃止されました"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "コードモデル %qs は %s ビットモード内ではサポートされません"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, fuzzy, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "間違った形式の %<#pragma init%> です"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "attribute(target(\"%s\")) が不明です"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41411,201 +41457,201 @@ msgstr "attribute(target(\"%s\")) が不明です"
 msgid "attribute %<target%> argument not a string"
 msgstr "属性 %qE の引数が文字列ではありません"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "attribute(target(\"%s\")) が不明です"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "仮引数 `%s' で指定された記憶クラス"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "属性 %qE の引数が文字列ではありません"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, fuzzy, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "静的リンクはサポートされていません"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "入れ子になった関数はこのターゲットではサポートされていません"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "前はここで宣言されました"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "サポートされていない組み合わせです: %s"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "組み込み関数へのサポートされていない引数の型です"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "組み込み関数へのサポートされていない引数の型です"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "組み込み関数へのサポートされていない引数の型です"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "-shared オプションは VAX ELF 用には現在はサポートされていません"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "-shared オプションは VAX ELF 用には現在はサポートされていません"
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "type attributes ignored after type is already defined"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "型が既に定義されているため型属性が無視されました"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "ラベル %qD はここで定義されています"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "%d 番目の %qE の引数は format 属性の候補のようです"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は異なる幅です"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は異なる幅です"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は異なる幅です"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は異なる幅です"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 #, fuzzy
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "%<#pragma pack%> の後に %<(%> がありません - 無視されました"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "-mtune スイッチ用の間違った値 %qs です"
@@ -41794,12 +41840,12 @@ msgstr "%qE 属性の引数が \"ilink1\" または \"ilink2\" ではありま
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41932,22 +41978,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "%qE 属性は無視されました"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "%qE は変数にのみ適用できます"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "不明な IRA アルゴリズム %qs です"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "無効な被演算子出力コード"
@@ -42494,12 +42540,12 @@ msgstr "-fpic はサポートされていません"
 msgid "%<-fPIE%> is not supported"
 msgstr "-fPIC はサポートされていません"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-pedantic と -traditional とは相互排他的です"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "割り込み関数は引数無しでなければいけません"
@@ -42509,7 +42555,7 @@ msgstr "割り込み関数は引数無しでなければいけません"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "関数が __fp16 型を返しません"
@@ -42843,7 +42889,7 @@ msgstr "入れ子になった関数はこのターゲットではサポートさ
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "組み込み関数への無効な引数です"
@@ -43165,7 +43211,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -43334,172 +43380,172 @@ msgstr "%qs への引数は 2 ビット符号無しリテラルでなければ
 msgid "parameter to builtin not valid: %s"
 msgstr "仮引数 %qD が設定されましたが使用されません"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "割り込みサービスルーチンを Thumb モードでコード化することはできません"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "最後の引数は 2 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "第五引数は 8 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "第三引数は 8 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "最後の引数は 1 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "最後の引数は 32 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "最後の引数は 4 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "最後の引数は 1 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE は isa オプション %s が必要です"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "最後の引数は 5 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "最後の引数の前の引数は 8 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "最後の引数は 8 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "引数は定数でなければいけません"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "正しくない命令:"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "正しくない命令:"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "最後の引数は 4 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "最後の引数は 5 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "最後の引数は 8 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "第五引数は 8 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "%s は [%d, %d] の範囲内の整数リテラルが予期されます"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE は isa オプション %s が必要です"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "引数は定数でなければいけません"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "無効な %<__builtin_prefetch%> の第二引数です。0 を使用します"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 msgid "invalid third argument"
 msgstr "無効な PHI 引数です"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "無効な %<__builtin_prefetch%> の第三引数です。0 を使用します"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "無効な %<__builtin_prefetch%> の第三引数です。0 を使用します"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "引数は定数でなければいけません"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "最後の引数は 32 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "最後の引数は即値でなければいけません"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "最後の引数は 2 ビット即値でなければいけません"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "最後の引数の前の引数は 8 ビット即値でなければいけません"
@@ -43894,8 +43940,8 @@ msgstr "%qs は前処理の有効なオプションではありません"
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "-mno-fentry は SEH と互換性がありません"
@@ -44139,7 +44185,7 @@ msgstr "複素浮動小数メンバを持つ構造体を渡す ABI は GCC 4.4 
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "複素浮動小数メンバを持つ構造体を渡す ABI は GCC 4.4 で変更になっています"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -44166,12 +44212,12 @@ msgstr "SSE が無効の状態で SSE レジスタ引数があります"
 msgid "x87 register return with x87 disabled"
 msgstr "x87 が無効な状態で x87 レジスタを戻して (return) います"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, fuzzy, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "SSE/SSE2 が有効でない状態で sseregparm 属性付きの %qD を呼び出しています"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -44181,130 +44227,130 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "%d バイト整列の仮引数を渡す ABI は GCC 4.6 で変更になっています"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "ms_hook_prologue は入れ子になった関数と両立できません"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "ms_hook_prologue 属性は 32 ビット用の -mfentry と併用できません"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "init_priority 属性はこのプラットフォームではサポートされていません"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "入れ子になった関数はこのターゲットではサポートされていません"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "このコンパイラ設定では %<-fsplit-stack%> はサポートされていません"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "このコンパイラ設定では %<-fsplit-stack%> はサポートされていません"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "このコンパイラ設定では %<-fsplit-stack%> はサポートされていません"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "2 バイト cop 命令は 64 ビット VLIW モードでは許可されていません"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "2 バイト cop 命令は 64 ビット VLIW モードでは許可されていません"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "2 バイト cop 命令は 64 ビット VLIW モードでは許可されていません"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "被演算子コード '%c' に無効な被演算子型が使用されました"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "高位レジスタを pop する為に使用できる低位レジスタがありません"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "-mcmodel= は 32 ビットシステム上ではサポートされていません"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "不明なアーキテクチャ %qs です"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "-mno-fentry は SEH と互換性がありません"
@@ -44357,7 +44403,7 @@ msgstr "gp_offset (%ld) または end_offset (%ld) が 0 より小さいです"
 msgid "argument %qd is not a constant"
 msgstr "引数 %qd が定数ではありません"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -44368,7 +44414,7 @@ msgstr "PRINT_OPERAND_ADDRESS, null ポインタ"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: 不明な句読点 '%c'"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -44523,48 +44569,48 @@ msgstr "attribute(target(\"%s\")) が不明です"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "attribute(target(\"%s\")) が不明です"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "このターゲットでは %<__int128%> はサポートされていません"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "入れ子になった関数はこのターゲットではサポートされていません"
@@ -45328,7 +45374,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "間違った組み込みコードです"
@@ -45551,83 +45597,83 @@ msgstr "%s: グラフファイルを開けません\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "コマンドラインオプション %qs はこの設定ではサポートされていません"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, fuzzy, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "%<-march=%s%> は選択した ABI とは互換性がありません"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "最適化オプションはまだサポートされていません"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "%qE 属性は型に関しては無視されます"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "__BELOW100__ 属性は自動記憶域クラスでのみ許可されています"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "%d 番目の %qE の引数は %d...%d の範囲でなければいけません"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "この設定では別名定義はサポートされていません"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -45862,327 +45908,327 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "%q#D 用のプロトタイプがクラス %qT 内のどれとも一致しません"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "不完全型へのポインタに関する計算です"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, fuzzy, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr "可変長オブジェクトが初期化されないようです"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "%s を開けません"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "可変長オブジェクトが初期化されないようです"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "ポインタを参照として宣言できません"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized gcc debugging option: %c"
 msgid "unrecognized RVV builtin"
 msgstr "認識できない gcc デバッグオプションです: %c"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "%<%D(%A)%> の呼び出しに適合する関数がありません"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "-mfpu 用の不明な値 %s です"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, fuzzy, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, fuzzy, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "複素浮動小数メンバを持つ構造体を渡す ABI は GCC 4.4 で変更になっています"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, fuzzy, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "複素浮動小数メンバを持つ構造体を渡す ABI は GCC 4.4 で変更になっています"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "プロトタイプが無い関数に AltiVec 引数が渡されました"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "組み込み関数 %qD は %<-mconstant-cfstrings%> フラグを要求します"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, fuzzy, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "%qE 属性への引数が 0 でも 1 でもありません"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE 属性は非クラス型に関しては無視されます"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "%qE 属性には整数定数引数が必要です"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, fuzzy, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "ビットフィールド命令を使用しない"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support ARM mode"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "ターゲット CPU は ARM モードをサポートしていません"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in the %s bit mode"
 msgid "code model %qs with %qs"
 msgstr "コードモデル %qs は %s ビットモード内ではサポートされません"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 は複素数型をサポートしません"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "%spreferred-stack-boundary=%d%s が %d と %d の間ではありません"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "割り込み関数は引数無しでなければいけません"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "-mtune スイッチ用の間違った値 %qs です"
@@ -47185,23 +47231,23 @@ msgstr "局所変数のメモリ要求が容量を超えています"
 msgid "%<function_profiler%> support"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "割り込み関数内で va_start を使用することは出来ません"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "%<__BELOW100__%> 属性は変数へのみ適用できます"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -47438,33 +47484,33 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D が定義されましたが使用されません"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "-f%s は CONST16 命令ではサポートされていません"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC が必要ですが CONST16 命令ではサポートされていません"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr ".bss セクションには未初期化変数のみ配置出来ます"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47551,7 +47597,7 @@ msgstr "%qs 属性は名前付き引数を持つプロトタイプが必要で
 msgid "%qs attribute only applies to variadic functions"
 msgstr ""
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47636,8 +47682,8 @@ msgstr "%s は型 %s ではありません (引数 %d)"
 msgid "could not get size of source file"
 msgstr "応答ファイル %s を書き込めませんでした"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "void の値が本来の意味通りに無視されませんでした"
@@ -48119,7 +48165,7 @@ msgstr ""
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE が誤った種類のタグとして宣言されました"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "%qE 属性は関数型にのみ適用できます"
@@ -48273,7 +48319,7 @@ msgstr "ISO C90 は仮引数配列宣言内での %<static%> または型修飾
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 は %<[*]%> 配列宣言をサポートしません"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
@@ -48283,7 +48329,7 @@ msgstr "マクロ引数内でディレクトリを使うことはできません
 msgid "%q+D is usually a function"
 msgstr "%q+D は通常は関数です"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "前に %qD 用の定義がありません"
@@ -48359,7 +48405,7 @@ msgstr "volatile フィールドがあるオブジェクトをレジスタに配
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "初期化されていない定数 %qD は C++ 内では無効です"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -48562,7 +48608,7 @@ msgstr "仮引数 %qE 用に記憶域クラスが指定されました"
 msgid "storage class specified for unnamed parameter"
 msgstr "無名仮引数用に記憶域クラスが指定されました"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "型名用に記憶域クラスが指定されました"
@@ -48736,7 +48782,7 @@ msgstr "型名は配列を返す関数として定義されています"
 msgid "function definition has qualified void return type"
 msgstr "関数定義が void 戻り型の修飾子を持っています"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "関数戻り値の型修飾子は無視されました"
@@ -48863,7 +48909,7 @@ msgstr "ISO C は const や volatile の関数型を禁止しています"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "構造体または共用体のメンバは可変型を持つことは出来ません"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "変数またはフィールド %qE が void と宣言されています"
@@ -49079,7 +49125,7 @@ msgstr "%qs 式内での型定義は C++ では無効です"
 msgid "%qT defined in underspecified object initializer"
 msgstr "ISO C90 は初期化用に副オブジェクトを指定することを禁止してます"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "宣言が何も宣言していません"
@@ -49145,7 +49191,7 @@ msgstr "構造体に名前付きメンバがありません"
 msgid "struct has no members"
 msgstr "構造体にメンバがありません"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -49215,7 +49261,7 @@ msgstr "%<enum %E%> の再定義です"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr "指定したモードは列挙値用には小さすぎます"
@@ -49273,7 +49319,7 @@ msgstr "%qE 用の列挙値が整数定数ではありません"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C は列挙値を %<int%> の範囲に制限しています"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "非インライン (noinline) 属性が与えられたインライン関数 %qD です"
@@ -49423,12 +49469,12 @@ msgstr "引数 %qD が組み込みプロトタイプと一致しません"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "引数 %qD がプロトタイプと一致しません"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "非 void を戻す関数内に return 文がありません"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "仮引数 %qD が設定されましたが使用されません"
@@ -49510,7 +49556,7 @@ msgstr "%<__thread%> が %<register%> と併せて使用されています"
 msgid "two or more data types in declaration specifiers"
 msgstr "宣言指定内に二個またはそれ以上の型があります"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> は GCC にとって長すぎます"
@@ -49618,7 +49664,7 @@ msgstr "ISO C90 は複素数型をサポートしません"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C は %<__int128%> 型をサポートしません"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<__int128%> はこのターゲットではサポートされていません"
@@ -49777,12 +49823,12 @@ msgstr "%q+D 用の整列は最低 %d でなければいけません"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ は %<__int128%> を %qs に対してはサポートしていません"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -49844,37 +49890,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%s は %s をサポートしません"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "左シフト回数が負です"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "左シフト回数が負です"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "右シフト回数が負です"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "左シフト回数 >= 型の幅となっています"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "右シフト回数 >= 型の幅となっています"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "左シフト回数 >= 型の幅となっています"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "右シフト回数 >= 型の幅となっています"
@@ -49894,7 +49940,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "行末 (EOL) が予期されます"
@@ -49904,7 +49950,7 @@ msgstr "行末 (EOL) が予期されます"
 msgid "ISO C forbids an empty translation unit"
 msgstr ""
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49951,8 +49997,8 @@ msgid "unknown type name %qE"
 msgstr "不明な型名 %qE です"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "宣言指定が予期されます"
@@ -49987,7 +50033,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "%<;%>、識別子または %<(%> が予期されます"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr ""
@@ -50002,12 +50048,12 @@ msgstr ""
 msgid "unexpected attribute"
 msgstr "packed 属性は必要ありません"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "getter/setter 属性は後に %<=%> が無ければいけません"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "getter/setter 属性は後に %<=%> が無ければいけません"
@@ -50050,7 +50096,7 @@ msgstr "ファイルスコープの空の宣言内に %<auto%> があります"
 msgid "%qs may only be used with a single declarator"
 msgstr "空の宣言です"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "%<,%> または %<;%> が予期されます"
@@ -50085,7 +50131,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "関数 `%s' を `mutable' としては宣言できません"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "文字列リテラルが予期されます"
@@ -50115,7 +50161,7 @@ msgstr "静的アサーション内の式が定数ではありません"
 msgid "static assertion failed: %E"
 msgstr "静的アサーションに失敗しました: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 msgid "static assertion failed"
 msgstr "静的アサーションに失敗しました: %E"
@@ -50169,8 +50215,8 @@ msgstr "モード %qs を列挙型用に使用できません"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "識別子が予期されます"
@@ -50200,12 +50246,12 @@ msgstr "未定義の型 %<%s %E%> の無効な使用法です"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "`%s' のセクションは前方でに宣言されたものと衝突します"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "列挙型リストの最後にコンマがあります"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50287,22 +50333,22 @@ msgstr "宣言指定または %<...%> が予期されます"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "関数が予期されます"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%s: オプション `%s' には引数が必要です\n"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "%qE 属性は型に適用できません"
@@ -50312,7 +50358,7 @@ msgstr "%qE 属性は型に適用できません"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 は %<[*]%> 配列宣言をサポートしません"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -50344,17 +50390,17 @@ msgstr "ISO C90 は初期化用に副オブジェクトを指定することを
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr ""
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -50364,44 +50410,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, fuzzy, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "認識できないアドレス"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "%qE 属性は型に適用できません"
@@ -50432,7 +50478,7 @@ msgstr "ISO C90 は宣言とコードの混合を禁止しています"
 msgid "expected %<}%> before %<else%>"
 msgstr "%<}%> が %<else%> の前に予期されます"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> の前に %<if%> がありません"
@@ -50447,7 +50493,7 @@ msgstr "複合文の最後にラベルがあります"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "文が予期されます"
@@ -50482,27 +50528,27 @@ msgstr "ISO C は十進浮動小数点をサポートしません"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "引数は複素数型でなければいけません"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr ""
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "%<if%> 文内の空の本体は中括弧で括ることを推奨します"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "%<else%> 文内の空の本体は中括弧で括ることを推奨します"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "%<else%> が曖昧になることを避けるために明示的に中括弧で括ることを推奨します"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -50522,12 +50568,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr ""
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -50542,8 +50588,8 @@ msgstr ""
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "重複した %<volatile%> です"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, fuzzy, gcc-internal-format
 msgid "first seen here"
 msgstr "構造体がここで定義されています"
@@ -50565,12 +50611,12 @@ msgstr "ISO C は中間項が省略された ?: 式を禁じます"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "フィールドの型はここで宣言されました"
@@ -50747,7 +50793,7 @@ msgstr "ISO C は %<__int128%> 型をサポートしません"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "式が予期されます"
@@ -50762,13 +50808,13 @@ msgstr "式内を中括弧で括ることは、関数内でのみ許可されて
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C は式内を中括弧で括ることを禁止しています"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "%<va_start%> の第二引数が、最後の名前付き引数ではありません"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -50915,7 +50961,7 @@ msgstr "%<__builtin___clear_cache%> への両方の引数はポインタでな
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "%<__builtin_prefetch%> への第三引数は定数でなければいけません"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "関数 %<__builtin_next_arg%> への引数の数が間違っています"
@@ -50956,7 +51002,7 @@ msgstr "%u 番目の引数が非定数整数の関数呼び出し %qE があり
 msgid "rotate count is negative"
 msgstr "右シフト回数が負です"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -51068,7 +51114,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -51108,12 +51154,12 @@ msgstr "objective-c メソッド定義が予期されます"
 msgid "no type or storage class may be specified here,"
 msgstr "型または記憶域クラスがここで指定されていません、"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "不明な property 属性です"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 msgid "missing property attribute"
 msgstr "不明な property 属性です"
@@ -51123,57 +51169,57 @@ msgstr "不明な property 属性です"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "不明な property 属性です"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "不明な property 属性です"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "Objective-C 文字列の前に連続した %<@%> があります"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "クラス名が予期されます"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, fuzzy, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "setter 名は %<:%> で終端されなければいけません"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma omp flush%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma GCC pch_preprocess%> は最初に無ければいけません"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp taskwait%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -51183,12 +51229,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma GCC pch_preprocess%> は最初に無ければいけません"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "for 文が予期されます"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> は最初に無ければいけません"
@@ -51198,11 +51244,11 @@ msgstr "%<#pragma GCC pch_preprocess%> は最初に無ければいけません"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "%qs 句が多すぎます"
@@ -51217,58 +51263,58 @@ msgstr "添え字は整数でなければいけません"
 msgid "%qD is not a variable"
 msgstr "%qD は変数ではありません"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD は変数ではありません"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "%<#pragma omp section%> または %<}%> が予期されます"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "式が予期されます"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "%<catch%> が予期されます"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -51291,22 +51337,22 @@ msgstr "%<num_threads%> 値は正でなければいけません"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "整数式が予期されます"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
@@ -51316,100 +51362,100 @@ msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, fuzzy, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "引数が多すぎます"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument"
 msgstr "packed 属性は必要ありません"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%qE 属性の引数が整数定数ではありません"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "%<using%> が予期されます"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, fuzzy, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "%<+%>、%<*%>、%<-%>、%<&%>、%<^%>、%<|%>、%<&&%> または %<||%> が予期されます"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "スケジュール %<runtime%> は %<chunk_size%> 仮引数をとりません"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "スケジュール %<auto%> は %<chunk_size%> 仮引数をとりません"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "`無効なスケジュールの種類です"
@@ -51419,38 +51465,38 @@ msgstr "`無効なスケジュールの種類です"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "%<operator%> が予期されます"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr "`%s' が重複しています"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "整数 0 とポインタとの順序比較です"
@@ -51465,22 +51511,22 @@ msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "重複する `virtual' 指定子"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "重複する `virtual' 指定子"
@@ -51490,7 +51536,7 @@ msgstr "重複する `virtual' 指定子"
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51505,313 +51551,313 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "RTP PIC は Thumb では使用できません"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "`無効なスケジュールの種類です"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "無効なマスクです"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, fuzzy, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 msgid "illegal comma"
 msgstr "不正な被演算子が検出されました"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "識別子または %<(%> が予期されます"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 msgid "invalid map kind"
 msgstr "無効なマスクです"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "`無効なスケジュールの種類です"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "`無効なスケジュールの種類です"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "不明な TLS モデル %qs です"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "インターフェースまたはインターフェースへのポインタが予期されます"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr "重複した %<const%> です"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "文字列リテラルが予期されます"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "重複した %<volatile%> です"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "重複した %<volatile%> です"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "重複した %<const%> です"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "ポインタが予期されます"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs は %qs と併用しなければいけません"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "ポインタが予期されます"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "セクション属性は `%s' には使えません"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "ファイルスコープの可変フィールドです"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "%<extern%> 変数 %qD の宣言が %<for%> ループ初期化宣言内にあります"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "%<#pragma message%> の後に文字列が予期されます"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -51826,7 +51872,7 @@ msgstr ""
 msgid "expected function name"
 msgstr "関数が予期されます"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "メンバ関数の名前を欠いています"
@@ -51836,22 +51882,22 @@ msgstr "メンバ関数の名前を欠いています"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -51876,7 +51922,7 @@ msgstr ""
 msgid "modified here"
 msgstr "共用体がここで定義されています"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "整数 0 とポインタとの順序比較です"
@@ -51911,112 +51957,112 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "%<+%>、%<*%>、%<-%>、%<&%>、%<^%>、%<|%>、%<&&%> または %<||%> が予期されます"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "RTP PIC は Thumb では使用できません"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "%qE は %qs (%qs 用) として前もって決められています"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after union definition"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "共用体定義の後には %<;%> が予期されます"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "%<#pragma omp atomic%> 用の無効な演算子です"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "%<delete%> が予期されます"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "%<#pragma omp atomic%> 用の無効な演算子です"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "%<#pragma omp atomic%> 用の無効な演算子です"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "%<#pragma omp atomic%> 用の無効な演算子です"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "初期化子の要素が定数式ではありません"
@@ -52026,27 +52072,27 @@ msgstr "初期化子の要素が定数式ではありません"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -52056,32 +52102,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "%<(%> またはファイル終端 (EOF) が予期されます"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp flush%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "%<#pragma omp%> 句が予期されます"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp flush%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "for 文が予期されます"
@@ -52089,70 +52135,70 @@ msgstr "for 文が予期されます"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "for 文が予期されます"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr ""
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough perfectly nested loops"
 msgid "not enough nested loops"
 msgstr "ループが完全な入れ子になっていません"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "%<operator%> が予期されます"
@@ -52162,7 +52208,7 @@ msgstr "%<operator%> が予期されます"
 msgid "expected a function name"
 msgstr "関数が予期されます"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 msgid "expected target-function call"
 msgstr "関数が予期されます"
@@ -52172,47 +52218,47 @@ msgstr "関数が予期されます"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "%<using%> が予期されます"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -52227,57 +52273,57 @@ msgstr "%<#pragma align%> は %D の前に現れなければいけません。
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "クラス名が予期されます"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "不明な演算子 %qs が %%:version-compare 内にあります"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "%s は 2 この引数のみ受け付けます"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr ""
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "文字列リテラルが予期されます"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "%qs スイッチは既にサポートされていません"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "クラス名が予期されます"
@@ -52287,27 +52333,27 @@ msgstr "クラス名が予期されます"
 msgid "variant %qD is not a function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "型名用に記憶域クラスが指定されました"
@@ -52317,7 +52363,7 @@ msgstr "型名用に記憶域クラスが指定されました"
 msgid "%qD is not of pointer type"
 msgstr "%qD は変数ではありません"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "%<none%> または %<shared%> が予期されます"
@@ -52328,17 +52374,17 @@ msgstr "%<none%> または %<shared%> が予期されます"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "%<using%> が予期されます"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "%<catch%> が予期されます"
@@ -52358,12 +52404,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "%qD はここで宣言されています"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "%d 番目の %qE の引数はアドレスでなければいけません"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "-I- が二回指定されました"
@@ -52373,7 +52419,7 @@ msgstr "-I- が二回指定されました"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "-f%s と -msdata=%s は併用できません"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "-f%s と -msdata=%s は併用できません"
@@ -52383,7 +52429,7 @@ msgstr "-f%s と -msdata=%s は併用できません"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
@@ -52399,84 +52445,84 @@ msgstr "%<#pragma align%> は %D の前に現れなければいけません。
 msgid "no declaration of base function %qs"
 msgstr "関数 %qE の暗黙的な宣言です"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "関数の定義が `register' と宣言されました"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "%<catch%> が予期されます"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "%<none%> または %<shared%> が予期されます"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma GCC pop_options%> に対応した %<#pragma GCC push_options%> がありません"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma GCC pop_options%> に対応した %<#pragma GCC push_options%> がありません"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
@@ -52501,13 +52547,13 @@ msgstr "`%s' の宣言はグローバル宣言を覆い隠します"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "前はここで宣言されました"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "unexpected clause"
 msgstr "クラス名が予期されます"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "PHI 定義がありません"
@@ -52567,32 +52613,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "%<#pragma omp section%> または %<}%> が予期されます"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -52607,164 +52653,164 @@ msgstr "可変長配列が使用されています"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "可変長配列が使用されています"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<while%>"
 msgid "expected %<sizes%>"
 msgstr "%<while%> が予期されます"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%qE 属性の引数が整数定数ではありません"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %qs or %qs"
 msgstr "%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp barrier%> は複合文内でのみ使用できます"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, fuzzy, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr "--driver は最早サポートされません"
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, fuzzy, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr "--driver は最早サポートされません"
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "代入として無効な左辺値です"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 msgid "expected directive name"
 msgstr "関数が予期されます"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown assumption clause %qs"
 msgstr "不明な spec 関数 %qs です"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "ポインタが予期されます"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "%<;%>、%<,%> または %<)%> が予期されます"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "不明なレジスタ名です: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE は最初に使用した後に %<threadprivate%> と宣言されています"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "自動変数 %qE は %<threadprivate%> になることは出来ません"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE は不完全型を持っています"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -52774,7 +52820,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -52789,7 +52835,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD は不完全型を持っています"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "void 式の無効な使用法です"
@@ -52820,171 +52866,171 @@ msgstr "不完全な typedef %qD の無効な使用法です"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "%qs 属性は関数へのみ適用出来ます"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "関数型が ISO C と完全互換ではありません"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "十進浮動小数型とベクトル型の被演算子を混ぜることは出来ません"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "十進浮動小数型と複素数型の被演算子を混ぜることは出来ません"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "十進浮動小数型と他の浮動小数型の被演算子を混ぜることは出来ません"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "ポインタターゲット型は C++ では互換性がありません"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "型は全く互換がありません"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "ポインタターゲット型は C++ では互換性がありません"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "関数の戻り型は %<volatile%> と互換性がありません"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, fuzzy, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "複合リテラル内での型定義は C++ では無効です"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT は %qE という名前のメンバを持っていません"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT は %qE という名前のメンバを持っていません"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "構造体または共用体ではない何かのメンバ %qE の要求です"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "%<void *%> ポインタの参照を解除しています"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "添字が付けられた値が、配列、ポインタまたはベクトルではありません"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "配列の添字が整数型ではありません"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "添字が付けられた値が関数へのポインタではありません"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "配列の添字が整数型ではありません"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C は %<register%> 配列に添字を付けることを禁止しています"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 は左が値でない配列に添字を付けることを禁止しています"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qE は初期化されていません"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "初期化内での列挙型の変換は C++ では無効です"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "列挙型定数がここで定義されています"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "呼び出されたオブジェクト %qE は関数ではありません"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "呼び出されたオブジェクト %qE は関数ではありません"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "呼び出されたオブジェクト %qE は関数ではありません"
@@ -52992,1875 +53038,1875 @@ msgstr "呼び出されたオブジェクト %qE は関数ではありません"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "関数が互換性のない型を通して呼び出されています"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "修飾子付き void 戻り型の関数が呼び出されています"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "正式な %d 番目の仮引数の型が不完全です"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は浮動小数型ではなく整数型としてです"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は複素数型ではなく整数型としてです"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は浮動小数点型ではなく複素数型としてです"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は整数型ではなく浮動小数型としてです"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は整数型ではなく複素数型としてです"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は複素数型ではなく浮動小数型としてです"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は %<float%> (%<double%> ではなく) としてです"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は %qT (%qT ではなく) としてです"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は異なる幅です"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は符号無しとしてです"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "プロトタイプによると渡している %d 番目の %qE の引数は符号付きとしてです"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to method %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "メソッド %qE への引数が多すぎます"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "関数 %qE への引数が多すぎます"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "関数 %qE への引数が多すぎます"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "インライン関数 %q+D を弱いとして宣言できません"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "関数へ引数を渡すときに %qT から %qT へ暗黙的に変換されます"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "関数 %qE へ渡す引数が少なすぎます"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "関数 %qE へ渡す引数が少なすぎます"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "関数 %qE へ渡す引数が少なすぎます"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "文字列リテラルの比較結果は不定です"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "ポインタと整数との比較を行なっています"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr ""
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "配列の添字が整数型ではありません"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "%qT と %qT の比較です"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, fuzzy, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "`void *' 型のポインタの差を求めようとしています"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "関数ポインタの差を求めようとしています"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "不完全型へのポインタに関する計算です"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "不完全型へのポインタに関する計算です"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "真偽式が予期されます"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, fuzzy, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C は複素共役用の `~' を受け付けません"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "abs への引数の型が間違っています"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "単項感嘆符(!)への引数の型が間違っています"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "列挙値の増分は C++ では無効です"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "列挙値の減分は C++ では無効です"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "真偽式が予期されます"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "真偽式が予期されます"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C は複素数型に関する %<++%> と %<--%> をサポートしません"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "増分する引数の型が間違っています"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "減分する引数の型が間違っています"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "不完全型へのポインタに対する演算"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "不完全型のポインタへの間接参照"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "%<void%> 型の式のアドレスを取得しています"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "ビットフィールド %qD のアドレスを取得できません"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "`this' は右辺値式であり、そのアドレスを取ることはできません"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "レジスタ変数 %qD のアドレスが要求されました"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "レジスタ変数 %qD のアドレスが要求されました"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "帯域レジスタ変数 %qD が入れ子になった関数内で使用されています"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "レジスタ変数 %qD が入れ子になった関数内で使用されています"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "大域レジスタ変数 %qD のアドレスが要求されました"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "レジスタ変数 %qD のアドレスが要求されました"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "defining a type in a compound literal is invalid in C++"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "複合リテラル内での型定義は C++ では無効です"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C は片側だけが void となる条件式を禁止しています"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "条件式内でポインタ型が一致しません"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "条件式内でポインタ型が一致しません"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C は %<void *%> と関数ポインタ間の比較式を禁止しています"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "条件式内でポインタ型が一致しません"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "関数 `%s' に対して不適切な保存クラス"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "second expression has type %qT"
 msgstr "被演算子として無効な式です"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "条件式内でポインタ型と整数型が適合しません"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "条件式での型の組合わせが適合しません"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "warn_unused_result 属性付きで宣言されている %qD の戻り値を無視しています"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "warn_unused_result 属性付きで宣言されている %qD の戻り値を無視しています"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "warn_unused_result 属性付きで宣言されている %qD の戻り値を無視しています"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "warn_unused_result 属性付きで宣言されている %qD の戻り値を無視しています"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "`%s' は前にここで宣言されました"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "カンマ演算子の左側の式に効力がありません"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "カンマ演算子の左側の式に効力がありません"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr ""
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "キャストが配列型を指定しています"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "キャストは関数型を指定しています"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C は非スカラーから同じ型へのキャストを禁止しています"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "関数 `%s' に対して不適切な保存クラス"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C は共用体型へのキャストを禁止しています"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "共用体の中にない型から共用体型へキャストしています"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr ""
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "ポインタから異なるサイズの整数へのキャストです"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "型 %qT の関数呼び出しから一致しない型 %qT へのキャストです"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "異なるサイズの整数からポインタへのキャストです"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C は関数ポインタからオブジェクトポインタ型への変換を禁止しています"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C はオブジェクトのポインタから関数のポインタ型への変換を禁止しています"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "不完全型 %qT から %qT へ変換できません"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "キャスト内での型定義は C++ 内では無効です"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "代入の抑制"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "代入内での列挙型の変換は C++ 内では無効です"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(%qs 用の初期化付近)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "小括弧で括られた文字列定数で配列が初期化されています"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 msgid "expected %e but argument is of type %e"
 msgstr "識別子または %<*%> が予期されます"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "%qD はここで宣言されています"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 msgid "%e declared here"
 msgstr "ここで宣言されています"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "%d 番目の %qE の引数を渡すときの列挙型の変換は C++ 内では無効です"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "代入内での列挙型の変換は C++ 内では無効です"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "初期化内での列挙型の変換は C++ では無効です"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "return 内での列挙型の変換は C++ では無効です"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "%q#T から %q#T への変換です"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C では引数から共用体への変換を禁止しています"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "予期しない型が `id' (%s) に指定されました"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "%d 番目の %qE の引数は format 属性の候補のようです"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "左辺への代入は format 属性の候補のようです"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "左辺の初期化は format 属性の候補のようです"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "戻り型は format 属性の候補のようです"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "互換性のないポインタ型から %d 番目の %qE の引数に渡しています"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "互換性のないポインタ型からの代入です"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "互換性のないポインタ型からの初期化です"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "互換性のないポインタ型からの戻りです"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C は関数のポインタと %<void *%> 間の代入を禁止しています"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C は関数ポインタと %<void *%> 間の初期化を禁止しています"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C は関数ポインタと %<void *%> の間の戻りを禁止しています"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "%d 番目の %qE の引数を渡すときのポインタの先の符号が異なります"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "代入でのポインタの先の符号が異なります"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "初期化でのポインタの先の符号が異なります"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "%d 番目の %qE の引数を渡すときのポインタの先の符号が異なります"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "互換性のないポインタ型から %d 番目の %qE の引数に渡しています"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "互換性のないポインタ型からの代入です"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "互換性のないポインタ型からの代入です"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "互換性のないポインタ型からの初期化です"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "互換性のないポインタ型からの初期化です"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "互換性のないポインタ型からの戻りです"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "互換性のないポインタ型からの戻りです"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "%d 番目の %qE の引数へ渡すときに整数からキャスト無しにポインタを作成しています"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "代入で整数からキャスト無しにポインタを作成しています"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "初期化で整数からキャスト無しにポインタを作成しています"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "%d 番目の %qE の引数へ渡すときに整数からキャスト無しにポインタを作成しています"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "passing argument %d 番目の %qE の引数を渡すときにポインタからキャスト無しに整数を作成しています"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "代入でポインタからキャスト無しに整数を作成しています"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "初期化でポインタからキャスト無しに整数を作成しています"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "passing argument %d 番目の %qE の引数を渡すときにポインタからキャスト無しに整数を作成しています"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "%d 番目の %qE の引数用の互換性がない型です"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "型 %qT への型 %qT からの代入時に互換性のない型です"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "型 %qT を型 %qT を使用して初期化時に互換性のない型です"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "型 %qT を戻すときに互換性のない型です。型 %qT が予期されます"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "伝統的な C では自動集約初期化を拒否します"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "expression in static assertion is not an integer constant expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "可変配列メンバを初期化しています"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, fuzzy, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "互換性のないポインタ型からの初期化です"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "char の配列にとって初期化子文字列が長すぎます"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "char の配列にとって初期化子文字列が長すぎます"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "適切でない型の配列が文字列定数で初期化されています"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "非左辺値配列の無効な使用です"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "無効な初期化子です"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "初期化子の要素が定数ではありません"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "配列が非定数配列式で初期化されています"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "%qT から %qT への変換が曖昧です"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "初期化子の要素がロード時に計算出来ません"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, fuzzy, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "初期化子の終わりに余分なブレースのグループ"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "スカラー初期化子が中括弧で囲まれています"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "入れ子になったコンテキスト内で可変配列メンバを初期化しています"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "初期化子の周りに中括弧がありません"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "初期化子を欠いています"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "スカラー初期化子内に余分な要素があります"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "レコードや共用体初期化子にフィールド名がありません"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr ""
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "初期化子内に非定数の配列インデックスがあります"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "初期化子内の配列インデックスが配列の境界を超えました"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "初期化子内に空の範囲インデックスがあります"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "初期化子の範囲インデックスが配列の境界を超えました"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "初期化されたフィールドが上書きされます"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "初期化されたフィールドが副作用で上書きされます"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "初期化内での列挙型の変換は C++ では無効です"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "共用体初期化子内の要素が多すぎます"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "構造体初期化子内の要素が多すぎます"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "共用体初期化子内の要素が多すぎます"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "伝統的な C では共用体の初期化を拒否します"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "配列初期化子内の要素が多すぎます"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "ベクトル初期化子内の要素が多すぎます"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "スカラー初期化子内の要素が多すぎます"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C では関数外での余分な %<;%> を許可していません"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in output operand outside of a function"
 msgstr "ISO C では関数外での余分な %<;%> を許可していません"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "出力被演算子 %d は %<&%> 制約を使用しなければいけません"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "alloc_size パラメータが範囲外です"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in input operand outside of a function"
 msgstr "ISO C では関数外での余分な %<;%> を許可していません"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD は関数スコープの外側で定義されていません"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C は %<goto *expr;%> を禁止しています"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "%d 番目の %qE の引数はアドレスでなければいけません"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "%<noreturn%> と宣言されている関数が %<return%> 文を持っています"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "非 void を戻す関数内に値が無い %<return%> があります"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "void を戻す関数内に値が有る %<return%> があります"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C は void を戻す関数内で、式をがある %<return%> を禁止しています"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "function returns address of label"
 msgstr "関数が局所変数のアドレスを返します"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "関数が局所変数のアドレスを返します"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch の内容が整数ではありません"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "ISO C では %<long%> による switch 文は %<int%> による switch に変換されます"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "case ラベルは整数定数式に出来ません"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "switch 文の外にある case ラベルです"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "switch 文の外にある %<default%> ラベルです"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "ループまたは switch 文の外にある break 文です"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "OpenMP のループ用に break 文が使用されています"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "ループの外にある continue 文です"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "効果がない文です"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "式の中の文に不完全型があります"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "異なる列挙型の比較に関して警告する"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "結果の数が異なります"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "型 %qT と %qT の間での比較です"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "浮動小数点の比較で == や != を使うのは安全ではありません"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C は %<void *%> と関数ポインタの比較を禁止しています"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "ポインタと整数との比較を行なっています"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "完全なポインタと不完全なポインタとの比較です"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C 関数ポインタの順序比較を禁じます"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "NULL ポインタがあるポインタの順序比較です"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "スカラーが必要な場所にポインタに変換できない配列が使用されています"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "スカラーが必要な場所で構造体型の値が使用されています"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "スカラーが必要な場所で共用体型の値が使用されています"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "スカラーが必要な場所で構造体型の値が使用されています"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "配列 new でのサイズは完全な型を持たねばなりません"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "配列 new でのサイズは完全な型を持たねばなりません"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "代入として無効な左辺値です"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "セクション属性は `%s' には使えません"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, fuzzy, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "可変長配列が使用されています"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "ISO C は関数型の修飾子を禁止しています"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "仮引数 %qD が不完全型を持っています"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "非整数型のビットフィールド %qD です"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr "読み取り専用変数 %qD の増分です"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "読み取り専用変数 %qD の増分です"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "初期化子は `%s' のサイズの特定に失敗しました"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "ポインタが予期されます"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "セクション属性は `%s' には使えません"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "可変長配列 %qE が使用されています"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE は %<reduction(%s)%> 用の無効な型を持っています"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "可変長配列が使用されています"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE は %<threadprivate%> (%<copyin%> 用として) でなければいけません"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE は %<firstprivate%> 句内では変数ではありません"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE は %<lastprivate%> 句内では変数ではありません"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "\"%s\" は C++ の演算子であり、マクロ名として使用することはできません"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not initialized with a constant expression"
 msgid "traits array must be initialized with constants"
 msgstr "%qD は定数式で初期化されませんでした"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "固定小数変換内で無効な型です"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "ソースはポインタではありません"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "%qs 句が多すぎます"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "重複した %<const%> です"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not const"
 msgid "%qD shall not be const"
 msgstr "%q#D は const ではありません"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE は %qs (%qs 用) として前もって決められています"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "%<va_arg%> の第一引数が %<va_list%> 型ではありません"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "%<va_arg%> の第一引数が %<va_list%> 型ではありません"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "%<va_arg%> の第一引数が %<va_list%> 型ではありません"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -55130,254 +55176,249 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD should be initialized"
 msgid "%s should not be null"
 msgstr "%qD は初期化されるべきです"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "レシーバ型 `%s' が無効です"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr ""
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr ""
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "不明な TLS モデル %qs です"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "クラスタイプ項を欠いています"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "プロシージャ開始と終了のスケジュールを行なわない"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55386,73 +55427,83 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "空の宣言です"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown type name %qE"
 msgid "Unknown type %d"
 msgstr "不明な型名 %qE です"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%s は %s をサポートしません"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55462,13 +55513,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "入力ファイルが多すぎます"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "friend 関数 `%s' を初期化できません"
@@ -55484,61 +55535,61 @@ msgstr "代替レジスタ名を使用する"
 msgid "%s exited with status %d"
 msgstr "%s は終了ステータス %d を返しました"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s\"%s\"%s は無効です"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: "
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr ""
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "プラグイン %s の初期化に失敗しました"
@@ -55984,7 +56035,7 @@ msgstr "%<operator %s%> は %qT 用としては適切ではありません"
 msgid "%q#D is private within this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 msgid "declared private here"
 msgstr "ここで宣言されています"
@@ -55994,7 +56045,7 @@ msgstr "ここで宣言されています"
 msgid "%q#D is protected within this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 msgid "declared protected here"
 msgstr "ここで宣言されています"
@@ -56328,7 +56379,7 @@ msgstr "不完全型への変換です"
 msgid "constructor delegates to itself"
 msgstr "定数が自身を参照しています"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 msgid "cannot convert %qH to %qI"
 msgstr "型 %qT から型 %qT へ変換できません"
@@ -56348,7 +56399,7 @@ msgstr "%<%D(%A)%> の呼び出しに適合する関数がありません"
 msgid "call to non-function %qD"
 msgstr "非関数 %qD の呼び出しです"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "コンストラクタ %<%T::%D%> を直接呼び出すことは出来ません"
@@ -56946,7 +56997,7 @@ msgstr "構造体に可変配列メンバ以外のメンバがありません"
 msgid "next member %q#D declared here"
 msgstr "`%s' は前にここで宣言されました"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "%q#T が再定義されています"
@@ -56956,7 +57007,7 @@ msgstr "%q#T が再定義されています"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -57088,7 +57139,7 @@ msgstr "関数 `%s' に対して不適切な保存クラス"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
@@ -57139,7 +57190,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -57174,845 +57225,845 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qE 属性は名前付き引数があるプロトタイプが必要です"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "初期化子の要素が定数ではありません"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr "%s は %s をサポートしません"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "関数 %<va_start%> への引数の数が間違っています"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr "#pragma message: %s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "非関数 %qD の呼び出しです"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "%<void *%> ポインタの参照を解除しています"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "無効なオプション %s"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "非関数 %qD の呼び出しです"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "元々はここで定義されました"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "可変長オブジェクトが初期化されないようです"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "オブジェクト以外がメンバ関数 %qD を呼び出すことは出来ません"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr ""
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "'o' 被演算子が定数ではありません"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 msgid "allocation performed here"
 msgstr "ここで宣言されています"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "`%s' の宣言は前方のローカルシンボルを覆い隠します"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "`%s' はその定義の前にプロトタイプなしで使われました"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr ""
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "右シフト回数が負です"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "右シフト回数が負です"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "カンマ演算子の左側の式に効力がありません"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "初期化子の要素が定数ではありません"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "配列の添字が配列境界の外にあります"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "配列の添字が配列境界の外にあります"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "配列の添字が配列境界の外にあります"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "配列の添字が配列境界の外にあります"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "初期化子を欠いています"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "%<void *%> ポインタの参照を解除しています"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%qD は定数式で初期化されませんでした"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "初期化子を欠いています"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "%qD は定数式で初期化されませんでした"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "入れ子になった関数はこのターゲットではサポートされていません"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "初期化子を欠いています"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 msgid "%qT object created here"
 msgstr "ここで宣言されています"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%qD はここで宣言されています"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 msgid "allocated here"
 msgstr "ここで宣言されています"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "%qD は定数式で初期化されませんでした"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qE は初期化されていません"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D は const ではありません"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D は volatile です"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD は定数式で初期化されませんでした"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr ""
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr ""
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "無効な %qD の使用です"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, fuzzy, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr "%q+D が再定義されました"
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, fuzzy, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "%q+D が再定義されました"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "関数 `%s' に対して不適切な保存クラス"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "フィールドの型はここで宣言されました"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr ""
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "'B' 被演算子が定数ではありません"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "ループまたは switch 文の外にある break 文です"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> used outside of class"
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%> がクラスの外側で使用されています"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "`%s' はその定義の前にプロトタイプなしで使われました"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "`%s' はその定義の前にプロトタイプなしで使われました"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "%qE の列挙値が整数定数式ではありません"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "仮想関数は friend にできません"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "定数式内でオーバーフローしました"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qE は最初に使用した後に %<threadprivate%> と宣言されています"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%q+F が %<static%> と宣言されましたが定義されていません"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "初期化子内に非定数の配列インデックスがあります"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "ファイル \"%s\" に戻るはずでした"
@@ -58148,361 +58199,360 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr ""
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "基底クラス %q#T が非仮想デストラクタを持っています"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "基底クラス %q#T が非仮想デストラクタを持っています"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "基底クラス %q#T が非仮想デストラクタを持っています"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not an aggregate"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not an array"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr ""
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qD は変数ではありません"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qD は %qD 内では宣言されていません"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "メンバ関数の名前を欠いています"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "ソースはポインタではありません"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "%q#D is not const"
-msgid "%qT is not consteval-only"
-msgstr "%q#D は const ではありません"
+msgid "%qT is not a structural type"
+msgstr "クラスタイプ項を欠いています"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "const `%s' を `mutable' として宣言できません"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "無効な定数"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "初期化子の要素が定数ではありません"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "-mhard-float はサポートされていません"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -58532,49 +58582,49 @@ msgstr "アセンブラ宣言は前の名前変更と競合するため無視さ
 msgid "previous declaration with fewer contracts here"
 msgstr "前方での `%s' の宣言"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "parameter declared here"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "%q#D が宣言されています"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 msgid "first declared here"
 msgstr "ここで宣言されています"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "関数が文字列型を返しません"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "関数が文字列型を返しません"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -58647,7 +58697,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%qD はここで定義されています"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "不明な型名 %qE です"
@@ -58719,89 +58769,89 @@ msgstr "ソースはポインタではありません"
 msgid "awaitable type %qT is not a structure"
 msgstr "型修飾子 `%s' は struct や class の後には使えません"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "入れ子になった関数はこのターゲットではサポートされていません"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "%<noreturn%> と宣言されている関数が %<return%> 文を持っています"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%> への第三引数は定数でなければいけません"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%> への第三引数は定数でなければいけません"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %qD"
 msgid "no suspend point info for %qD"
 msgstr "前に %qD 用のプロトタイプがありません"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "%qE が重複しています"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "case の値としてポインタは許可されていません"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "ms_hook_prologue は入れ子になった関数と両立できません"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -58827,69 +58877,75 @@ msgstr "%qD はテンプレート関数ではありません"
 msgid "%qs used outside of constant expressions"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declarator"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "宣言子が予期されます"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%qD のアドレスは常に %<true%> と評価されます"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qE attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "%qE 属性の無効な引数です"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "マクロ引数リストにあり得ないトークン"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -58934,7 +58990,7 @@ msgstr ""
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "%qT から %qT への変換が曖昧です"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr ""
@@ -59326,7 +59382,7 @@ msgstr "前方での `%s' の宣言"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "使用している宣言 %q+D は前に使用している宣言と競合しています"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "前方での `%s' の宣言"
@@ -59550,12 +59606,12 @@ msgstr ""
 msgid "previous specification in %q#D here"
 msgstr "前の %q+D の宣言はここです"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "無効な宣言です"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared here without exporting"
@@ -59762,7 +59818,7 @@ msgstr "(`%s' の初期化は不完全です)"
 msgid "  enters %<template for%> statement"
 msgstr "文が予期されます"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
@@ -59808,2418 +59864,2428 @@ msgstr ""
 msgid "template parameters do not match template %qD"
 msgstr "仮引数 `%s' の型が宣言されていません"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "要求された整列が 2 の累乗ではありません"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q+#D は無効です。無名共用体は非静的データメンバのみ持つことが出来ます"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "無名構造体が名前つき型の中にありません"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "一つの宣言に複数の型があります"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "`enum %s' の再宣言"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "非関数 `%s' の引数に format 属性が指定されました"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, fuzzy, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "typdef 宣言で型名を欠いています"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ は無名構造体を禁止しています"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "非関数 `%s' の引数に format 属性が指定されました"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "非関数 `%s' の引数に format 属性が指定されました"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr ""
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "コンストラクタに対する戻り値の型指定は無視されました"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "%s に対する記憶クラス指定子 `%s'"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%s に対する記憶クラス指定子 `%s'"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%s に対する記憶クラス指定子 `%s'"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%s に対する記憶クラス指定子 `%s'"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%s に対する記憶クラス指定子 `%s'"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "`%s' の宣言で型がデフォルトの `int' とされました"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "自動テンプレート実体化を有効にする"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "`com_interface' 属性はクラス定義にのみ用いる事ができます"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored"
 msgstr "%qE 属性は無視されました"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "`com_interface' 属性はクラス定義にのみ用いる事ができます"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef `%s' が初期化されました"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "`%s' の宣言に `extern' がついており、初期化もされています"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, fuzzy, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "初期化された変数 `%s' は dllimport マークされています"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "%q#D のテンプレート宣言です"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "ポインタ宣言子に不適切な型修飾子"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, fuzzy, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "重複した初期化子"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, fuzzy, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "変数 `%s' には初期化子がありますが、不完全型です"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "配列 `%s' の要素に不完全型があります"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, fuzzy, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "仮引数 `%s' は不完全型です"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr ""
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, fuzzy, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "自明でないラベルのついた初期化子です"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "初期化子は `%s' のサイズの特定に失敗しました"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "`%s' での配列サイズを欠いています"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "ISO C は サイズ 0 の配列 `%s' を禁じます"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr ""
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr ""
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "未初期化定数を ROM に置かない"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "レジスタ変数 %qD が入れ子になった関数内で使用されています"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "初期化された変数 %q+D は dllimport とマークされています"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr ""
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, fuzzy, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "無効なビット列初期化子です"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "無名基底クラスの初期設定子が曖昧です"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "要求されたメンバ `%s' は多重継承グラフの中で曖昧です"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "無効な初期化子です"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, fuzzy, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "入力ファイルが多すぎます"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, fuzzy, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "スカラー初期化子がブレースで囲まれています"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "スカラー初期化子がブレースで囲まれています"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, fuzzy, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "初期化子のまわりのブレースを欠いています"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "ソースは不完全型へのポインタです"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "配列 `%s' の要素に不完全型があります"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, fuzzy, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "ISO C89 は複合リテラルを禁じます"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "`%s' は不完全型です"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, fuzzy, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "共用体初期化子内の要素が多すぎます"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, fuzzy, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "_Pramga が括弧で囲まれた文字列リテラルを受け取りました"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "コンストラクタの静的メンバ初期化子は無効です"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "ISO C++ は new 式の初期化での `=' を禁じます"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(クラス外での初期化を必要とします)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, fuzzy, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "register 変数 `%s' のアドレスが要求されました"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "仮引数 %qD が初期化されます"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "%d 番目の %qE の引数はアドレスでなければいけません"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "宣言内にない %<[*]%> です"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "宣言の中に代入(初期化ではなく)があります"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ は名前つき戻り値を許可しません"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "%qs に対して記憶域クラスが指定されています"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "`%s' の宣言に `extern' がついており、初期化もされています"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "非メンバ関数での `this' の使用は無効です"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "戻り値の型が不完全型です"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "複雑なパラメタをもつ関数は inline にできません"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, fuzzy, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "前方での `%s' の宣言"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%qE 属性は変数および関数へのみ適用できます"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, fuzzy, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "関数 `%s' が変数であるかのように初期化されました"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "不完全型のポインタへの間接参照"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 msgid "lambda declared here"
 msgstr "ここで宣言されています"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr ""
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "ソースは不完全型へのポインタです"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 は可変長の配列 %qE を禁止しています"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "定数式が欠けているか無効です"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "ソースは不完全型へのポインタです"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr "メンバ関数 %qD 用の無効な初期化子です"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "%qs が構造体フィールド用に指定されています"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "メンバ関数 %qD 用の無効な初期化子です"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr ""
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "%<offsetof%> を静的データメンバ %qD へ適用できません"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "初期化子は `%s' のサイズの特定に失敗しました"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "`%s' での配列サイズを欠いています"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "ISO C は サイズ 0 の配列 `%s' を禁じます"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, fuzzy, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "他のクラス `%s' のデストラクタを、メンバにはできません"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, fuzzy, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "他のクラス `%s' のデストラクタを、メンバにはできません"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr ""
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr ""
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr ""
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr ""
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr ""
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "領域 `%s' は関数として宣言されています"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr ""
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr ""
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "--driver は最早サポートされません"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "%qD はテンプレート関数ではありません"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, fuzzy, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "宣言の中に代入(初期化ではなく)があります"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr ""
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "`::main' を template としては宣言できません"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "`::main' を inline としては宣言できません"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "`::main' を template としては宣言できません"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "静的メンバ %qD はビットフィールドに出来ません"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "静的メンバ %qD はビットフィールドに出来ません"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "静的メンバ %qD はビットフィールドに出来ません"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 msgid "  declared here"
 msgstr "ここで宣言されています"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr ""
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qs は -mcpu= への引数としては無効です"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "`main' は `int' を返さなければなりません"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr ""
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "typedef %q+D が再定義されました"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%qD はここで宣言されています"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, fuzzy, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "メンバ関数へのポインタが呼ばれましたが、クラススコープ内ではありません"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "`::main' を template としては宣言できません"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "自動変数 %qE は %<threadprivate%> になることは出来ません"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "--driver は最早サポートされません"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "ISO C++ は new 式の初期化での `=' を禁じます"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr ""
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr ""
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ は new 式の初期化での `=' を禁じます"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ は new 式の初期化での `=' を禁じます"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "定数式が欠けているか無効です"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C は サイズ 0 の配列 `%s' を禁じます"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C は サイズ 0 の配列 `%s' を禁じます"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C89 は可変長サイズの配列 `%s' を禁じます"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C89 は可変長サイズの配列 `%s' を禁じます"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "可変長配列が使用されています"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "配列の次元がオーバーフローしました"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "領域 `%s' は関数として宣言されています"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "`%s' の宣言は void の配列"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "creating array of void"
 msgstr "`%s' の宣言は void の配列"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 msgid "creating array of functions"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "creating array of references"
 msgstr "配列参照での添字を欠いています"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 msgid "creating array of function members"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "可変長配列が使用されています"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, fuzzy, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "コンストラクタに対する戻り値の型指定は無視されました"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, fuzzy, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "コンストラクタに対する戻り値の型指定は無視されました"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, fuzzy, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "コンストラクタに対する戻り値の型指定は無視されました"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "コンストラクタに対する戻り値の型指定は無視されました"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "%qD の宣言内でテンプレート仮引数リストが多すぎます"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "`%s' の宣言が矛盾しています"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "無名変数やフィールドが void と宣言されました"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "変数またはフィールドが void と宣言されました"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "大域スコープ外の関数 `%s' に対する記憶クラス `inline' は無効です"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr "ms_hook_prologue は入れ子になった関数と両立できません"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "ms_hook_prologue は入れ子になった関数と両立できません"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "コンストラクタは virtual 宣言できません"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 msgid "%e and %e specified together"
 msgstr "%<signed%> と %<unsigned%> が %qs に対して両方指定されています"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "未定義の型 `%s %s' の使用は不適切です"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "未定義の型 `%s %s' の使用は不適切です"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "未定義の型 `%s %s' の使用は不適切です"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "`%s' の宣言は仮引数を覆い隠します"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, fuzzy, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "関数の定義が `register' と宣言されました"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "`%s' の宣言は関数の配列"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "`%s' の extern 宣言がネストしています"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "%q+D の再宣言は仮引数を隠します"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "宣言内にない %<[*]%> です"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, fuzzy, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C は単なる %<complex%> を %<double complex%> を意味するものとしてはサポートしません"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ では型の無い %qs の宣言を禁止しています"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "このターゲットでは %<__int128%> はサポートされていません"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ は %<__int128%> を %qs に対してはサポートしていません"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qs は %qs と併用しなければいけません"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%<__thread%> が %<typedef%> と併せて使用されています"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%<__thread%> が %<typedef%> と併せて使用されています"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%<__thread%> が %<typedef%> と併せて使用されています"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "complex は %qs に対しては無効です"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "仮引数宣言の中の typedef 宣言は無効です"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "仮引数 `%s' で指定された記憶クラス"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "仮引数 %qs に対して記憶域クラスタ指定されています"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "仮引数は %<constexpr%> として宣言してはいけません"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> がクラス宣言外で使用されています"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "無効な宣言です"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "%qs の宣言内に複数の記憶域クラスがあります"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "%qs に対して記憶域クラスが指定されています"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, fuzzy, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "ネストした関数 `%s' は `extern' に宣言されました"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, fuzzy, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "`%s' のトップレベルの宣言が `auto' を指定します"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr ""
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "friend 関数宣言内の記憶クラス指定子は無効です"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "%qs の宣言内に複数の記憶域クラスがあります"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr ""
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "関数を inline にできません"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "静的メンバ %qD はビットフィールドに出来ません"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, fuzzy, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "仮想関数は friend にできません"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "%<restrict%> の誤った使用法です"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "トップレベルでの `this' の使用は無効です"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "関数戻り値の型修飾子は無視されました"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, fuzzy, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "`%s' は関数を返す関数として宣言されています"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, fuzzy, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "`%s' は配列を返す関数として宣言されています"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr ""
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, fuzzy, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, fuzzy, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "コンストラクタは virtual 宣言できません"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "コンストラクタは virtual 宣言できません"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "コンストラクタは virtual 宣言できません"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "コンストラクタは virtual 宣言できません"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "コンストラクタは virtual 宣言できません"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "仮想関数は friend にできません"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "静的メンバ %qD はビットフィールドに出来ません"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, fuzzy, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "デストラクタは仮引数を取りません"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "参照を参照として宣言できません"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "参照を参照として宣言できません"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr ""
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "メンバ関数は暗黙的にそのクラスの friend です"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "オブジェクト以外がメンバ関数 %qD を呼び出すことは出来ません"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<virtual%> がクラス宣言外で使用されています"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "空の宣言内に %<inline%> があります"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "`explicit' にできるのは、コンストラクタだけです"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, fuzzy, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, fuzzy, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "非オブジェクトメンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, fuzzy, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "関数 `%s' を `mutable' としては宣言できません"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "static `%s' を mutable として宣言できません"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "const `%s' を `mutable' として宣言できません"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "関数 `%s' を `mutable' としては宣言できません"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "宣言内にない %<[*]%> です"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr ""
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "クラス宣言の外側で virtual 指定しています"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, fuzzy, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "複雑なパラメタをもつ関数は inline にできません"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, fuzzy, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, fuzzy, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "クラス `%s' を大域スコープの friend にしようとしています"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, fuzzy, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "非メンバ関数での `this' の使用は無効です"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, fuzzy, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "`%s' の宣言はグローバル宣言を覆い隠します"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "`enum %s' の再宣言"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "仮引数宣言の中で `::' を使えません"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, fuzzy, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "%qD は関数テンプレートではありません"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "無効なデフォルトテンプレート引数"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C は サイズ 0 の配列 `%s' を禁じます"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C は サイズ 0 の配列 `%s' を禁じます"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "無効な用法の of %%d, %%x, 又は %%X"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "%s: 関数 `%s' の宣言が変換されていません\n"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "領域 `%s' は関数として宣言されています"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "`%s' の宣言により `this' のメンバが覆い隠されます"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%s を開けません"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "変数 %qD が関数として再宣言されました"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "元の型はここで宣言されました"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "領域 `%s' は不完全な型です"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, fuzzy, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "仮引数が不完全型です"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "`%s' は関数でもメンバ関数でもありません -- friend とは宣言できません"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "`%s' は関数でもメンバ関数でもありません -- friend とは宣言できません"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "`%s' 属性は関数に対してのみ適用されます"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "宣言の中に代入(初期化ではなく)があります"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "仮引数 %q+D が %<inline%> と宣言されています"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "関数を inline にできません"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "非オブジェクトメンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "関数 `%s' に対する記憶クラス `auto' は無効です"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, fuzzy, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "関数 `%s' に対する記憶クラス `register' は無効です"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "関数 `%s' に対する記憶クラス `auto' は無効です"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "関数 `%s' に対する記憶クラス `auto' は無効です"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "関数 %qD への代入です"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "初期化子リストは非メンバ関数では使えません"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "大域スコープ外の関数 `%s' に対する記憶クラス `inline' は無効です"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "大域スコープ外の関数 `%s' に対する記憶クラス `inline' は無効です"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, fuzzy, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "virtual な非クラス関数 `%s'"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "他の関数内で static 関数を宣言できません"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr ""
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "%<extern%> 変数 %qD の宣言が %<for%> ループ初期化宣言内にあります"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "仮引数は %<constexpr%> として宣言してはいけません"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, fuzzy, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "`%s' が初期化されるところで、`extern' 宣言されました"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, fuzzy, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "関数がローカル変数のアドレスを返しています"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "関数がローカル変数のアドレスを返しています"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "仮引数宣言の中で `::' を使えません"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "仮引数 `%s' は無効です"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "パラメタはメソッドの型を不正に宣言しました"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr ""
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "`::main' を static としては宣言できません"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr ""
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ は無名構造体を禁止しています"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr ""
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr ""
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "%s%s への変換で型変換演算子が利用されることは決してありません"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "%s%s への変換で型変換演算子が利用されることは決してありません"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "%s%s への変換で型変換演算子が利用されることは決してありません"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "%s%s への変換で型変換演算子が利用されることは決してありません"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "%s%s への変換で型変換演算子が利用されることは決してありません"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr ""
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "%qD の無効なテンプレート宣言です"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr ""
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "前方での `%s' の宣言"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr ""
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "前方での `%s' の宣言"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr ""
@@ -62231,101 +62297,101 @@ msgstr ""
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr ""
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "function template %qD redeclared as a class template"
 msgid "class template %qD redeclared as non-template"
 msgstr "関数テンプレート %qD がクラステンプレートとして再定義されました"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr ""
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, fuzzy, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "事前の宣言なしの大域関数に関して警告する"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "`%s' の宣言は仮引数を覆い隠します"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr ""
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, fuzzy, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "型修飾子 `%s' は struct や class の後には使えません"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, fuzzy, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "重複した case の値"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 msgid "previous definition here"
 msgstr "`%s' は前にここで定義されました"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "述語は識別子でなければなりません"
@@ -62334,87 +62400,92 @@ msgstr "述語は識別子でなければなりません"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "`%s' の列挙値が整数定数ではありません"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "`%s' の列挙値が整数定数ではありません"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "整数定数が %<unsigned long%> 型に対して大きすぎます"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "ISO C は列挙値を %<int%> の範囲に制限しています"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, fuzzy, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "列挙値がオーバーフロー"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "%qE 用の列挙値が整数定数ではありません"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "%q#T が複数定義されています"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, fuzzy, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "戻り値の型が不完全型です"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr ""
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "非 void を戻す関数内に return 文がありません"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "関数の戻り型は %<volatile%> と互換性がありません"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "非 void を戻す関数内に return 文がありません"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr ""
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 msgid "using %qs"
 msgstr "%s を閉じているときにエラーが発生しました: %m"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "前方での `%s' の宣言"
+
+#: cp/decl.cc:21341
 #, fuzzy, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "%qD の型をデフォルトの %<int%> にします"
@@ -62847,351 +62918,351 @@ msgstr "`%s' が別のシンボル種として再宣言されました"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "%s:%d から include されたファイル内"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "%s:%d から include されたファイル内"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "%s:%d から include されたファイル内"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In static member function %qD"
 msgstr "静的メンバ関数 %qs 内"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In copy constructor %qs"
 msgid "In copy constructor %qD"
 msgstr "コピーコンストラクタ %qs 内"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In constructor %qs"
 msgid "In constructor %qD"
 msgstr "コンストラクタ %qs 内"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In destructor %qs"
 msgid "In destructor %qD"
 msgstr "デストラクタ %qs 内"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "ラムダ関数内"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "静的メンバ関数 %qs 内"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "メンバ関数 %qs 内"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "関数 %qs 内"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "  in thrown expression"
 msgid "but %qE is an expression"
 msgstr "  throw された式の中"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "%qs が構造体フィールド用に指定されています"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD は変数ではありません"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "関数パラメータ"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD は関数テンプレートではありません"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "%qD は変数ではありません"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD は名前空間です"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s: %qs のインスタンス内:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s: %qs のインスタンス内:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "%s:%d:   ここから再帰的に実体化されました"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "%s:%d:   %qs から再帰的に実体化されました\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "%s:%d:   ここから再帰的に実体化されました"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 msgid "required from here\n"
 msgstr "ここから呼び出されました"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%s:%d:%d:   %qs から実体化されました\n"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "前方での `%s' の宣言"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "Ada では -c または -S が必要です"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "引数がありません"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 msgid "(no argument)"
 msgstr "引数がありません"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr ""
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qT は %qE という名前のメンバを持っていません"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qT は %qE という名前のメンバを持っていません"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%qD は %qD 内では宣言されていません"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr ""
@@ -63414,7 +63485,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "%qE は初期化されていません"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -63530,7 +63601,7 @@ msgstr ""
 msgid "type %qT is not a direct base of %qT"
 msgstr ""
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class type"
@@ -63722,43 +63793,43 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "初期設定子の末尾が本来より早く出現しました"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "delete での配列サイズが不明です"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "戻り値の型が不完全型です"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
@@ -63793,82 +63864,90 @@ msgstr "不完全な typedef `%s' の使用は不適切です"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "無効な宣言です"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr ""
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD の整列は元の宣言より大きいです"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD の整列は元の宣言より大きいです"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "無効な #pragma %s です"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "--driver は最早サポートされません"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%s への #pragma implementation はファイルが include された後で出現しました"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, fuzzy, gcc-internal-format
 msgid "%qD not defined"
 msgstr "\"%s\" は定義されていません"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qE が宣言されていません (この関数内での最初の使用)"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr ""
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -63878,64 +63957,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "警告: "
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -64324,7 +64396,7 @@ msgstr "リンク無し %q+D の再定義です"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "`%s' の宣言が矛盾しています"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "無効な宣言です"
@@ -64339,429 +64411,429 @@ msgstr "無効な宣言です"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "無効な宣言です"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "`%s' の宣言が矛盾しています"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "無効な宣言です"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "無効な宣言です"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "無効な宣言です"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "無効な宣言です"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "%qD 用のデフォルト引数がありません"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 msgid "existing default declared here"
 msgstr "フィールドの型はここで宣言されました"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "仮引数リストからの仮引数名を欠いています"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "初期化された変数 `%s' は dllimport マークされています"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "定義がありません"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "型 %qT の引数が %qT と一致しません"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "列挙型 %q+D の再宣言です"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "`%s' が別のシンボル種として再宣言されました"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr ""
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD は %qD 内では宣言されていません"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD は %qD 内では宣言されていません"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "メンバ関数の名前を欠いています"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "%qD はここで宣言されています"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, fuzzy, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "%s\"%s\"%s は許可されていません"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "前の %q+D の宣言はここです"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "inconsistent imported macro definition %qE"
 msgstr "インスタンス変数の仕様が一貫していません"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "%s: ファイル `%s' を削除できません: %s\n"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "`コンパイラのバージョンを表示する"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 バージョン %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr ""
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, fuzzy, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "例外処理を無効にしました. 有効にするには -fexceptions を使ってください"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "<戻り値> "
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "スタック制限式はサポートされていません"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "%s を開くのに失敗しました"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "%s を開くのに失敗しました"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "%q+D のセクションが前の宣言と競合しています"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "%q+D のセクションが前の宣言と競合しています"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "%q+D のセクションが前の宣言と競合しています"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "%q+D のセクションが前の宣言と競合しています"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, fuzzy, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "%qD はここで宣言されています"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, fuzzy, gcc-internal-format
 msgid "import declared in global module"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "リンク無し %q+D の再定義です"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "前はここで宣言されました"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "前はここで宣言されました"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "%q#D が宣言されています"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "リンク無し %q+D の再定義です"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "%s を閉じているときにエラーが発生しました: %m"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, fuzzy, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "-mrecip=%s 用の不明なオプションです"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 msgid "module declared here"
 msgstr "ここで宣言されています"
@@ -64773,108 +64845,108 @@ msgstr "ここで宣言されています"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 msgid "module already declared"
 msgstr "シンボルの頭にアンダースコアをつける"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 msgid "module already imported"
 msgstr "シンボルの頭にアンダースコアをつける"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "%qD はここで宣言されています"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "<不明な演算子>"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "伝統的な前処理を有効にする"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "%%R への無効な被演算子です"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "無効な %qD の使用です"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "%qs へ書き込み中にエラーが発生しました"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "%qD はここで宣言されています"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "%s を開くのに失敗しました"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "不明な TLS モデル %qs です"
@@ -64889,7 +64961,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
@@ -64934,261 +65006,272 @@ msgstr "`%s' の宣言は仮引数を覆い隠します"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "`%s' の宣言により `this' のメンバが覆い隠されます"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %qD but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "仮引数 %qD 用の宣言がありますが、そのような仮引数はありません"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "friend 宣言がクラス定義の中にありません"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s: %s: "
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s: %s: "
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, fuzzy, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%qD はここで宣言されています"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%qD はここで宣言されています"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr ""
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "%q#D のテンプレート宣言です"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD は %qD 内では宣言されていません"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "%q#D が宣言されています"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, fuzzy, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "`%s' の宣言が矛盾しています"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD は %qD 内では宣言されていません"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "領域 `%s' は関数として宣言されています"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%s: オプション `%s' には引数が必要です\n"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "非インライン (noinline) 属性が与えられたインライン関数 %qD です"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "`%s' 属性の疑似命令が無視されました"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "`this' は静的メンバ関数から使用できません"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "弱い %q+D は %qE として定義できません"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 msgid "it was later defined here"
 msgstr "構造体がここで定義されています"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "初期化された変数 `%s' は dllimport マークされています"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "%qs スイッチは既にサポートされていません"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "#line 指示を生成しない"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr ""
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "リンク無し %q+D の再定義です"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "%<namespace%> が予期されます"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "メソッド属性を指定するのは最後のみでなければいけません"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%q+D  のアドレス領域は前の宣言と競合しています"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "`%s' は前にここで定義されました"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -65218,7 +65301,7 @@ msgstr "識別子 %qE は C++ 予約語と競合しています"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
@@ -65263,7 +65346,7 @@ msgstr ""
 msgid "request for member %qE in non-class type %qT"
 msgstr ""
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr ""
@@ -65333,7 +65416,7 @@ msgstr "%s 宣言の後ろのセミコロンを欠いています"
 msgid "%qE is not a class template"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr ""
@@ -65644,1697 +65727,1707 @@ msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "関数が予期されます"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD は関数テンプレートではありません"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "-Wno-strict-prototypes は C++ では受け付けられません"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ はブレースでまとめられた式を禁じます"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr ""
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr ""
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "このメディア関数は fr500 上でのみ利用できます"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr ""
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr ""
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "`%s' の宣言により `this' のメンバが覆い隠されます"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr ""
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr ""
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr ""
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "`com_interface' 属性はクラス定義にのみ用いる事ができます"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr ""
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr ""
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "関数 %<__builtin_next_arg%> への引数の数が間違っています"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "関数 %<__builtin_next_arg%> への引数の数が間違っています"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "関数 %<__builtin_next_arg%> への引数の数が間違っています"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "関数 %<__builtin_next_arg%> への引数の数が間違っています"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "インライン関数 %q+D を弱いとして宣言できません"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ は複合リテラルを禁じます"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "一つの空の宣言中に、二つの型が指定されています"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "無効な %qD の使用です"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%T::%D%> は有効な宣言子ではありません"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "非スカラー型"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr ""
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "参照型に対して new を適用できません"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "被演算子が非整数型のシフト演算です"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ は名前つき戻り値を許可しません"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr ""
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "file ends in default argument"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "デフォルト引数内でファイルが終了しています"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "__builtin_eh_return はこのターゲットではサポートされていません"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "式が予期されます"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr ""
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "自動テンプレート実体化を有効にする"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, fuzzy, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "配列 new でのサイズは完全な型を持たねばなりません"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "古いスタイルのキャストを使用しています"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, fuzzy, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "|| と共に使われる && の周りでは括弧をつけることをお勧めします"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ は名前つき戻り値を許可しません"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "一つの空の宣言中に、二つの型が指定されています"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr ""
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, fuzzy, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "単項演算式内で無効な被演算子です"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "%s を参照として宣言できません"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "読み取り専用変数 %qD の増分です"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr "%qs 句が多すぎます"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "仮引数 `%s' で指定された記憶クラス"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "仮引数 `%s' で指定された記憶クラス"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "仮引数 `%s' で指定された記憶クラス"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "%qD はここで宣言されています"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "仮引数配列宣言内の属性が無視されました"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "ラベル付き文が予期されます"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case ラベル %qE が switch 文の中にありません"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr ""
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 msgid "condition declares an array"
 msgstr "関数が集合体を返しています"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 msgid "condition declares a function"
 msgstr "フィールド %qE が関数として宣言されています"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr ""
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr ""
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "sizeof が関数型に適用されました"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "式の中の文に不完全型があります"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr ""
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in vector initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "ベクトル初期化子内の要素が多すぎます"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ は計算型 goto を禁じます"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr ""
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 msgid "expected module-partition"
 msgstr "テンプレート名が予期されます"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 msgid "expected module-name"
 msgstr "テンプレート名が予期されます"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 msgid "scope opened here"
 msgstr "共用体がここで定義されています"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 msgid "private module fragment"
 msgstr "引数がありません"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "一つの空の宣言中に、二つの型が指定されています"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C では関数外での余分な %<;%> を許可していません"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C では関数外での余分な %<;%> を許可していません"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "クラス定義の後には %<;%> が予期されます"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "%qE 属性は無視されました"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "一つの空の宣言中に、二つの型が指定されています"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr "ソースは不完全型へのポインタです"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "空の宣言です"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr "%qs が構造体フィールド用に指定されています"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "空の宣言です"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "メンバ関数 %qD 用の無効な初期化子です"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "データ領域 '%s' は前の宣言と矛盾します"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> がクラスの外側で使用されています"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr ""
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "%+D によりセクション型が競合します"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> は C++0x で意味が変更になります。削除してください"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "%q+D は %q#T 内では無効です"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%q+D は %q#T 内では無効です"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "%q+D は %q#T 内では無効です"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, fuzzy, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "`%s' は関数でもメンバ関数でもありません -- friend とは宣言できません"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "無効なリンク指定です"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr ""
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "参照型に対して new を適用できません"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "void 式の不適切な使用"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "void 式の不適切な使用"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "メンバ `%s' に対する無効な初期値"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "%q+D は静的宣言の後に非静的宣言が続いています"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, fuzzy, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "前時代的な古いスタイルの基底クラス初期化子です"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "識別子が予期されます"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, fuzzy, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "%<#pragma message%> の後に文字列が予期されます"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "二進演算内で無効な被演算子です"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "演算子が予期されます"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr ""
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "-ms2600 が -ms 無しで使用されています"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "無効なパラメータ %qs です"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "無効なデフォルトテンプレート引数"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "strftime フォーマットは引数をフォーマットできません"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr ""
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr ""
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "無効な型: `void &'"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "テンプレート引数が予期されます"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, fuzzy, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "マクロ引数リストにあり得ないトークン"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "テンプレート名が予期されます"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "テンプレート引数が予期されます"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr ""
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "型指定が予期されます"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "void 式の不適切な使用"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr ""
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "型名が予期されます"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 msgid "concept defined here"
 msgstr "共用体がここで定義されています"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "無効な %qD の使用です"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "宣言 %qD が何も宣言していません"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "インスタンス化されない型に対する無効な操作です"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "自動テンプレート実体化を有効にする"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr ""
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "ここでは %<namespace%> 定義は許可されていません"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "%<;%> または %<{%> が予期されます"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr ""
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr ""
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ は enum の %s を禁じます"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD は名前空間名ではありません"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "名前空間名が予期されます"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "名前空間名が予期されます"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "ここでは %<namespace%> 定義は許可されていません"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "インライン関数をインライン化できない場合に警告する"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr ""
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "ここでは %<namespace%> 定義は許可されていません"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr ""
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "未定義の型 `%s %s' の使用は不適切です"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "前方での `%s' の宣言"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "一つの空の宣言中に、二つの型が指定されています"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "インターフェースまたはインターフェースへのポインタが予期されます"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "重複した %<volatile%> です"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%qD は関数スコープの外側で定義されていません"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "alloc_size パラメータが範囲外です"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "関数宣言中に（型の無い）仮引数名があります"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "ISO C++ は new 式の初期化での `=' を禁じます"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "関数宣言中に（型の無い）仮引数名があります"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "関数 %qD が変数として再宣言されました"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "帯域レジスタ変数 %qD が入れ子になった関数内で使用されています"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "%qE 属性の引数が整数定数ではありません"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "%s: 関数 `%s' の宣言が変換されていません\n"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "0 で初期化されるデータを bss セクション内に配置する"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "0 で初期化されるデータを bss セクション内に配置する"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "0 で初期化されるデータを bss セクション内に配置する"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "ここでは関数定義は許可されていません"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "初期化子リストは非メンバ関数では使えません"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, fuzzy, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "friend 関数 `%s' を初期化できません"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr ""
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "関数テンプレート %qD がクラステンプレートとして再定義されました"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, fuzzy, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "配列の添字が整数型ではありません"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr ""
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr ""
@@ -67343,276 +67436,276 @@ msgstr ""
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "無効な宣言子です"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "トップレベルでの `this' の使用は無効です"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "無効な宣言です"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "宣言子が予期されます"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD は名前空間です"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "ポインタ演算子が予期されます"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr ""
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "重複する `virtual' 指定子"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "型指定子が予期されます"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "`%s' の引数として無効な型"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "合っていない引数です"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "`restrict' の用法が不適切です"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "void 式の不適切な使用"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "型指定子が予期されます"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "%<,%> または %<...%> が予期されます"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "too few template parameter lists in declaration of %qD"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "%qD の宣言内でテンプレート仮引数リストが少なすぎます"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, fuzzy, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "メソッドは関数ポインタに変換できません"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "strftime フォーマットは引数をフォーマットできません"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "strftime フォーマットは引数をフォーマットできません"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "strftime フォーマットは引数をフォーマットできません"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ は名前つき戻り値を許可しません"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ は名前つき戻り値を許可しません"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ は名前つき戻り値を許可しません"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr ""
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "クラス定義の後には %<;%> が予期されます"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "構造体定義の後には %<;%> が予期されます"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "共用体定義の後には %<;%> が予期されます"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "型指定子が予期されます"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "%<{%> または %<:%> が予期されます"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr ""
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "%qD の宣言内に無効なクラス名です"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "宣言の中に代入(初期化ではなく)があります"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr ""
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "関数テンプレート %qD がクラステンプレートとして再定義されました"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "%q+#T の前の定義"
@@ -67620,272 +67713,272 @@ msgstr "%q+#T の前の定義"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr ""
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr ""
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "ビットフィールドの幅が %qD 非整数型 %qT です"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "メンバ宣言の最後には %<;%> が予期されます"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "メンバ宣言の最後には %<;%> が予期されます"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "attributes in parameter array declarator ignored"
 msgid "attributes on base specifiers are ignored"
 msgstr "仮引数配列宣言内の属性が無視されました"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "例外仕様の検査をするコードを生成しない"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "void 式の不適切な使用"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "一つの空の宣言中に、二つの型が指定されています"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "空の宣言内に %<inline%> があります"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "file ends in default argument"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "デフォルト引数内でファイルが終了しています"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "識別子または %<(%> が予期されます"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "%qE 属性は R8C ターゲット用にはサポートされていません"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "%<:%> または %<...%> が予期されます"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "式が予期されます"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "RTP PIC は Thumb では使用できません"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "%qE 属性は %qE 用としては無視されます"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "インスタンス化されない型に対する無効な操作です"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "要求された整列が定数ではありません"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "要求された整列が定数ではありません"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "無効な宣言です"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr ""
@@ -67894,433 +67987,433 @@ msgstr ""
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr ""
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, fuzzy, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "--driver は最早サポートされません"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr ""
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr ""
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "`%s' の extern 宣言がネストしています"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "宣言が何も宣言していません"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr ""
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "`>>' はテンプレートクラス名は `> >' とすべきです"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "`>>' はテンプレートクラス名は `> >' とすべきです"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "テンプレート型統一中 `%s' が使用されました"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "%+D によりセクション型が競合します"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> が %qD の前にあります"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%<__thread%> が %<typedef%> と併せて使用されています"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ は `long long' を受け入れません"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr ""
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "%qE が重複しています"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "`%s' が重複しています"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "%<new%> が予期されます"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "%<delete%> が予期されます"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "%<return%> が予期されます"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "%<extern%> が予期されます"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "%<static_assert%> が予期されます"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "%<decltype%> が予期されます"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "%<operator%> が予期されます"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "%<class%> が予期されます"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "%<template%> が予期されます"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "%<namespace%> が予期されます"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "%<using%> が予期されます"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "%<asm%> が予期されます"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "%<try%> が予期されます"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "%<catch%> が予期されます"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "%<throw%> が予期されます"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "%<catch%> が予期されます"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "%<__label__%> が予期されます"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "%<@try%> が予期されます"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "%<@synchronized%> が予期されます"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "%<@throw%> が予期されます"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "%<static_assert%> が予期されます"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "%<static_assert%> が予期されます"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "%<@end%> が予期されます"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "%<::%> が予期されます"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "%<...%> が予期されます"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "%<*%> が予期されます"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "%<~%> が予期されます"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "%<:%> または %<::%> が予期されます"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "%<:%> が予期されます"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr ""
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "前はここで宣言されました"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "参照を参照として宣言できません"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "名前無しテンプレートクラスです"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "ラベル %qD はここで定義されています"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qD はここで宣言されています"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "`%s' が別のシンボル種として再宣言されました"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "デフォルト引数内でファイルが終了しています"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "objective-c メソッド定義が予期されます"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr ""
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr ""
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr ""
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, fuzzy, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "識別子が必要です"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr ""
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr ""
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "不明な property 属性です"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "整数式が予期されます"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "%<class%>、%<typename%>、または %<template%> が予期されます"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "無効な初期化子です"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
@@ -68329,173 +68422,173 @@ msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "--driver は最早サポートされません"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, fuzzy, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "唯一の仮引数となる %<void%> には修飾子がつきません"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "レジスタ変数 `%s' が入れ子関数の中で使われました"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma GCC pop_options%> に対応した %<#pragma GCC push_options%> がありません"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma align%> は %D の前に現れなければいけません。無視しています"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD は変数ではありません"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "%<try%> が予期されます"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "無効な初期化子です"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "式が予期されます"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "参照型に対して new を適用できません"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "\"%s\" はマクロ仮引数リストに現れてはなりません"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "%<#pragma omp section%> または %<}%> が予期されます"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "メンバ関数の名前を欠いています"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "レジスタ変数 %qD が入れ子になった関数内で使用されています"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "#pragma GCC java_exceptions の末尾にゴミ"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp taskwait%> は複合文内でのみ使用できます"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp taskwait%> は複合文内でのみ使用できます"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "#pragma GCC optimize は関数内では許可されていません"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "ret 命令は実装されていません"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "#if 式の中では文字列定数が使えません"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -68969,492 +69062,497 @@ msgstr ""
 msgid "redeclaration of %qD with different constraints"
 msgstr "`%s' が別のシンボル種として再宣言されました"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "`%s' の宣言は仮引数リストのシンボルを覆い隠します"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr ""
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] ""
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "`%s' の宣言は仮引数を覆い隠します"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "テンプレート仮引数 %q+#D です"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "ここで %q#D として再宣言されています"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "redeclared here"
 msgstr "ここで宣言されています"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "`%s' が別のシンボル種として再宣言されました"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "元の定義はここに出現しています"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "`%s' が別のシンボル種として再宣言されました"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "`%s' の引数として無効な型"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "テンプレート仮引数 %q+#D です"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "型 %qT と %qT の間での比較です"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "strftime フォーマットは引数をフォーマットできません"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "%qE 属性の引数が整数定数ではありません"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  候補では %d 個の引数が予期されますが、%d 個の引数が与えられています"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  候補では %d 個の引数が予期されますが、%d 個の引数が与えられています"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "型 %qT から型 %qT へ変換できません"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "不完全型のポインタへの間接参照"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "型 %qT の引数が %qT と一致しません"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "`%s' の引数として無効な型"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "`%s' の引数として無効な型"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "%qD のアドレスは常に %<true%> と評価されます"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr ""
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "`%s' の引数として無効な型"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "`%s' の引数として無効な型"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr ""
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr ""
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr ""
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr ""
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "`restrict' の用法が不適切です"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "クロスコンパイル時の実数値テンプレート仮引数"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, fuzzy, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "予期しない型が `id' (%s) に指定されました"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, fuzzy, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "予期しない型が `id' (%s) に指定されました"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "クロスコンパイル時の実数値テンプレート仮引数"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "予期しない型が `id' (%s) に指定されました"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "%qE から %qT へ変換できません"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "マクロ引数 \"%s\" は文字列化されます"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr ""
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "関数 %<va_start%> への引数の数が間違っています"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr ""
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "クロスコンパイル時の実数値テンプレート仮引数"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr ""
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%qD は関数テンプレートではありません"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr ""
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, fuzzy, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "空の宣言です"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "内部一貫性がありません"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "テンプレート内で `%s' を使用しています"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 msgid "first error appeared here"
 msgstr "構造体がここで定義されています"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "共用体に可変配列メンバがあります"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE は宣言の開始ではありません"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "%q#D 用のデフォルト引数の再定義です"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "メンバ関数へのポインタが呼ばれましたが、クラススコープ内ではありません"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr ""
@@ -69472,125 +69570,125 @@ msgstr ""
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "sizeof が関数型に適用されました"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "仮引数 `%s' は無効です"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, fuzzy, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "無効な宣言です"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, fuzzy, gcc-internal-format
 msgid "function returning an array"
 msgstr "関数が集合体を返しています"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, fuzzy, gcc-internal-format
 msgid "function returning a function"
 msgstr "`%s' は関数を返す関数として宣言されています"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "%<locus%> が型として定義されていません"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, fuzzy, gcc-internal-format
 msgid "forming reference to void"
 msgstr "一時オブジェクトへの参照を返そうとしています"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "不完全型のポインタへの間接参照"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "参照を参照として宣言できません"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "参照を参照として宣言できません"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, fuzzy, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "大きさゼロの配列を作ろうとしています"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "配列 %q+D は一つの要素を持っていると見なされます"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr ""
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type template"
 msgstr "宣言または式が予期されます"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, fuzzy, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "テンプレート内で `%s' を使用しています"
@@ -69598,208 +69696,208 @@ msgstr "テンプレート内で `%s' を使用しています"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "`%s' の宣言により `this' のメンバが覆い隠されます"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr ""
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "void 式の不適切な使用"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qE がここでは宣言されていません (関数内ではない)"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "関数 %<__builtin_next_arg%> への引数の数が間違っています"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qE attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "%qE 属性用に間違った数の引数が指定されました"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr ""
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr ""
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, fuzzy, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "static フィールド `%s' を欠いています"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr ""
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr ""
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, fuzzy, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "初期化子の要素が定数ではありません"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, fuzzy, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "不正な文字列定数です"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "自動テンプレート実体化を有効にする"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "自動テンプレート実体化を有効にする"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 msgid "%s %#qS"
 msgstr "%s: %s"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr ""
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr ""
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr ""
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "%s: `%s' の初期化:\n"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ は減算にメソッドへのポインタを使うことを禁じます"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, fuzzy, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "自動テンプレート実体化を有効にする"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ は減算に関数へのポインタを使うことを禁じます"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr ""
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "初期化子リストは非メンバ関数では使えません"
@@ -69811,526 +69909,581 @@ msgstr "初期化子リストは非メンバ関数では使えません"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "インラインテンプレートの明示的な実体化のみを生成する"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "'#' にマクロ仮引数名が続いていません"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "'#' にマクロ仮引数名が続いていません"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr ""
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "デストラクタを静的メンバ関数とすることはできません"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "%s=%s は数値ではありません"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "`%s' の宣言は仮引数リストのシンボルを覆い隠します"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "非テンプレート %qD がテンプレートとして使用されています"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "spec %qs が無効です"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "マクロ引数 \"%s\" は文字列化されます"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "inline に出来ると見なされていない関数です"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "間接関数 %q+D は弱い参照として宣言できません"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "マクロ引数 \"%s\" は文字列化されます"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "無効なメソッド宣言です。メソッド名が必要です"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr ""
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "命令が制約を満たしません:"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "命令が制約を満たしません:"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "命令が制約を満たしません:"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "参照型に対して new を適用できません"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "関数型に対して new を適用できません"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%qE 属性は非クラス型に関しては無視されます"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "%qE 属性は非クラス型に関しては無視されます"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "関数型に対して new を適用できません"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "関数型に対して new を適用できません"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "関数 %qE へ十分な引数がありません"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a namespace-name"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qD は名前空間名ではありません"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, fuzzy, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "`com_interface' 属性はクラス定義にのみ用いる事ができます"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "%<operator%> が予期されます"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not open Go dump file %qs: %m"
 msgid "couldn%'t look up %qs"
 msgstr "Go ダンプファイル %qs を開けません: %m"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr "予期しない型が `id' (%s) に指定されました"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT must be an object type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "%qs は %qs と併用しなければいけません"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "テンプレート引数が予期されます"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "ビットフィールド %qD を関数型として宣言できません"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "enum constant defined here"
 msgid "%<consteval%> block defined here"
 msgstr "列挙型定数がここで定義されています"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "無効な PHI 引数です"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<decltype%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "%<decltype%> が予期されます"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "packed 属性は必要ありません"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "関数 %qE へ十分な引数がありません"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "整数式が予期されます"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "整数式が予期されます"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown metafunction %qD"
 msgstr "不明な spec 関数 %qs です"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "オーバーロードされた仮想関数名について警告する"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "仮引数宣言の中で `::' を使えません"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "add %<constexpr%>"
 msgstr "重複した %<const%> です"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "組み込み関数 %qD は単一の引数をとります"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "真偽式が予期されます"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr ""
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "すべてのコンストラクタとデストラクタが非公開の場合に警告する"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "関数 `%s' に対して不適切な保存クラス"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr "%qs を呼び出しで使用されるレジスタとして使用できません"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, fuzzy, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr "計算式内のオーバーフローに関して警告する"
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD は関数テンプレートではありません"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -70661,590 +70814,590 @@ msgstr "インスタンス化されない型に対する無効な操作です"
 msgid "invalid base-class specification"
 msgstr "無効な宣言です"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "無名共用体内に保護されたメンバ %q+#D があります"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr ""
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "alloc_size パラメータが範囲外です"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments"
 msgstr "合っていない引数です"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr ""
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "要求されたメンバ `%s' は多重継承グラフの中で曖昧です"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "定数式がオーバーフローしました"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, fuzzy, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "レジスタ '%c' が不明です"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "配列の添字が整数型ではありません"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "右シフト回数が負の数です"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "仮引数宣言の中の記憶域クラス指定は無効です"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "ISO C++ はメンバ関数への `sizeof' の適用を禁じます"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "ISO C++ はメンバ関数への `sizeof' の適用を禁じます"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "ISO C++ はメンバ関数への `sizeof' の適用を禁じます"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "constructor priorities are not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "コンストラクタのプロパティはサポートされません"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE は %<reduction%> 用の無効な型を持っています"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "整数式が予期されます"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "インスタンス変数 `%s' は private と宣言されています"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "インスタンス変数 `%s' は private と宣言されています"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "%qE は句 %qs 内では変数ではありません"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "\"%s\" は C++ の演算子であり、マクロ名として使用することはできません"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length traits arrays are not supported"
 msgstr "可変長配列が使用されています"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "%qs 句が多すぎます"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "添え字は整数でなければいけません"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tree%> がポインタ型として定義されていません"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "%qE の列挙値が整数定数式ではありません"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "静的アサーションに失敗しました: %E"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr ""
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "%<__builtin_prefetch%> への第三引数は定数でなければいけません"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "<未解決オーバーロードされた関数型>"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_next_arg%> が引数無しで呼び出されました"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_next_arg%> が引数無しで呼び出されました"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a field reference"
 msgid "%qs argument %qT is a reference"
 msgstr "引数はフィールド参照でなければいけません"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "クラスタイプ項を欠いています"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "カンマ演算子の左側の式に効力がありません"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "%<__builtin_prefetch%> への第二引数は定数でなければいけません"
@@ -71252,353 +71405,353 @@ msgstr "%<__builtin_prefetch%> への第二引数は定数でなければいけ
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "マクロ引数内でディレクトリを使うことはできません"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr ""
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 msgid " declared here"
 msgstr "ここで宣言されています"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT is a floating-point type"
 msgstr "%qD は関数テンプレートではありません"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT is a fixed-point type"
 msgstr "%qD は関数テンプレートではありません"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%s に `%s' という名前のメンバはありません"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T がポインタデータメンバを持っています"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "%qT と %qT の比較です"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs は gcov データファイルではありません"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "基底クラス %q#T が非仮想デストラクタを持っています"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD は変数ではありません"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "`com_interface' 属性はクラス定義にのみ用いる事ができます"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "`com_interface' 属性はクラス定義にのみ用いる事ができます"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "`java_interface' 属性は Java クラス定義に対してのみ用いる事ができます"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "%qE 属性は変数および関数へのみ適用できます"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "%s: オプション `%s' には引数が必要です\n"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "%qE 属性は型に適用できません"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "空の宣言内に %<inline%> があります"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT はテンプレート型ではありません"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> がビットフィールドに適用されています"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "%qs が無名仮引数用に指定されました"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %qD but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "仮引数 %qD 用の宣言がありますが、そのような仮引数はありません"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "要求された init_priority は整数型の定数ではありません"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, fuzzy, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "init_priority 属性はクラス型オブジェクトのファイルスコープ定義でのみ使えます"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "要求された init_priority が範囲外です"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "要求された init_priority は内部で使用するために予約されています"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "`%s' の宣言により `this' のメンバが覆い隠されます"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "%s: オプション `%s' には引数が必要です\n"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%T::%D%> は有効な宣言子ではありません"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%T::%D%> は有効な宣言子ではありません"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "%qE 属性は非クラス型に関しては無視されます"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%qE 属性は関数へのみ適用出来ます。%s へは適用できません"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "`%s' 属性は関数に対してのみ適用されます"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "%qE 属性の引数が文字列定数ではありません"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "暗黙の関数宣言に関して警告する"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "%qE は変数にのみ適用できます"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "%qs が無名仮引数用に指定されました"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "関数パラメータ"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr "ベクトル型の delete ですが、ポインタでも配列型でもありません"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "関数が文字列型を返しません"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "Tree 検査: %s があるべき所に %s があります(%s 内, %s:%d)"
@@ -71797,807 +71950,812 @@ msgstr "%qT は %qE という名前のメンバを持っていません"
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT は %qE という名前のメンバを持っていません"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr ""
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "%s に `%s' という名前のメンバはありません"
+
+#: cp/typeck.cc:3781
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "メンバ関数の名前を欠いています"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr ""
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "メンバへのポインタでの無効な `%s' の使用"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "メンバへのポインタでの無効な `%s' の使用"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "メンバへのポインタでの無効な `%s' の使用"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "配列参照での添字を欠いています"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, fuzzy, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "`register' と宣言された配列に添字をつけようとしています"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "添字をつけられた値が配列でもポインタでもありません"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, fuzzy, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "メンバへのポインタ構築の使用でオブジェクトを欠いています"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 msgid "no default version in scope"
 msgstr "無効なバージョン番号 %qs です"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ はプログラムの中から `::main' を呼び出すことを禁じます"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "\"%s\" はマクロ名としては使えません"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "関数に対する引数が多すぎます"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "関数への引数が少なすぎます"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, fuzzy, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "仮引数が不完全型です"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, fuzzy, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "仮引数が不完全型です"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "%qD のアドレスは常に %<true%> と評価されます"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr ""
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, fuzzy, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "関数ポインタが計算で使われました"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ はポインタと整数との比較を禁じます"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "%qT と %qT の比較です"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "非浮動小数点引数での順序付けられない比較です"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "関数へ引数を渡すときに %qT から %qT へ暗黙的に変換されます"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, fuzzy, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "二項演算子 %s が不適切です"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ は減算に `void *' 型のポインタを使うことを禁じます"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ は減算に関数へのポインタを使うことを禁じます"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ は減算にメソッドへのポインタを使うことを禁じます"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "ポインタ演算で不完全型へのポインタを使うことは無効です"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "メンバへのポインタでの無効な `%s' の使用"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ は非左辺値式へのキャストのアドレスを取ることを禁じます"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ は非左辺値式へのキャストのアドレスを取ることを禁じます"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ は非左辺値式へのキャストのアドレスを取ることを禁じます"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "一時オブジェクトのアドレスを取ろうとしています"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ は `::main' 関数のアドレスを取ることを禁じます"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, fuzzy, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "ポインタを参照として宣言できません"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "ビットフィールド %qD のアドレスを取得できません"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<void%> 型の式のアドレスを取得しています"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ は enum の %s を禁じます"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ は enum の %s を禁じます"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "不完全型へのポインタに対する演算"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "不完全型のポインタへの間接参照"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ は減算に `void *' 型のポインタを使うことを禁じます"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ は減算に `void *' 型のポインタを使うことを禁じます"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, fuzzy, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "`this' は右辺値式であり、そのアドレスを取ることはできません"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "無名基底クラスの初期設定子が曖昧です"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr ""
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr ""
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr ""
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "初期化子リストは複合式として取り扱われました"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "関数 `%s' に対して不適切な保存クラス"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "関数戻り値の型修飾子は無視されました"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "戻り値の型が不完全型です"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 msgid "converting from %qH to %qI"
 msgstr "NaN から整数への変換です"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 msgid "cast from %qH to %qI loses precision"
 msgstr "%s: 全体的な精度の低下"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "型が全く異なるポインタの比較でキャストを欠いています"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "キャストによってポインタが示す型の要求アラインメントが増加します"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ は関数ポインタとオブジェクトポインタの間でのキャストを禁じます"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, fuzzy, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "不完全な typedef `%s' の使用は不適切です"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C は共用体型へのキャストを禁じます"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, fuzzy, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "関数 `%s' に対して不適切な保存クラス"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "%qE を型 %qT から型 %qT へ変換できません"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr ""
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr ""
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "%d 番目の引数が `%s' の型と互換性がありません"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 msgid "array used as initializer"
 msgstr "配列の不正な初期化"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "代入として無効な左辺値です"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   ポインタからメンバ関数への変換で"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, fuzzy, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   ポインタからメンバへの変換で"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "無効なバージョン番号形式"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 msgid "cannot convert %qH to %qI in return"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "ポインタ型へ変換できません"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "format 属性をの候補となりそうな関数について警告する"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "引数 %d 個の `%s' を渡します"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "一時オブジェクトへの参照を返そうとしています"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "一時オブジェクトへの参照を返そうとしています"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "非左辺値への参照が返されました"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "要求された大域レジスタ変数 `%s' のアドレス"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "要求された大域レジスタ変数 `%s' のアドレス"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "return 文に十分な値がありません"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "return 文に十分な値がありません"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "デストラクタから値を返そうとしています"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "コンストラクタの関数 try ブロックのハンドラからは return できません"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "コンストラクタから値を返そうとしています"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, fuzzy, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "戻り型が関数で、`return' に値がありません"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 msgid "returning initializer list"
 msgstr "初期化子がありません"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "戻り型が関数で、`return' に値がありません"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "無効なメソッド宣言です。メソッド名が必要です"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "無効な %%s 値"
@@ -73004,17 +73162,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "不明な property 属性です"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "領域 `%s' は関数として宣言されています"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -73040,44 +73198,44 @@ msgstr "初期化子を欠いています"
 msgid "the address of %qD will never be %<null%>"
 msgstr "%qD のアドレスは常に %<true%> と評価されます"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "ポインタを参照として宣言できません"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 msgid "nested function missing body"
 msgstr "オブジェクトコードに関数名を格納する"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "間接関数 %q+D を弱いとして宣言できません"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "レジスタ変数 %qD が入れ子になった関数内で使用されています"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "参照を参照として宣言できません"
@@ -73156,34 +73314,34 @@ msgstr "%qs への有効な引数は次の通りです: %s"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "%qs への有効な引数は次の通りです: %s"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "%s を書き込み用に開けません: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "出力ファイル %s を開いています: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "%s を書き込み用に開けません: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "依存関係ファイル %s を開いています: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -73284,7 +73442,7 @@ msgstr "不明な TLS モデル %qs です"
 msgid "%qs is not an associative array"
 msgstr "%qD は変数ではありません"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -73300,23 +73458,23 @@ msgstr "%qD は通常は非静的関数です。"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs は %qs 用には有効ではありません"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "%s:%d:   %qs から再帰的に実体化されました\n"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "定数式内でオーバーフローしました"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "定数式内でオーバーフローしました"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "定数式がオーバーフローしました"
@@ -73409,17 +73567,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "入れ子になった関数はこのターゲットではサポートされていません"
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "-fno-rtti が指定されると typeid を使えません"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -73743,8 +73901,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74021,7 +74179,7 @@ msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "無効なビット列初期化子です"
@@ -74096,7 +74254,7 @@ msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
@@ -74236,7 +74394,7 @@ msgstr "可変長オブジェクトは初期化されないことになるでし
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr ""
@@ -74251,7 +74409,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
@@ -74392,8 +74550,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74492,9 +74650,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -74509,12 +74667,12 @@ msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
@@ -74609,618 +74767,618 @@ msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "`%s' は 0 か 2 個の引数しかとりません"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "`%s' オプションに対する引数がありません"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "関数 `%s' への引数が少なすぎます"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "無効な文字定数が #if にあります"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "最後の引数は 2 ビット即値でなければいけません"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "引数は定数でなければいけません"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr ""
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "戻り型が void の関数で、`return' に値があります"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "セクション属性は `%s' には使えません"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "フォーマットへの引数が多すぎます"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "フォーマットへの引数が多すぎます"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "フォーマットへの引数が多すぎます"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr ""
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "引数1と引数2が異なる型を持っています"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -75285,12 +75443,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -75340,2058 +75498,2058 @@ msgstr ""
 msgid "Simplification error"
 msgstr "gimplification に失敗しました"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "無効なビット列初期化子です"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "無効なビット列初期化子です"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "無効なビット列初期化子です"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "空のスカラー初期化子です"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "スカラー初期化子内に余分な要素があります"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "述語は識別子でなければなりません"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "ファイル \"%s\" に戻るはずでした"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "長さ 0 の初期化は推奨されません"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "配列初期化子内の要素が多すぎます"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "配列初期化子内の要素が多すぎます"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "引数の型が異なります"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "無効な文字定数が #if にあります"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "%qD は既に %qT 内で定義されています"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr ""
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "データ領域 '%s' は前の宣言と矛盾します"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr ""
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "引数は定数でなければいけません"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "初期化子を欠いています"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "多次元配列は初期化子で初期化することができません"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "配列を仮引数リストによって初期化しようとしています"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "シンボルの頭にアンダースコアをつける"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "ANSI C++ は定数でない集合体の初期化子式を禁じます"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "無効な文字定数が #if にあります"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "関数を inline にできません"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "ポインタ型へ変換できません"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "重複した初期化子"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr ""
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "長さ 0 の初期化は推奨されません"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "-traditional は C++ では受け付けられません"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "`%s' の extern 宣言がネストしています"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "正式な仮引数項を欠いています"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "長さ 0 の初期化は推奨されません"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "長さ 0 の初期化は推奨されません"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "VAX 浮動小数では丸めモードを利用できません"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "VAX 浮動小数では丸めモードを利用できません"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "%<operator new%> の第一引数はデフォルト引数を持っていてはいけません"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "%qE の列挙値が整数定数式ではありません"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "無効な型引数です"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr "メソッド定義がクラスコンテキスト内ではありません"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "定義の後で `%s' 属性をセットすることはできません"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "定義の後に %qE 属性を設定できません"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "定義した後に %qT に適用される属性を無視しています"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "定義の後に %qE 属性を設定できません"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "定義の後に %qE 属性を設定できません"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "大域 register 変数が関数定義の後ろにあります"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "定義の後で `%s' 属性をセットすることはできません"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "定義の後で `%s' 属性をセットすることはできません"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 msgid "Missing symbol"
 msgstr "数値がありません"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "不明なレジスタ名です: %s"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "仮引数名が省略されています"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "ファイル \"%s\" に戻るはずでした"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "仮引数名が省略されています"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "プロシージャ開始と終了のスケジュールを行なわない"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "配列の次元を宣言で指定することはできません"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "仮引数リストに仮引数名がありません"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "%s: オプション `%s' には引数が必要です\n"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "`%s' の extern 宣言がネストしています"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "section 属性はローカル変数に対しては指定できません"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "行番号 %u に戻るはずでした"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "式内"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr ""
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr ""
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "文が予期されます"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr ""
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr ""
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "無効なビット列初期化子です"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "'%s' トークンの所で文法エラー"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "式文が無効です"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "switch 文の中でラベル `%s' が重複しています"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "行番号 %u に戻るはずでした"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "switch 文の中でラベル `%s' が重複しています"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "%<(%> が予期されます"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "述語は識別子でなければなりません"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "ポインタ型へ変換できません"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "switch 文の中でラベル `%s' が重複しています"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "配列を仮引数リストによって初期化しようとしています"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "式文が無効です"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "式文が無効です"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "式内"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "読み込んだ状態ファイル %s を閉じるのに失敗しました [%s]"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "`%s' の extern 宣言がネストしています"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "関数を inline にできません"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "空の宣言です"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "\"%s\" は C++ の演算子であり、マクロ名として使用することはできません"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "\"%s\" は C++ の演算子であり、マクロ名として使用することはできません"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "%qD は既に定義されています"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "反復子 `%s' は非整数型です"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "`*' の前に型の名前があるべきです"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "重複するアクセス指定子"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "重複するアクセス指定子"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "識別子が必要です"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "')' が必要です"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "行番号 %u に戻るはずでした"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "%<::%> が予期されます"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr ""
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "%<=%> が予期されます"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "不明なレジスタ名です: %s"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr "重複するアクセス指定子"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "%<,%> が予期されます"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "不明なレジスタ名です: %s"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "プロシージャ開始と終了のスケジュールを行なわない"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "`%s' の宣言に二つ以上のデータ型が指定されました"
@@ -77534,408 +77692,408 @@ msgstr "不明なレジスタ名です: %s"
 msgid "IM part_ref at %C"
 msgstr "不明なレジスタ名です: %s"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "ANSI C++ は定数でない集合体の初期化子式を禁じます"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "ANSI C++ は定数でない集合体の初期化子式を禁じます"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "関数を inline にできません"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "`%s' はその定義の前にプロトタイプなしで使われました"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "配列 `%s' の大きさは非整数型"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "二重にクォートされた文字列は #if 式内では使えません"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr ""
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr "(`%s' の初期化は不完全です)"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "キャストは関数型を指定しています"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr ""
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -77943,197 +78101,197 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "ANSI C++ は定数でない集合体の初期化子式を禁じます"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "`asm' の引数が定数文字列ではありません "
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "`asm' の引数が定数文字列ではありません "
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "`asm' の引数が定数文字列ではありません "
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "`asm' の引数が定数文字列ではありません "
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -78154,7 +78312,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -78215,42 +78373,42 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "%qT と %qT の比較です"
@@ -78375,12 +78533,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -78806,307 +78964,312 @@ msgstr "フォーマット引数がポインタではありません (引数 %d)
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "`%s' オプションに対する引数がありません"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr ""
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr ""
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, fuzzy, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, fuzzy, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "`%s' の引数として無効な型"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "%q+D が未定義シンボル %qE の別名となっています"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "値をベクトルには変換できません"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "式の中の文に不完全型があります"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "`%s' オプションに対する引数がありません"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "引数は定数でなければいけません"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr ""
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr ""
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "section 属性はローカル変数に対しては指定できません"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr ""
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "関数 `%s' に対する引数が多すぎます"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "関数 `%s' に対する引数が多すぎます"
@@ -79295,7 +79458,7 @@ msgstr "NaN から整数への変換です"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "値をベクトルには変換できません"
@@ -79841,7 +80004,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -80012,12 +80175,12 @@ msgstr "式の整数がオーバーフローしました"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -80519,7 +80682,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr ""
@@ -81032,92 +81195,92 @@ msgstr "switch 文の中でラベル `%s' が重複しています"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr ""
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "式内"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "'%s' トークンの所で文法エラー"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "文が予期されます"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -82103,7 +82266,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -82139,12 +82302,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -82621,7 +82784,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "式の中の文に不完全型があります"
@@ -82641,7 +82804,7 @@ msgstr ""
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -82671,17 +82834,17 @@ msgstr "セクション属性は `%s' には使えません"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "値をベクトルには変換できません"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "値をベクトルには変換できません"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -82801,8 +82964,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -82882,7 +83045,7 @@ msgstr "%qD は変数ではありません"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "%qD は変数ではありません"
@@ -82905,7 +83068,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -82945,7 +83108,7 @@ msgstr "%qE がデータ句内で二回以上出現しています"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE がデータ句内で二回以上出現しています"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -83260,598 +83423,608 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "初期化子の要素が定数式ではありません"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "環境変数 %qs が定義されていません"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "環境変数 %qs が定義されていません"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "長さ 0 の初期化は推奨されません"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "式が予期されます"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "レジスタ変数 `%s' が入れ子関数の中で使われました"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "レジスタ変数 `%s' が入れ子関数の中で使われました"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "関数 `%s' に対して不適切な保存クラス"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "不十分な型情報"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "整数 0 とポインタとの順序比較です"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%<num_threads%> 値は正でなければいけません"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "静的アサーション内の式が整数定数式ではありません"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, fuzzy, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "%qD は変数ではありません"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, fuzzy, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "セクション属性は `%s' には使えません"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, fuzzy, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "長さ 0 の初期化は推奨されません"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "配列の次元を宣言で指定することはできません"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -84515,62 +84688,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr ""
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -84578,7 +84751,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -85037,1081 +85210,1081 @@ msgstr "'%s' トークンの所で文法エラー"
 msgid "%qs at %C is not a variable"
 msgstr "\"%s\" は正常なファイル名ではありません"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "明示的なテンプレート引数リストは許可されていません"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "二重にクォートされた文字列は #if 式内では使えません"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "右シフト回数が負の数です"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr ""
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "インスタンス変数の仕様が一貫していません"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "インスタンス変数の仕様が一貫していません"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "非メンバ `%s' を `mutable' とは宣言できません"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "関数 `%s' に対する引数が多すぎます"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr ""
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "ラベル %s があらゆる関数の外側で参照されました"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "`%s' の引数として無効な型"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "`%s' の引数として無効な型"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "%s: オプション `%s' はあいまいです\n"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr ""
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "spec 関数 %qs の引数内でエラーが発生しました"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "数値型が予期されます"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "`%s' オプションに対する引数がありません"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "<未解決オーバーロードされた関数型>"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "%qE は廃止されました"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "<未解決オーバーロードされた関数型>"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "%qE は廃止されました"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "shared と mdll とは共存できません"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "インライン関数をインライン化できない場合に警告する"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "符号無しの式 >= 0 という比較は常に true です"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "無効なオプション %s"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "inconsistent operand constraints in an %<asm%>"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "%<asm%> 内の被演算子制約に一貫性がありません"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr "無効なオプション %s"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr "無効なオプション %s"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "%qs は %qs と併用しなければいけません"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "不明な型名 %qE です"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "<不明な演算子>"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "フォーマット引数がポインタではありません (引数 %d)"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "配列参照での添字を欠いています"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "無効な参照型です"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "引数は定数でなければいけません"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "式の中の文に不完全型があります"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "引数は定数でなければいけません"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "引数は定数でなければいけません"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "式の中の文に不完全型があります"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "要求されたアラインメントが大きすぎます"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "配列参照での添字を欠いています"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "不正な被演算子が検出されました"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -86120,12 +86293,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -86134,414 +86307,414 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "`%s' の宣言は関数の配列"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%qE は廃止されました"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "無効な参照型です"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "添え字は整数でなければいけません"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "switch 文の中でラベル `%s' が重複しています"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "弱い参照属性は別名属性より前に出現しなければいけません"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "section 属性はローカル変数に対しては指定できません"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "セクション属性は `%s' には使えません"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "値をベクトルには変換できません"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "数値型が予期されます"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "switch 文の中でラベル `%s' が重複しています"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "変数 %qD が設定されましたが使用されていません"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "\"%s\" は C++ の演算子であり、マクロ名として使用することはできません"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "式文が無効です"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -86550,314 +86723,314 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "式の中の文に不完全型があります"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "spec 関数 %qs の引数内でエラーが発生しました"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "\"%s\" は C++ の演算子であり、マクロ名として使用することはできません"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "仮引数 %u が void 型を持っています"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "数値型が予期されます"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "無効なオプション %s"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr ""
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -86865,212 +87038,212 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "コンストラクタ %qs 内"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr ""
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "値をベクトルには変換できません"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "無効なオプション %s"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -87078,1056 +87251,1056 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "配列 `%s' の大きさが大きすぎます"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s 内、位置 %s:%d"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "可変長オブジェクトは初期化されないことになるでしょう"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "式の中の文に不完全型があります"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "ANSI C++ は定数でない集合体の初期化子式を禁じます"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "%qD は既に定義されています"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr "読み込んだ状態ファイル %s を閉じるのに失敗しました [%s]"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "%qE 属性は %s 属性と競合します"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "%s に互換性のない型"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "関数 `%s' への引数が少なすぎます"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "関数を inline にできません"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "式文が無効です"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, fuzzy, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "データ領域 '%s' は前の宣言と矛盾します"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "`%s' に `extern' と初期化子の両方があります"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "初期化子内に非定数の配列インデックスがあります"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "ラベル `%s' が定義されましたが使われていません"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "ラベル `%s' が定義されましたが使われていません"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr ""
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "メソッド仕様内での構文解析エラー"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -88147,97 +88320,97 @@ msgstr "存在しないディレクトリ \"%s\" を無視します\n"
 msgid "%qs is not a directory"
 msgstr "%s は型 %s ではありません (引数 %d)"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "文字定数の中でファイルの終端を検出しました"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "無効な文字定数が #if にあります"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "ファイル \"%s\" から出ましたが入っていません"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "プリプロセス命令中に %s があります"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "出力ファイル `%s' を open できません"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "出力ファイル `%s' を open できません"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "入力ファイル %s を close できません"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "%qs は有効な出力ファイルではありません"
@@ -88402,218 +88575,218 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "`%s' オプションに対する引数がありません"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "`%s' の第二引数は `char **' とすべきです"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "配列のサイズが大きすぎます"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "定数式がオーバーフローしました"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Trampoline は、まだ実装されていません"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "関数呼び出しが集合体の値を持っています"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "`%s' の引数として無効な型"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -88951,74 +89124,74 @@ msgstr "行番号 %u に戻るはずでした"
 msgid "Labeled DO statement at %L"
 msgstr "式内"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -89048,29 +89221,35 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "initializer element is not a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "初期化子の要素が定数式ではありません"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "一時オブジェクトへの参照を返そうとしています"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -89172,113 +89351,113 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr "ANSI C++ は定数でない集合体の初期化子式を禁じます"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "仮引数 %u が void 型を持っています"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "フォーマットへの引数が多すぎます"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "インスタンス変数 `%s' は %s と宣言されています"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "仮引数 `%s' が void と宣言されています"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "FPU レジスタ内の機能の値を返す"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "DW_LOC_OP %s は実装されていません"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -89308,12 +89487,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr ""
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "関数 `%s' への引数が少なすぎます"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -89329,12 +89508,12 @@ msgstr "言語 %s は認識できません"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "`__builtin_args_info' の引数は定数でなければなりません"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "環境変数 %qs が定義されていません"
@@ -89359,183 +89538,183 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 msgid "optional class parameter"
 msgstr "無効な PHI 引数です"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "unhandled expression type"
 msgstr "被演算子として無効な式です"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 msgid "unhandled expression"
 msgstr "式が予期されます"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 msgid "Used here"
 msgstr "共用体がここで定義されています"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "プロシージャ開始と終了のスケジュールを行なわない"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "最後の引数は 2 ビット即値でなければいけません"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "コンストラクタを静的メンバ関数とすることはできません"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "代入として無効な左辺値です"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "組み込み関数 `%s' は非関数として宣言されました"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "値をベクトルには変換できません"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "呼び出されたオブジェクトは関数ではありません"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "-f%s と -msdata=%s は併用できません"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "`%s' の引数として無効な型"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "メソッドは関数ポインタに変換できません"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "右シフト回数が負の数です"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "型名用に記憶域クラスが指定されました"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "-pipe は実装されていません"
@@ -89880,7 +90059,7 @@ msgstr ""
 msgid "two or more sections for %s"
 msgstr ""
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -90217,32 +90396,32 @@ msgstr "配列の不正な初期化"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "要求された整列が定数ではありません"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "要求された整列が 2 の累乗ではありません"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "要求された整列が定数ではありません"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -92555,10 +92734,6 @@ msgstr ""
 #~ msgid "static field %qD is not mappable"
 #~ msgstr "\"%s\" は正常なファイル名ではありません"
 
-#, fuzzy, gcc-internal-format
-#~ msgid "lambda-expression in template parameter type"
-#~ msgstr "`%s' の宣言は仮引数リストのシンボルを覆い隠します"
-
 #, fuzzy, gcc-internal-format
 #~ msgid "lambda templates are only available with %<-std=c++14%> or %<-std=gnu++14%>"
 #~ msgstr "制限のない共用体は -std=c++0x または -std=gnu++0x を指定した時のみ使用できます"
@@ -92726,10 +92901,6 @@ msgstr ""
 #~ msgid "%s functions cannot be abstract"
 #~ msgstr "割り込み関数は引数無しでなければいけません"
 
-#, fuzzy, gcc-internal-format
-#~ msgid "cannot override a non-virtual function"
-#~ msgstr "オーバーロードされた仮想関数名について警告する"
-
 #, fuzzy, gcc-internal-format
 #~ msgid "cannot be both final and abstract"
 #~ msgstr "%qE は %<mips16%> と %<nomips16%> 属性の両方を持つことは出来ません"
--- a/src/gcc/po/ka.po
+++ b/src/gcc/po/ka.po
@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc-14.2.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2024-08-28 06:11+0200\n"
 "Last-Translator: Temuri Doghonadze <temuri.doghonadze@gmail.com>\n"
 "Language-Team: Georgian <(nothing)>\n"
@@ -1254,12 +1254,12 @@ msgstr "მეტსახელი:"
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr ""
@@ -2078,13 +2078,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2532,7 +2532,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr ""
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr ""
@@ -2607,7 +2607,7 @@ msgstr ""
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2644,7 +2644,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr ""
@@ -2754,7 +2754,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2800,7 +2800,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5062,7 +5062,7 @@ msgstr ""
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5417,7 +5417,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5722,212 +5722,217 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, no-c-format
 msgid "This option is deprecated."
 msgstr ""
@@ -11249,7 +11254,7 @@ msgstr ""
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18161,79 +18166,79 @@ msgstr ""
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 msgid "argument must be passed by copying"
 msgstr ""
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 msgid "volatile function type"
 msgstr ""
 
-#: calls.cc:2614
+#: calls.cc:2615
 msgid "nested function"
 msgstr ""
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr ""
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support %s"
 msgid "frontend does not support sibling call"
 msgstr "%s -ს %s-ის მხარდაჭერა არ გააჩნია"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 msgid "variable size arguments"
 msgstr ""
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr ""
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr ""
 
@@ -18349,12 +18354,12 @@ msgstr ""
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr ""
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19584,11 +19589,11 @@ msgstr ""
 msgid "this is the insn:"
 msgstr ""
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 msgid "unable to reload address in "
 msgstr ""
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr ""
 
@@ -19803,7 +19808,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr ""
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<ანონიმური>"
@@ -20183,20 +20188,20 @@ msgstr ""
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr ""
@@ -20241,71 +20246,71 @@ msgstr ""
 msgid "invalid address mode"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 msgid "postincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr ""
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20322,13 +20327,13 @@ msgid "invalid %%r value"
 msgstr ""
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr ""
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr ""
@@ -20343,7 +20348,7 @@ msgstr ""
 msgid "invalid %%h value"
 msgstr ""
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr ""
@@ -20358,7 +20363,7 @@ msgstr ""
 msgid "invalid %%M value"
 msgstr ""
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr ""
@@ -20688,7 +20693,7 @@ msgstr ""
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -20933,126 +20938,126 @@ msgstr ""
 msgid "Expected register or constant integer."
 msgstr ""
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr ""
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr ""
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr ""
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr ""
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr ""
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr ""
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr ""
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr ""
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr ""
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr ""
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr ""
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr ""
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr ""
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr ""
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr ""
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr ""
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr ""
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr ""
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr ""
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr ""
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21131,9 +21136,9 @@ msgstr ""
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr ""
@@ -21198,7 +21203,7 @@ msgid "insn contains an invalid address !"
 msgstr ""
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr ""
 
@@ -21273,7 +21278,7 @@ msgstr ""
 msgid "invalid %%H value"
 msgstr ""
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr ""
@@ -21323,32 +21328,32 @@ msgstr ""
 msgid "unsupported memory expression:"
 msgstr ""
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, c-format
 msgid "invalid vector operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, c-format
 msgid "invalid register number for 'N' modifier"
 msgstr ""
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr ""
@@ -21405,7 +21410,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr ""
@@ -21445,7 +21450,7 @@ msgstr ""
 msgid "invalid %%k value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr ""
@@ -21475,17 +21480,17 @@ msgstr ""
 msgid "invalid %%u value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr ""
@@ -21694,27 +21699,27 @@ msgstr ""
 msgid "floating-point constant not a valid immediate operand"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, c-format
 msgid "'h' operand is not SImode register"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr ""
@@ -21770,24 +21775,24 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr ""
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr ""
 
@@ -21819,7 +21824,7 @@ msgstr ""
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr ""
 
@@ -21844,8 +21849,8 @@ msgstr ""
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr ""
@@ -21873,7 +21878,7 @@ msgstr ""
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr ""
@@ -21881,7 +21886,7 @@ msgstr ""
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr ""
@@ -21901,13 +21906,13 @@ msgstr ""
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr ""
@@ -21916,7 +21921,7 @@ msgstr ""
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -21933,13 +21938,13 @@ msgstr ""
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr ""
@@ -21949,7 +21954,7 @@ msgstr ""
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr ""
@@ -21959,18 +21964,18 @@ msgid "expected %<.%>"
 msgstr ""
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr ""
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr ""
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr ""
@@ -21980,45 +21985,45 @@ msgstr ""
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr ""
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr ""
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr ""
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr ""
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr ""
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr ""
@@ -22044,7 +22049,7 @@ msgstr ""
 msgid "  after user-defined conversion:"
 msgstr ""
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] ""
@@ -22144,7 +22149,7 @@ msgstr ""
 msgid "<statement>"
 msgstr ""
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr ""
@@ -22171,252 +22176,288 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr ""
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr ""
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-msgid "array element not a constant integer"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
 msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr ""
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+msgid "array element not a constant integer"
+msgstr ""
+
+#: cp/reflect.cc:1117
 msgid "reflection does not represent a type"
 msgstr ""
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 msgid "reflection does not have template arguments"
 msgstr ""
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 msgid "reflection does not represent a function or function type"
 msgstr ""
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 msgid "operators argument is not a valid operator"
 msgstr ""
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 msgid "reflection does not have a type"
 msgstr ""
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr ""
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr ""
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr ""
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr ""
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 msgid "reflection not suitable for alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 msgid "alignment_of on function type"
 msgstr ""
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr ""
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr ""
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr ""
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr ""
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 msgid "reflection does not represent a template"
 msgstr ""
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 msgid "invalid argument to can_substitute"
 msgstr ""
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 msgid "type is not object or reference type"
 msgstr ""
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 msgid "name is not a valid identifier"
 msgstr ""
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr ""
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 msgid "both alignment and bit_width specified"
 msgstr ""
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr ""
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr ""
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr ""
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr ""
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+msgid "reflection does not have non-array object type"
+msgstr ""
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr ""
+
+#: cp/reflect.cc:6526
+msgid "current scope does not represent a class nor a member function"
+msgstr ""
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr ""
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr ""
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 msgid "not a complete class type"
 msgstr ""
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 msgid "value cannot be extracted"
 msgstr ""
 
@@ -22460,52 +22501,52 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr ""
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr ""
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr ""
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr ""
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr ""
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr ""
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr ""
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -22521,61 +22562,61 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr ""
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 msgid "BOZ literal constant"
 msgstr ""
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr ""
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected argument"
 msgid "Procedure unexpected as argument"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr ""
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -22645,7 +22686,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr ""
 
@@ -22654,17 +22695,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -22840,11 +22881,11 @@ msgstr ""
 msgid "implied END DO"
 msgstr ""
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "მინიჭება"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr ""
 
@@ -22852,125 +22893,125 @@ msgstr ""
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr ""
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr ""
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr ""
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr ""
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr ""
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr ""
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr ""
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr ""
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr ""
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr ""
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr ""
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -22979,31 +23020,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -23066,27 +23107,27 @@ msgstr ""
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23183,7 +23224,7 @@ msgid "expected boolean type"
 msgstr ""
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr ""
@@ -23246,7 +23287,7 @@ msgstr "არასაკმარისი არგუმენტები"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr ""
@@ -23641,7 +23682,7 @@ msgstr ""
 msgid "target OS does not support unaligned accesses"
 msgstr ""
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr ""
@@ -23884,13 +23925,13 @@ msgstr ""
 msgid "Global declarative %s for %s"
 msgstr ""
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24051,12 +24092,12 @@ msgstr ""
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr ""
@@ -24481,8 +24522,8 @@ msgstr ""
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr ""
@@ -24499,7 +24540,7 @@ msgstr ""
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr ""
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr ""
@@ -24509,7 +24550,7 @@ msgstr ""
 msgid "expected %i or more, found %i"
 msgstr ""
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr ""
@@ -24592,12 +24633,12 @@ msgstr ""
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -24713,133 +24754,133 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, gcc-internal-format
 msgid "location is after end of function"
 msgstr ""
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr ""
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr ""
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr ""
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr ""
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr ""
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr ""
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr ""
@@ -24849,7 +24890,7 @@ msgstr ""
 msgid "offset %qwi outside bounds of constant string"
 msgstr ""
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr ""
@@ -24952,7 +24993,7 @@ msgstr ""
 msgid "illegal argument 0 to %qs"
 msgstr ""
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr ""
@@ -25026,12 +25067,12 @@ msgstr ""
 msgid "cannot tail-call: %s"
 msgstr ""
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr ""
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr ""
@@ -25675,342 +25716,342 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr ""
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr ""
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr ""
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr ""
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr ""
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr ""
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr ""
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr ""
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr ""
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr ""
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr ""
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr ""
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr ""
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr ""
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr ""
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr ""
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr ""
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr ""
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr ""
@@ -26774,17 +26815,17 @@ msgstr ""
 msgid "impossible constraint in %<asm%>"
 msgstr ""
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "ფუნქცია აგრეგატს აბრუნებს"
@@ -27453,7 +27494,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -27493,7 +27534,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr ""
@@ -27513,24 +27554,24 @@ msgstr ""
 msgid "function may return address of local variable"
 msgstr ""
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr ""
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -28420,7 +28461,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr ""
@@ -28490,204 +28531,204 @@ msgstr ""
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, gcc-internal-format
 msgid "call to %qD here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr ""
@@ -29490,346 +29531,346 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr ""
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr ""
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr ""
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr ""
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr ""
@@ -29849,7 +29890,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr ""
@@ -30079,12 +30120,12 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr ""
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr ""
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -30451,7 +30492,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -31833,22 +31874,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr ""
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -32786,167 +32827,167 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr ""
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr ""
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr ""
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr ""
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr ""
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr ""
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr ""
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr ""
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr ""
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -32957,598 +32998,598 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr ""
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr ""
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr ""
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr ""
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr ""
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr ""
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr ""
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr ""
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr ""
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr ""
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr ""
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand"
 msgid "invalid type for %qs"
 msgstr "არასწორი ოპერანდი"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr ""
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr ""
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr ""
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr ""
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr ""
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr ""
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr ""
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr ""
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr ""
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr ""
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr ""
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr ""
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr ""
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr ""
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr ""
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr ""
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr ""
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr ""
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr ""
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr ""
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr ""
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr ""
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr ""
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr ""
@@ -33728,12 +33769,12 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr ""
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr ""
@@ -34242,7 +34283,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -34662,28 +34703,28 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr ""
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr ""
 
-#: tree.cc:15804
+#: tree.cc:15824
 msgid "%qD conflicts for version %qB"
 msgstr ""
 
-#: tree.cc:15817
+#: tree.cc:15837
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr ""
 
@@ -34757,7 +34798,7 @@ msgstr ""
 msgid "no initializers are allowed in section %qs"
 msgstr ""
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr ""
@@ -34902,7 +34943,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr ""
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr ""
@@ -34947,53 +34988,53 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr ""
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr ""
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr ""
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr ""
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr ""
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr ""
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr ""
@@ -35008,12 +35049,12 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr ""
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr ""
@@ -35220,12 +35261,12 @@ msgstr ""
 msgid "mode %qs applied to inappropriate type"
 msgstr ""
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr ""
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr ""
@@ -35235,18 +35276,18 @@ msgstr ""
 msgid "section attribute argument not a string constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr ""
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr ""
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr ""
@@ -35331,7 +35372,7 @@ msgstr ""
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr ""
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr ""
@@ -35377,12 +35418,12 @@ msgstr ""
 msgid "%qE attribute is only applicable on functions"
 msgstr ""
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr ""
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr ""
@@ -35392,12 +35433,12 @@ msgstr ""
 msgid "%<symver%> attribute argument not a string constant"
 msgstr ""
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -35488,23 +35529,23 @@ msgstr ""
 msgid "visibility argument not a string"
 msgstr ""
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr ""
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr ""
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -35521,7 +35562,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr ""
@@ -35592,7 +35633,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr ""
@@ -35667,7 +35708,7 @@ msgstr ""
 msgid "%qE argument is not a function"
 msgstr ""
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr ""
@@ -35733,7 +35774,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr ""
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr ""
@@ -35894,15 +35935,15 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr ""
@@ -36168,7 +36209,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr ""
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr ""
@@ -36339,8 +36380,8 @@ msgstr ""
 msgid "missing sentinel in function call"
 msgstr ""
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -37349,7 +37390,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr ""
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -37404,7 +37445,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr ""
@@ -37419,17 +37460,17 @@ msgstr ""
 msgid "%qE is not initialized"
 msgstr ""
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr ""
@@ -37439,7 +37480,7 @@ msgstr ""
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr ""
@@ -37534,18 +37575,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr ""
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -37555,8 +37596,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr ""
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr ""
@@ -38071,7 +38112,7 @@ msgstr ""
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr ""
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr ""
@@ -38143,8 +38184,8 @@ msgstr ""
 msgid "wrong type argument to %s"
 msgstr ""
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -38630,17 +38671,17 @@ msgstr ""
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr ""
@@ -38906,7 +38947,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] ""
 msgstr[1] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -39838,7 +39879,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -40469,7 +40510,7 @@ msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr ""
@@ -40515,7 +40556,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -40566,7 +40607,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -40659,19 +40700,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -40717,208 +40758,208 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -40926,194 +40967,194 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, gcc-internal-format
 msgid "%q+D defined here"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -41301,12 +41342,12 @@ msgstr ""
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41439,22 +41480,22 @@ msgid "argument of %qE attribute ignored"
 msgstr ""
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr ""
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr ""
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr ""
@@ -41987,12 +42028,12 @@ msgstr ""
 msgid "%<-fPIE%> is not supported"
 msgstr ""
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr ""
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr ""
@@ -42002,7 +42043,7 @@ msgstr ""
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr ""
@@ -42329,7 +42370,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr ""
@@ -42646,7 +42687,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -42812,168 +42853,168 @@ msgstr ""
 msgid "parameter to builtin not valid: %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, gcc-internal-format
 msgid "invalid third argument"
 msgstr ""
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, gcc-internal-format
 msgid "second argument must be a const"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr ""
@@ -43368,8 +43409,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr ""
@@ -43611,7 +43652,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -43636,12 +43677,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -43651,128 +43692,128 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr ""
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr ""
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr ""
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr ""
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr ""
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -43823,7 +43864,7 @@ msgstr ""
 msgid "argument %qd is not a constant"
 msgstr ""
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr ""
@@ -43833,7 +43874,7 @@ msgstr ""
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr ""
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr ""
@@ -43987,48 +44028,48 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr ""
@@ -44781,7 +44822,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr ""
@@ -45004,82 +45045,82 @@ msgstr ""
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr ""
@@ -45308,321 +45349,321 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr ""
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr ""
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr ""
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr ""
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, gcc-internal-format
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr ""
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr ""
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -46618,22 +46659,22 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr ""
@@ -46853,32 +46894,32 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -46964,7 +47005,7 @@ msgstr ""
 msgid "%qs attribute only applies to variadic functions"
 msgstr ""
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47045,8 +47086,8 @@ msgstr ""
 msgid "could not get size of source file"
 msgstr ""
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr ""
@@ -47524,7 +47565,7 @@ msgstr ""
 msgid "%qE defined as wrong kind of tag"
 msgstr ""
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr ""
@@ -47673,7 +47714,7 @@ msgstr ""
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr ""
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr ""
@@ -47683,7 +47724,7 @@ msgstr ""
 msgid "%q+D is usually a function"
 msgstr ""
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr ""
@@ -47759,7 +47800,7 @@ msgstr ""
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr ""
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -47959,7 +48000,7 @@ msgstr ""
 msgid "storage class specified for unnamed parameter"
 msgstr ""
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr ""
@@ -48132,7 +48173,7 @@ msgstr ""
 msgid "function definition has qualified void return type"
 msgstr ""
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr ""
@@ -48259,7 +48300,7 @@ msgstr ""
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr ""
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr ""
@@ -48471,7 +48512,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr ""
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr ""
@@ -48536,7 +48577,7 @@ msgstr ""
 msgid "struct has no members"
 msgstr ""
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr ""
@@ -48601,7 +48642,7 @@ msgstr ""
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr ""
@@ -48656,7 +48697,7 @@ msgstr ""
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr ""
@@ -48806,12 +48847,12 @@ msgstr ""
 msgid "argument %qD doesn%'t match prototype"
 msgstr ""
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr ""
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr ""
@@ -48893,7 +48934,7 @@ msgstr ""
 msgid "two or more data types in declaration specifiers"
 msgstr ""
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr ""
@@ -48997,7 +49038,7 @@ msgstr ""
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr ""
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr ""
@@ -49154,12 +49195,12 @@ msgstr ""
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -49220,37 +49261,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr ""
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr ""
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr ""
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr ""
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr ""
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr ""
@@ -49270,7 +49311,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr ""
@@ -49280,7 +49321,7 @@ msgstr ""
 msgid "ISO C forbids an empty translation unit"
 msgstr ""
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49327,8 +49368,8 @@ msgid "unknown type name %qE"
 msgstr ""
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr ""
@@ -49363,7 +49404,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr ""
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr ""
@@ -49378,12 +49419,12 @@ msgstr ""
 msgid "unexpected attribute"
 msgstr ""
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr ""
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr ""
@@ -49426,7 +49467,7 @@ msgstr ""
 msgid "%qs may only be used with a single declarator"
 msgstr ""
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr ""
@@ -49460,7 +49501,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr ""
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr ""
@@ -49490,7 +49531,7 @@ msgstr ""
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr ""
@@ -49544,8 +49585,8 @@ msgstr ""
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr ""
@@ -49575,12 +49616,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr ""
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr ""
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -49661,22 +49702,22 @@ msgstr ""
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr ""
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr ""
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr ""
@@ -49686,7 +49727,7 @@ msgstr ""
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr ""
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr ""
@@ -49716,17 +49757,17 @@ msgstr ""
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr ""
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -49736,44 +49777,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr ""
@@ -49804,7 +49845,7 @@ msgstr ""
 msgid "expected %<}%> before %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -49819,7 +49860,7 @@ msgstr ""
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr ""
@@ -49854,27 +49895,27 @@ msgstr ""
 msgid "declaration in the controlling expression must have an initializer"
 msgstr ""
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr ""
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -49894,12 +49935,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr ""
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -49914,8 +49955,8 @@ msgstr ""
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr ""
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -49937,12 +49978,12 @@ msgstr ""
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr ""
@@ -50116,7 +50157,7 @@ msgstr ""
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr ""
@@ -50131,12 +50172,12 @@ msgstr ""
 msgid "ISO C forbids braced-groups within expressions"
 msgstr ""
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr ""
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -50281,7 +50322,7 @@ msgstr ""
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr ""
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr ""
@@ -50321,7 +50362,7 @@ msgstr ""
 msgid "rotate count is negative"
 msgstr ""
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -50431,7 +50472,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -50471,12 +50512,12 @@ msgstr ""
 msgid "no type or storage class may be specified here,"
 msgstr ""
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, gcc-internal-format
 msgid "missing property attribute"
 msgstr ""
@@ -50486,57 +50527,57 @@ msgstr ""
 msgid "unknown property attribute %<%s%s%>"
 msgstr ""
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr ""
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr ""
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -50546,12 +50587,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr ""
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr ""
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr ""
@@ -50561,11 +50602,11 @@ msgstr ""
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr ""
@@ -50580,58 +50621,58 @@ msgstr ""
 msgid "%qD is not a variable"
 msgstr ""
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr ""
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr ""
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr ""
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr ""
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr ""
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -50654,22 +50695,22 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr ""
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr ""
@@ -50679,99 +50720,99 @@ msgstr ""
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr ""
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr ""
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr ""
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr ""
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr ""
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr ""
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr ""
@@ -50781,38 +50822,38 @@ msgstr ""
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr ""
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -50827,22 +50868,22 @@ msgstr ""
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr ""
@@ -50852,7 +50893,7 @@ msgstr ""
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -50867,311 +50908,311 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr ""
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr ""
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr ""
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr ""
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr ""
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr ""
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr ""
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr ""
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr ""
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr ""
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr ""
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr ""
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr ""
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr ""
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr ""
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr ""
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr ""
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -51186,7 +51227,7 @@ msgstr ""
 msgid "expected function name"
 msgstr ""
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr ""
@@ -51196,22 +51237,22 @@ msgstr ""
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr ""
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -51236,7 +51277,7 @@ msgstr ""
 msgid "modified here"
 msgstr ""
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -51271,110 +51312,110 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr ""
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr ""
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr ""
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr ""
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr ""
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr ""
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr ""
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr ""
@@ -51384,27 +51425,27 @@ msgstr ""
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr ""
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr ""
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr ""
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -51414,32 +51455,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr ""
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr ""
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr ""
@@ -51447,68 +51488,68 @@ msgstr ""
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, gcc-internal-format
 msgid "loop nest expected"
 msgstr ""
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr ""
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr ""
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr ""
@@ -51519,7 +51560,7 @@ msgstr ""
 msgid "expected a function name"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "expected target-function call"
@@ -51530,47 +51571,47 @@ msgstr "მოულოდნელი არგუმენტი"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr ""
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -51585,57 +51626,57 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr ""
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr ""
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr ""
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr ""
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr ""
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr ""
@@ -51645,27 +51686,27 @@ msgstr ""
 msgid "variant %qD is not a function"
 msgstr ""
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr ""
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -51675,7 +51716,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr ""
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr ""
@@ -51685,17 +51726,17 @@ msgstr ""
 msgid "%<need_device_addr%> is not valid for C"
 msgstr ""
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr ""
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr ""
@@ -51715,12 +51756,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr ""
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr ""
@@ -51730,7 +51771,7 @@ msgstr ""
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr ""
@@ -51740,7 +51781,7 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -51755,84 +51796,84 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr ""
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr ""
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr ""
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr ""
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr ""
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr ""
@@ -51857,13 +51898,13 @@ msgstr ""
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr ""
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected clause"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr ""
@@ -51923,32 +51964,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr ""
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -51963,160 +52004,160 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr ""
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr ""
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr ""
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr ""
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr ""
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr ""
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr ""
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, gcc-internal-format
 msgid "unknown directive name"
 msgstr ""
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr ""
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr ""
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -52126,7 +52167,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -52141,7 +52182,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr ""
@@ -52172,167 +52213,167 @@ msgstr ""
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr ""
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr ""
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr ""
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr ""
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr ""
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr ""
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr ""
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr ""
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, gcc-internal-format
 msgid "array subscript is negative"
 msgstr ""
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr ""
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr ""
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr ""
@@ -52340,1852 +52381,1852 @@ msgstr ""
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr ""
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr ""
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr ""
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr ""
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr ""
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr ""
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr ""
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr ""
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr ""
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr ""
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr ""
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr ""
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr ""
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr ""
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr ""
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr ""
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr ""
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr ""
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr ""
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr ""
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr ""
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr ""
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr ""
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr ""
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr ""
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr ""
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr ""
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr ""
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr ""
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr ""
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr ""
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr ""
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr ""
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr ""
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr ""
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr ""
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr ""
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 msgid "expected %e but argument is of type %e"
 msgstr ""
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr ""
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "declared here"
 msgid "%e declared here"
 msgstr "აღწერილია აქ"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr ""
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 msgid "returning %e from a function with incompatible return type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr ""
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr ""
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr ""
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr ""
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr ""
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr ""
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr ""
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr ""
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr ""
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr ""
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr ""
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr ""
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr ""
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr ""
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr ""
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr ""
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr ""
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr ""
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr ""
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr ""
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr ""
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr ""
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, gcc-internal-format
 msgid "function returns address of nested function referencing local context"
 msgstr ""
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr ""
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr ""
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr ""
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr ""
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr ""
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr ""
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr ""
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr ""
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr ""
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr ""
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr ""
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr ""
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr ""
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr ""
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr ""
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr ""
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr ""
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr ""
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr ""
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -54452,253 +54493,248 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr ""
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr ""
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr ""
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr ""
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr ""
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr ""
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -54707,72 +54743,82 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr ""
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr ""
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr ""
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -54782,12 +54828,12 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, gcc-internal-format
 msgid "Too many subscripts"
 msgstr ""
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr ""
@@ -54802,61 +54848,61 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr ""
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr ""
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr ""
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr ""
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr ""
@@ -55292,7 +55338,7 @@ msgstr ""
 msgid "%q#D is private within this context"
 msgstr ""
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr ""
@@ -55302,7 +55348,7 @@ msgstr ""
 msgid "%q#D is protected within this context"
 msgstr ""
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr ""
@@ -55626,7 +55672,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr ""
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr ""
 
@@ -55645,7 +55691,7 @@ msgstr ""
 msgid "call to non-function %qD"
 msgstr ""
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -56239,7 +56285,7 @@ msgstr ""
 msgid "next member %q#D declared here"
 msgstr ""
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr ""
@@ -56249,7 +56295,7 @@ msgstr ""
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -56380,7 +56426,7 @@ msgstr ""
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -56431,7 +56477,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -56466,841 +56512,841 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr ""
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr ""
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr ""
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr ""
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s -ს %s-ის მხარდაჭერა არ გააჩნია"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "%qD called with unexpected %qs argument"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr ""
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr ""
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr ""
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr ""
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr ""
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr ""
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr ""
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr ""
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr ""
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr ""
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr ""
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr ""
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr ""
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr ""
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr ""
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr ""
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr ""
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, gcc-internal-format
 msgid "%qT object created here"
 msgstr ""
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr ""
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr ""
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr ""
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr ""
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr ""
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr ""
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, gcc-internal-format
 msgid "use of %qD"
 msgstr ""
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr ""
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr ""
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr ""
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr ""
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr ""
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr ""
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr ""
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr ""
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr ""
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr ""
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr ""
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr ""
@@ -57432,353 +57478,353 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr ""
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr ""
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr ""
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr ""
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr ""
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr ""
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr ""
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr ""
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "function returns an aggregate"
 msgid "%qT is not an aggregate"
 msgstr "ფუნქცია აგრეგატს აბრუნებს"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, gcc-internal-format
 msgid "%qT is not an array"
 msgstr ""
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr ""
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr ""
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, gcc-internal-format
 msgid "%qT is not a class"
 msgstr ""
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr ""
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr ""
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr ""
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr ""
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, gcc-internal-format
 msgid "%qT is not a function"
 msgstr ""
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr ""
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr ""
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr ""
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr ""
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr ""
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr ""
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr ""
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr ""
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr ""
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr ""
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr ""
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr ""
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr ""
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr ""
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr ""
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr ""
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr ""
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr ""
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, gcc-internal-format
 msgid "%qT is not a union"
 msgstr ""
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr ""
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr ""
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, gcc-internal-format
-msgid "%qT is not consteval-only"
+msgid "%qT is not a structural type"
 msgstr ""
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr ""
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr ""
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr ""
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr ""
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, gcc-internal-format
 msgid "invalid constraints"
 msgstr ""
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr ""
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr ""
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -57809,49 +57855,49 @@ msgstr ""
 msgid "previous declaration with fewer contracts here"
 msgstr "წინა დეკლარაცია"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "parameter declared here"
 msgstr "აღწერილია აქ"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr ""
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "first declared here"
 msgstr "აღწერილია აქ"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr ""
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr ""
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr ""
@@ -57922,7 +57968,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr ""
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr ""
@@ -57994,83 +58040,83 @@ msgstr ""
 msgid "awaitable type %qT is not a structure"
 msgstr ""
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr ""
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr ""
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr ""
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr ""
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr ""
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr ""
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr ""
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -58095,68 +58141,73 @@ msgstr ""
 msgid "%qs used outside of constant expressions"
 msgstr ""
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr ""
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr ""
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -58197,7 +58248,7 @@ msgstr ""
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr ""
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr ""
@@ -58585,7 +58636,7 @@ msgstr ""
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr ""
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr ""
@@ -58807,12 +58858,12 @@ msgstr ""
 msgid "previous specification in %q#D here"
 msgstr ""
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr ""
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr ""
@@ -59017,7 +59068,7 @@ msgstr ""
 msgid "  enters %<template for%> statement"
 msgstr ""
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr ""
@@ -59062,2419 +59113,2429 @@ msgstr ""
 msgid "template parameters do not match template %qD"
 msgstr ""
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr ""
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr ""
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr ""
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr ""
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr ""
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr ""
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr ""
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr ""
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr ""
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr ""
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr ""
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr ""
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr ""
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr ""
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr ""
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr ""
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr ""
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr ""
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr ""
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr ""
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr ""
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr ""
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr ""
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr ""
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr ""
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr ""
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr ""
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr ""
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr ""
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr ""
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr ""
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr ""
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr ""
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr ""
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr ""
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr ""
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr ""
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr ""
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr ""
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr ""
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr ""
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr ""
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr ""
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr ""
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr ""
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr ""
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr ""
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr ""
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr ""
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr ""
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr ""
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr ""
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr ""
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr ""
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr ""
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr ""
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr ""
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr ""
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr ""
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr ""
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr ""
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr ""
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr ""
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr ""
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr ""
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr ""
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr ""
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr ""
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr ""
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "lambda declared here"
 msgstr "აღწერილია აქ"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr ""
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, gcc-internal-format
 msgid "in base class of %qT"
 msgstr ""
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr ""
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr ""
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr ""
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr ""
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr ""
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr ""
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr ""
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr ""
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr ""
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr ""
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr ""
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr ""
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr ""
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr ""
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr ""
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr ""
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr ""
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr ""
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr ""
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr ""
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr ""
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr ""
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr ""
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr ""
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr ""
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr ""
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr ""
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr ""
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr ""
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr ""
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr ""
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr ""
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr ""
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr ""
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr ""
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr ""
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr ""
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr ""
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr ""
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr ""
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr ""
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "double constants not supported"
 msgid "variable concepts are no longer supported"
 msgstr "ორმაგი კონსტანტები მხარდაჭერილი არაა"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr ""
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr ""
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr ""
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr ""
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr ""
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr ""
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr ""
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr ""
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr ""
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr ""
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr ""
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr ""
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr ""
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr ""
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr ""
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr ""
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr ""
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr ""
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr ""
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 msgid "%e and %e specified together"
 msgstr ""
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr ""
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr ""
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr ""
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr ""
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr ""
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr ""
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr ""
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr ""
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr ""
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr ""
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr ""
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr ""
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr ""
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr ""
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr ""
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr ""
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr ""
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr ""
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr ""
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr ""
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr ""
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr ""
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr ""
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr ""
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr ""
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr ""
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr ""
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr ""
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr ""
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr ""
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr ""
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr ""
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr ""
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr ""
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr ""
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr ""
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr ""
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr ""
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr ""
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr ""
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr ""
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr ""
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr ""
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr ""
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr ""
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr ""
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr ""
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr ""
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr ""
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr ""
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr ""
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr ""
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr ""
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr ""
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr ""
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr ""
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr ""
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr ""
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr ""
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr ""
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr ""
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr ""
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr ""
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr ""
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr ""
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr ""
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr ""
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr ""
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr ""
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr ""
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr ""
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr ""
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr ""
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr ""
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr ""
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr ""
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr ""
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr ""
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr ""
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr ""
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr ""
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr ""
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr ""
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr ""
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr ""
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr ""
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr ""
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr ""
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr ""
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr ""
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr ""
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr ""
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr ""
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr ""
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr ""
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr ""
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr ""
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr ""
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr ""
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr ""
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr ""
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr ""
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr ""
@@ -61486,100 +61547,100 @@ msgstr ""
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr ""
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr ""
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr ""
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr ""
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr ""
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr ""
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr ""
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr ""
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr ""
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr ""
@@ -61588,87 +61649,93 @@ msgstr ""
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr ""
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr ""
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr ""
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr ""
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr ""
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr ""
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr ""
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr ""
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr ""
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr ""
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr ""
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr ""
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr ""
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr ""
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "previous declaration"
+msgid "%qs used without %qs declaration"
+msgstr "წინა დეკლარაცია"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -62098,336 +62165,336 @@ msgstr ""
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr ""
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr ""
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr ""
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, gcc-internal-format
 msgid "In static member function %qD"
 msgstr ""
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr ""
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr ""
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr ""
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr ""
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr ""
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, gcc-internal-format
 msgid "In member function %qD"
 msgstr ""
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr ""
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, gcc-internal-format
 msgid "but %qE is a type"
 msgstr ""
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr ""
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr ""
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "ფუნქციის პარამეტრი"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, gcc-internal-format
 msgid "but %qE is a function"
 msgstr ""
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr ""
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr ""
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr ""
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr ""
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr ""
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr ""
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr ""
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr ""
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr ""
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr ""
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr ""
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr ""
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, gcc-internal-format
 msgid "in requirements "
 msgstr ""
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr ""
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr ""
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr ""
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr ""
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr ""
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr ""
@@ -62648,7 +62715,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr ""
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -62764,7 +62831,7 @@ msgstr ""
 msgid "type %qT is not a direct base of %qT"
 msgstr ""
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -62955,42 +63022,42 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr ""
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, gcc-internal-format
 msgid "operator %<delete%> used on incomplete type"
 msgstr ""
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
@@ -63025,82 +63092,90 @@ msgstr ""
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr ""
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr ""
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr ""
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr ""
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr ""
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr ""
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr ""
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -63110,64 +63185,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -63551,7 +63619,7 @@ msgstr ""
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr ""
@@ -63566,423 +63634,423 @@ msgstr ""
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr ""
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr ""
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr ""
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "existing default declared here"
 msgstr "აღწერილია აქ"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr ""
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr ""
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr ""
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr ""
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr ""
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr ""
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr ""
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr ""
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr ""
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr ""
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr ""
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr ""
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr ""
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr ""
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr ""
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr ""
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr ""
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr ""
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr ""
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr ""
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr ""
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr ""
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr ""
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr ""
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr ""
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr ""
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr ""
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr ""
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr ""
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr ""
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "module declared here"
@@ -63995,107 +64063,107 @@ msgstr "აღწერილია აქ"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr ""
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr ""
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr ""
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr ""
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr ""
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr ""
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr ""
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr ""
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr ""
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr ""
@@ -64110,7 +64178,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
@@ -64155,260 +64223,270 @@ msgstr ""
 msgid "declaration of %qD shadows a member of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr ""
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr ""
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr ""
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr ""
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr ""
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr ""
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr ""
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr ""
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr ""
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr ""
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr ""
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr ""
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr ""
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr ""
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr ""
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -64438,7 +64516,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -64484,7 +64562,7 @@ msgstr ""
 msgid "request for member %qE in non-class type %qT"
 msgstr ""
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr ""
@@ -64554,7 +64632,7 @@ msgstr ""
 msgid "%qE is not a class template"
 msgstr ""
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr ""
@@ -64865,1691 +64943,1702 @@ msgstr ""
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr ""
 
-#: cp/parser.cc:6341
-#, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr ""
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr ""
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr ""
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr ""
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr ""
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr ""
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr ""
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr ""
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr ""
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr ""
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr ""
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr ""
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr ""
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr ""
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr ""
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr ""
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr ""
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr ""
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, gcc-internal-format
 msgid "selected function declared here"
 msgstr ""
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr ""
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr ""
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr ""
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr ""
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr ""
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr ""
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr ""
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr ""
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr ""
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr ""
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr ""
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr ""
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr ""
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr ""
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr ""
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr ""
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr ""
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr ""
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr ""
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr ""
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr ""
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr ""
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr ""
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "declared here"
+msgid "%q#E declared here"
+msgstr "აღწერილია აქ"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr ""
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr ""
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr ""
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr ""
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr ""
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr ""
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, gcc-internal-format
 msgid "condition declares a function"
 msgstr ""
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr ""
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr ""
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr ""
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr ""
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr ""
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr ""
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr ""
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr ""
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr ""
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr ""
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr ""
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr ""
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "previously defined here"
 msgid "scope opened here"
 msgstr "ადრე აქ იყო აღწერილი"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr ""
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr ""
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr ""
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr ""
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr ""
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr ""
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr ""
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr ""
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr ""
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr ""
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr ""
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr ""
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr ""
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr ""
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr ""
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr ""
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr ""
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr ""
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr ""
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr ""
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr ""
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr ""
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr ""
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr ""
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr ""
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr ""
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr ""
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr ""
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr ""
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr ""
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr ""
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr ""
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr ""
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr ""
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr ""
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr ""
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr ""
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr ""
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr ""
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr ""
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr ""
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr ""
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr ""
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr ""
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr ""
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr ""
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr ""
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr ""
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr ""
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr ""
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr ""
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr ""
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr ""
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr ""
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr ""
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr ""
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr ""
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr ""
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr ""
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr ""
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr ""
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr ""
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr ""
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr ""
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr ""
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr ""
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr ""
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr ""
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr ""
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr ""
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr ""
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr ""
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr ""
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr ""
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr ""
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr ""
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr ""
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr ""
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr ""
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr ""
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr ""
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr ""
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr ""
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr ""
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr ""
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr ""
@@ -66558,275 +66647,275 @@ msgstr ""
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr ""
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr ""
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr ""
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr ""
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr ""
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr ""
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr ""
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr ""
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr ""
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr ""
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr ""
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr ""
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr ""
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr ""
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr ""
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr ""
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr ""
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr ""
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr ""
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr ""
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr ""
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr ""
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr ""
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr ""
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr ""
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr ""
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr ""
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr ""
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr ""
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr ""
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr ""
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr ""
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr ""
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr ""
@@ -66834,268 +66923,268 @@ msgstr ""
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr ""
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr ""
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr ""
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr ""
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr ""
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr ""
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr ""
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr ""
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr ""
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr ""
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr ""
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr ""
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr ""
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, gcc-internal-format
 msgid "attributes are ignored on %qs"
 msgstr ""
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr ""
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr ""
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr ""
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr ""
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr ""
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr ""
@@ -67104,432 +67193,432 @@ msgstr ""
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr ""
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr ""
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr ""
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr ""
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr ""
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr ""
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr ""
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr ""
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr ""
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr ""
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr ""
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr ""
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr ""
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr ""
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr ""
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr ""
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr ""
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr ""
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr ""
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr ""
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr ""
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr ""
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr ""
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr ""
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr ""
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr ""
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr ""
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr ""
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr ""
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr ""
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr ""
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr ""
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr ""
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr ""
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr ""
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr ""
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr ""
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr ""
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr ""
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr ""
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr ""
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr ""
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr ""
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr ""
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr ""
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr ""
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr ""
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr ""
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr ""
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr ""
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr ""
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr ""
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr ""
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr ""
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr ""
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr ""
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr ""
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr ""
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr ""
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr ""
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr ""
@@ -67538,173 +67627,173 @@ msgstr ""
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr ""
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr ""
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr ""
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr ""
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr ""
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr ""
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr ""
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr ""
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr ""
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr ""
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr ""
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr ""
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr ""
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr ""
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr ""
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr ""
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -68176,495 +68265,500 @@ msgstr ""
 msgid "redeclaration of %qD with different constraints"
 msgstr ""
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr ""
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr ""
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr ""
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr ""
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr ""
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr ""
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr ""
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr ""
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr ""
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr ""
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr ""
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr ""
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr ""
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr ""
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr ""
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr ""
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr ""
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr ""
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr ""
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr ""
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr ""
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr ""
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr ""
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr ""
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr ""
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr ""
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr ""
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr ""
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr ""
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr ""
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr ""
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr ""
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr ""
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr ""
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr ""
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr ""
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr ""
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr ""
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr ""
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr ""
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr ""
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr ""
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr ""
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr ""
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr ""
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr ""
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr ""
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr ""
@@ -68682,122 +68776,122 @@ msgstr ""
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr ""
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr ""
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr ""
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr ""
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr ""
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr ""
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr ""
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr ""
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr ""
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr ""
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr ""
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr ""
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr ""
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr ""
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr ""
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr ""
@@ -68805,206 +68899,206 @@ msgstr ""
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr ""
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr ""
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr ""
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr ""
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr ""
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr ""
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr ""
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr ""
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr ""
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr ""
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr ""
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr ""
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr ""
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr ""
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr ""
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr ""
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr ""
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr ""
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr ""
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr ""
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr ""
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr ""
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr ""
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr ""
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr ""
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr ""
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr ""
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr ""
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr ""
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr ""
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr ""
@@ -69016,515 +69110,570 @@ msgstr ""
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr ""
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr ""
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr ""
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr ""
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr ""
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr ""
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr ""
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr ""
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr ""
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr ""
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr ""
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr ""
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr ""
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr ""
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr ""
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr ""
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr ""
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr ""
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr ""
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr ""
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:476
 #, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr ""
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr ""
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, gcc-internal-format
 msgid "couldn%'t look up %qs"
 msgstr ""
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected return type of %qs"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr ""
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr ""
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr ""
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr ""
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr ""
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr ""
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "მოულოდნელი არგუმენტი"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:7826
 #, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr ""
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr ""
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr ""
+
+#: cp/reflect.cc:8540
+#, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr ""
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr ""
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr ""
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr ""
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr ""
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr ""
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr ""
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr ""
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -69855,584 +70004,584 @@ msgstr ""
 msgid "invalid base-class specification"
 msgstr ""
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr ""
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr ""
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr ""
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr ""
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr ""
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr ""
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr ""
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr ""
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr ""
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr ""
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr ""
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr ""
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr ""
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr ""
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr ""
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr ""
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr ""
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr ""
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr ""
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr ""
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr ""
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr ""
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr ""
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr ""
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr ""
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr ""
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr ""
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr ""
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr ""
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr ""
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr ""
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr ""
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr ""
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr ""
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr ""
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr ""
@@ -70440,343 +70589,343 @@ msgstr ""
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr ""
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr ""
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr ""
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr ""
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr ""
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr ""
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr ""
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr ""
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr ""
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr ""
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, gcc-internal-format
 msgid "%qD is not public"
 msgstr ""
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr ""
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr ""
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr ""
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr ""
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr ""
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr ""
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr ""
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr ""
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr ""
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr ""
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr ""
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr ""
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr ""
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr ""
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr ""
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr ""
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr ""
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr ""
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr ""
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr ""
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr ""
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr ""
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr ""
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr ""
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr ""
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr ""
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr ""
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr ""
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr ""
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, gcc-internal-format
 msgid "annotation applied to a label"
 msgstr ""
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "ფუნქციის პარამეტრი"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr ""
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, gcc-internal-format
 msgid "annotation does not have copy constructible type"
 msgstr ""
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr ""
@@ -70976,795 +71125,800 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr ""
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr ""
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr ""
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr ""
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr ""
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr ""
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr ""
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr ""
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr ""
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr ""
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr ""
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr ""
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr ""
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr ""
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr ""
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr ""
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr ""
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr ""
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr ""
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr ""
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr ""
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr ""
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr ""
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr ""
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr ""
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr ""
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr ""
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr ""
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr ""
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr ""
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr ""
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr ""
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr ""
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr ""
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr ""
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr ""
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr ""
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr ""
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr ""
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr ""
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr ""
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr ""
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr ""
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr ""
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr ""
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr ""
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr ""
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr ""
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr ""
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr ""
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr ""
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr ""
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr ""
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr ""
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr ""
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr ""
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr ""
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr ""
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr ""
@@ -72168,17 +72322,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr ""
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr ""
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -72203,43 +72357,43 @@ msgstr ""
 msgid "the address of %qD will never be %<null%>"
 msgstr ""
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr ""
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr ""
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr ""
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr ""
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr ""
@@ -72317,32 +72471,32 @@ msgstr ""
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr ""
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr ""
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr ""
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr ""
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr ""
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -72439,7 +72593,7 @@ msgstr ""
 msgid "%qs is not an associative array"
 msgstr ""
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -72454,22 +72608,22 @@ msgstr ""
 msgid "%qs is not a field, but a %qs"
 msgstr ""
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr ""
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr ""
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr ""
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr ""
@@ -72560,17 +72714,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -72892,8 +73046,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -73170,7 +73324,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr ""
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr ""
@@ -73245,7 +73399,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr ""
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr ""
@@ -73385,7 +73539,7 @@ msgstr ""
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr ""
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr ""
@@ -73400,7 +73554,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr ""
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr ""
@@ -73541,8 +73695,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -73641,9 +73795,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr ""
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -73658,12 +73812,12 @@ msgstr ""
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr ""
@@ -73758,618 +73912,618 @@ msgstr ""
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr ""
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr ""
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr ""
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr ""
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr ""
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr ""
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr ""
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr ""
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr ""
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr ""
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr ""
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr ""
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr ""
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr ""
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr ""
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr ""
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr ""
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr ""
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr ""
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr ""
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr ""
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr ""
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr ""
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr ""
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr ""
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr ""
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr ""
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr ""
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr ""
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr ""
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr ""
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr ""
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr ""
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr ""
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr ""
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr ""
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr ""
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -74434,12 +74588,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -74489,2058 +74643,2058 @@ msgstr ""
 msgid "Simplification error"
 msgstr ""
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr ""
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr ""
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr ""
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr ""
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr ""
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr ""
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr ""
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr ""
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr ""
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr ""
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr ""
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr ""
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr ""
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr ""
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr ""
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr ""
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr ""
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr ""
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr ""
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr ""
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr ""
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr ""
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr ""
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr ""
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr ""
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr ""
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr ""
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr ""
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr ""
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr ""
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr ""
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr ""
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr ""
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr ""
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr ""
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr ""
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr ""
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr ""
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr ""
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr ""
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr ""
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr ""
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr ""
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr ""
@@ -76683,408 +76837,408 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr ""
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr ""
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr ""
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr ""
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr ""
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr ""
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr ""
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr ""
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr ""
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr ""
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -77092,197 +77246,197 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr ""
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -77303,7 +77457,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -77364,42 +77518,42 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr ""
@@ -77524,12 +77678,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -77955,307 +78109,312 @@ msgstr ""
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr ""
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr ""
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr ""
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr ""
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr ""
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr ""
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr ""
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr ""
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr ""
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr ""
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr ""
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr ""
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr ""
@@ -78444,7 +78603,7 @@ msgstr ""
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr ""
@@ -78990,7 +79149,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -79161,12 +79320,12 @@ msgstr ""
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -79668,7 +79827,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr ""
@@ -80181,92 +80340,92 @@ msgstr ""
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr ""
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr ""
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr ""
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -81249,7 +81408,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -81284,12 +81443,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -81765,7 +81924,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr ""
@@ -81785,7 +81944,7 @@ msgstr ""
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -81815,17 +81974,17 @@ msgstr ""
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -81945,8 +82104,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -82026,7 +82185,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr ""
@@ -82049,7 +82208,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -82089,7 +82248,7 @@ msgstr ""
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr ""
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -82401,598 +82560,608 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr ""
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -83655,62 +83824,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr ""
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr ""
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr ""
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -83718,7 +83887,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -84175,1080 +84344,1080 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr ""
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr ""
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr ""
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr ""
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr ""
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr ""
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr ""
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr ""
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr ""
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr ""
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr ""
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr ""
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr ""
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr ""
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr ""
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr ""
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr ""
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr ""
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -85257,12 +85426,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -85271,413 +85440,413 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr ""
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr ""
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -85686,314 +85855,314 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr ""
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr ""
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr ""
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -86001,212 +86170,212 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr ""
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -86214,1056 +86383,1056 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr ""
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr ""
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr ""
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr ""
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr ""
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr ""
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr ""
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr ""
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr ""
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr ""
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -87283,97 +87452,97 @@ msgstr ""
 msgid "%qs is not a directory"
 msgstr ""
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr ""
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr ""
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr ""
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr ""
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr ""
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr ""
@@ -87538,218 +87707,218 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr ""
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr ""
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr ""
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr ""
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr ""
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr ""
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -88087,74 +88256,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr ""
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -88184,29 +88353,34 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr ""
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -88308,114 +88482,114 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr ""
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "sorry, unimplemented"
 msgid "Unsigned not yet implemented"
 msgstr "განხორციელებული არაა"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -88445,12 +88619,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr ""
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr ""
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -88466,12 +88640,12 @@ msgstr ""
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr ""
@@ -88496,182 +88670,182 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, gcc-internal-format
 msgid "optional class parameter"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr ""
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr ""
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr ""
@@ -89008,7 +89182,7 @@ msgstr ""
 msgid "two or more sections for %s"
 msgstr ""
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -89332,32 +89506,32 @@ msgstr ""
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr ""
--- a/src/gcc/po/nl.po
+++ b/src/gcc/po/nl.po
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 4.9-b20140202\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2014-02-05 12:25+0100\n"
 "Last-Translator: Benno Schulenberg <benno@vertaalt.nl>\n"
 "Language-Team: Dutch <vertaling@vrijschrift.org>\n"
@@ -1291,12 +1291,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr ""
@@ -2117,13 +2117,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2572,7 +2572,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr ""
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr ""
@@ -2647,7 +2647,7 @@ msgstr ""
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2684,7 +2684,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Genereer directe aftakkingen naar locale functies"
@@ -2794,7 +2794,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2840,7 +2840,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5120,7 +5120,7 @@ msgstr "ingebouwde functie %qs is niet geïmplementeerd"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5479,7 +5479,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr ""
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5784,212 +5784,217 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "registervariabele %qs gebruikt in geneste functie"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Geef de naam op van hardware/formaat voor floating-point getallen op het doelplatform"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "case-label niet in een switch-statement"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "case-label niet in een switch-statement"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "case-label niet in een switch-statement"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 msgid "This option is deprecated."
 msgstr "%<%.*s%> is niet gedefinieerd"
@@ -11322,7 +11327,7 @@ msgstr "ISO C staat het testen van asserties niet toe"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18295,86 +18300,86 @@ msgstr "Volg de ISO 1990 C standaard"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument must be a constant"
 msgid "argument must be passed by copying"
 msgstr "argument moet een constante zijn"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 msgid "callee returns twice"
 msgstr "teller van links shift is negatief"
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 msgid "volatile function type"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 msgid "nested function"
 msgstr "ongeldige operand van %s"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 msgid "inconsistent number of popped arguments"
 msgstr "%Jherdefinitie van parameter %qD"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 msgid "frontend does not support sibling call"
 msgstr "%s ondersteunt %s niet"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 msgid "variable size arguments"
 msgstr "geen argumenten"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 msgid "hidden string length argument passed on stack"
 msgstr "%qs is geen iterator"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
 msgstr ""
 
@@ -18495,12 +18500,12 @@ msgstr "operand van '%%l' is geen label"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "floating-point constante verkeerd gebruikt"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19780,13 +19785,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "dit is de insn:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "Disable indexed addressing"
 msgid "unable to reload address in "
 msgstr "Schakel geïndexeerde adressering uit"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr ""
 
@@ -20022,7 +20027,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC heuristieken: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anoniem>"
@@ -20409,20 +20414,20 @@ msgstr "ongeldige operand voor code '%c'"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "ongeldige operand voor '%%%c'"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid constant"
 msgid "invalid vector constant"
@@ -20471,82 +20476,82 @@ msgstr "ongeldige operandprefix '%%%c'"
 msgid "invalid address mode"
 msgstr "ongeldige adresseringsmodus"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "ongeldige conversie van %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "ongeldige registernaam voor %qs"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "pointers are not permitted as case values"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "pointers zijn niet toegestaan als case-waarden"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 msgid "negation operation not permitted on svbool_t"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 msgid "subscript operation not supported on svbool_t"
 msgstr "sectie-attributen worden niet ondersteund op dit doelsysteem"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands in binary operation"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "ongeldige operanden in binaire bewerking"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20563,13 +20568,13 @@ msgid "invalid %%r value"
 msgstr "ongeldige waarde voor %%r"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "ongeldige waarde voor %%R"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "ongeldige waarde voor %%N"
@@ -20584,7 +20589,7 @@ msgstr "ongeldige waarde voor %%P"
 msgid "invalid %%h value"
 msgstr "ongeldige waarde voor %%h"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "ongeldige waarde voor %%L"
@@ -20599,7 +20604,7 @@ msgstr "ongeldige waarde voor %%m"
 msgid "invalid %%M value"
 msgstr "ongeldige waarde voor %%M"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "ongeldige waarde voor %%U"
@@ -20953,7 +20958,7 @@ msgstr "onverwachte operand"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21202,135 +21207,135 @@ msgstr "ongeldige constante"
 msgid "Expected register or constant integer."
 msgstr "accumulator is geen integer-constante"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "ongeldige UNSPEC als operand"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 msgid "invalid use of asm flag output"
 msgstr "ongeldige lvalue in toewijzing"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "ongeldige operand voor code '%c'"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "ongeldige operand voor code '%c'"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "ongeldige operand voor code '%c'"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "ongeldige operand voor code '%c'"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "operand is noch een constante, noch een conditiecode ⇒ ongeldige operandcode 'c'"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "ongeldige operand voor '%c'"
 
 # "constraints" hier te vertalen ("beperkingen"/"restricties") of niet?
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "ongeldige constraints voor operand"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 msgid "invalid vector immediate"
 msgstr "Ongeldig token in expressie"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "onbekende insn-modus"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "ongeldige conversie van %<__fpreg%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "ongeldige conversie van %<__fpreg%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "ongeldige conversie naar %<__fpreg%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "ongeldige registernaam voor %qs"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21410,9 +21415,9 @@ msgstr "'%%%c' is geen geldige operand-prefix"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "ongeldig gebruik van '%%%c'"
@@ -21481,7 +21486,7 @@ msgid "insn contains an invalid address !"
 msgstr "ongeldig adres"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "ongeldig adres"
 
@@ -21558,7 +21563,7 @@ msgstr "ongeldige rotate insn"
 msgid "invalid %%H value"
 msgstr "ongeldige waarde voor %%H"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "ongeldige waarde voor %%d"
@@ -21611,33 +21616,33 @@ msgstr "niet-ondersteunde versie"
 msgid "unsupported memory expression:"
 msgstr "ongeldige waarheidsexpressie"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 msgid "invalid vector operand"
 msgstr "ongeldige operand voor %%P"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "ongeldige operand voor 'b' modifier"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr ""
@@ -21699,7 +21704,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "ongeldige waarde voor %%H"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "ongeldige waarde voor %%D"
@@ -21740,7 +21745,7 @@ msgstr ""
 msgid "invalid %%k value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "ongeldige waarde voor %%K"
@@ -21771,18 +21776,18 @@ msgstr ""
 msgid "invalid %%u value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr ""
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%H value"
 msgid "invalid %%V value"
 msgstr "ongeldige waarde voor %%H"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "ongeldige waarde voor %%x"
@@ -22009,28 +22014,28 @@ msgstr "ongeldige operand voor %%s"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "een floating-point constante is geen geldige onmiddellijke operand"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "'B' operand is geen constante"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "'o' operand is geen constante"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "'B' operand is geen constante"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr ""
@@ -22094,24 +22099,24 @@ msgstr "ongeldige letter gebruikt als operand-modifier"
 msgid "Unable to load DLL."
 msgstr "kan %qs niet emuleren"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "slechte test"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "ongeldig masker"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "ongeldige waarde voor %%t/%%b"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "geen register in adres"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "adres-offset is geen constante"
 
@@ -22145,7 +22150,7 @@ msgstr "{anoniem}"
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "{{anoniem}}"
 
@@ -22170,8 +22175,8 @@ msgstr "{{anoniem}}"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "ongeldige operand van %s"
@@ -22199,7 +22204,7 @@ msgstr "ongeldige operand van %s"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "ongeldige operand van %s"
@@ -22207,7 +22212,7 @@ msgstr "ongeldige operand van %s"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "ongeldige operand van %s"
@@ -22228,13 +22233,13 @@ msgstr "ongeldige operand van %s"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "ongeldige operand van %s"
@@ -22243,7 +22248,7 @@ msgstr "ongeldige operand van %s"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, fuzzy, gcc-internal-format
 msgid "expected %<{%>"
@@ -22260,13 +22265,13 @@ msgstr "ongeldige operand van %s"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "ongeldige operand van %s"
@@ -22276,7 +22281,7 @@ msgstr "ongeldige operand van %s"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "ongeldige operand van %s"
@@ -22287,18 +22292,18 @@ msgid "expected %<.%>"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "ongeldige operand van %s"
@@ -22308,45 +22313,45 @@ msgstr "ongeldige operand van %s"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "top-level declaratie van %qs specifieert %<auto%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anoniem)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "ongeldige operand van %s"
@@ -22374,7 +22379,7 @@ msgstr "kandidaat 1:"
 msgid "  after user-defined conversion:"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 #, fuzzy
 msgid "candidate is:"
 msgid_plural "candidates are:"
@@ -22483,7 +22488,7 @@ msgstr "meerdere parameters hebben de naam %qs"
 msgid "<statement>"
 msgstr "ongeldige beginwaarde"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, fuzzy, gcc-internal-format
 msgid "<unknown>"
 msgstr "onbekende machine-modus %qs"
@@ -22510,300 +22515,340 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr ""
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 #, fuzzy
 msgid "<unknown operator>"
 msgstr "onbekende operator '%s' in %%:version-compare"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "accumulator is geen integer-constante"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 msgid "reflect_constant failed"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "accumulator is geen integer-constante"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "functie geeft geen string-type terug"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 msgid "reflection does not have template arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 msgid "reflection does not represent a function or function type"
 msgstr "opgeroepen object is geen functie"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 msgid "operators argument is not a valid operator"
 msgstr "de formaatstring is geen string-type"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 msgid "reflection does not have a type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "functie geeft geen string-type terug"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 msgid "reflection does not represent parameter of current function"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "opgeroepen object is geen functie"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 msgid "non-constant offset for offset_of"
 msgstr "%Jdeclaratie van %qD als niet-static volgt declaratie als static"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "dereferentie van pointer naar onvolledig type"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "function not considered for inlining"
 msgid "reflection not suitable for alignment_of"
 msgstr "functie wordt niet als kandidaat voor inlining beschouwd"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 msgid "alignment_of on function type"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 msgid "reflection with incomplete type in alignment_of"
 msgstr "ongeldige toepassing van %qs op onvolledig type %qT "
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "dereferentie van pointer naar onvolledig type"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 msgid "reflect_function failed"
 msgstr "ongeldige operand van %s"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "argument to '-Xassembler' is missing"
 msgid "value member missing"
 msgstr "het argument van '-Xassembler' ontbreekt"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 msgid "unexpected value of value member"
 msgstr "ongeldige operand van %s"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "functie geeft geen string-type terug"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 msgid "reflection represents non-integral or bool type"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "functie geeft geen string-type terug"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 msgid "invalid argument to can_substitute"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 msgid "type is not object or reference type"
 msgstr "herhaald lid %qs"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 msgid "name is not a valid identifier"
 msgstr "het argument van %<cleanup%> is geen naam"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 msgid "neither name nor bit_width specified"
 msgstr "registernaam niet opgegeven voor %qs"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 #, fuzzy
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "breedte van bitveld %qs is geen integerconstante"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 msgid "both alignment and bit_width specified"
 msgstr "%Jer kan geen alignment opgegeven worden voor %qD"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 msgid "bit_width 0 with specified name"
 msgstr "veldbreedte"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "teller van rechtse shift is negatief"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 msgid "alignment is not power of two"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 msgid "alignment is negative"
 msgstr "teller van links shift is negatief"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 msgid "alignment is smaller than alignment_of"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+msgid "reflection does not have non-array object type"
+msgstr "%qs is smaller dan waarden van zijn type"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "cast to union type from type not present in union"
+msgid "current scope does not represent a function"
+msgstr "cast naar union-type van een type dat geen deel uitmaakt van de union"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+msgid "current scope does not represent a class nor a member function"
+msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 msgid "incomplete parent class"
 msgstr "herhaalde definitie %qs"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 msgid "neither complete class type nor namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 msgid "not a complete class type"
 msgstr "teruggeeftype is onvolledig"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 msgid "value cannot be extracted"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
@@ -22855,58 +22900,58 @@ msgstr "conversie gooit constantheid weg"
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "kandidaten zijn:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "argument van verkeerd type voor unaire min"
 
 # 'unary' = 'unair'?
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "argument van verkeerd type voor unaire plus"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "argument van verkeerd type voor bit-complement"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "argument van verkeerd type voor abs"
 
 # OK, ik geef het op: wat is hier een goede vertaling voor 'conjugation'?
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "argument van verkeerd type voor vervoeging"
 
 # 'unary' = 'unair'?
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 msgid "in argument to unary !"
 msgstr "argument van verkeerd type voor unaire plus"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 #, fuzzy
 msgid "no pre-increment operator for type"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 #, fuzzy
 msgid "no pre-decrement operator for type"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -22924,69 +22969,69 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "floating-point constante verkeerd gebruikt"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr ""
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, fuzzy, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, fuzzy, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "ongeldige constante"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 msgid "Expression is polymorphic"
 msgstr "ongeldige expressie als operand"
 
 # vertaling voor 'statement'?
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "expression statement has incomplete type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 msgid "Procedure unexpected as argument"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 msgid "Type shall have a character length of 1"
 msgstr "opvulkarakter in strfmon-formaat"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "types zijn niet helemaal compatibel"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -23056,7 +23101,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 msgid "array assignment"
 msgstr "beginwaarde ontbreekt"
@@ -23066,17 +23111,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -23263,12 +23308,12 @@ msgstr ""
 msgid "implied END DO"
 msgstr ""
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 #, fuzzy
 msgid "assignment"
 msgstr "beginwaarde ontbreekt"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 #, fuzzy
 msgid "pointer assignment"
 msgstr "ongeldige lvalue in toewijzing"
@@ -23277,139 +23322,139 @@ msgstr "ongeldige lvalue in toewijzing"
 msgid "simple IF"
 msgstr ""
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 msgid "allocatable argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 msgid "asynchronous argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 msgid "optional argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 msgid "pointer argument"
 msgstr "ongeldige lvalue in toewijzing"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 msgid "target argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 msgid "value argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 msgid "volatile argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 msgid "assumed-shape argument"
 msgstr "slechte combinatie van argumenten"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 msgid "assumed-rank argument"
 msgstr "slechte combinatie van argumenten"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 msgid "coarray argument"
 msgstr "beginwaarde ontbreekt"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 msgid "polymorphic argument"
 msgstr "geen argumenten"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 msgid "assumed-type argument"
 msgstr "slechte combinatie van argumenten"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 msgid "iterator variable"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 msgid "End expression in DO loop"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr ""
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr ""
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -23418,31 +23463,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -23505,27 +23550,27 @@ msgstr "functie-oproep heeft geaggregeerde waarde"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -23629,7 +23674,7 @@ msgid "expected boolean type"
 msgstr "ongeldige operand van %s"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 msgid "expected integer"
 msgstr "ongeldige operand van %s"
@@ -23700,7 +23745,7 @@ msgstr "geen argumenten"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 msgid "too many arguments"
 msgstr "te veel argumenten voor formaat"
@@ -24133,7 +24178,7 @@ msgstr ""
 msgid "target OS does not support unaligned accesses"
 msgstr "doel-CPU ondersteunt geen interworking"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "sectie-attributen worden niet ondersteund op dit doelsysteem"
@@ -24383,13 +24428,13 @@ msgstr "In functie %qs"
 msgid "Global declarative %s for %s"
 msgstr "herhaalde label-declaratie %qs"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24554,12 +24599,12 @@ msgstr "%<%.*s%> is niet gedefinieerd"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "onbekende machine-modus %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "onbekende machine-modus %qs"
@@ -25005,8 +25050,8 @@ msgstr "attribuut %qE botst met attribuut %s"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "eerdere declaratie van %qs"
@@ -25023,7 +25068,7 @@ msgstr "attribuut-commando %qE wordt genegeerd"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "attribuut-commando %qs wordt genegeerd"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "verkeerd aantal argumenten opgegeven voor attribuut %qE"
@@ -25033,7 +25078,7 @@ msgstr "verkeerd aantal argumenten opgegeven voor attribuut %qE"
 msgid "expected %i or more, found %i"
 msgstr "ongeldige operand van %s"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "ongeldige operand van %s"
@@ -25116,12 +25161,12 @@ msgstr ""
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25237,134 +25282,134 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "location is after end of function"
 msgstr "doorgeven van argument %d van %qs"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "ongeldige operand van %s"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot open source file %s\n"
 msgid "cannot open profile file %s"
 msgstr "Kan bronbestand %s niet openen\n"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "kan %s niet vinden"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "kan %s niet vinden"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "kan %s niet vinden"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "kan %s niet vinden"
@@ -25375,7 +25420,7 @@ msgstr "kan %s niet vinden"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "offset buiten de grenzen van een constante string"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qs tevoren hier gedeclareerd"
@@ -25480,7 +25525,7 @@ msgstr "te veel argumenten voor procedure `%s'"
 msgid "illegal argument 0 to %qs"
 msgstr "ontbrekend argument bij %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -25558,12 +25603,12 @@ msgid "cannot tail-call: %s"
 msgstr "[kan %s niet vinden]"
 
 # dit klinkt niet al te best
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "%qs is geen iterator"
@@ -26207,344 +26252,344 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "teller van links shift is negatief"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "beginwaarde ontbreekt"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline clone count is not compatible"
 msgstr "beginwaarde-element is niet constant"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr ""
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "%<return%> met waarde in een functie die void teruggeeft"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr ""
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "case-selector niet compatibel met label"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "case-selector niet compatibel met label"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "sectie-pointer ontbreekt"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr ""
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "sectie-pointer ontbreekt"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "teller van links shift is negatief"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "sectie-pointer ontbreekt"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "sectie-pointer ontbreekt"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr ""
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, fuzzy, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "dit is een eerdere declaratie"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "ongeldige beginwaarde"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of register to a different size"
 msgid "origin points to a different parent"
 msgstr "conversie van register naar een andere grootte"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr ""
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "het argument van '-%s' ontbreekt"
@@ -27324,17 +27369,17 @@ msgstr "variabele %qs is te groot"
 msgid "impossible constraint in %<asm%>"
 msgstr ""
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr ""
@@ -28013,7 +28058,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "%Jflexibel array-lid niet aan het eind van de struct"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -28053,7 +28098,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 msgid "%qD defined here"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
@@ -28074,24 +28119,24 @@ msgstr "herhaald lid %qs"
 msgid "function may return address of local variable"
 msgstr "functie geeft adres van lokale variabele terug"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "functie geeft adres van lokale variabele terug"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -28982,7 +29027,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 msgid "returned from %qD"
 msgstr "eerdere grant voor %qs"
@@ -29053,210 +29098,210 @@ msgstr "%Jgeneste functie %qD gedeclareerd maar niet gedefinieerd"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "onbekende machine-modus %qs"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "ongeldig type-argument %qs"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "ongeldig type-argument %qs"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "valid arguments to %qs are: %s"
 msgid "valid models are %e"
 msgstr "geldige argumenten van %qs zijn: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "ongeldig type-argument %qs"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared with attribute noinline"
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "functie %q+D is geherdeclareerd met attribuut 'noinline'"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qs"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "ongeldig vector-type voor attribuut %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "kan oproep van %qs niet inline maken"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 msgid "assigned here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr "%Jer kan geen alignment opgegeven worden voor %qD"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "ongeldige macronaam %<%.*s%>"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 msgid "call to %qD here"
 msgstr "kan oproep van %qs niet inline maken"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "%qs is geen geldige pointer-modus"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "herhaald lid %qs"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "%qs is geen geldige pointer-modus"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "geen register in adres"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "impliciete declaratie van functie %qE"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "call to %qD"
 msgstr "kan oproep van %qs niet inline maken"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "adres van globale registervariabele %qs gevraagd"
@@ -30069,346 +30114,346 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, fuzzy, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "eerdere definitie van %qs"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "geen beginwaarde voor variant-veld %qs"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, fuzzy, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "eerdere definitie van %qs"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, fuzzy, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "eerdere definitie van %qs"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, fuzzy, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "array subscript is geen integer"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "ongeldige operand voor %p-code"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, fuzzy, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "eerdere definitie van %qs"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, fuzzy, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, fuzzy, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "eerdere definitie van %qs"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 msgid "mismatching definition"
 msgstr "beginwaarde ontbreekt"
@@ -30428,7 +30473,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "ongeldige opslagklasse voor functie %qs"
@@ -30661,12 +30706,12 @@ msgstr "ongeldige macronaam %<%.*s%>"
 msgid "unable to find a register to spill"
 msgstr ""
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr ""
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -31043,7 +31088,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -32452,22 +32497,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr "operand %<%d%> is geen register"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -33412,171 +33457,171 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "In functie %qs"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "ongeldige constraints voor operand"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "grootte van array %qs is van een niet-integer type"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "subscript ontbreekt in array-referentie"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of register to a different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "conversie van register naar een andere grootte"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "ongeldige operand voor %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in shift expression"
 msgid "type mismatch in %qs"
 msgstr "types in shift-expressie komen niet overeen"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid shift operand"
 msgid "invalid %qs offset operator"
 msgstr "ongeldige shift-operand"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "ongeldige operand voor %%R"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "ongeldige shift-operand"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr ""
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr "waarde van struct-type gebruikt waar een scalair nodig is"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "ongeldige expressie als operand"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "functie kan niet inline gemaakt worden"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "ongeldige PC in tabel met regelnummers"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "ongeldige conversie in 'gimple'-aanroep"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "ongeldige PC in tabel met regelnummers"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -33587,611 +33632,611 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_next_arg%> opgeroepen zonder argument"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "ongeldig argument voor %<__builtin_return_address%>"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "ongeldige operand in de instructie"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, fuzzy, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, fuzzy, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "ongeldige operanden voor binaire %s-operator"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid vector types in nop conversion"
 msgstr "ongeldige types in NOP-conversie"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "ongeldige types in NOP-conversie"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "ongeldige types in adresruimte-conversie"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr ""
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in conversion to floating point"
 msgid "invalid types in conversion to floating-point"
 msgstr "ongeldige types in conversie naar floating-point"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "ongeldige types in conversie naar integer"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in shift expression"
 msgid "type mismatch in %qs expression"
 msgstr "types in shift-expressie komen niet overeen"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "ongeldige registernaam voor %qs"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "ongeldige registernaam voor %qs"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "niet-triviale conversie in unaire bewerking"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "niet-register als linkerhand van binaire bewerking"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "ongeldige operanden in binaire bewerking"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "ongeldige operanden voor binaire %s-operator"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "%qs is geen geldige pointer-modus"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "ongeldige waarheidsexpressie"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "ongeldige operanden voor binaire %s-operator"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "ongeldige waarheidsexpressie"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "ongeldige registernaam voor %qs"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "niet-ondersteunde versie"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid position or size in %qs"
 msgstr "%qs is geen geldige pointer-modus"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "grootte van array %qs is van een niet-integer type"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "te veel argumenten voor procedure `%s'"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%qs is geen iterator"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "ongeldige lvalue in toewijzing"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "ongeldige lvalue in toewijzing"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "ongeldige beginwaarde"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "ongeldige operand voor %%R"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "ongeldige waarde voor %%C"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qs"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "ongeldig vector-type voor attribuut %qs"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "non-register as LHS of binary operation"
 msgid "non-register as LHS with vector constructor"
 msgstr "niet-register als linkerhand van binaire bewerking"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "te weinig argumenten voor functie %qE"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "ongeldige operand voor %%s-code"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "ongeldige operand voor %%s-code"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, fuzzy, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "waarde met subscript is noch een array, noch een pointer"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "ongeldige operand voor %%s-code"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "ongeldige operand voor %%s-code"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "default-label niet in een switch-statement"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "case-label niet in een switch-statement"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "ongeldige operand voor %%s-code"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "case-label niet in een switch-statement"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "case-label niet in een switch-statement"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "case-label niet in een switch-statement"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "label context is not the current function declaration"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "ongeldige operand in de instructie"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "Ongeldig token in expressie"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "ongeldig adres"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "beginwaarde ontbreekt"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "ongeldige waarde voor %%C"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible type for argument %d of %qE"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "incompatibel type voor argument %d van %qE"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr ""
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "implicit declaration of function %qE"
 msgid "local declaration from a different function"
 msgstr "impliciete declaratie van functie %qE"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr ""
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr ""
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr ""
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "extra accolade-groep aan einde van beginwaarde"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "extra accolade-groep aan einde van beginwaarde"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "case-selector niet compatibel met label"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr "parameter %qD krijgt beginwaarde"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "eerdere impliciete declaratie van %qs"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "-pipe wordt niet ondersteund"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "beginwaarde ontbreekt"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%> functie keert terug"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, fuzzy, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "%Hde returnwaarde van %qD, gedeclareerd met het %<warn_unused_result%> atribuut, wordt genegeerd"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "%Hde returnwaarde van een functie, gedeclareerd met het %<warn_unused_result%> atribuut, wordt genegeerd"
@@ -34374,13 +34419,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "ongeldig element-type voor attribuut %qs"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -34895,7 +34940,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -35315,30 +35360,30 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "eerdere declaratie van %qs"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "%qD conflicts with used function"
 msgid "%qD conflicts for version %qB"
 msgstr "%qD botst met gebruikte functie"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
@@ -35414,7 +35459,7 @@ msgstr "Enkel variabelen met beginwaarde kunnen in het 8-bit gebied geplaatst wo
 msgid "no initializers are allowed in section %qs"
 msgstr "ingebouwde functie %qs kan niet uitgeschakeld worden"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, fuzzy, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "registernaam niet opgegeven voor %qs"
@@ -35565,7 +35610,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr ""
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "alias-definities worden niet ondersteund in deze configuratie; genegeerd"
@@ -35610,53 +35655,53 @@ msgstr ""
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "argument %d is alleen-lezen"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "argument %d is alleen-lezen"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "argumenten aan macro %qs gegeven"
@@ -35673,13 +35718,13 @@ msgstr "attribuut %qE is enkel van toepassing op variabelen en functies"
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for field of type %qT"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "attribuut %qE wordt genegeerd voor veld van type %qT"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "herhalings-aantal is geen integerconstante"
@@ -35904,12 +35949,12 @@ msgstr "kan %qs-modus niet gebruiken voor enumeratie-types"
 msgid "mode %qs applied to inappropriate type"
 msgstr "%qs-modus toegepast op ongeschikt type"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "%Jsectie-attributen worden niet ondersteund voor dit doelsysteem"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "sectie-attribuut is niet toegestaan voor %q+D"
@@ -35921,18 +35966,18 @@ msgstr "sectie-attribuut is niet toegestaan voor %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "het argument van attribuut %qE is geen string-constante"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "sectie-attribuut kan niet opgegeven worden voor lokale variabelen"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "%Jsectie van %qD geeft een conflict met een eerdere declaratie"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "%<%.*s%> is niet gedefinieerd"
@@ -36024,7 +36069,7 @@ msgstr "het argument van %<cleanup%> is geen naam"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "%Jgeneste functie %qD gedeclareerd maar niet gedefinieerd"
@@ -36075,13 +36120,13 @@ msgstr "attribuut %qE is enkel van toepassing op variabelen"
 msgid "%qE attribute is only applicable on functions"
 msgstr "attribuut %qE is enkel van toepassing op functies"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "attribuut %qs is enkel van toepassing op functies"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -36094,12 +36139,12 @@ msgstr "attribuut %qE is enkel van toepassing op variabelen"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "het argument van attribuut %qE is geen string-constante"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -36196,23 +36241,23 @@ msgstr "attribuut %qE wordt genegeerd omdat %qT reeds gedefinieerd is"
 msgid "visibility argument not a string"
 msgstr "zichtbaarheidsargument is geen string"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "attribuut %qE wordt genegeerd voor types"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qs als ander soort symbool geherdeclareerd"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -36230,7 +36275,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "attribuut %qE is enkel van toepassing op functies"
@@ -36307,7 +36352,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -36385,7 +36430,7 @@ msgstr "%<%.*s%> is niet gedefinieerd"
 msgid "%qE argument is not a function"
 msgstr "het argument van %<cleanup%> is geen functie"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr ""
@@ -36455,7 +36500,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "attribuut %qE wordt genegeerd voor types"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a string constant argument"
 msgid "%qE attribute requires a string argument"
@@ -36624,16 +36669,16 @@ msgid "requested position is less than zero"
 msgstr "gevraagde positie is kleiner dan nul"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "herhaalde label-declaratie %qs"
 
 # XXX FIXME:  duplicate
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "het argument van attribuut %qE is geen string-constante"
@@ -36913,7 +36958,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "gebruik liefst haakjes rond toewijzingen die als waarheid gebruikt worden"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "ongeldig gebruik van %<restrict%>"
@@ -37087,8 +37132,8 @@ msgstr "te weinig argumenten om een sentinel in te passen"
 msgid "missing sentinel in function call"
 msgstr "sentinel ontbreekt in functie-oproep"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -38115,7 +38160,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr "traditionele C verwerpt het aaneenplakken van stringconstantes"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -38170,7 +38215,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "ongeldig type voor iteratie-variabele %qE"
@@ -38186,17 +38231,17 @@ msgstr "ongeldig type voor iteratie-variabele %qE"
 msgid "%qE is not initialized"
 msgstr "parameter %qD krijgt beginwaarde"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, fuzzy, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "Ongeldig token in expressie"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "Ongeldig token in expressie"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 msgid "missing increment expression"
 msgstr "toewijzingsonderdrukking"
@@ -38206,7 +38251,7 @@ msgstr "toewijzingsonderdrukking"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "Ongeldig token in expressie"
@@ -38304,18 +38349,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qs is geen iterator"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "bitveld %qs heeft een ongeldig type"
@@ -38325,8 +38370,8 @@ msgstr "bitveld %qs heeft een ongeldig type"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "te veel invoerbestanden"
@@ -38854,7 +38899,7 @@ msgstr "misvormde #pragma pack"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "misvormde #pragma pack"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "rommel aan einde van %<#pragma %s%>"
@@ -38927,8 +38972,8 @@ msgstr "move insn niet opgevangen"
 msgid "wrong type argument to %s"
 msgstr "argument van verkeerd type voor abs"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -39422,17 +39467,17 @@ msgstr "kan functie %<main%> niet inline maken"
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, fuzzy, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "%s van alleen-lezen locatie"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "%s van alleen-lezen locatie"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, fuzzy, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "%s van alleen-lezen locatie"
@@ -39704,7 +39749,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "cast laat qualifiers van doeltype van pointer vallen"
 msgstr[1] "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -40658,7 +40703,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -41300,7 +41345,7 @@ msgstr "%s maakt integer van pointer zonder een cast"
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "%Jherdefinitie van %qD"
@@ -41346,7 +41391,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "%qs is geen bestand, pipe of tty"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -41399,7 +41444,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -41497,19 +41542,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec argument doorgegeven aan functie zonder prototype"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41555,212 +41600,212 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "attribuut %qs wordt genegeerd"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "ongeldige operanden voor binaire %s-operator"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%H value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "ongeldige waarde voor %%H"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "Ongeldige optie voor floating-point emulatie: -mfpe-%s"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "onbekende spec-functie '%s'"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "ongeldig argument voor %<__builtin_frame_address%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "ongeldig argument voor %<__builtin_frame_address%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "optie -mcpu=%s geeft conflicten met optie -mtune="
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "ondersteunt geen multilib"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "ISO C ondersteunt de %<%c%> lengte-optie niet"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "misvormde #pragma pack"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "misvormde #pragma weak"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41768,194 +41813,194 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr "het argument van %<alias%> is geen string"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "het argument van %<alias%> is geen string"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "het argument van %<alias%> is geen string"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "het argument van %<alias%> is geen string"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "misvormde #pragma pack"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "instructie-scheduling wordt niet ondersteund op deze doelmachine"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "dit is een eerdere declaratie"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, fuzzy, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "operandnummer buiten bereik"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "niet-ondersteunde versie"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "ongebruikte argumenten in $-stijl formaat"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, fuzzy, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "ongebruikte argumenten in $-stijl formaat"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "ongebruikte argumenten in $-stijl formaat"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "ongebruikte argumenten in $-stijl formaat"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "De -shared optie wordt op het ogenblik niet ondersteund voor VAX ELF."
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "%s met andere breedte ten gevolge van prototype"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "Alignment moet een kleine macht van twee zijn, en niet %d, in #pragma pack"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "%s met andere breedte ten gevolge van prototype"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "%s met andere breedte ten gevolge van prototype"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "%s met andere breedte ten gevolge van prototype"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "ongeldig type-argument %qs"
@@ -42147,12 +42192,12 @@ msgstr "het argument van %<asm%> is geen constante string"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -42292,22 +42337,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "attribuut %qE wordt genegeerd"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "attribuut %qE is enkel van toepassing op variabelen"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "onbekende machine-modus %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "ongeldig gebruik van %<restrict%>"
@@ -42853,12 +42898,12 @@ msgstr "-pipe wordt niet ondersteund"
 msgid "%<-fPIE%> is not supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-G en -static sluiten elkaar uit"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
@@ -42868,7 +42913,7 @@ msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "functie %qs kan geen waarde teruggeven"
@@ -43208,7 +43253,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "ongeldig argument voor %<__builtin_return_address%>"
@@ -43532,7 +43577,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -43705,174 +43750,174 @@ msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
 msgid "parameter to builtin not valid: %s"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr "Ongeldige optie voor floating-point emulatie: -mfpe-%s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "ongeldige const_double operand"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "ongeldige const_double operand"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "vectorlength must be an integer constant"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "vectorlengte moet een integerconstante zijn"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "argument moet een constante zijn"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ongeldig tweede argument voor %<__builtin_prefetch%>; zal nul gebruiken"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 msgid "invalid third argument"
 msgstr "ongeldige waarde voor %%C"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ongeldig derde argument voor __builtin_prefetch; zal nul gebruiken"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ongeldig derde argument voor __builtin_prefetch; zal nul gebruiken"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "second argument must be a const"
 msgstr "argument moet een constante zijn"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "%<defined%> zonder een naam"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "%<defined%> zonder een naam"
@@ -44275,8 +44320,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "case-selector niet compatibel met label"
@@ -44523,7 +44568,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -44548,12 +44593,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -44563,128 +44608,128 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "case-selector niet compatibel met label"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "case-selector niet compatibel met label"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "sectie-attributen worden niet ondersteund op dit doelsysteem"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "sectie-attributen worden niet ondersteund op dit doelsysteem"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "conflicterende types voor ingebouwde functie %qs"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "conflicterende types voor ingebouwde functie %qs"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "ISO C90 ondersteunt geen flexibele array-leden"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "herdefinitie van %<union %s%>"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "onbekende machine-modus %qs"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -44735,7 +44780,7 @@ msgstr ""
 msgid "argument %qd is not a constant"
 msgstr "argument %qd is geen constante"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr ""
@@ -44745,7 +44790,7 @@ msgstr ""
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "onbekende spec-functie '%s'"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr ""
@@ -44898,48 +44943,48 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "het argument van %<alias%> is geen string"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "%Jsectie-attributen worden niet ondersteund voor dit doelsysteem"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "sectie-attributen worden niet ondersteund op dit doelsysteem"
@@ -45710,7 +45755,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 msgid "bad builtin code"
 msgstr "slechte conditiecode"
@@ -45939,85 +45984,85 @@ msgstr "Kan tussentijds uitvoerbestand '%s' niet openen\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "-pipe wordt niet ondersteund"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "de zwakke declaratie van %qs moet publiek zijn"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute requires a void return type"
 msgstr "attribuut %qE wordt genegeerd voor types"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "attribuut %qE botst met attribuut %s"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a constant"
 msgid "complement argument must be constant"
 msgstr "argument moet een constante zijn"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "alias-definities worden niet ondersteund in deze configuratie; genegeerd"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "alias-definities worden niet ondersteund in deze configuratie; genegeerd"
@@ -46252,326 +46297,326 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "%qs is geen bestand, pipe of tty"
 
 # 'Arithmetic'?? 'rekensom' is wel correct, maar het klinkt zo stom.
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "rekensom met pointer naar onvolledig type"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "cast geeft functie-type op"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognizable insn:"
 msgid "unrecognized RVV builtin"
 msgstr "onherkenbare insn:"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "ongeldig type-argument %qs"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "slechte waarde (%s) voor de -march= optie"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec argument doorgegeven aan functie zonder prototype"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "%Jingebouwde functie %qD gedeclareerd als niet-functie"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "het argument van %<asm%> is geen constante string"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%<%c%> optie gebruikt bij type %<%c%>"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "doel-CPU ondersteunt geen interworking"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "ISO C ondersteunt de %<%c%> lengte-optie niet"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 ondersteunt geen complexe types"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred_stack_boundary=%d ligt niet tussen 2 en 31"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "ongeldig type-argument %qs"
@@ -47583,22 +47628,22 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "variabele %qs is te groot"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "attribuut %<__BELOW100__%> is enkel van toepassing op variabelen"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "%<__BELOW100__%> attribute only applies to variables"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -47831,32 +47876,32 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "doel-CPU ondersteunt geen interworking"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "Enkel variabelen met beginwaarde kunnen in het 8-bit gebied geplaatst worden."
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47946,7 +47991,7 @@ msgstr "attribuut %qs vereist prototypes met benoemde argumenten"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "attribuut %qs is enkel van toepassing op variadische functies"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -48030,8 +48075,8 @@ msgstr "%qs is geen iterator"
 msgid "could not get size of source file"
 msgstr "kan niet schrijven naar antwoordbestand %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "void-waarde niet genegeerd zoals het hoort"
@@ -48517,7 +48562,7 @@ msgstr "overflow in constante expressie"
 msgid "%qE defined as wrong kind of tag"
 msgstr ""
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to function types"
 msgid "%qE attribute applied to %qD with void return type"
@@ -48677,7 +48722,7 @@ msgstr "ISO C90 ondersteunt geen %<static%> of type-qualificaties in declaratore
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 ondersteunt geen %<[*]%> declaratoren van arrays"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "%<%.*s%> is niet gedefinieerd"
@@ -48687,7 +48732,7 @@ msgstr "%<%.*s%> is niet gedefinieerd"
 msgid "%q+D is usually a function"
 msgstr "%J%qD is meestal een functie"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "%Jgeen eerdere declaratie voor %qD"
@@ -48765,7 +48810,7 @@ msgstr "een object met een volatile veld kan niet in een register geplaatst word
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "ongeïnitialiseerde const %qD is ongeldig in C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -48966,7 +49011,7 @@ msgstr "opslagklasse opgegeven voor parameter %qs"
 msgid "storage class specified for unnamed parameter"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "opslagklasse opgegeven voor typenaam"
@@ -49140,7 +49185,7 @@ msgstr "%qs gedeclareerd als een functie die een array teruggeeft"
 msgid "function definition has qualified void return type"
 msgstr "functiedefinitie heeft een gekwalificeerde %<void%> als teruggeeftype"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "typekwalificaties op teruggeeftypes van functies worden genegeerd"
@@ -49268,7 +49313,7 @@ msgstr "ISO C verbiedt %<const%> of %<volatile%> functie-types"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "argument %d is alleen-lezen"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, fuzzy, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "variabele of veld %qs als void gedeclareerd"
@@ -49482,7 +49527,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr "onbekend veld %qs opgegeven in beginwaarde"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "declaratie declareert niets"
@@ -49547,7 +49592,7 @@ msgstr "struct heeft geen benoemde leden"
 msgid "struct has no members"
 msgstr "struct heeft geen leden"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "%Jflexibel array-lid in union"
@@ -49613,7 +49658,7 @@ msgstr "herdeclaratie van %<enum %qs%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -49673,7 +49718,7 @@ msgstr "ISO C beperkt enumeratiewaarden tot het bereik van het %<int%> type"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C beperkt enumeratiewaarden tot het bereik van het %<int%> type"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "%J%<noinline%> attribuut gegeven aan ingebouwde functie %qD"
@@ -49823,12 +49868,12 @@ msgstr "argument %qs komt niet overeen met prototype"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "argument %qs komt niet overeen met prototype"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, fuzzy, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "%<return%> zonder waarde in een functie die een niet-void waarde teruggeeft"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "parameter %qD krijgt beginwaarde"
@@ -49911,7 +49956,7 @@ msgstr "%<__thread%> samen met %<register%> gebruikt"
 msgid "two or more data types in declaration specifiers"
 msgstr "twee of meer data types opgegeven bij declaratie"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> is te lang voor GCC"
@@ -50020,7 +50065,7 @@ msgstr "ISO C90 ondersteunt geen complexe types"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C ondersteunt %<long long%> niet"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "sectie-attributen worden niet ondersteund voor dit doelsysteem"
@@ -50178,12 +50223,12 @@ msgstr "%<defined%> zonder een naam"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ ondersteunt %<long long%> niet"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -50245,39 +50290,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%<__thread%> samen met %s gebruikt"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "teller van links shift is negatief"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "teller van links shift is negatief"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "teller van rechtse shift is negatief"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "teller van links shift is >= breedte van het type"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "teller van rechtse shift is >= breedte van het type"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "teller van links shift is >= breedte van het type"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -50298,7 +50343,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 msgid "expected end of line"
 msgstr "ongeldige operand van %s"
@@ -50308,7 +50353,7 @@ msgstr "ongeldige operand van %s"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C verbiedt een leeg bronbestand"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -50356,8 +50401,8 @@ msgid "unknown type name %qE"
 msgstr "onbekende machine-modus %qs"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, fuzzy, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "meerdere opslagklassen in declaratie van %qs"
@@ -50392,7 +50437,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr ""
@@ -50407,13 +50452,13 @@ msgstr "herhaalde definitie %qs"
 msgid "unexpected attribute"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "sectie-attribuut is niet toegestaan voor %q+D"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -50459,7 +50504,7 @@ msgstr "%<auto%> in lege declaratie op bestandsniveau"
 msgid "%qs may only be used with a single declarator"
 msgstr "macro %qs gebruikt zonder argumenten"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr ""
@@ -50495,7 +50540,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "veld %qs als een functie gedeclareerd"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr ""
@@ -50525,7 +50570,7 @@ msgstr "beginwaarde-element is niet constant"
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 msgid "static assertion failed"
 msgstr "pex_init mislukt"
@@ -50581,8 +50626,8 @@ msgstr "kan %qs-modus niet gebruiken voor enumeratie-types"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, fuzzy, gcc-internal-format
 msgid "expected identifier"
 msgstr "ongeldige operand van %s"
@@ -50612,12 +50657,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "komma aan het einde van enumerator-lijst"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50698,22 +50743,22 @@ msgstr "top-level declaratie van %qs specifieert %<auto%>"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute does not apply to types"
 msgid "%qE attribute does not take any arguments"
@@ -50725,7 +50770,7 @@ msgstr "attribuut %qE heeft geen betekenis voor types"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 ondersteunt geen %<[*]%> declaratoren van arrays"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -50756,17 +50801,17 @@ msgstr "ISO C90 verbiedt het opgeven van het te initialiseren element"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "ISO C staat het gebruik van %<varargs.h%> niet toe"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -50776,44 +50821,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "herhalings-aantal is geen integerconstante"
@@ -50844,7 +50889,7 @@ msgstr "ISO C90 verbiedt labeldeclaraties"
 msgid "expected %<}%> before %<else%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -50859,7 +50904,7 @@ msgstr "ISO C verbiedt een label aan het einde van een samengesteld statement"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, fuzzy, gcc-internal-format
 msgid "expected statement"
 msgstr "ongeldige beginwaarde"
@@ -50894,27 +50939,27 @@ msgstr "ISO C ondersteunt %<long long%> niet"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 msgid "expected declaration"
 msgstr "lege declaratie"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, fuzzy, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "leeg body in een else-statement"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, fuzzy, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "leeg body in een else-statement"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -50934,12 +50979,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr "ongeldig register in de instructie"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -50955,8 +51000,8 @@ msgstr "sentinel ontbreekt in functie-oproep"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "herhaalde case-waarde"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -50978,12 +51023,12 @@ msgstr "ISO C verbiedt het weglaten van de middelste term van een ?: expresie"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "%qs tevoren hier gedeclareerd"
@@ -51160,7 +51205,7 @@ msgstr "ISO C90 ondersteunt %<long long%> niet"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, fuzzy, gcc-internal-format
 msgid "expected expression"
 msgstr "ongeldige waarheidsexpressie"
@@ -51176,13 +51221,13 @@ msgstr "accolade-groep in expressie enkel toegestaan binnen een functie"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C verbiedt accolade-groepen in expressies"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "de tweede parameter van %<va_start%> is niet het laatste benoemde argument"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -51333,7 +51378,7 @@ msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "te weinig argumenten voor functie %<va_start%>"
@@ -51373,7 +51418,7 @@ msgstr "niet-floating-point argument voor functie %qs"
 msgid "rotate count is negative"
 msgstr "teller van links shift is negatief"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -51483,7 +51528,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -51523,12 +51568,12 @@ msgstr "meerdere opslagklassen in declaratie van %qs"
 msgid "no type or storage class may be specified here,"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 msgid "missing property attribute"
 msgstr "beginwaarde ontbreekt"
@@ -51538,57 +51583,57 @@ msgstr "beginwaarde ontbreekt"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "onbekende operator '%s' in %%:version-compare"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "herdeclaratie van %qs"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "misvormde #pragma pack(pop[,id])"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -51598,12 +51643,12 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "overflow in constante expressie"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "misvormde #pragma pack(pop[,id])"
@@ -51613,11 +51658,11 @@ msgstr "misvormde #pragma pack(pop[,id])"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "te veel invoerbestanden"
@@ -51632,58 +51677,58 @@ msgstr "%<defined%> zonder een naam"
 msgid "%qD is not a variable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -51706,22 +51751,22 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr ""
@@ -51731,100 +51776,100 @@ msgstr ""
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "te veel argumenten voor formaat"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, fuzzy, gcc-internal-format
 #| msgid "both %<long%> and %<void%> in declaration specifiers"
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "zowel %<long%> als %<void%> opgegeven bij declaratie"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "ongeldige const_double operand"
@@ -51834,39 +51879,39 @@ msgstr "ongeldige const_double operand"
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "herhaalde %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "expressie-statement heeft onvolledig type"
@@ -51881,22 +51926,22 @@ msgstr "ongeldige operand van %s"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "herhaalde case-waarde"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "herhaalde case-waarde"
@@ -51906,7 +51951,7 @@ msgstr "herhaalde case-waarde"
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51921,315 +51966,315 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "case-selector niet compatibel met label"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "ongeldige const_double operand"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "ongeldige const_double operand"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr ""
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "ongeldige const_double operand"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "ongeldige const_double operand"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "onbekende machine-modus %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr "onbekende machine-modus %qs"
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr ""
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "herhaalde case-waarde"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<target%> modifier"
 msgstr "herhaalde %<restrict%>"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "herhaalde case-waarde"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "ongeldige operand van %s"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%<__thread%> samen met %s gebruikt"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "lege declaratie"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "de declaratie van %qs verbergt een globale declaratie"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "ongeldige linker operand van %s"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -52244,7 +52289,7 @@ msgstr "%<%.*s%> is niet gedefinieerd"
 msgid "expected function name"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qs is meestal een functie"
@@ -52254,22 +52299,22 @@ msgstr "%qs is meestal een functie"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr ""
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -52294,7 +52339,7 @@ msgstr ""
 msgid "modified here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "expressie-statement heeft onvolledig type"
@@ -52329,110 +52374,110 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "case-selector niet compatibel met label"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "conflicterende declaraties van %qs"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "ongeldige bewerking met %<__fpreg%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "ongeldige bewerking met %<__fpreg%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "ongeldige bewerking met %<__fpreg%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, fuzzy, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "ongeldige bewerking met %<__fpreg%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "beginwaarde-element is niet constant"
@@ -52442,27 +52487,27 @@ msgstr "beginwaarde-element is niet constant"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr ""
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -52472,32 +52517,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "top-level declaratie van %qs specifieert %<auto%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 msgid "for statement expected"
 msgstr "overflow in constante expressie"
@@ -52505,68 +52550,68 @@ msgstr "overflow in constante expressie"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 msgid "loop nest expected"
 msgstr "overflow in constante expressie"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, fuzzy, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "herdeclaratie van %qs"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "geen argumenten"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "ongeldige operand van %s"
@@ -52576,7 +52621,7 @@ msgstr "ongeldige operand van %s"
 msgid "expected a function name"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 msgid "expected target-function call"
 msgstr "ongeldige operand van %s"
@@ -52586,47 +52631,47 @@ msgstr "ongeldige operand van %s"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -52641,57 +52686,57 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "herdeclaratie van %qs"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "onbekende machine-modus %qs"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "__builtin_saveregs wordt niet ondersteund door dit doelsysteem"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "herdeclaratie van %qs"
@@ -52701,27 +52746,27 @@ msgstr "herdeclaratie van %qs"
 msgid "variant %qD is not a function"
 msgstr "%qs is meestal een functie"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "te veel invoerbestanden"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "opslagklasse opgegeven voor structure-veld %qs"
@@ -52731,7 +52776,7 @@ msgstr "opslagklasse opgegeven voor structure-veld %qs"
 msgid "%qD is not of pointer type"
 msgstr "%qs is geen iterator"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "ongeldige operand van %s"
@@ -52741,17 +52786,17 @@ msgstr "ongeldige operand van %s"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "ongeldige operand van %s"
@@ -52771,12 +52816,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "%Jgeneste functie %qD gedeclareerd maar niet gedefinieerd"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "Alignment moet een kleine macht van twee zijn, en niet %d, in #pragma pack"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "functie-definitie als %<typdef%> gedeclareerd"
@@ -52786,7 +52831,7 @@ msgstr "functie-definitie als %<typdef%> gedeclareerd"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "%Jparameter %qD heeft een onvolledig type"
@@ -52796,7 +52841,7 @@ msgstr "%Jparameter %qD heeft een onvolledig type"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
@@ -52812,84 +52857,84 @@ msgstr "cast geeft functie-type op"
 msgid "no declaration of base function %qs"
 msgstr "impliciete declaratie van functie %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "functie-definitie als %<register%> gedeclareerd"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "ongeldige operand van %s"
@@ -52914,12 +52959,12 @@ msgstr "de declaratie van %qs verbergt een parameter"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "dit is een eerdere declaratie"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 msgid "unexpected clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "beginwaarde ontbreekt"
@@ -52979,32 +53024,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr ""
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -53019,160 +53064,160 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 msgid "expected directive name"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "onbekende machine-modus %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 msgid "unknown directive name"
 msgstr "onbekende machine-modus %qs"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, fuzzy, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "label %qs gebruikt maar niet gedefinieerd"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, fuzzy, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%Jparameter %u heeft een onvolledig type"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -53182,7 +53227,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -53197,7 +53242,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr "%qs heeft een onvolledig type"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "ongeldig gebruik van een void-expressie"
@@ -53229,170 +53274,170 @@ msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
 # goede vertaling van variadic?
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "attribuut %qs is enkel van toepassing op variadische functies"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, fuzzy, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "functie-types zijn niet echt compatibel in ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "types zijn niet helemaal compatibel"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "types zijn niet helemaal compatibel"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, fuzzy, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%Jinvalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "%Jongeldig gebruik van structure met flexibel array-lid"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "union heeft geen lid dat %qs heet"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, fuzzy, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "union heeft geen lid dat %qs heet"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, fuzzy, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, fuzzy, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "vraag naar lid %qs in iets dat geen structure of union is"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "%<void *%> pointer wordt gederefereerd"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "waarde met subscript is noch een array, noch een pointer"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "array subscript is geen integer"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "doorgeven van argument %d van pointer naar functie"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "array subscript is geen integer"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C verbiedt het gebruik van subscripts bij een %<register%> array"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, fuzzy, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 verbiedt het gebruik van subscripts bij een array die geen lvalue is"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qs als ander soort symbool geherdeclareerd"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "opgeroepen object is geen functie"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "opgeroepen object is geen functie"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "opgeroepen object is geen functie"
@@ -53400,1903 +53445,1903 @@ msgstr "opgeroepen object is geen functie"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr ""
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "functiedefinitie heeft een gekwalificeerde %<void%> als teruggeeftype"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "het type van formele parameter %d is onvolledig"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "%s als integer in plaats van floating-point ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "%s als floating-point in plaats van complex ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "%s als complex in plaats van floating-point ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "%s als floating-point in plaats van integer ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "%s als complex in plaats van floating-point ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "%s als floating-point in plaats van complex ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "%s als %<float%> in plaats van %<double%> ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "%s als floating-point in plaats van complex ten gevolge van een prototype"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "%s met andere breedte ten gevolge van prototype"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "%s als unsigned ten gevolge van prototype"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "%s als signed ten gevolge van prototype"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "te veel argumenten voor functie %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "te veel argumenten voor functie %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "te veel argumenten voor functie %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "ongeldige registernaam voor %qs"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "te weinig argumenten voor functie %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "te weinig argumenten voor functie %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "te weinig argumenten voor functie %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr ""
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "vergelijking tussen pointer en integer"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "array subscript is geen integer"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "vergelijking tussen %qT en %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, fuzzy, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "pointer van type %<void *%> gebruikt in aftrekking"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "pointer naar functie gebruikt in aftrekking"
 
 # 'Arithmetic'?? 'rekensom' is wel correct, maar het klinkt zo stom.
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "rekensom met pointer naar onvolledig type"
 
 # 'Arithmetic'?? 'rekensom' is wel correct, maar het klinkt zo stom.
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "rekensom met pointer naar onvolledig type"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, fuzzy, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C ondersteunt het %<%c%> formaat niet"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "argument van verkeerd type voor abs"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "argument van verkeerd type voor unair uitroepingsteken"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C ondersteunt het %<%c%> formaat niet"
 
 # Wat is beter: 'incrementeren', 'incrementering', of 'increment'?
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "argument van verkeerd type voor incrementeren"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "argument van verkeerd type voor decrementeren"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr ""
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "kan adres van bitveld %qs niet nemen"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "kan adres van bitveld %qs niet nemen"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "adres van registervariabele %qs gevraagd"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr "adres van registervariabele %qs gevraagd"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, fuzzy, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "globale registervariabele %qs gebruikt in geneste functie"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, fuzzy, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "registervariabele %qs gebruikt in geneste functie"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, fuzzy, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "adres van globale registervariabele %qs gevraagd"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, fuzzy, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "adres van registervariabele %qs gevraagd"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, fuzzy, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "ongeldige registernaam voor %qs"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C verbiedt voorwaardelijke expressies met maar één void-zijde"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "pointertypes in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "pointertypes in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "pointertypes in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C verbiedt voorwaardelijke expressies tussen %<void *%> en een functiepointer"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "pointertypes in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "second expression has type %qT"
 msgstr "ongeldige expressie als operand"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "types in voorwaardelijke expressie komen niet overeen (pointer/integer)"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "%Hde returnwaarde van %qD, gedeclareerd met het %<warn_unused_result%> atribuut, wordt genegeerd"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "%Hde returnwaarde van %qD, gedeclareerd met het %<warn_unused_result%> atribuut, wordt genegeerd"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "%Hde returnwaarde van %qD, gedeclareerd met het %<warn_unused_result%> atribuut, wordt genegeerd"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "%Hde returnwaarde van %qD, gedeclareerd met het %<warn_unused_result%> atribuut, wordt genegeerd"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "linker operand van comma-expressie heeft geen effect"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "linker operand van comma-expressie heeft geen effect"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 msgid "cast adds %q#v qualifier to function type"
 msgstr "cast geeft functie-type op"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "cast geeft array-type op"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "cast geeft functie-type op"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C verbiedt het casten van een niet-scalair naar hetzelfde type"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C verbiedt casts naar een union-type"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "cast naar union-type van een type dat geen deel uitmaakt van de union"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "cast verhoogt het benodigde alignment van het doeltype"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "cast van pointer naar integer met andere grootte"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "cast naar pointer van integer met andere grootte"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C verbiedt een vergelijking van %<void *%> met een functie-pointer"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C verbiedt een vergelijking van %<void *%> met een functie-pointer"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "toewijzingsonderdrukking"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, fuzzy, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(dicht bij initialisatie van %qs)"
 
 # moet beter kunnen - "... waar haakjes rond staan" klinkt ook al niet geweldig
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "array heeft stringconstante tussen haakjes als beginwaarde"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 msgid "expected %e but argument is of type %e"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 msgid "%e declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, fuzzy, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "ongeldige registernaam voor %qs"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "%s maakt gekwalificeerde functiepointer van een niet gekwalificeerde"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "%s maakt gekwalificeerde functiepointer van een niet gekwalificeerde"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "%s maakt gekwalificeerde functiepointer van een niet gekwalificeerde"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "%s maakt gekwalificeerde functiepointer van een niet gekwalificeerde"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, fuzzy, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C verbiedt conversie van argumenten naar union type"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, fuzzy, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "ongeldige registernaam voor %qs"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "cast van pointer naar integer met andere grootte"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "%s als complex in plaats van floating-point ten gevolge van een prototype"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C verbiedt %s tussen functiepointer en %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C verbiedt %s tussen functiepointer en %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C verbiedt %s tussen functiepointer en %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C verbiedt %s tussen functiepointer en %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
 # 'signedness' = 'signed-heid'?
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
 # 'signedness' = 'signed-heid'?
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
 # 'signedness' = 'signed-heid'?
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
 # 'signedness' = 'signed-heid'?
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "doelen van pointer in %s verschillen in signedness"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "toewijzing vanuit incompatibel pointertype"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "toewijzing vanuit incompatibel pointertype"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "initialisatie vanuit incompatibel pointertype"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "initialisatie vanuit incompatibel pointertype"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "pointer naar lid-functie gebruikt in rekensom"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "%<return%> met waarde in een functie die void teruggeeft"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "%s maakt pointer van integer zonder een cast"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "%s maakt pointer van integer zonder een cast"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "%s maakt pointer van integer zonder een cast"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "%s maakt pointer van integer zonder een cast"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "%s maakt integer van pointer zonder een cast"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "%s maakt integer van pointer zonder een cast"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "%s maakt integer van pointer zonder een cast"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "%s maakt integer van pointer zonder een cast"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "incompatibel type voor argument %d van %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr ""
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr ""
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "array-index in beginwaarde is niet van een integer type"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "array-index in beginwaarde is niet van een integer type"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "initialisatie van flexibel array-lid"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "beginwaarde-string voor array van chars is te lang"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "beginwaarde-string voor array van chars is te lang"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "array van ongeschikt type heeft stringconstante als beginwaarde"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "ongeldig gebruik van array die geen lvalue is"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "ongeldige beginwaarde"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "beginwaarde-element is niet constant"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "array krijgt niet-constante array-expressie als beginwaarde"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "beginwaarde-element kan niet berekend worden tijdens het laden"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, fuzzy, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "extra accolade-groep aan einde van beginwaarde"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "accolades rond scalaire beginwaarde"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "initialisatie van flexibel array-lid in een geneste context"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "accolades ontbreken rond beginwaarde"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "extra elementen in scalaire beginwaarde"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "array-index in beginwaarde van niet-array"
 
 # of gewoon "veldnaam niet in beginwaarde van record of union"?
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "veldnaam in beginwaarde van iets anders dan record of union"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "array-index in beginwaarde is niet van een integer type"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "array-index in beginwaarde is niet van een integer type"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "niet-constante array-index in beginwaarde"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "array-index in beginwaarde overschrijdt de grenzen van de array"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "leeg indexbereik in beginwaarde"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "array-indexbereik in beginwaarde overschrijdt de grenzen van de array"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "geïnitialiseerd veld wordt overschreven"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "geïnitialiseerd veld met neveneffecten wordt overschreven"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "overtollige elementen in beginwaarde van union"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "overtollige elementen in beginwaarde van struct"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "niet-statische initialisatie van flexibel array-lid"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "overtollige elementen in beginwaarde van union"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr ""
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "overtollige elementen in beginwaarde van array"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "overtollige elementen in beginwaarde van vector"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "overtollige elementen in beginwaarde van scalair"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C staat geen extra %<;%> buiten een functie toe"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr "ISO C staat geen extra %<;%> buiten een functie toe"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr "operand %<%d%> is geen register"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr "ISO C staat geen extra %<;%> buiten een functie toe"
 
 # betere vertaling voor 'function scope'?
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD is niet gedefinieerd buiten een functie"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C verbiedt %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "het argument van %<cleanup%> is geen naam"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, fuzzy, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "als %<noreturn%> gedeclareerde functie bevat een %<return%> statement"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, fuzzy, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> zonder waarde in een functie die een niet-void waarde teruggeeft"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, fuzzy, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> met waarde in een functie die void teruggeeft"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "%<return%> met waarde in een functie die void teruggeeft"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of label"
 msgstr "functie geeft adres van lokale variabele terug"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "functie geeft adres van lokale variabele terug"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch-waarde is geen integer"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, fuzzy, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "%<long%> switch-expressie wordt in ISO C niet naar %<int%> geconverteerd"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case-label niet in een switch-statement"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, fuzzy, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "default-label niet in een switch-statement"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break-statement niet in een lus of switch"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, fuzzy, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "break-statement niet in een lus of switch"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue-statement niet in een lus"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "statement zonder effect"
 
 # vertaling voor 'statement'?
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "vergelijking tussen types %qT en %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr ""
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C verbiedt een vergelijking van %<void *%> met een functie-pointer"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "vergelijking tussen pointer en integer"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "vergelijking van volledige en onvolledige pointers"
 
 # 'ordered' -> 'bevolen' of 'geordend'? Waarschijnlijk het laatste.
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C verbiedt geordende vergelijkingen tussen pointers naar functies"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "geordende vergelijking van pointer met null-pointer"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "geordende vergelijking van pointer met integer nul"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, fuzzy, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "waarde van array-type gebruikt waar een scalair nodig is"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, fuzzy, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "waarde van struct-type gebruikt waar een scalair nodig is"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, fuzzy, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "waarde van union-type gebruikt waar een scalair nodig is"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "waarde van struct-type gebruikt waar een scalair nodig is"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "ongeldige operand van %s"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "te veel invoerbestanden"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "grootte van array %qs is van een niet-integer type"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "ISO C90 verbiedt array %qs van variabele grootte"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "ISO C verbiedt gekwalificeerde functie-types"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "%Jparameter %qD heeft een onvolledig type"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "breedte van bitveld %qs is geen integerconstante"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "ongeldige operand voor 'o' modifier"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "ongeldige operand van %s"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "ISO C verbiedt gekwalificeerde functie-types"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "ISO C90 verbiedt array %qs van variabele grootte"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr ""
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "grootte van %qs is %u bytes"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "ISO C90 verbiedt array %qs van variabele grootte"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr "overflow in constante expressie"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "niet-ondersteunde versie"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qs is geen static veld"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "waarde met subscript is noch een array, noch een pointer"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "te veel invoerbestanden"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr ""
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "%qs is geen iterator"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
 # Of misschien beter "... niet van het %<va_list%> type"?
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "het eerste argument van %<va_arg%> is geen %<va_list%>"
 
 # Of misschien beter "... niet van het %<va_list%> type"?
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "het eerste argument van %<va_arg%> is geen %<va_list%>"
 
 # Of misschien beter "... niet van het %<va_list%> type"?
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "het eerste argument van %<va_arg%> is geen %<va_list%>"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -55572,253 +55617,248 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "parameter %qs krijgt beginwaarde"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s: ongeldige bestandsnaam: %s\n"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr ""
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr ""
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "onbekende machine-modus %qs"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qs is smaller dan waarden van zijn type"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55827,73 +55867,83 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "lege declaratie"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "onbekende machine-modus %qs"
 
 # 'signedness' = 'signed-heid'?
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, fuzzy, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr "doelen van pointer in %s verschillen in signedness"
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%<%.*s%> is niet gedefinieerd"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55903,13 +55953,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "te veel invoerbestanden"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "kan %s niet vinden"
@@ -55925,61 +55975,61 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr "%s gaf exit-status %d terug"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr "spec '%s' is ongeldig"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: fout bij wachten op proces: %s\n"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr "%s: fout bij wachten op proces: %s\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to open %s"
 msgid "failed compiling %s"
@@ -56425,7 +56475,7 @@ msgstr ""
 msgid "%q#D is private within this context"
 msgstr "registervariabele %qs gebruikt in geneste functie"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 msgid "declared private here"
 msgstr "%qs tevoren hier gedeclareerd"
@@ -56435,7 +56485,7 @@ msgstr "%qs tevoren hier gedeclareerd"
 msgid "%q#D is protected within this context"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 msgid "declared protected here"
 msgstr "%qs tevoren hier gedeclareerd"
@@ -56771,7 +56821,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr ""
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 msgid "cannot convert %qH to %qI"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
@@ -56791,7 +56841,7 @@ msgstr "Teveel argumenten in oproep van %qs"
 msgid "call to non-function %qD"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -57390,7 +57440,7 @@ msgstr "%Jflexibel array-lid in overigens lege struct"
 msgid "next member %q#D declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, fuzzy, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "herdefinitie van %qs"
@@ -57400,7 +57450,7 @@ msgstr "herdefinitie van %qs"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -57531,7 +57581,7 @@ msgstr "ongeldige opslagklasse voor functie %qs"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -57582,7 +57632,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%J%qD is gewoonlijk een niet-static funtie"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -57617,845 +57667,845 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s ondersteunt %s niet"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr ""
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "te weinig argumenten voor functie %<va_start%>"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr ""
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "%<register%> in lege declaratie op bestandsniveau"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "%<void *%> pointer wordt gederefereerd"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "functie-definitie als %<typdef%> gedeclareerd"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr ""
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "kon '%s' niet uitvoeren: %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "'o' operand is geen constante"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 msgid "allocation performed here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%J%qD werd voor haar definitie gebruikt zonder protoype"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "linker operand van comma-expressie heeft geen effect"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "linker operand van comma-expressie heeft geen effect"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "array subscript is geen integer"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "array subscript is geen integer"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "%<void *%> pointer wordt gederefereerd"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "sectie-attributen worden niet ondersteund op dit doelsysteem"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 msgid "%qT object created here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 msgid "allocated here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "array-index in beginwaarde van niet-array"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%qs is geen iterator"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 msgid "use of %qD"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "%Jeerder hier gebruikt"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "'B' operand is geen constante"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "break-statement niet in een lus of switch"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "functiedefinitie heeft een gekwalificeerde %<void%> als teruggeeftype"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "overflow in constante expressie"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "niet-constante array-index in beginwaarde"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "onverwachte operand"
@@ -58588,354 +58638,354 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%qs is meestal een functie"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%J%qD is gewoonlijk een niet-static funtie"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an aggregate"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an array"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "%J%qD is gewoonlijk een niet-static funtie"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "%qs is meestal een functie"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%J%qD is gewoonlijk een niet-static funtie"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "%J%qD is gewoonlijk een niet-static funtie"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%J%qD is gewoonlijk een niet-static funtie"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-msgid "%qT is not consteval-only"
+msgid "%qT is not a structural type"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "%qs is geen iterator"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "iterator %qs is van een afgeleid type"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "ongeldige constante"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
 # is de "," deel van de special format spec of niet?  en moet "true" hier vertaald worden of niet?
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "structure heeft geen lid dat %qs heet"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -58966,47 +59016,47 @@ msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
 msgid "previous declaration with fewer contracts here"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "parameter declared here"
 msgstr "%Jparameter %qD als %<inline%> gedeclareerd"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "herdeclaratie van %qs"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 msgid "first declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -59078,7 +59128,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%Jeerder hier gebruikt"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "union heeft geen lid dat %qs heet"
@@ -59150,86 +59200,86 @@ msgstr "continue-statement niet in een lus"
 msgid "awaitable type %qT is not a structure"
 msgstr "argument %qs komt niet overeen met prototype"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "als %<noreturn%> gedeclareerde functie bevat een %<return%> statement"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "%Jgeen eerder prototype voor %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "herhaalde %qs"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "pointers zijn niet toegestaan als case-waarden"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -59254,69 +59304,74 @@ msgstr "%qs is meestal een functie"
 msgid "%qs used outside of constant expressions"
 msgstr "overflow in constante expressie"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "lege declaratie"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "overflow in constante expressie"
 
 # is de "," deel van de special format spec of niet?  en moet "true" hier vertaald worden of niet?
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "%qs is geen iterator"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qs is geen iterator"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qs is geen iterator"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -59361,7 +59416,7 @@ msgstr "ongeldige registernaam voor %qs"
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, fuzzy, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "kan niet derefereren, is geen pointer."
@@ -59751,7 +59806,7 @@ msgstr "eerdere declaratie van %qs"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "eerdere declaratie van %qs"
@@ -59972,12 +60027,12 @@ msgstr "argumenten aan macro %qs gegeven"
 msgid "previous specification in %q#D here"
 msgstr "eerdere definitie van %qs"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "%Jeerder hier gebruikt"
@@ -60182,7 +60237,7 @@ msgstr "(dicht bij initialisatie van %qs)"
 msgid "  enters %<template for%> statement"
 msgstr "herdeclaratie van %qs"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "macro %qs gebruikt zonder argumenten"
@@ -60227,2427 +60282,2437 @@ msgstr "%qs is geen iterator"
 msgid "template parameters do not match template %qD"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "ongeldig gebruik van onvolledige typedef %qs"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr "anonieme %s gedeclareerd binnen parameterlijst"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "herdeclaratie van %qs"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, fuzzy, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "nutteloos sleutelwoord of typenaam in lege declaratie"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr ""
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, fuzzy, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "type krijgt standaardwaarde %<int%> in de declaratie van %qs"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%<register%> in lege declaratie op bestandsniveau"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "herhaalde definitie %qs"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr ""
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "attribuut wordt genegeerd"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr ""
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD krijgt beginwaarde (gebruik beter __typeof__)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "de declaratie van %qs is %<extern%> en heeft een beginwaarde"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, fuzzy, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "functie-definitie als %<auto%> gedeclareerd"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%qs is geen static veld"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "herdeclaratie van %qs"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "herhaalde label-declaratie %qs"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, fuzzy, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "dubbele beginwaarde"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "de zwakke declaratie van %qs moet aan de definitie voorafgaan"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, fuzzy, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "variabele %qs heeft beginwaarde, maar een onvolledig type"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "elementen van array %qs hebben een onvolledig type"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, fuzzy, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "parameter %qs heeft een onvolledig type"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qs als ander soort symbool geherdeclareerd"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, fuzzy, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "beginwaarde legt grootte van %qs niet vast"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "array-grootte ontbreekt in %qs"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "array %qs heeft grootte die negatief of 0 is"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "opslaggrootte van %qs is onbekend"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "opslaggrootte van %qs is niet constant"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "ongeïnitialiseerde const %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr ""
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr ""
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr ""
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "union heeft geen lid dat %qs heet"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "ongeldige beginwaarde"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, fuzzy, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "ongeldige beginwaarde voor veld %qs"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, fuzzy, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "accolades rond scalaire beginwaarde"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "accolades rond scalaire beginwaarde"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, fuzzy, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "accolades ontbreken rond beginwaarde"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "elementen van array %qs hebben een onvolledig type"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, fuzzy, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "ISO C90 verbiedt het gebruik van samengestelde expressies als lvalues"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%qs heeft een onvolledig type"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, fuzzy, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "overtollige elementen in beginwaarde van union"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr ""
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr ""
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, fuzzy, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "adres van registervariabele %qs gevraagd"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "%qs is hier niet gedeclareerd (eerste gebruik in deze functie)"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "Alignment moet een kleine macht van twee zijn, en niet %d, in #pragma pack"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "te weinig argumenten voor functie %qs"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "%Jherdeclaratie van enum %qD"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "de declaratie van %qs is %<extern%> en heeft een beginwaarde"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "type van teruggeefwaarde is onvolledig"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, fuzzy, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, fuzzy, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "typedef %qs krijgt beginwaarde alsof het een variabele is"
 
 # Betere vertaling voor 'decompose'?
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decompose address"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "kan adres niet ontleden"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 msgid "lambda declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "dereferentie van pointer naar onvolledig type"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 verbiedt array %qs van variabele grootte"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "teruggeeftype is onvolledig"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "opslagklasse opgegeven voor structure-veld %qs"
 msgstr[1] "opslagklasse opgegeven voor structure-veld %qs"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "dubbele beginwaarde"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "dubbele beginwaarde"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "ongeldig gebruik van onvolledige typedef %qs"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "beginwaarde legt grootte van %qs niet vast"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "array-grootte ontbreekt in %qs"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "array %qs heeft grootte die negatief of 0 is"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, fuzzy, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "%qs is meestal een functie"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, fuzzy, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "de zwakke declaratie van %qs moet aan de definitie voorafgaan"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr ""
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "parameter %qs als void gedeclareerd"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 msgid "  declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "Ongeldige optie %qs"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr ""
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, fuzzy, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "functie-definitie als %<auto%> gedeclareerd"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "functie-definitie als %<auto%> gedeclareerd"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, fuzzy, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "de declaratie van %qs is %<extern%> en heeft een beginwaarde"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ verbiedt array %qs met lengte 0"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ verbiedt array %qs met lengte 0"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ verbiedt array %qs van variabele lengte"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ verbiedt array %qs van variabele lengte"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr ""
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr ""
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "%qs wordt gedeclareerd als een array van voids"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "creating array of void"
 msgstr "doorgeven van argument %d van %qs"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 msgid "creating array of functions"
 msgstr "doorgeven van argument %d van %qs"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "creating array of references"
 msgstr "doorgeven van argument %d van %qs"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 msgid "creating array of function members"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr "ISO C90 verbiedt array %qs van variabele grootte"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, fuzzy, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "registernaam niet opgegeven voor %qs"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "registernaam niet opgegeven voor %qs"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "structure heeft geen lid dat %qs heet"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 msgid "%e and %e specified together"
 msgstr "zowel 'signed' als 'unsigned' opgegeven voor %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "ongeldig gebruik van het niet gedefinieerde type %<%s %s%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "ongeldig gebruik van het niet gedefinieerde type %<%s %s%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, fuzzy, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "functie-definitie als %<register%> gedeclareerd"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "herdeclaratie van %qs"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, fuzzy, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain %<complex%> meaning %<double complex%>"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C ondersteunt gewone %<complex%> niet in de betekenis van %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ verbiedt lid-declaraties zonder leden"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "__builtin_saveregs wordt niet ondersteund door dit doelsysteem"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ ondersteunt %<long long%> niet"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%<__thread%> samen met %s gebruikt"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%<__thread%> samen met %<typedef%> gebruikt"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%<__thread%> samen met %<typedef%> gebruikt"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, fuzzy, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "'complex' ongeldig voor %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, fuzzy, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, fuzzy, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, fuzzy, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "top-level declaratie van %qs specifieert %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr ""
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr ""
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr ""
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "functiedefinitie heeft een gekwalificeerde %<void%> als teruggeeftype"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "typekwalificaties op teruggeeftypes van functies worden genegeerd"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "functiedefinitie heeft een gekwalificeerde %<void%> als teruggeeftype"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs gedeclareerd als een functie die een array teruggeeft"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "%<noreturn%> function returns non-void value"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<noreturn%> functie geeft niet-void waarde terug"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, fuzzy, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, fuzzy, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "structure heeft geen lid dat %qs heet"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "structure heeft geen lid dat %qs heet"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "structure heeft geen lid dat %qs heet"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "structure heeft geen lid dat %qs heet"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr ""
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr ""
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, fuzzy, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "parameter %qs heeft enkel een voorwaartse declaratie"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr ""
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, fuzzy, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "argument %d is alleen-lezen"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, fuzzy, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "argument %d is alleen-lezen"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%> bij lege declaratie"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr ""
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, fuzzy, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, fuzzy, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, fuzzy, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "%Jtypedef %qD als %<inline%> gedeclareerd"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr ""
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, fuzzy, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr ""
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, fuzzy, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "%s laat qualifiers van doeltype van pointer vallen"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, fuzzy, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "de declaratie van %qs verbergt een globale declaratie"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "dubbele beginwaarde"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, fuzzy, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "cast geeft functie-type op"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "%Jparameter %qD als %<inline%> gedeclareerd"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, fuzzy, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ verbiedt array %qs met lengte 0"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 ondersteunt geen flexibele array-leden"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "eerdere impliciete declaratie van `%s'"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "In functie %qs"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "eerdere impliciete declaratie van `%s'"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "open %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "herdeclaratie van %<enum %s%>"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "variabele of veld %qs als void gedeclareerd"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, fuzzy, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "parameter %qs heeft een onvolledig type"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qs mag niet als alleen-lezen gedeclareerd worden"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qs mag niet als alleen-lezen gedeclareerd worden"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "%qs is geen static veld"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, fuzzy, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, fuzzy, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr ""
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr ""
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, fuzzy, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "de zwakke declaratie van %qs moet aan de definitie voorafgaan"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs krijgt beginwaarde en is als %<extern%> gedeclareerd"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs heeft zowel %<extern%> als een beginwaarde"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "ongeldig type-argument %qs"
 
 # Of is 'verbiedt parameterdeclaraties op voorhand' beter?
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "ISO C verbiedt voorwaartse declaraties van parameters"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "parameter %qs als void gedeclareerd"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, fuzzy, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, fuzzy, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr ""
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, fuzzy, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "%s laat qualifiers van doeltype van pointer vallen"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr ""
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr ""
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, fuzzy, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "beginwaarde ontbreekt"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "dit is een eerdere declaratie"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr ""
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "dit is een eerdere declaratie"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr ""
@@ -62659,100 +62724,100 @@ msgstr ""
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, fuzzy, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "parameter %qs heeft enkel een voorwaartse declaratie"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qs is geen iterator"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, fuzzy, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, fuzzy, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "overtollige elementen in beginwaarde van union"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, fuzzy, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "%qs is geen typedef of ingebouwd type"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, fuzzy, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "herhaalde case-waarde"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 msgid "previous definition here"
 msgstr "eerdere definitie van %qs"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "grootte van array %qs is van een niet-integer type"
@@ -62761,88 +62826,93 @@ msgstr "grootte van array %qs is van een niet-integer type"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "enumeratiewaarde voor %qE is geen integerconstante"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "enumeratiewaarde voor %qE is geen integerconstante"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "ISO C beperkt enumeratiewaarden tot het bereik van het %<int%> type"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "ISO C beperkt enumeratiewaarden tot het bereik van het %<int%> type"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, fuzzy, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "overflow in enumeratiewaarden"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qE is not an integer constant"
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "enumeratiewaarde voor %qE is geen integerconstante"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, fuzzy, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "herdefinitie van %qs"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, fuzzy, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "type van teruggeefwaarde is onvolledig"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr ""
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "%<return%> zonder waarde in een functie die een niet-void waarde teruggeeft"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "%<return%> zonder waarde in een functie die een niet-void waarde teruggeeft"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, fuzzy, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "kan klasse '%s' niet vinden"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 msgid "using %qs"
 msgstr "%J%s %<%c%s%>"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "%qs gebruikt vóór declaratie"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -63275,345 +63345,345 @@ msgstr "impliciete declaratie van functie %qs"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    inline gemaakt vanuit %qs op %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d%R"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    inline gemaakt vanuit %qs op %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    inline gemaakt vanuit %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "In memberfunctie %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "In functie %qs"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "In functie %qs"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "In functie %qs"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 msgid "In lambda function"
 msgstr "In memberfunctie %qs"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "In memberfunctie %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "In memberfunctie %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "In functie %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "%qs is geen iterator"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "overflow in constante expressie"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "%qs is meestal een functie"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "%s heeft geen benoemde leden"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr "%qs is geen iterator"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "%qs is geen iterator"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "%qs is geen iterator"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "%qs is geen iterator"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "eerdere impliciete declaratie van %qs"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "eerdere impliciete declaratie van %qs"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "van hieruit opgeroepen"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, fuzzy, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "eerdere grant voor %qs"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "van hieruit opgeroepen"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 msgid "required from here\n"
 msgstr "van hieruit opgeroepen"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "eerdere grant voor %qs"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "-c of -S is vereist voor Ada"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "geen argumenten"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "geen argumenten"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, fuzzy, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, fuzzy, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<%.*s%> is niet gedefinieerd"
@@ -63834,7 +63904,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "parameter %qs krijgt beginwaarde"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -63950,7 +64020,7 @@ msgstr "%qs is geen bestand, pipe of tty"
 msgid "type %qT is not a direct base of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class type"
@@ -64141,43 +64211,43 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr ""
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "teruggeeftype is onvolledig"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
@@ -64212,82 +64282,90 @@ msgstr "ongeldig gebruik van onvolledige typedef %qs"
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%<#pragma implementation%> voor \"%s\" staat na diens #include"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, fuzzy, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -64297,64 +64375,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -64743,7 +64814,7 @@ msgstr "%Jherdeclaratie van %qD zonder specifieke linkage"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "conflicterende declaraties van %qs"
@@ -64758,428 +64829,428 @@ msgstr "conflicterende declaraties van %qs"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "%Jonverenigbare types voor ingebouwde functie %qD"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "conflicterende types voor %qs"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "herdeclaratie van %qs"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 msgid "existing default declared here"
 msgstr "%Jeerder hier gebruikt"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "externe declaratie van %qs komt niet overeen met de globale declaratie"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "beginwaarde ontbreekt"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "externe declaratie van %qs komt niet overeen met de globale declaratie"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "%Jherdeclaratie van enum %qD"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%<%c%> optie gebruikt bij type %<%c%>"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "herdeclaratie van %<enum %s%>"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "%qs als ander soort symbool geherdeclareerd"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qs is geen iterator"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qs is geen iterator"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, fuzzy, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "label %qs gebruikt maar niet gedefinieerd"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "herdefinitie van %qs"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr ""
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "kan bestand '%s' niet openen"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiled module is %sversion %s"
 msgstr "collect2 versie %s\n"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 versie %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 msgid "module %qs found"
 msgstr "veld %qs niet gevonden"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr ""
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to open %s"
 msgid "failed to read compiled module: %s"
 msgstr "kan %s niet openen"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "sectie van %qs geeft een conflict met een eerdere declaratie"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, fuzzy, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "%Jsectie van %qD geeft een conflict met een eerdere declaratie"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "%Jeerder hier gebruikt"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "%Jeerder hier gebruikt"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "%Jherdeclaratie van %qD zonder specifieke linkage"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "Creating '%s'\n"
 msgid "reading CMI %qs"
 msgstr "Aanmaken van '%s'\n"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, fuzzy, gcc-internal-format
 #| msgid "failed to open %s"
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "kan %s niet openen"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, fuzzy, gcc-internal-format
 #| msgid "failed to open %s"
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "kan %s niet openen"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr ""
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 msgid "module declared here"
 msgstr "%qs tevoren hier gedeclareerd"
@@ -65191,110 +65262,110 @@ msgstr "%qs tevoren hier gedeclareerd"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 msgid "module already declared"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 msgid "module already imported"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr ""
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
 # of "preprocessing" behouden?
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing"
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Schakel traditionele voorverwerking in"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "ongeldige macronaam %<%.*s%>"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid module name %qs"
 msgstr "%qs is geen geldige pointer-modus"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "#error %s"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "kon exit-status niet ophalen"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "onbekende 'unspec' relocatie"
@@ -65310,7 +65381,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "functie %q+D is geherdeclareerd met attribuut 'noinline'"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
@@ -65355,263 +65426,273 @@ msgstr "de declaratie van %qs verbergt een parameter"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "%Jdeclaratie voor parameter %qD maar er is zo geen parameter"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "%Jsectie van %qD geeft een conflict met een eerdere declaratie"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%J%s %<%c%s%>"
 
 # XXX FIXME:  useless gettextization
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s%s\n"
 msgid "%s %s %p %d"
 msgstr "%s %s%s\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%qs als ander soort symbool geherdeclareerd"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "%qs is geen iterator"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qs is geen iterator"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%d constructor(s) gevonden\n"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, fuzzy, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "eerdere impliciete declaratie van `%s'"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "attribuut-commando %qD wordt genegeerd"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "  %qE"
 msgstr "%s voor %qs"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 msgid "it was later defined here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, fuzzy, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "%Jherdeclaratie van %qD zonder specifieke linkage"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr "ongeldige operand van %s"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "%qD conflicts with used function"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%qD botst met gebruikte functie"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "eerdere definitie van %qs"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr ""
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr ""
@@ -65641,7 +65722,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
@@ -65686,7 +65767,7 @@ msgstr "%<%.*s%> is niet gedefinieerd"
 msgid "request for member %qE in non-class type %qT"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%.*s%> is niet gedefinieerd"
@@ -65756,7 +65837,7 @@ msgstr "conflicterende declaraties van %qs"
 msgid "%qE is not a class template"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qs is geen iterator"
@@ -66068,1703 +66149,1713 @@ msgstr ""
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "%qs is geen iterator"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "sectie-attributen worden niet ondersteund voor dit doelsysteem"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ verbiedt accolade-groepen in expressies"
 
 # 'braced-group'? Wie schrijft verdorie die foutmeldingen?
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, fuzzy, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "accolade-groep in expressie enkel toegestaan binnen een functie"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "overbodige herdeclaratie van %qs in zelfde bereik"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr ""
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, fuzzy, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, fuzzy, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "parameter %qs heeft enkel een voorwaartse declaratie"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, fuzzy, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "te weinig argumenten voor functie %<va_start%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "te weinig argumenten voor functie %<va_start%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "te weinig argumenten voor functie %<va_start%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "te weinig argumenten voor functie %<va_start%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ verbiedt het gebruik van samengestelde expressies als lvalues"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "%<sizeof%> toegepast op een bitveld"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "herhaalde definitie %qs"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, fuzzy, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "gebruik liefst haakjes rond && binnen ||"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, fuzzy, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, fuzzy, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "ongeldige operanden voor binaire %s-operator"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "opslagklasse opgegeven voor parameter %qs"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "%qs tevoren hier gedeclareerd"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, fuzzy, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case-label niet in een switch-statement"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "%d constructor(s) gevonden\n"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr "ongeldige lvalue in asm-statement"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 msgid "condition declares an array"
 msgstr "%qs gedeclareerd als een functie die een array teruggeeft"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 msgid "condition declares a function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 msgid "expected initializer"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in vector initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "overtollige elementen in beginwaarde van vector"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr ""
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ verbiedt geneste functies"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 msgid "expected module-partition"
 msgstr "lege declaratie"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 msgid "expected module-name"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr ""
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr "overbodige herdeclaratie van %qs in zelfde bereik"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 msgid "scope opened here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 msgid "private module fragment"
 msgstr "geen argumenten"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "overbodige herdeclaratie van %qs in zelfde bereik"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C staat geen extra %<;%> buiten een functie toe"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C staat geen extra %<;%> buiten een functie toe"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored"
 msgid "attributes may be inserted here"
 msgstr "attribuut wordt genegeerd"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "export-declarations are not permitted here"
 msgstr "pointers zijn niet toegestaan als case-waarden"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "lege declaratie"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "twee of meer data types in de declaratie van %qs"
 
 # vertaling voor "storage class specifier"?
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "useless storage class specifier in empty declaration"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "nutteloze storage class specifier in lege declaratie"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, fuzzy, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "conflicterende types voor %qs"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "herdefinitie van %<union %s%>"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "Ongeldige optie %qs"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "herdefinitie van %<union %s%>"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, fuzzy, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "%qs mag niet als alleen-lezen gedeclareerd worden"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "ongeldige linker operand van %s"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "%s laat qualifiers van doeltype van pointer vallen"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "%Jdeclaratie van %qD als static volgt declaratie als niet-static"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "ongeldige const_double operand"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 msgid "expected operator"
 msgstr "onverwachte operand"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "ongeldig gebruik van onvolledige typedef %qs"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "ongeldige macronaam %<%.*s%>"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 msgid "expected template-id"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, fuzzy, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, fuzzy, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "%qs is geen iterator"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 msgid "expected template-name"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, fuzzy, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "parameter %qs heeft enkel een voorwaartse declaratie"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, fuzzy, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "top-level declaratie van %qs specifieert %<auto%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 msgid "expected template-argument"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 msgid "expected type specifier"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 msgid "expected type-name"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 msgid "concept defined here"
 msgstr "%qs tevoren hier gedefinieerd"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "declaratie declareert niets"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr ""
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "herhaalde definitie %qs"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "herhaalde definitie %qs"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "%qs wordt gedeclareerd als een array van functies"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr ""
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ verbiedt het %sen van een enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "modi in %s expressie komen niet overeen"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, fuzzy, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "ongeldig gebruik van onvolledige typedef %qs"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "ongeldig gebruik van onvolledige typedef %qs"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "geen eerdere declaratie voor %qs"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "herhaalde case-waarde"
 
 # betere vertaling voor 'function scope'?
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%qD is niet gedefinieerd buiten een functie"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qs is geen iterator"
 
 # betere vertaling voor 'function scope'?
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%qD is niet gedefinieerd buiten een functie"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "eerdere declaratie van %qs"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "functie %qs geherdeclareerd als inline"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr ""
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "het argument van %<cleanup%> is geen naam"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, fuzzy, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "ingebouwde functie %qs kan niet uitgeschakeld worden"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, fuzzy, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "functie %qs geherdeclareerd als inline"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, fuzzy, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "array subscript is geen integer"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%qs is geen iterator"
@@ -67773,275 +67864,275 @@ msgstr "%qs is geen iterator"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 msgid "invalid declarator"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, fuzzy, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "nutteloze type-kwalificatie in lege declaratie"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 msgid "expected declarator"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, fuzzy, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "herhaald lid %qs"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "onverwachte operand"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, fuzzy, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "herhaalde case-waarde"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "herhaalde case-waarde"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "herhaalde case-waarde"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "geneste functie %qs is als %<extern%> gedeclareerd"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, fuzzy, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ staat het gebruik van %<varargs.h%> niet toe"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 msgid "expected class-name"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "conflicterende declaraties van %qs"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "herhaalde case-waarde"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, fuzzy, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, fuzzy, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "POS mag niet opgegeven worden voor een lijst van veld-declaraties"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, fuzzy, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "parameter %qs heeft enkel een voorwaartse declaratie"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "eerdere definitie van %qs"
@@ -68049,273 +68140,273 @@ msgstr "eerdere definitie van %qs"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 msgid "expected class-key"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, fuzzy, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "%<__alignof%> toegepast op bitveld"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "breedte van bitveld %qs is geen integerconstante"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, fuzzy, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "attributes in parameter array declarator ignored"
 msgid "attributes on base specifiers are ignored"
 msgstr "attributen genegeerd in declarator van parameter-array"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "%s laat qualifiers van doeltype van pointer vallen"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> bij lege declaratie"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "top-level declaratie van %qs specifieert %<auto%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "attribuut 'nonnull' is gebruikt zonder argumenten voor een niet-prototype"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "case-selector niet compatibel met label"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "attribuut %qE wordt genegeerd wegens %qE"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "gevraagde positie is geen integerconstante"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "gevraagd alignment is geen constante"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, fuzzy, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "twee of meer data types in de declaratie van %qs"
@@ -68324,433 +68415,433 @@ msgstr "twee of meer data types in de declaratie van %qs"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, fuzzy, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, fuzzy, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "herdeclaratie van %<enum %s%>"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "ongeldige linker operand van %s"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "herdeclaratie van %qs"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "declaratie declareert niets"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "ongeldige linker operand van %s"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "conflicterende types voor %qs"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, fuzzy, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> vóór %<extern%> gebruikt"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%<__thread%> samen met %<typedef%> gebruikt"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ ondersteunt %<long long%> niet"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "zowel %<short%> als %<char%> opgegeven bij declaratie"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "herhaalde %qs"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "herhaalde %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, fuzzy, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, fuzzy, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, fuzzy, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, fuzzy, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, fuzzy, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, fuzzy, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, fuzzy, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, fuzzy, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, fuzzy, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, fuzzy, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, fuzzy, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, fuzzy, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr ""
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, fuzzy, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, fuzzy, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "Ongeldige optie %qs"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "dit is een eerdere declaratie"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qs als ander soort symbool geherdeclareerd"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, fuzzy, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "meerdere opslagklassen in declaratie van %qs"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr ""
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr ""
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr ""
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "prefix-attributen worden genegeerd vóór %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 msgid "invalid type for property"
 msgstr "ongeldige operand voor 'p' modifier"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "onbekende machine-modus %qs"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "%qs is geen iterator"
@@ -68759,174 +68850,174 @@ msgstr "%qs is geen iterator"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "registervariabele %qs gebruikt in geneste functie"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr ""
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qs is geen iterator"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "ongeldige beginwaarde"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr ""
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "types in voorwaardelijke expressie komen niet overeen"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr ""
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qs is meestal een functie"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "overflow in constante expressie"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "misvormde #pragma weak"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr ""
 
 # 'braced-group'? Wie schrijft verdorie die foutmeldingen?
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "accolade-groep in expressie enkel toegestaan binnen een functie"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr ""
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -69400,499 +69491,504 @@ msgstr "ongeldige linker operand van %s"
 msgid "redeclaration of %qD with different constraints"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "opslagklasse opgegeven voor parameter %qs"
+
+#: cp/pt.cc:6461
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, fuzzy, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "macro %qs gebruikt zonder argumenten"
 msgstr[1] "macro %qs gebruikt zonder argumenten"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "eerdere declaratie van %qs"
 msgstr[1] "eerdere declaratie van %qs"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, fuzzy, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, fuzzy, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "ongeldige naam %qs"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 msgid "redeclared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "%Jherdefinitie van typedef %qD"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "functie-definitie als %<typdef%> gedeclareerd"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "ingebouwde functie %qs als niet-functie gedeclareerd"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "iterator %qs is van een afgeleid type"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr ""
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, fuzzy, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, fuzzy, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr ""
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr ""
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "argument %d is alleen-lezen"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr ""
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d or more)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "verkeerd aantal sjabloonargumenten (%d, moet %d of meer zijn)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "gegeven voor %q+D"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "argumenten aan macro %qs gegeven"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D is geen functiesjabloon"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, fuzzy, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "parameter %qs heeft enkel een voorwaartse declaratie"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, fuzzy, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "lege declaratie"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "herdeclaratie van %qs"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 msgid "first error appeared here"
 msgstr "functie-definitie als %<typdef%> gedeclareerd"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "%Jflexibel array-lid in union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find 'nm'"
 msgid "cannot index an empty pack"
 msgstr "kan 'nm' niet vinden"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "herdefinitie van %<struct %s%>"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "pointer naar lid-functie gebruikt in rekensom"
 
 # Betere term voor "mismatched"?
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mismatched arguments"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -69911,122 +70007,122 @@ msgstr "slechte combinatie van argumenten"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "variabele %qs als inline gedeclareerd"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "ongeldige operand voor %p-code"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, fuzzy, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "herdeclaratie van %qs"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, fuzzy, gcc-internal-format
 msgid "function returning an array"
 msgstr "%qs gedeclareerd als een functie die een array teruggeeft"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, fuzzy, gcc-internal-format
 msgid "function returning a function"
 msgstr "%qs gedeclareerd als een functie die een functie teruggeeft"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr ""
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "%s laat qualifiers van doeltype van pointer vallen"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "%s laat qualifiers van doeltype van pointer vallen"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "herhaald lid %qs"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, fuzzy, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "herhaald lid %qs"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, fuzzy, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "doorgeven van argument %d van %qs"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr "%Jarray %qD wordt aangenomen één element te bevatten"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "herdeclaratie van %qs"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, fuzzy, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "%qs is geen iterator"
@@ -70034,210 +70130,210 @@ msgstr "%qs is geen iterator"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "argument %qs komt niet overeen met prototype"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%J%qD als inline gedeclareerd na zijn definitie"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "te weinig argumenten voor functie %<va_start%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qE attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "verkeerd aantal argumenten opgegeven voor attribuut %qE"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, fuzzy, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "ontbrekende witruimte na getal %qs"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, fuzzy, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "eerste argument van %qs zou een %<int%> moeten zijn"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, fuzzy, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "argument %d is alleen-lezen"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, fuzzy, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr ""
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "herhaalde definitie %qs"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "herhaalde definitie %qs"
 
 # XXX FIXME:  useless gettextization
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %qs"
 msgid "%s %#qS"
 msgstr "%s %qs"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qs is geen static veld"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr ""
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "eerdere impliciete declaratie van %qs"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "herhaalde definitie %qs"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "pointer naar functie gebruikt in aftrekking"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, fuzzy, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "herhaalde definitie %qs"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "pointer naar functie gebruikt in aftrekking"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, fuzzy, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "herhaalde definitie %qs"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "impliciete declaratie van functie %qs"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
@@ -70249,516 +70345,573 @@ msgstr "globale registervariabele volgt op een functiedefinitie"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "eerdere impliciete declaratie van %qs"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "%qs staat niet aan het begin van een declaratie"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "niet-beëindigde parameterlijst in %<#define%>"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "de declaratie van %qs verbergt een symbool uit de parameterlijst"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "macro %qs gebruikt zonder argumenten"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "%qs is geen iterator"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "argument %d is alleen-lezen"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "functie wordt niet als kandidaat voor inlining beschouwd"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "%Jeerder hier gebruikt"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "kan %qs niet nabootsen"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr ""
 
 #: cp/reflect.cc:130
-#, fuzzy, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "%<sizeof%> toegepast op een bitveld"
-
-#: cp/reflect.cc:137
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr ""
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "meerdere parameters hebben de naam %qs"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr ""
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "%<register%> in lege declaratie op bestandsniveau"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr ""
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d, expected %<const int%>"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "incompatibel type voor argument %d, verwachtte %<const int%>"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qs is geen iterator"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "kon '%s' niet uitvoeren: %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "kon '%s' niet uitvoeren: %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr "ongeldige operand van %s"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr "%qs is geen iterator"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "%qs is geen iterator"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "ongeldige beginwaarde"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, fuzzy, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "het argument van %<cleanup%> is geen functie"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "cast geeft functie-type op"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "functie-definitie als %<typdef%> gedeclareerd"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "ongeldig type-argument %qs"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr "ongeldige operand van %s"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d, expected %<const int%>"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "incompatibel type voor argument %d, verwachtte %<const int%>"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "conflicterende types voor %qs"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "conflicterende types voor %qs"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "onbekende spec-functie '%s'"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "modi in %s expressie komen niet overeen"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "veld %qs als een functie gedeclareerd"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "attributen genegeerd in declarator van parameter-array"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "functie-definitie als %<auto%> gedeclareerd"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr ""
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "overflow in constante expressie"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "modi in %s expressie komen niet overeen"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "ongeldige opslagklasse voor functie %qs"
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr ""
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "overflow in constante expressie"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "%qs is geen iterator"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -71091,591 +71244,591 @@ msgstr "ongeldig gebruik van het niet gedefinieerde type %<%s %s%>"
 msgid "invalid base-class specification"
 msgstr "ongeldige linker operand van %s"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qs is geen iterator"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "kan functie %<main%> niet inline maken"
 
 # Betere term voor "mismatched"?
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched arguments"
 msgid "missing template arguments"
 msgstr "slechte combinatie van argumenten"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, fuzzy, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "modi in %s expressie komen niet overeen"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, fuzzy, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "grootte van %qs is %u bytes"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "overflow in constante expressie"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, fuzzy, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "opslaggrootte van %qs is onbekend"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qs is geen iterator"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "array subscript is geen integer"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "grootte van array %qs is negatief"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "nutteloze type-kwalificatie in lege declaratie"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "%<this%> is niet beschikbaar in static member-funties"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
 # XXX FIXME:  useless gettextization
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %qs"
 msgid "%s %#qD"
 msgstr "%s %qs"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "ongeldig gebruik van %<restrict%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "ongeldige waarheidsexpressie"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 #| msgid "vectorlength must be an integer constant"
 msgid "%<vector%> length expression must be integral"
 msgstr "vectorlengte moet een integerconstante zijn"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "%<defined%> zonder een naam"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr ""
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr "ISO C90 verbiedt array %qs van variabele grootte"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "te veel invoerbestanden"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "%<defined%> zonder een naam"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "%<defined%> zonder een naam"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "%<defined%> zonder een naam"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "rekensom met pointer naar onvolledig type"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "%qs is geen iterator"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%Jparameter %u heeft een onvolledig type"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "beginwaarde-element is niet constant"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr ""
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, fuzzy, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "%Jdeclaratie van %qD als niet-static volgt declaratie als static"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "modi in %s expressie komen niet overeen"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "%qs is geen iterator"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "%qs is geen iterator"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_next_arg%> opgeroepen zonder argument"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_next_arg%> opgeroepen zonder argument"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "%<defined%> zonder een naam"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qs is geen iterator"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "linker operand van comma-expressie heeft geen effect"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "argument %d is alleen-lezen"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
@@ -71683,361 +71836,361 @@ msgstr "derde argument voor %<__builtin_prefetch%> moet een constante zijn"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "cast geeft functie-type op"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr ""
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 msgid " declared here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "%qs is geen iterator"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "%qs is geen iterator"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr "%s heeft geen benoemde leden"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "vergelijking tussen %qT en %qT"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "veld %qs heeft een onvolledig type"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%qs is geen iterator"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qs heeft een onvolledig type"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to function types"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "attribuut %qE is enkel van toepassing op functie-types"
 
 # XXX FIXME:  duplicate
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "het argument van attribuut %qE is geen string-constante"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "attribuut %qE is enkel van toepassing op class-definities"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "attribuut %qE is enkel van toepassing op class-definities"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "attribuut %qE is enkel van toepassing op class-definities"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute has no effect"
 msgid "%qE attribute takes no arguments"
 msgstr "attribuut %qE heeft geen effect"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute does not apply to types"
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "attribuut %qE heeft geen betekenis voor types"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "herhaalde label-declaratie %qs"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%qs is geen iterator"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> toegepast op bitveld"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "%<__alignof%> toegepast op bitveld"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "%Jdeclaratie voor parameter %qD maar er is zo geen parameter"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "gevraagde positie is geen integerconstante"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr ""
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr ""
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "herdeclaratie van %qs"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qE attribute is not a string constant"
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "argument van attribuut %qE is geen string-constante"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qE attribute is not a string constant"
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "argument van attribuut %qE is geen string-constante"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr ""
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "'%%%c' is not a valid operand prefix"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "'%%%c' is geen geldige operand-prefix"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr ""
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr ""
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "herhaalde definitie %qs"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to functions, not %s"
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "attribuut %qE is enkel van toepassing op functies, niet %s"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute applies only to functions"
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "attribuut %qE is enkel van toepassing op functies"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "herhalings-aantal is geen integerconstante"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "attribuut %qE is enkel van toepassing op variabelen"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "%<__alignof%> toegepast op bitveld"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 msgid "annotation on void parameter"
 msgstr "de declaratie van %qs verbergt een parameter"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "functie geeft geen string-type terug"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "functie geeft geen string-type terug"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr ""
@@ -72238,816 +72391,821 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "union heeft geen lid dat %qs heet"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "%qs is geen bestand, pipe of tty"
+
+#: cp/typeck.cc:3781
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qs is meestal een functie"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qs is geen iterator"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "ongeldig gebruik van array die geen lvalue is"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "ongeldig gebruik van array die geen lvalue is"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "ongeldig gebruik van array die geen lvalue is"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "subscript ontbreekt in array-referentie"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, fuzzy, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "subscript ontbreekt in array-referentie"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "waarde met subscript is noch een array, noch een pointer"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, fuzzy, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "array-grootte ontbreekt in %qs"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr ""
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ verbiedt accolade-groepen in expressies"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "veld %qs als een functie gedeclareerd"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "te weinig argumenten voor functie %qs"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "te veel argumenten voor functie %qE"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "te weinig argumenten voor functie %qE"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "te veel argumenten voor functie %qE"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "te weinig argumenten voor functie %qE"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "te weinig argumenten voor functie %qs"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "te veel argumenten voor functie"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "te weinig argumenten voor functie"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, fuzzy, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "parameter heeft een onvolledig type"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, fuzzy, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "parameter heeft een onvolledig type"
 
 # is de "," deel van de special format spec of niet?  en moet "true" hier vertaald worden of niet?
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
 # is de "," deel van de special format spec of niet?  en moet "true" hier vertaald worden of niet?
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
 # is de "," deel van de special format spec of niet?  en moet "true" hier vertaald worden of niet?
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
 # is de "," deel van de special format spec of niet?  en moet "true" hier vertaald worden of niet?
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %qT and %qT"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "vergelijking tussen types %qT en %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %qT and %qT"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "vergelijking tussen types %qT en %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
 # 'Arithmetic'?? 'rekensom' is wel correct, maar het klinkt zo stom.
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "rekensom met pointer naar onvolledig type"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, fuzzy, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, fuzzy, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "pointer naar functie gebruikt in rekensom"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ verbiedt een vergelijking tussen pointer en integer"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "operand-types zijn %qT en %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "geordende vergelijking van pointer met integer nul"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with null pointer"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "geordende vergelijking van pointer met null-pointer"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, fuzzy, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "ongeldige operanden voor binaire %s-operator"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "pointer van type %<void *%> gebruikt in aftrekking"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "pointer naar functie gebruikt in aftrekking"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "pointer naar functie gebruikt in aftrekking"
 
 # 'Arithmetic'?? 'rekensom' is wel correct, maar het klinkt zo stom.
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, fuzzy, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "rekensom met pointer naar onvolledig type"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "ongeldig gebruik van array die geen lvalue is"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr ""
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, fuzzy, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "ongeldig gebruik van array die geen lvalue is"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ verbiedt het adres van een gecaste expressie"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ verbiedt het adres van een gecaste expressie"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ verbiedt het adres van een gecaste expressie"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ verbiedt het adres van een gecaste expressie"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, fuzzy, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "ongeldige beginwaarde voor member %qs"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "kan adres van bitveld %qs niet nemen"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ verbiedt het %sen van een enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ verbiedt het %sen van een enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ verbiedt het %sen van een pointer van type %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ verbiedt het %sen van een pointer van type %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, fuzzy, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "kan adres van bitveld %qs niet nemen"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "cast laat qualifiers van doeltype van pointer vallen"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "typekwalificaties op teruggeeftypes van functies worden genegeerd"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "type van teruggeefwaarde is onvolledig"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 msgid "converting from %qH to %qI"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr ""
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "een cast ontbreekt bij vergelijking van ongelijke pointer-types"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "cast verhoogt het benodigde alignment van het doeltype"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ verbiedt voorwaardelijke expressies tussen 0 en een functiepointer"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, fuzzy, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ verbiedt casts naar een union-type"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, fuzzy, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "ongeldige opslagklasse voor functie %qs"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr ""
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr ""
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr ""
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr ""
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 msgid "array used as initializer"
 msgstr "array-index in beginwaarde van niet-array"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "ongeldige lvalue in toewijzing"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, fuzzy, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "pointer naar lid-functie gebruikt in rekensom"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 msgid "cannot convert %qH to %qI in return"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "doorgeven van argument %d van %qs"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr ""
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "herhaald lid %qs"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "adres van globale registervariabele %qs gevraagd"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "adres van globale registervariabele %qs gevraagd"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "adres van globale registervariabele %qs gevraagd"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "ongeldige lvalue in asm-statement"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr ""
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr ""
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, fuzzy, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "%<return%> zonder waarde in een functie die een niet-void waarde teruggeeft"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 msgid "returning initializer list"
 msgstr "beginwaarde ontbreekt"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "%<return%> zonder waarde in een functie die een niet-void waarde teruggeeft"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "ongeldige registernaam voor %qs"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s value"
 msgid "using rvalue as lvalue"
@@ -73456,17 +73614,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "onbekende machine-modus %qs"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%J%qD als inline gedeclareerd na oproep"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -73492,45 +73650,45 @@ msgstr "ongeldige beginwaarde voor member %qs"
 msgid "the address of %qD will never be %<null%>"
 msgstr "het adres van %qD, zal altijd %<true%> zijn"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "Sla functienamen op in objectcode"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qs mag niet als alleen-lezen gedeclareerd worden"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "global register variable %qs used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "globale registervariabele %qs gebruikt in geneste functie"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "herhaald lid %qs"
@@ -73610,32 +73768,32 @@ msgstr "ongeldig type-argument %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "geldige argumenten van %qs zijn: %s"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "open %s"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "kan bestand '%s' niet openen"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "open %s"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "dynamische dependencies.\n"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -73732,7 +73890,7 @@ msgstr "onbekende machine-modus %qs"
 msgid "%qs is not an associative array"
 msgstr "%qs is geen iterator"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -73747,23 +73905,23 @@ msgstr "%J%qD is gewoonlijk een niet-static funtie"
 msgid "%qs is not a field, but a %qs"
 msgstr "-fPIC is niet geldig met -mcoff"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "overflow in constante expressie"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "overflow in constante expressie"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "overflow in constante expressie"
@@ -73854,17 +74012,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -74189,8 +74347,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74468,7 +74626,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr ""
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "%s voor %qs"
@@ -74556,7 +74714,7 @@ msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -74726,7 +74884,7 @@ msgstr "overflow in constante expressie"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr ""
@@ -74743,7 +74901,7 @@ msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
@@ -74888,8 +75046,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "expressie-statement heeft onvolledig type"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -74989,9 +75147,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "overflow in constante expressie"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -75006,14 +75164,14 @@ msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be an array"
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
@@ -75115,652 +75273,652 @@ msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "ongeldige registernaam voor %qs"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be an array"
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be an array"
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be an array"
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr ""
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr ""
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr ""
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -75827,12 +75985,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "Initialisatie op %C is niet voor een pointervariable"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -75882,2069 +76040,2069 @@ msgstr ""
 msgid "Simplification error"
 msgstr "herdeclaratie van %qs"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "dubbele beginwaarde"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "extra elementen in scalaire beginwaarde"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "vectorlength must be an integer constant"
 msgid "Repeat spec must be an integer at %C"
 msgstr "vectorlengte moet een integerconstante zijn"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "vector overflow in expressie"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "overtollige elementen in beginwaarde van array"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "overtollige elementen in beginwaarde van array"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "%qs is geen iterator"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr ""
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "opvulkarakter in strfmon-formaat"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument must be a constant"
 msgid "CHARACTER length must be a constant at %L"
 msgstr "argument moet een constante zijn"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
 # rank -> rang: correct in Fortran-context?
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "beginwaarde ontbreekt in PARAMETER op %L"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "subscript ontbreekt in array-referentie"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr ""
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "parameter %qs wijst naar een onvolledig type"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr ""
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "een parameterlijst met een beletselteken kan niet overeenkomen met een declaratie met lege parameterlijst"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%qs neemt ofwel geen, ofwel twee argumenten"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "opvulkarakter in strfmon-formaat"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "%qs is smaller dan waarden van zijn type"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "dubbele beginwaarde"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "dubbele beginwaarde"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Initialisatie op %C is niet voor een pointervariable"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "sectie-attributen worden niet ondersteund voor dit doelsysteem"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "afrondingsmodus niet ondersteund voor VAX-floats"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "afrondingsmodus niet ondersteund voor VAX-floats"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "de tweede parameter van %<va_start%> is niet het laatste benoemde argument"
 
 # vertaling voor 'statement'?
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "expressie-statement heeft onvolledig type"
 
 # vertaling voor 'statement'?
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "opvulkarakter in strfmon-formaat"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "beginwaarde ontbreekt"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "beginwaarde ontbreekt"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, fuzzy, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "%s: definitie van functie '%s' niet omgezet\n"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr ""
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 msgid "Missing symbol"
 msgstr "beginwaarde ontbreekt"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr ""
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "%qs is geen iterator"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "%Jparameternaam weggelaten"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "conflicterende declaraties van %qs"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "conflicterende declaraties van %qs"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr ""
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Array subscript-stap verwacht op %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "constant object wordt beschreven (argument %d)"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "parameternaam ontbreekt uit parameterlijst"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Functienaam '%s' niet toegestaan op %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "ongeldige beginwaarde"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "ongeldige operand van %s"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr ""
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr ""
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr ""
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr ""
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Initialisatie op %C is niet voor een pointervariable"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "%qs is meestal een functie"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "herhaalde case-waarde"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "conflicterende declaraties van %qs"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "lege declaratie"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "gevraagd alignment is geen macht van 2"
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "kan klasse '%s' niet vinden"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr ""
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr ""
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr ""
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Array subscript verwacht op %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "ongeldige operand van %s"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "constant object wordt beschreven (argument %d)"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, fuzzy, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "constant object wordt beschreven (argument %d)"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "ongeldige operand van %s"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Array subscript verwacht op %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "ongeldige operand van %s"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr ""
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "ongeldige operand van %s"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "onbekende operator '%s' in %%:version-compare"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "%s voor %qs"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "%s voor %qs"
@@ -78087,410 +78245,410 @@ msgstr "kan niet derefereren, is geen pointer."
 msgid "IM part_ref at %C"
 msgstr "%s voor %qs"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "%J%qD werd voor haar definitie gebruikt zonder protoype"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr ""
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr ""
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr ""
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr ""
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs is meestal een functie"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "ongeldige lvalue in toewijzing"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "expressie-statement heeft onvolledig type"
@@ -78498,199 +78656,199 @@ msgstr "expressie-statement heeft onvolledig type"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "ongeldig gebruik van een void-expressie"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "ongeldige waarheidsexpressie"
 
 # dit klinkt niet al te best
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
 # dit klinkt niet al te best
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "overflow in constante expressie"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -78711,7 +78869,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -78772,42 +78930,42 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "%s between %L and %L"
@@ -78933,12 +79091,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -79364,307 +79522,312 @@ msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, fuzzy, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, fuzzy, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, fuzzy, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "kan klasse '%s' niet vinden"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, fuzzy, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr ""
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr ""
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "te veel argumenten voor %s %q+#D"
@@ -79853,7 +80016,7 @@ msgstr "ongeldige registernaam voor %qs"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
@@ -80403,7 +80566,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -80576,12 +80739,12 @@ msgstr "integer overflow in expressie"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -81084,7 +81247,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
@@ -81599,92 +81762,92 @@ msgstr "ongeldige expressie als operand"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "overflow in constante expressie"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "%s voor %qs"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -82673,7 +82836,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -82708,12 +82871,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -83187,7 +83350,7 @@ msgstr "conflicterende declaraties van %qs"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "%qs is geen bestand, pipe of tty"
@@ -83208,7 +83371,7 @@ msgstr "kon 0x%l.8x niet naar een regio omzetten"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -83238,17 +83401,17 @@ msgstr "kon 0x%l.8x niet naar een regio omzetten"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
@@ -83368,8 +83531,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -83449,7 +83612,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "functie-oproep heeft geaggregeerde waarde"
@@ -83472,7 +83635,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -83512,7 +83675,7 @@ msgstr ""
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr ""
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -83825,598 +83988,608 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "grootte van array %qs is van een niet-integraal type"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "registervariabele %qs gebruikt in geneste functie"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "modi in %s expressie komen niet overeen"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -85084,62 +85257,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "overflow in constante expressie"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -85147,7 +85320,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -85607,1089 +85780,1089 @@ msgstr "%s voor %qs"
 msgid "%qs at %C is not a variable"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "%s voor %qs"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr ""
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr ""
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr ""
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, fuzzy, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "%qs is meestal een functie"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "%qs is meestal een functie"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "te veel argumenten voor %s %q+#D"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "naar label %s gerefereerd buiten enige functie"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "globale registervariabele volgt op een functiedefinitie"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "de terugkeerwaarde van een functie kan geen funtie zijn"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr ""
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "conflicterende declaraties van %qs"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs is meestal een functie"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "%s voor %qs"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "einde van niet-void functie werd bereikt zonder teruggeefwaarde"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "%<%.*s%> is niet gedefinieerd"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "-shared en -mdll zijn niet compatibel"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "kan functie %<main%> niet inline maken"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "vergelijking van 'unsigned'-expressie >= 0 is altijd waar"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Ongeldige soort voor %s op %L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr ""
 
 # Ongeldig soort wat?
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "Ongeldige soort voor %s op %L"
 
 # Ongeldig soort wat?
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "Ongeldige soort voor %s op %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr ""
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "onbekende operator '%s' in %%:version-compare"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "onbekende operator '%s' in %%:version-compare"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr ""
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr ""
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "linker operand van comma-expressie heeft geen effect"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "subscript ontbreekt in array-referentie"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "subscript ontbreekt in array-referentie"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Ongeldige vorm van arrayverwijzing op %C"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
 # vertaling voor 'statement'?
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
 # vertaling voor 'statement'?
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr ""
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
@@ -86698,12 +86871,12 @@ msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
@@ -86712,414 +86885,414 @@ msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "kan niet derefereren, is geen pointer."
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr ""
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr ""
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "data area attributes cannot be specified for local variables"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "datagebied-attributen kunnen niet opgegeven worden voor lokale variabelen"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "%s voor %qs"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "%s voor %qs"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -87128,317 +87301,317 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "expressie-statement heeft onvolledig type"
 
 # vertaling voor 'statement'?
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "fout in argumenten voor spec-functie '%s'"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "%Jparameter %u heeft %<void%> als type"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Ongeldige soort voor %s op %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "%<defined%> zonder een naam"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "continue-statement niet in een lus"
@@ -87446,214 +87619,214 @@ msgstr "continue-statement niet in een lus"
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "In functie %qs"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr ""
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, fuzzy, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "%s van alleen-lezen variabele %qs"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
 # Ongeldig soort wat?
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "Ongeldige soort voor %s op %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr ""
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "parameter %qs als void gedeclareerd"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -87661,1062 +87834,1062 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "String-lengte bij %L is te groot"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, fuzzy, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s voor %qs"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een array zijn"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "attribuut %qE botst met attribuut %s"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "attribuut %qE botst met attribuut %s"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "attribuut %qE botst met attribuut %s"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "attribuut %qE botst met attribuut %s"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, fuzzy, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "veld %qs heeft al een beginwaarde gekregen"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet kleiner dan rang %d zijn"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, fuzzy, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Lege array-constructor op %C is niet toegestaan"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute conflicts with attribute %s"
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "attribuut %qE botst met attribuut %s"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "herhaalde label-declaratie %qs"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "(dicht bij initialisatie van %qs)"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "niet-constante array in DATA statement %L."
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Substring bij %L heeft lengte nul"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "overflow in constante expressie"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Intrinsic '%s' op %L moet minstens twee argumenten hebben"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -88738,97 +88911,97 @@ msgstr "Niet-bestaande include-map \"%s\""
 msgid "%qs is not a directory"
 msgstr "%qs is geen iterator"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr ""
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "karakterconstante met meer dan één karakter"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "opvulkarakter in strfmon-formaat"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "label %qs gedefinieerd maar niet gebruikt"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "ongeldig preprocessing-commando"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "kan bestand '%s' niet openen"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "kan bestand '%s' niet openen"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "kan bestand '%s' niet openen"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "-fPIC is niet geldig met -mcoff"
@@ -88993,219 +89166,219 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Ontbrekende argumenten voor intrinsic %s op %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr ""
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "omvang van array %qs is te groot"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
 # vertaling voor 'intrinsic'? 'intrinsiek(e) xxx', maar wat als xxx te gebruiken?
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet %s zijn"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "overflow in constante expressie"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "functie-oproep heeft geaggregeerde waarde"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "ongeldig type-argument %qs"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -89546,74 +89719,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr "ongeldige beginwaarde"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "grootte van %qs is %u bytes"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -89643,29 +89816,34 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "beginwaarde-element is niet constant"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "doorgeven van argument %d van %qs"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -89768,113 +89946,113 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%qs is geen bestand, pipe of tty"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "%s: definitie van functie '%s' niet omgezet\n"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "-pipe wordt niet ondersteund"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Te veel argumenten voor %s op %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "statische variable %qs is als dllimport aangeduid"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "parameter %qs als void gedeclareerd"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "parameter %qs als void gedeclareerd"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "%s: definitie van functie '%s' niet omgezet\n"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr ""
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr ""
@@ -89904,12 +90082,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "onbekende machine-modus %qs"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -89926,12 +90104,12 @@ msgstr "Intrinsieke functie %s(%d) wordt niet herkend"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een constante zijn"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "ongeldig type-argument %qs"
@@ -89956,184 +90134,184 @@ msgstr "sectie-attributen worden niet ondersteund voor dit doelsysteem"
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 msgid "optional class parameter"
 msgstr "geen argumenten"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "unhandled expression type"
 msgstr "ongeldige expressie als operand"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 msgid "unhandled expression"
 msgstr "ongeldige waarheidsexpressie"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 msgid "Used here"
 msgstr "%qs tevoren hier gedeclareerd"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr ""
 
 # vertaling voor 'statement'?
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "expressie-statement heeft onvolledig type"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "object van variabele lengte mag geen beginwaarde krijgen"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "parameternamen (zonder types) in functiedeclaratie"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "kon 0x%l.8x niet naar een regio omzetten"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "%qs is meestal een functie"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "%qs is meestal een functie"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "case-selector niet compatibel met label"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "Bestandsnaam ontbreekt na %qs optie"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "'%s' argument voor intrinsic '%s' op %L moet een scalair zijn"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "argument-formaat opgegeven voor niet-functie %qs"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "-pipe wordt niet ondersteund"
@@ -90477,7 +90655,7 @@ msgstr "fclose %s"
 msgid "two or more sections for %s"
 msgstr "twee of meer data types in de declaratie van %qs"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -90807,32 +90985,32 @@ msgstr "array-index in beginwaarde van niet-array"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "gevraagd alignment is geen constante"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "gevraagd alignment is geen macht van 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "gevraagd alignment is te groot"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "%Jer kan geen alignment opgegeven worden voor %qD"
@@ -92761,10 +92939,6 @@ msgstr ""
 #~ msgid "junk at end of '#pragma options'"
 #~ msgstr "rommel aan einde van '#pragma options'"
 
-#, gcc-internal-format
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "incompatibel type voor argument %d, verwachtte %<const int%>"
-
 #, fuzzy, gcc-internal-format
 #~ msgid "%qs and floating point or vector arguments"
 #~ msgstr "%J%qD neemt ofwel geen, ofwel twee argumenten"
@@ -93631,10 +93805,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "niet-static methode '%s' vervangt static methode"
 
-#, fuzzy, gcc-internal-format
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%qs gebruikt vóór declaratie"
-
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #~ msgid "missing field '%s' in '%s'"
 #~ msgstr "beginwaarde ontbreekt"
--- a/src/gcc/po/ru.po
+++ b/src/gcc/po/ru.po
@@ -12,7 +12,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 9.1-b20190414\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2019-05-04 12:10+0300\n"
 "Last-Translator: Pavel Maryanov <acid@jack.kiev.ua>\n"
 "Language-Team: Russian <gnu@d07.ru>\n"
@@ -1328,13 +1328,13 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Известные уровни ISA (могут быть заданы с ключом -mips)"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 #| msgid "The version of the C++ ABI in use."
 msgid "Specify the PTX ISA version to use."
 msgstr "Используемая версия C++ ABI."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers."
 msgid "Initialize ptx registers."
@@ -2162,13 +2162,13 @@ msgstr "Включить подразумеваемое преобразован
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "Использовать заданную защиту стека"
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2639,7 +2639,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Считать, что процессор имеет прямой порядок байт (big endian)."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Считать, что процессор имеет обратный порядок байт (little endian)."
@@ -2716,7 +2716,7 @@ msgstr "Использовать более короткие, но менее б
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2755,7 +2755,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Исключать указатель кадра в листовых функциях."
@@ -2873,7 +2873,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2922,7 +2922,7 @@ msgstr "-msve-vector-bits=N\tЗадаёт число бит в регистре
 msgid "The possible TLS dialects:"
 msgstr "Возможные диалекты TLS:"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5266,7 +5266,7 @@ msgstr "Поддерживать RTM внутренние функции и ге
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5640,7 +5640,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "Предполагаемая цена для инструкции ветвления."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, fuzzy, no-c-format
 #| msgid "Use given stack-protector guard."
 msgid "Use branch-protection features."
@@ -5954,221 +5954,226 @@ msgstr "Генерировать код для обхода аппаратной
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr "Генерировать код для обхода аппаратной ошибки ARM Cortex-A53 номер 843419."
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer."
 msgid "The register used to access the thread pointer:"
 msgstr "Способ доступа к указателю на нить."
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 #| msgid "Specify thread pointer register number."
 msgid "Specify the thread pointer register."
 msgstr "Задать номер регистра указателя потока."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "Не предполагать, что система поддерживает невыровненный доступ к памяти."
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Битовый размер для непосредственных смещений TLS.  Допустимые значения: 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "-march=ARCH\tUse features of architecture ARCH."
 msgid "Use features of architecture ARCH."
 msgstr "-march=ARCH\tИспользовать возможности и планировать код для заданной архитектуры."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "-mcpu=CPU\tUse features of and optimize for CPU."
 msgid "Use features of and optimize for CPU."
 msgstr "-mcpu=CPU\tИспользовать возможности заданного CPU и оптимизировать код для него."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, fuzzy, no-c-format
 #| msgid "-mtune=CPU\tOptimize for CPU."
 msgid "Optimize for CPU."
 msgstr "-mtune=CPU\tОптимизировать код для заданного процессора."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "-mabi=ABI\tGenerate code that conforms to the specified ABI."
 msgid "Generate code that conforms to the specified ABI."
 msgstr "-mabi=ABI\tГенерировать код в соответствии с заданным ABI."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, fuzzy, no-c-format
 #| msgid "-moverride=STRING\tPower users only! Override CPU optimization parameters."
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr "-moverride=STRING\tТолько для опытных пользователей! Переопределить параметры оптимизации CPU."
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "Известные AArch64 ABIs (для использования с -mabi= опцией):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr "Загрузки литеральных значений относительно счетчика команд (PC)."
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr "Выбрать область применения подписанных адресов возврата из функций."
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Допустимые значения ключа -msign-return-address=option:"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Разрешить аппроксимацию обратного значения корня квадратного.   При этом точность вычисления обратного значения корня квадратного сокращается до примерно 16 разрядов для одинарной точности и до 32 разрядов для двойной точности."
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr "Разрешить аппроксимацию квадратного корня.   При этом точность вычисления квадратного корня сокращается до примерно 16 разрядов для одинарной точности и до 32 разрядов для двойной точности. If enabled, it implies -mlow-precision-recip-sqrt."
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "Возможные длины вектора SVE:"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, fuzzy, no-c-format
 #| msgid "-msve-vector-bits=N\tSet the number of bits in an SVE vector register to N."
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "-msve-vector-bits=N\tЗадаёт число бит в регистре вектора SVE, равное N."
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr "Включает подробный режим выдачи дампа стоимостной модели в файлы отладочных дампов."
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate a call to abort if a noreturn function returns."
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Генерировать вызов abort, если в noreturn-функции выполняется возврат управления."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "builtin %qF is deprecated."
 msgid "This option is deprecated."
@@ -11656,7 +11661,7 @@ msgstr "Выполнить векторизацию циклов на древо
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18811,96 +18816,96 @@ msgstr "Компилировать в соответствии с ISO 2014 C++."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Компилировать в соответствии со стандартом ISO 2011 C (неполная экспериментальная поддержка)"
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a map"
 msgid "argument must be passed by copying"
 msgstr "аргумент 1 должен быть отображением"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 #| msgid "caller edge frequency is negative"
 msgid "callee returns twice"
 msgstr "значение счётчика дуг вызова отрицательно"
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "переменная %qD имеет тип функции"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "ожидалась функция"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "different number of parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "разное число параметров"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s не поддерживает split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 #, fuzzy
 #| msgid "LHS in noreturn call"
 msgid "inside another call"
 msgstr "левая часть в вызове без возврата (noreturn)"
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "value argument"
 msgid "variable size arguments"
 msgstr "value аргумент"
 
 #
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "passing too large argument on stack"
 msgid "hidden string length argument passed on stack"
 msgstr "передача слишком большого аргумента на стек"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "static assertion failed"
 msgid "tail call production failed"
@@ -19025,12 +19030,12 @@ msgstr "операнд '%%l' не является меткой"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "некорректное использование плавающей константы"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -20499,13 +20504,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "это insn:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "invalid operand address"
 msgid "unable to reload address in "
 msgstr "некорректный адрес операнда"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "ошибка при генерации загрузок операндов на регистры для:"
 
@@ -20743,7 +20748,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sэвристики GGC: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonymous>"
@@ -21138,20 +21143,20 @@ msgstr ""
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "недопустимый операнд для кода '%%%c'"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr ""
@@ -21198,89 +21203,89 @@ msgstr "некорректный префикс операнда '%%%c'"
 msgid "invalid address mode"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "некорректное преобразование из %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "некорректное преобразование к типу %qT от типа %qT"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 #| msgid "no pre-increment operator for type"
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "нет преинкрементного оператора для типа"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 #| msgid "no pre-decrement operator for type"
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "нет предекрементного оператора для типа"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "no post-increment operator for type"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "нет постинкрементного оператора для типа"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 #| msgid "no post-decrement operator for type"
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "нет постдекрементного оператора для типа"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "%<auto%> parameter not permitted in this context"
 msgid "negation operation not permitted on svbool_t"
 msgstr "%<auto%> параметр недопустим в данном контексте"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 #| msgid "stack usage computation not supported for this target"
 msgid "subscript operation not supported on svbool_t"
 msgstr "вычисление размера используемой области стека не поддерживается для этой целевой платформы"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands in binary operation"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "неверные операнды в бинарной операции"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -21297,13 +21302,13 @@ msgid "invalid %%r value"
 msgstr "некорректное значение %%r"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "некорректное значение %%R"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "некорректное значение %%N"
@@ -21318,7 +21323,7 @@ msgstr "некорректное значение %%P"
 msgid "invalid %%h value"
 msgstr "некорректное значение %%h"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "некорректное значение %%L"
@@ -21333,7 +21338,7 @@ msgstr "некорректное значение %%M"
 msgid "invalid %%M value"
 msgstr "некорректное значение %%M"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "некорректное значение %%U"
@@ -21684,7 +21689,7 @@ msgstr "некорректный операнд"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21933,137 +21938,137 @@ msgstr "недопустимая константа"
 msgid "Expected register or constant integer."
 msgstr "Ожидался интерфейс или указатель на интерфейс"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "некорректный операнд UNSPEC"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "недопустимое использование регистра '%s'>"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "некорректное использование флага вывода в asm"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "недопустимый размер операнда для кода 'O'"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "недопустимый размер операнда для кода 'z'"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand type used with operand code 'Z'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "недопустимый тип операнда для кода 'Z'"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand size for operand code 'O'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "недопустимый размер операнда для кода 'O'"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "операнд не является кодом условия, неверный код операнда 'Y'"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "операнд не является кодом условия, неверный код операнда 'D'"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "операнд не является кодом условия, неверный код операнда '%c'"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "операнд не является ссылкой на память со смещением, неверный код операнда 'H'"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "операнд не является кодом условия, неверный код операнда 'K'"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "операнд не является специфическим целым, неверный код операнда 'r'"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "операнд не является целым, неверный код операнда 'R'"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "операнд не является специфическим целым, неверный код операнда 'R'"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "операнд не является ссылкой на память со смещением, неверный код операнда 'H'"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "некорректный код операнда '%c'"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "некорректные ограничения для операнда"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr ""
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "некорректный режим инструкции"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "некорректное преобразование из %<__fpreg%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "некорректное преобразование из %<__fpreg%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "некорректное преобразование к %<__fpreg%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "некорректное преобразование к типу %qT от типа %qT"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -22142,9 +22147,9 @@ msgstr "'%%%c' не является корректным префиксом о
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "недопустимое использование '%%%c'"
@@ -22209,7 +22214,7 @@ msgid "insn contains an invalid address !"
 msgstr "инструкция содержит некорректный адрес !"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "некорректный адрес"
 
@@ -22286,7 +22291,7 @@ msgstr "некорректная операция"
 msgid "invalid %%H value"
 msgstr "некорректное %%J значение"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "неверное значение для кода %%d"
@@ -22345,35 +22350,35 @@ msgstr "неподдерживаемая комбинация: %s"
 msgid "unsupported memory expression:"
 msgstr "неподдерживаемое преобразование с фиксированной точкой"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%r operand"
 msgid "invalid vector operand"
 msgstr "неверный операнд для %%r"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "некорректный операнд для модификатора 'b'"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "unsupported size for integer register"
 msgid "modifier 'H' is for integer registers only"
 msgstr "неподдерживаемый размер для целочисленного регистра"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -22444,7 +22449,7 @@ msgstr "некорректная 128-битная пересылка"
 msgid "invalid %%A value"
 msgstr "некорректное %%J значение"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "неверное значение для кода %%D"
@@ -22484,7 +22489,7 @@ msgstr "недопустимое значение для кода %%J"
 msgid "invalid %%k value"
 msgstr "недопустимое значение для кода %%k"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "недопустимое значение для кода %%K"
@@ -22515,18 +22520,18 @@ msgstr "недопустимое значение для кода %%T"
 msgid "invalid %%u value"
 msgstr "недопустимое значение для кода %%u"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "недопустимое значение для кода %%v"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%J value"
 msgid "invalid %%V value"
 msgstr "некорректное %%J значение"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "неверное значение для кода %%x"
@@ -22747,28 +22752,28 @@ msgstr "некорректный операнд для %%s"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "плавающая константа не является корректным непосредственным операндом"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "операнд с кодом 'B' - не константа"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "в операнде с кодом 'B' установлено несколько битов"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "операнд с кодом 'o' - не константа"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "операнд с кодом 'B' - не константа"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: некорректный код"
@@ -22826,24 +22831,24 @@ msgstr "некорректный адрес операнда (4)"
 msgid "Unable to load DLL."
 msgstr "Генерировать код для DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "Некорректная проверка"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "некорректная маска"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "неверное значение для кода %%t/%%b"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "не задан регистр в адресе"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "адресное смещение - не константа"
 
@@ -22877,7 +22882,7 @@ msgstr "{anonymous}"
 msgid "aka"
 msgstr "aka"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anonymous})"
 
@@ -22902,8 +22907,8 @@ msgstr "({anonymous})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "ожидалось %<;%>"
@@ -22931,7 +22936,7 @@ msgstr "ожидалось %<:%> или %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "ожидалась %<)%>"
@@ -22939,7 +22944,7 @@ msgstr "ожидалась %<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "ожидалась %<]%>"
@@ -22959,13 +22964,13 @@ msgstr "ожидалось %<;%>, %<,%> или %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "ожидалась %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "ожидалось %<[%>"
@@ -22974,7 +22979,7 @@ msgstr "ожидалось %<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22991,13 +22996,13 @@ msgstr "ожидалась %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "ожидалось %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "ожидалось %<while%>"
@@ -23007,7 +23012,7 @@ msgstr "ожидалось %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "ожидалась %<,%>"
@@ -23017,18 +23022,18 @@ msgid "expected %<.%>"
 msgstr "ожидалась %<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "ожидалось %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "ожидалось %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "ожидалась %<,%> или %<)%>"
@@ -23038,46 +23043,46 @@ msgstr "ожидалась %<,%> или %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "ожидалось %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "ожидалась %<)%> или %<,%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "ожидалась %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<else%>"
 msgstr "ожидалось %<delete%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "ожидалось %<#pragma omp section%> или %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anonymous)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "ожидалось %<<%>"
@@ -23107,7 +23112,7 @@ msgstr "кандидат"
 msgid "  after user-defined conversion:"
 msgstr "Включить определяемые пользователем инструкции."
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "кандидат"
@@ -23208,7 +23213,7 @@ msgstr "<ошибка параметра шаблона>"
 msgid "<statement>"
 msgstr "<оператор>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<неизвестный>"
@@ -23235,325 +23240,369 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<ошибка выражения>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<неизвестный оператор>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "На глобальном уровне:"
 
-#: cp/reflect.cc:565
+#: cp/reflect.cc:408
 #, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "номер сумматора не является целой константой"
+#| msgid "template constraint failure"
+msgid "reflect_constant_array failed"
+msgstr "нарушение ограничения шаблона"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "template constraint failure"
 msgid "reflect_constant failed"
 msgstr "нарушение ограничения шаблона"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "номер сумматора не является целой константой"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "redeclaration of friend %q#D may not have default template arguments"
 msgid "reflection does not have template arguments"
 msgstr "редекларация friend %q#D не может иметь подразумеваемые аргументы шаблона"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "called object is not a function or function pointer"
 msgid "reflection does not represent a function or function type"
 msgstr "вызываемый объект не является функцией или указателем на функцию"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "format string argument is not a string type"
 msgid "operators argument is not a valid operator"
 msgstr "аргумент, задающий формат, имеет не строковый тип"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%qE не класс"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "в декларации friend нет имени класса или функции"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 #| msgid "called object is not a function or function pointer"
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "вызываемый объект не является функцией или указателем на функцию"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 #| msgid "non-constant condition for static assertion"
 msgid "non-constant offset for offset_of"
 msgstr "неконстантное условие для static assertion"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type %qT"
 msgid "reflection with incomplete type in size_of"
 msgstr "доступ по указателю на неполный тип %qT"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment."
 msgid "reflection not suitable for alignment_of"
 msgstr "Не выравнивать данные, доступные на запись."
 
 #
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "invalid new of function type"
 msgid "alignment_of on function type"
 msgstr "некорректное new типа функции"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 #| msgid "indirection will not access object of incomplete type %qT in statement"
 msgid "reflection with incomplete type in alignment_of"
 msgstr "косвенность не даст доступ к объекту неполного типа %qT в операторе"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type %qT"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "доступ по указателю на неполный тип %qT"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "expected function name"
 msgid "reflect_function failed"
 msgstr "ожидалось имя функции"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "argument to '-Xassembler' is missing"
 msgid "value member missing"
 msgstr "не задан аргумент ключа '-Xassembler'"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "expected pass name"
 msgid "unexpected value of value member"
 msgstr "ожидалось pass имя"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "%qD does not have integral or enumeration type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "%qD не имеет целый или перечислимый тип"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 #| msgid "expected integer or boolean type"
 msgid "reflection represents non-integral or bool type"
 msgstr "ожидалось выражение или булевый тип"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qE attribute"
 msgid "invalid argument to can_substitute"
 msgstr "некорректный аргумент атрибута %qE"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "target is not pointer or reference"
 msgid "type is not object or reference type"
 msgstr "цель не есть указатель или ссылка"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%<%c%> is not a valid character in an identifier"
 msgid "name is not a valid identifier"
 msgstr "%<%c%> не является корректным символом в идентификаторе"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "не задано имя регистра для %q+D"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "нельзя задавать выравнивание для %q+D"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "ширина поля"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "сдвиг вправо на отрицательное число позиций"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "-faligned-new=%d is not a power of two"
 msgid "alignment is not power of two"
 msgstr "-faligned-new=%d не есть степень двойки"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "right rotate count is negative"
 msgid "alignment is negative"
 msgstr "счетчик циклического сдвига вправо отрицателен"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "выравнивание %qD больше чем в исходной декларации"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "%qE does not have pointer or array type"
+msgid "reflection does not have non-array object type"
+msgstr "%qE не имеет тип указателя или массива"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "%qD does not refer to a function"
+msgid "current scope does not represent a function"
+msgstr "%qD не ссылается на функцию"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "в декларации friend нет имени класса или функции"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qE"
 msgid "incomplete parent class"
 msgstr "неполная реализация класса %qE"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qE is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qE не класс или пространство имен"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "source is of incomplete class type"
 msgid "not a complete class type"
 msgstr "источник имеет неполный тип класса"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "a template cannot be defaulted"
 msgid "value cannot be extracted"
@@ -23599,52 +23648,52 @@ msgstr "преобразование типа отбрасывает конст
 msgid "source type is not polymorphic"
 msgstr "тип источника не является полиморфным"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "претенденты:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "неверный тип аргумента для унарного минуса"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "неверный тип аргумента для унарного плюса"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "неверный тип аргумента для побитового дополнения"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "неверный тип аргумента для abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "неверный тип аргумента для сопряжения"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "в аргументе унарного !"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "нет преинкрементного оператора для типа"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "нет постинкрементного оператора для типа"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "нет предекрементного оператора для типа"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "нет постдекрементного оператора для типа"
 
@@ -23662,73 +23711,73 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "Строка усечена в %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "аргументы 'a%d' и 'a%d' для внутренней функции '%s'"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "аргументы '%s' и '%s' для внутренней функции %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "аргументы '%s' и '%s' для внутренней функции '%s'"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "%qD is not a pointer variable"
 msgid "NULL() is not interoperable"
 msgstr "%qD не указательная переменная"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "недопустимая константа"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "End expression in DO loop"
 msgid "Expression is polymorphic"
 msgstr "Конечное выражение в DO цикле"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "%qs в EXTENDS выражении в %C не есть производный тип"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected argument"
 msgid "Procedure unexpected as argument"
 msgstr "неожиданный аргумент"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 #| msgid "Old-style character length at %C"
 msgid "Type shall have a character length of 1"
 msgstr "Старый стиль длины строки в %C"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "типы не вполне совместимы"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 #| msgid "Assumed size array %qs in namelist %qs at %C is not allowed"
 msgid "Assumed-size arrays are not interoperable"
@@ -23804,7 +23853,7 @@ msgstr "Отмененная возможность:"
 msgid "Unsigned:"
 msgstr "<unnamed-signed:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "присваивание массивов"
 
@@ -23813,17 +23862,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -24017,11 +24066,11 @@ msgstr "блочный IF"
 msgid "implied END DO"
 msgstr "предписанный END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "присваивание"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "присваивание указателя"
 
@@ -24029,125 +24078,125 @@ msgstr "присваивание указателя"
 msgid "simple IF"
 msgstr "простой IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "элементная процедура"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "размещаемый аргумент"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "асинхронный аргумент"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "необязательный аргумент"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "аргумент-указатель"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "целевой аргумент"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "value аргумент"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "volatile аргумент"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "assumed-shape аргумент"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "assumed-rank аргумент"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "coarray аргумент"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "аргумент параметризованного производного типа"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "полиморфный аргумент"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "атрибут NO_ARG_CHECK"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "аргумент предполагаемого типа"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "результат-массив"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "указательный или размещаемый результат"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr "результат с неконстантной character длиной"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "процедура bind(c)"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Переменная цикла"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "Переменная итератора"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Начальное выражение в DO цикле"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "Конечное выражение в DO цикле"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Шаговое выражение в DO цикле"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "DEALLOCATE объект"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "ALLOCATE объект"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "STAT переменная"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "ERRMSG переменная"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "элемент в READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "ACQUIRED_LOCK переменная"
 
@@ -24156,31 +24205,31 @@ msgstr "ACQUIRED_LOCK переменная"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Разные CHARACTER длины (%ld/%ld) в конструкторе массива"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "Целочисленное переполнение при вычислении объема памяти для размещения"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Фактическая длина строки не соответствует декларированной для формального аргумента '%s' (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Фактическая длина строки меньше декларированной для формального аргумента '%s' (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "Цель переотображения ранга слишком мала (%ld < %ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Присваивание скаляра неразмещенному массиву"
 
@@ -24245,27 +24294,27 @@ msgstr "Аргумент NCOPIES от REPEAT встроенной функции
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Аргумент NCOPIES от REPEAT встроенной функции слишком велик"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -24365,7 +24414,7 @@ msgid "expected boolean type"
 msgstr "ожидался булевый тип"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "ожидалось целое"
@@ -24430,7 +24479,7 @@ msgstr "недостаточно аргументов"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "слишком много аргументов"
@@ -24840,7 +24889,7 @@ msgstr "поддержка профилирования для VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "целевая OS не поддерживает невыровненные доступы"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "профилирование пока не реализовано для этой архитектуры"
@@ -25096,13 +25145,13 @@ msgstr "неопознанный ключ: %qs"
 msgid "Global declarative %s for %s"
 msgstr "старая декларация %q#D"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -25273,13 +25322,13 @@ msgstr "%qs устарело; используйте -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs устарело; используйте -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown stack check parameter %qs"
 msgid "unknown autovec preference %qs"
 msgstr "неизвестный параметр проверки стека %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -25750,8 +25799,8 @@ msgstr ""
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "предыдущая декларация здесь"
@@ -25768,7 +25817,7 @@ msgstr "директива описания атрибута %qE проигно
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%<%E::%E%> scoped attribute директива проигнорирована"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "для атрибута %qE задано неверное число аргументов"
@@ -25779,7 +25828,7 @@ msgstr "для атрибута %qE задано неверное число а
 msgid "expected %i or more, found %i"
 msgstr "ожидалось %<(%> или конец строки"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<,%> before %qE"
 msgid "expected %i, found %i"
@@ -25863,12 +25912,12 @@ msgstr "атрибуты типов игнорируются, если тип у
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25991,138 +26040,138 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "отсутствует call_stmt, соответствующий дуге %s->%s"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 #| msgid "creating run-time relocation"
 msgid "corresponding source location"
 msgstr "создание настройки времени выполнения"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of functions"
 msgid "location is after end of function"
 msgstr "создание массива функций"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "Не ожидался TAG."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "Ошибка открытия файла профиля %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr "AutoFDO магическое число профиля не соответствует"
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "AutoFDO profile version %u does match %u"
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "AutoFDO версия профиля %u не соответствует %u"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read string table from %s"
 msgid "cannot read summary information from %s"
 msgstr "ошибка чтения таблицы цепочек из %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "ошибка чтения таблицы цепочек из %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "ошибка чтения профиля функции из %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read function profile from %s"
 msgid "cannot read module profile from %s"
@@ -26133,7 +26182,7 @@ msgstr "ошибка чтения профиля функции из %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "смещение %qwi вне границ константной строки"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "%qE declared here"
@@ -26245,7 +26294,7 @@ msgstr "константный аргумент для %qs вне диапазо
 msgid "illegal argument 0 to %qs"
 msgstr "отсутствует аргумент для %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -26325,13 +26374,13 @@ msgstr "%Kаргумент %d должен быть непосредственн
 msgid "cannot tail-call: %s"
 msgstr "ошибка хвостового вызова: %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "функция возвращает агрегатное значение"
 
 #
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "передача слишком большого аргумента на стек"
@@ -26989,352 +27038,352 @@ msgstr "блоки не были размещены последовательн
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "число меток блоков в списке RTL-инструкций (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr ""
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing dimension specification at %C"
 msgid "missing direct call for speculation %i"
 msgstr "Отсутствует спецификатор измерения в %C"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing barrier after block %i"
 msgid "missing ref for speculation %i"
 msgstr "отсутствует барьер после блока %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "для дуги %s->%s установлено вспомогательное поле"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "подставляемый клон в том же списке comdat группы"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "inline clone is forced to output"
 msgid "inline clone count is not compatible"
 msgstr "inline клон принудительно выводится"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "tp_first_run must be non-negative"
 msgstr "значение %<priority%> должен быть неотрицательным"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "локальные символы должны быть определены"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "видимый извне inline клон"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "взятие inline клона с адресом"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "inline клон принудительно выводится"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "inline clone is forced to output"
 msgid "inline clone is referenced by assembly"
 msgstr "inline клон принудительно выводится"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 #| msgid "returns_nonnull attribute on a function not returning a pointer"
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "returns_nonnull атрибут для функции не возвращающей указатель"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "target specific option mismatch"
 msgid "semantic interposition mismatch"
 msgstr "несовпадение ключей, специфических для целевой платформы"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "aux поле установлено для косвенной дуги из %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "edge count is not compatible with function count"
 msgstr "-mnop-mcount несовместимо с этой целью"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "ms_hook_prologue is not compatible with nested function"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "ms_hook_prologue несовместим с вложенной функцией"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "Косвенная дуга из %s не помечена как косвенная или имеет ассоциированную indirect_info, соответствующий оператор есть: "
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr "comdat-local функция вызвана из %s вне ее comdat"
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "некорректный указатель inlined_to"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "множественные inline-вызовы"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "указатель inlined_to установлен для не inline вызова"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "указатель inlined_to установлен, но не найдено ни одного предшественника"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "указатель inlined_to ссылается на себя"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "cgraph_node имеет некорректный clone_of"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "cgraph_node имеет некорректный список клонов"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "cgraph_node в списке клонов, но он не клон"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "cgraph_node имеет некорректный prev_clone указатель"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "испорчен двусвязный список клонов"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "Alias имеет дуги вызовов"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "Alias имеет не-alias ссылку"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "Alias имеет более одной alias ссылки"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "Проанализированный alias не имеет ссылки"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "Нет дуги из thunk-узла"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "Более одной дуги исходит из thunk-узла"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "Thunk не должен иметь тела"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "разделяемый call_stmt:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "дуга указывает на неверную декларацию:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "косвенная дуга с неизвестной вызываемой функцией, соответствующая call_stmt, в известной декларации"
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "отсутствует дуга callgraph для инструкции вызова:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "ссылка на мертвый оператор"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "отсутствует call_stmt, соответствующий дуге %s->%s"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "косвенная дуга из %s не имеет соответствующего call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of register to a different size"
 msgid "origin points to a different parent"
 msgstr "преобразование регистра к другому размеру"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "процедура verify_cgraph_node выявила ошибки"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: section %s is missing"
 msgid "%s: section %s.%d is missing"
@@ -28159,17 +28208,17 @@ msgstr "общий размер локальных объектов слишко
 msgid "impossible constraint in %<asm%>"
 msgstr "некорректное ограничение в %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "переменная %q+D может быть испорчена вызовами %<longjmp%> или %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "аргумент %q+D мог быть испорчен вызовами %<longjmp%> или %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "функция возвращает агрегатное значение"
@@ -28895,7 +28944,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "элемент регулируемого массива %qD не в конце %q#T"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -28937,7 +28986,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr ""
@@ -28957,24 +29006,24 @@ msgstr "переход по пустому указателю"
 msgid "function may return address of local variable"
 msgstr "функция может возвращать адрес локальной переменной"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "функция возвращает адрес локальной переменной"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -30003,7 +30052,7 @@ msgstr "%<%.*s%> директивная запись от %wu до %wu байт
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 #| msgid "required from %q#D\n"
 msgid "returned from %qD"
@@ -30084,233 +30133,233 @@ msgstr "в вызове встроенной функции размещения
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "неизвестный спецификатор архитектуры в модели памяти встроенной функции"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model argument %d of %qE"
 msgid "invalid memory model %qs for %qD"
 msgstr "некорректный аргумент %d модели памяти для %qE"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model argument %d of %qE"
 msgid "invalid memory model %wi for %qD"
 msgstr "некорректный аргумент %d модели памяти для %qE"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "valid arguments to %qs are: %s"
 msgid "valid models are %e"
 msgstr "допустимые аргументы %qs: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model argument %d of %qE"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "некорректный аргумент %d модели памяти для %qE"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, fuzzy, gcc-internal-format
 #| msgid "failure memory model cannot be stronger than success memory model for %<__atomic_compare_exchange%>"
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "модель памяти для случая отказа не может быть сильнее, чем для случая успеха в вызове %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, fuzzy, gcc-internal-format
 #| msgid "failure memory model cannot be stronger than success memory model for %<__atomic_compare_exchange%>"
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "модель памяти для случая отказа не может быть сильнее, чем для случая успеха в вызове %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE attribute not available to functions with variable number of arguments"
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "атрибут %qE не доступен для функций с переменным числом аргументов"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Kargument %i value %qE is negative"
 msgid "argument %i value %s is negative"
 msgstr "%Kаргумент %i значение %qE отрицательное"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "referencing argument %u of type %qT"
 msgstr "ожидался тип %qT, но аргумент имеет тип %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared here"
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "в вызове функции %qD определенной здесь"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "некорректный тип элемента для атрибута %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to built-in function %qD"
 msgid "in a call to function %qD"
 msgstr "в вызове встроенной функции %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "in a call with type %qT"
 msgstr "  в вызове %qD"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "assigned here"
 msgstr "структура определена здесь"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not refer to a namespace scope function"
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD не ссылается на функцию в контексте пространства имен"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "pointer %qE may be used after %qD"
 msgstr "Cray pointer %qs в %s клаузуле в %L"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "pointer %qE used after %qD"
 msgstr "Cray pointer %qs в %s клаузуле в %L"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "нельзя задавать выравнивание для %q+D"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %qD"
 msgid "pointer used after %qD"
 msgstr "неиспользуемый параметр %qD"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "in call to %qD, declared here"
 msgid "call to %qD here"
 msgstr "в вызове %qD, декларированной здесь"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "неизвестная машинный режим %qs для указателя"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "предполагается указатель на элемент %qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "неизвестная машинный режим %qs для указателя"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD объявлено здесь"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "plugin cannot register an unnamed pass"
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "plugin-модуль не может зарегистрировать безымянный проход"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "unnamed class defined here"
 msgid "unnamed temporary defined here"
 msgstr "неименованный класс определен здесь"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to built-in allocation function %qD"
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "в вызове встроенной функции размещения %qD"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to built-in allocation function %qD"
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "в вызове встроенной функции размещения %qD"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  в вызове %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %qD returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -31178,271 +31227,271 @@ msgstr "токен %u имеет y-location == %u"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "недопустимое использование атрибута %<fallthrough%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "виртуальная таблица типа %qD нарушает правило одного определения"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "переменная того же ассемблерного имени, что и виртуальная таблица, определена в другой единице трансляции"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "виртуальная таблица типа %qD содержит RTTI информацию"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr "но предназначена чем-то из другой единицы трансляции"
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "RTTI не будет работать с этим типом"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "конфликтующий тип определенный в другой единице трансляции имеет виртуальную таблицу другого размера"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "конфликтующий тип определенный в другой единице трансляции с другой RTTI информацией"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "конфликтующий тип определенный в другой единице трансляции"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "содержит дополнительный виртуальный метод %qD"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "конфликтующий тип определенный в другой единице трансляции имеет виртуальную таблицу с большим числом элементов"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "виртуальный метод %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr "должен соответствовать виртуальному методу %qD, но не соответствует"
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "конфликтующий тип определенный в другой единице трансляции имеет виртуальную таблицу с другим содержимым"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT itself violates the C++ One Definition Rule"
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "тип %qT сам по себе нарушает C++ Правило Одного Определения"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "тип %qT нарушает C++ Правило Одного Определения"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "другой тип определен в другой единице трансляции"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr "первое отличие соответствующего определения есть поле %qD"
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr "первое отличие соответствующего определения есть метод %qD"
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT defined in anonymous namespace can not match type %qT across the translation unit boundary"
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "тип %qT определенный в анонимном пространстве имен не может соответствовать типу %qT в другой единице трансляции"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT defined in anonymous namespace can not match across the translation unit boundary"
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "тип %qT определенный в анонимном пространстве имен не может иметь соответствие в другой единице трансляции"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "несовместимый тип определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "имя типа %qs должно соответствовать имени типа %qs"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "несовместимый тип определен здесь"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "типы массива имеют разные границы"
 
 #
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "несоответствие типа возвращаемого значения"
 
 #
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "несоответствие типа неявного this указателя"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "несоответствие типов в параметре %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "типы имеют разные счетчики параметров"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "тип %qT сам по себе нарушает C++ Правило Одного Определения"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "тип %qT должен соответствовать типу %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "тип с другой точностью определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 #| msgid "a type with different number of fields is defined in another translation unit"
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "тип с другим числом полей определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "тип с другой знаковостью определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "это определено как указатель в другом адресном пространстве в другой единице трансляции"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "это определено как указатель на другой тип в другой единице трансляции"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "массив другого размера определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "имеет другое возвращаемое значение в другой единице трансляции"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "имеет другие параметры в другой единице трансляции"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "тип определенный в другой единице трансляции не полиморфный"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "тип определенный в другой единице трансляции полиморфный"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "тип с другими указателями виртуальной таблицы определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "тип с другими базами определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "поле с другим именем определено в другой единице трансляции"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "поле с тем же именем, но другим типом определено в другой единице трансляции"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "поля имеют другое расположение в другой единице трансляции"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "тип с другим числом полей определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "тип с другим размером определен в другой единице трансляции"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "Array bound mismatch"
 msgid "memory layout mismatch"
 msgstr "Границы массива не совпадают"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "дополнительная база определена здесь"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
@@ -31450,7 +31499,7 @@ msgstr[0] "Декларирование типа %qD final включит дев
 msgstr[1] "Декларирование типа %qD final включит девиртуализацию %i вызовов"
 msgstr[2] "Декларирование типа %qD final включит девиртуализацию %i вызовов"
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
@@ -31458,7 +31507,7 @@ msgstr[0] "Декларирование типа %qD final включит дев
 msgstr[1] "Декларирование типа %qD final включит девиртуализацию %i вызова, выполненного %lli раза"
 msgstr[2] "Декларирование типа %qD final включит девиртуализацию %i вызова, выполненного %lli раза"
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
@@ -31466,7 +31515,7 @@ msgstr[0] "Декларирование виртуального деструк
 msgstr[1] "Декларирование виртуального деструктора %qD final включит девиртуализацию %i вызовов"
 msgstr[2] "Декларирование виртуального деструктора %qD final включит девиртуализацию %i вызовов"
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
@@ -31474,7 +31523,7 @@ msgstr[0] "Декларирование метода %qD final включит д
 msgstr[1] "Декларирование метода %qD final включит девиртуализацию %i вызовов"
 msgstr[2] "Декларирование метода %qD final включит девиртуализацию %i вызовов"
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
@@ -31482,7 +31531,7 @@ msgstr[0] "Декларирование виртуального деструк
 msgstr[1] "Декларирование виртуального деструктора %qD final включит девиртуализацию %i вызова, выполненного %lli раз"
 msgstr[2] "Декларирование виртуального деструктора %qD final включит девиртуализацию %i вызова, выполненного %lli раз"
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
@@ -31490,53 +31539,53 @@ msgstr[0] "Декларирование метода %qD final включит д
 msgstr[1] "Декларирование метода %qD final включит девиртуализацию %i вызова, выполненного %lli раз"
 msgstr[2] "Декларирование метода %qD final включит девиртуализацию %i вызова, выполненного %lli раз"
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT violates the C++ One Definition Rule"
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "тип %qT нарушает C++ Правило Одного Определения"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 #| msgid "an enum with different values is defined in another translation unit"
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "перечисление с другими значениями определено в другой единице трансляции"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "перечисление с другим именем значения определено в другой единице трансляции"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "перечисление с другими значениями определено в другой единице трансляции"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 #| msgid "a field with different name is defined in another translation unit"
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "поле с другим именем определено в другой единице трансляции"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 #| msgid "a type defined in another translation unit is not polymorphic"
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "тип определенный в другой единице трансляции не полиморфный"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 #| msgid "a type defined in another translation unit is polymorphic"
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "тип определенный в другой единице трансляции полиморфный"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 #| msgid "it is defined as a pointer to different type in another translation unit"
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "это определено как указатель на другой тип в другой единице трансляции"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -31559,7 +31608,7 @@ msgstr "во входном файле отсутствует информаци
 msgid "IPA modref summary is missing in input file"
 msgstr "во входном файле отсутствует информация о межпроцедурных inline-подстановках"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function in gimple call"
 msgid "invalid jump function in LTO stream"
@@ -31805,12 +31854,12 @@ msgstr "Макс. number of generated reload insns per insn is achieved (%d)\n"
 msgid "unable to find a register to spill"
 msgstr "не найден регистр для выталкивания в память"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "некорректные ограничители операндов в операторе %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Max. number of generated reload insns per insn is achieved (%d)\n"
 msgid "maximum number of generated reload insns per insn achieved (%d)"
@@ -32206,7 +32255,7 @@ msgstr "%<depend(sink)%> клаузула ждет лексически боле
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "%<depend(sink)%> ссылается на итерацию отсутствующую в пространстве итераций"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -33716,25 +33765,25 @@ msgstr "явно использованные регистры должны бы
 msgid "output operand %d must use %<&%> constraint"
 msgstr "выходной операнд %d должен содержать ограничитель %<&%>"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data: [%u] Некорректный next_regno для пустого списка (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data: цикл в списке номеров регистров (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data: : [%u] Некорректный oldest_regno (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -34734,188 +34783,188 @@ msgstr "внешняя транзакция в %<transaction_safe%> функци
 msgid "ignoring loop annotation"
 msgstr "игнорирование аннотации цикла"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "константа не перевычислена после изменения ADDR_EXPR"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "побочные эффекты не перевычислены после изменения ADDR_EXPR"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "адрес был взят, а бит ADDRESSABLE не установлен"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 #| msgid "non-scalar type"
 msgid "non-scalar %qs"
 msgstr "нескалярный тип"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size operand to %qs"
 msgstr "некорректная позиция или размер для BIT_FIELD_REF"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, fuzzy, gcc-internal-format
 #| msgid "integral result type precision does not match field size of BIT_FIELD_REF"
 msgid "integral result type precision does not match field size of %qs"
 msgstr "точность целочисленного типа результата не соответствует размеру поля в BIT_FIELD_REF"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, fuzzy, gcc-internal-format
 #| msgid "mode size of non-integral result does not match field size of BIT_FIELD_REF"
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "размер режима нецелочисленного результата не соответствует размеру поля в BIT_FIELD_REF"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 #| msgid "shift of non-integer operand"
 msgid "%qs of non-mode-precision operand"
 msgstr "сдвиг нецелого операнда"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, fuzzy, gcc-internal-format
 #| msgid "position plus size exceeds size of referenced object in BIT_FIELD_REF"
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "позиция плюс размер превышает размер указуемого объекта в BIT_FIELD_REF"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in array reference"
 msgid "type mismatch in %qs reference"
 msgstr "несоответствие типов в ссылке на массив"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of an SSA_NAME on the left hand side"
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "преобразование SSA_NAME в левой части"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "conversion of register to a different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "преобразование регистра к другому размеру"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "некорректный операнд для %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in parameter %i"
 msgid "type mismatch in %qs"
 msgstr "несоответствие типов в параметре %i"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offset operand of MEM_REF"
 msgid "invalid %qs offset operator"
 msgstr "некорректный операнд смещения для MEM_REF"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid address operand in MEM_REF"
 msgid "invalid address operand in %qs"
 msgstr "некорректный операнд адреса в MEM_REF"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offset operand in MEM_REF"
 msgid "invalid offset operand in %qs"
 msgstr "некорректный операнд отступа в MEM_REF"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "некорректное использование %qD"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "простой IF"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "структурное значение употреблено в контексте, где допустимо только скалярное значение"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "некорректное выражение в левой части операции min"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "gimple вызов имеет две цели"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "gimple вызов не имеет цели"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "некорректная функция в gimple вызове"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "не функция в gimple вызове"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "некорректное состояние pure const для функции"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "некорректная левая часть в gimple вызове"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "LHS in noreturn call"
 msgid "LHS in %<noreturn%> call"
 msgstr "левая часть в вызове без возврата (noreturn)"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "некорректное преобразование в gimple вызове"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "некорректная статическая цепочка в gimple вызове"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "статическая цепочка с функцией, которая не использует ее"
@@ -34926,649 +34975,649 @@ msgstr "статическая цепочка с функцией, котора
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_unreachable or __builtin_trap call with arguments"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "вызов __builtin_unreachable или __builtin_trap с аргументами"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "некорректный аргумент в gimple вызове"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "некорректные операнды в gimple сравнении"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "несоответствие типов операндов сравнения"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "неподдерживаемая операция или тип для векторного сравнения, возвращающего boolean"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "невекторные операнды в векторном сравнении"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "некорректный тип результата в векторном сравнении"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "фиктивный тип результата в векторном сравнении"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "не-регистр в левой части унарной операции"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "неверные операнды унарной операции"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid vector types in nop conversion"
 msgstr "неверные типы в nop-преобразовании"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "неверные типы в nop-преобразовании"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "неверные типы в преобразовании адресного пространства"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "неверные типы в преобразовании с фиксированной точкой"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in conversion to floating point"
 msgid "invalid types in conversion to floating-point"
 msgstr "некорректные типы в преобразовании к типу с плавающей точкой"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "некорректные типы в преобразовании к целочисленному типу"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in sad expression"
 msgid "type mismatch in %qs expression"
 msgstr "несоответствие типов в sad выражении"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid prototype for '%s'"
 msgid "invalid types for %qs"
 msgstr "некорректный прототип для '%s'"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid prototype for '%s'"
 msgid "invalid type for %qs"
 msgstr "некорректный прототип для '%s'"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "нетривиальное преобразование в унарной операции"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "не регистр в левой части бинарной операции"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "неверные операнды в бинарной операции"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid non-vector operands to vector valued plus"
 msgid "invalid non-vector operands to %qs"
 msgstr "неверные невекторные операнды векторной операции плюс"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "неизвестная машинный режим %qs для указателя"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "vector types expected in sad expression"
 msgid "vector type expected in %qs"
 msgstr "ожидались векторные типы в sad выражении"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "несоответствие типов в бинарном выражении"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "не регистр в левой части тернарной операции"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "неверные операнды тернарной операции"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, fuzzy, gcc-internal-format
 #| msgid "the first argument of a VEC_COND_EXPR must be of a boolean vector type of the same number of elements as the result"
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr "первый аргумент VEC_COND_EXPR должен быть boolean векторного типа с тем же числом элементов, что и результат"
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "vector types expected in sad expression"
 msgid "vector types expected in %qs"
 msgstr "ожидались векторные типы в sad выражении"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 #| msgid "vectors with different element number found in vector permute expression"
 msgid "vectors with different element number found in %qs"
 msgstr "в векторном выражении перестановки обнаружены векторы с разным числом элементов"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid offload table in %s"
 msgid "invalid mask type in %qs"
 msgstr "некорректная таблица разгрузки в %s"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "not allowed type combination in BIT_INSERT_EXPR"
 msgid "not allowed type combination in %qs"
 msgstr "недопустимая комбинация типов в BIT_INSERT_EXPR"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size in BIT_INSERT_EXPR"
 msgid "invalid position or size in %qs"
 msgstr "некорректная позиция или размер в BIT_INSERT_EXPR"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 #| msgid "'h' applied to non-register operand"
 msgid "%qs into non-mode-precision operand"
 msgstr "'h' применено к нерегистровому операнду"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "insertion out of range in BIT_INSERT_EXPR"
 msgid "insertion out of range in %qs"
 msgstr "вставка вне диапазона в BIT_INSERT_EXPR"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "vector insertion not at element boundary"
 msgid "%qs not at element boundary"
 msgstr "векторная вставка не на границе элемента"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion at assignment"
 msgid "non-trivial conversion in %qs"
 msgstr "нетривиальное преобразование в присваивании"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid array assignment"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "некорректное присваивание массива"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "non-decl/MEM_REF LHS in clobber statement"
 msgid "%qs LHS in clobber statement"
 msgstr "non-decl/MEM_REF LHS в затирающем операторе"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "некорректный операнд для %%R"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %qD"
 msgid "invalid %qs size argument in load"
 msgstr "некорректный аргумент для %qD"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rhs for gimple memory store"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "Некорректная правая часть в gimple операции записи в память"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "non-register as LHS of ternary operation"
 msgid "non-register as LHS with vector constructor"
 msgstr "не регистр в левой части тернарной операции"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect type of vector CONSTRUCTOR elements"
 msgid "incorrect type of vector %qs elements"
 msgstr "некорректный тип элементов векторного CONSTRUCTOR"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect number of vector CONSTRUCTOR elements"
 msgid "incorrect number of vector %qs elements"
 msgstr "некорректное число элементов векторного CONSTRUCTOR"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "некорректный тип элементов векторного CONSTRUCTOR"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, fuzzy, gcc-internal-format
 #| msgid "vector CONSTRUCTOR with non-NULL element index"
 msgid "vector %qs with non-NULL element index"
 msgstr "векторный CONSTRUCTOR с non-NULL индексом элемента"
 
 #
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 #| msgid "vector CONSTRUCTOR element is not a GIMPLE value"
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "элемент векторного CONSTRUCTOR не есть GIMPLE-значение"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 #| msgid "non-vector CONSTRUCTOR with elements"
 msgid "non-vector %qs with elements"
 msgstr "non-vector CONSTRUCTOR с элементами"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "не параметрический %qs не может содержать параметры"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "некорректный операнд в операторе return"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "некорректное преобразование в операторе return"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "цель оператора goto не является ни меткой, ни указателем"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "некорректный операнд для оператора switch"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "оператор switch с нецелочисленным типом"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "некорректная default case метка в операторе switch"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "invalid CASE_CHAIN"
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "некорректная CASE_CHAIN"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "некорректная case метка в операторе switch"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "некорректный case диапазон в операторе switch"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "несоответствие точности типов в операторе switch"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "несоответствие типов для case метки в операторе switch"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "case метки не отсортированы в операторе switch"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "label's context is not the current function decl"
 msgid "label context is not the current function declaration"
 msgstr "контекст метки не есть декларация текущей функции"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect entry in label_to_block_map"
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "некорректный элемент в label_to_block_map"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "некорректная установка номера landing pad"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "некорректный код сравнения в gimple условном выражении"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "некорректные метки в gimple условном выражении"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI result"
 msgid "invalid %<PHI%> result"
 msgstr "некорректный результат PHI"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<PHI%> def"
 msgstr "отсутствует определение PHI"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI argument"
 msgid "invalid %<PHI%> argument"
 msgstr "некорректный аргумент PHI"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in PHI argument %u"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "несовместимые типы в аргументе PHI %u"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_gimple failed"
 msgid "%<verify_gimple%> failed"
 msgstr "процедура verify_gimple выявила ошибки"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, fuzzy, gcc-internal-format
 #| msgid "dead STMT in EH table"
 msgid "dead statement in EH table"
 msgstr "мертвый оператор в таблице EH"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr "расположения блока ссылок не в дереве блоков"
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "Local declaration from a different function"
 msgid "local declaration from a different function"
 msgstr "Локальная декларация из другой функции"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) указывает не на тот блок"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr "PHI узел с расположением"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "недопустимое разделение узлов дерева"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "виртуальный PHI с расположениями аргументов"
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) указывает не на тот блок"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "оператор помечен как throw, но не является таковым"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "оператор помечен как throw в середине блока"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "процедура verify_gimple выявила ошибки"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "с ENTRY_BLOCK ассоциирован IL"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "с EXIT_BLOCK ассоциирован IL"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "сквозной выход из блока %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "избыточные фигурные скобки в конце инициализатора"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "избыточные фигурные скобки в конце инициализатора"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "exit block count is not compatible with entry block count"
 msgstr "-mnop-mcount несовместимо с этой целью"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE не инициализирован"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-mnop-mcount несовместимо с этой целью"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 #| msgid "Label %qs at %C doesn't match IF label %qs"
 msgid "label %qD to block does not match in bb %d"
 msgstr "Метка %qs в %C не соответствует IF метке %qs"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type %qT"
 msgid "label %qD has incorrect context in bb %d"
 msgstr "поле %qD имеет неполный тип %qT"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "инструкция управления потоком выполнения внутри блока %d"
 
 #
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "label %s in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "метка %s в середине базового блока %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "сквозная дуга после оператора управления в блоке %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "дуга true/false после не GIMPLE_COND в блоке %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "некорректные флаги выходной дуги в конце блока %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "явный переход goto в конце блока %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "дуга return не указывает на конец блока %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "случай default - не в начале case-вектора"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "case-метки не отсортированы: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "лишняя исходящая дуга %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "отсутствует дуга %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "выход из функции с атрибутом %<noreturn%>"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "управление достигает конца не-void функции"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "результат %qD, декларированной с атрибутом warn_unused_result, игнорируется"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of function declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -35759,13 +35808,13 @@ msgstr "цель не поддерживает атомарное изменен
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "цель не поддерживает атомарное изменение профиля, выбран одиночный режим"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "некорректный тип элемента для атрибута %qs"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid use of attribute %<fallthrough%>"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -36332,7 +36381,7 @@ msgstr "векторное условие будет расширено по ч
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "векторная операция перемешивания будет выполнена по частям"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr "векторизация не получилась для simd цикла"
@@ -36808,31 +36857,31 @@ msgstr "TYPE_CACHED_VALUES_P установлен хотя не должен"
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "TYPE_METHOD_BASETYPE не есть главный вариант"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "предыдущая декларация %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D конфликтует с предыдущей декларацией"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "%qD conflicts with used function"
 msgid "%qD conflicts for version %qB"
 msgstr "%qD противоречит использованной функции"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -36917,7 +36966,7 @@ msgstr "только нулевые инициализаторы допуска
 msgid "no initializers are allowed in section %qs"
 msgstr "только нулевые инициализаторы допускаются в секции %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "не задано имя регистра для %q+D"
@@ -37073,7 +37122,7 @@ msgstr "слабая ссылка %q+D в конечном счёте напра
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "слабая ссылка %q+D должна иметь статическое связывание"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "в данной конфигурации определения алиасов не поддерживаются"
@@ -37119,62 +37168,62 @@ msgstr "Использовать компактную раскладку в ст
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "некорректный аргумент шаблона %d"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "некорректный аргумент шаблона %d"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "%qE attribute argument has type %qT"
 msgstr "ожидался тип %qT, но аргумент имеет тип %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "аргумент по умолчанию для %q#D имеет тип %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "аргумент атрибута %qE не целая константа"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "аргумент атрибута %qE не целая константа"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to base type of a function pointer"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "атрибут %qE применим только к базовому типу указателя на функцию"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to base type of a function pointer"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "атрибут %qE применим только к базовому типу указателя на функцию"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "аргументы по умолчанию разрешены только для параметров функций"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "%Kargument %i value %qE exceeds maximum object size %E"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -37192,13 +37241,13 @@ msgstr "атрибут %qE не доступен для функций с пер
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "атрибут %qE не доступен для функций с переменным числом аргументов"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a void return type"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "атрибут %qE требует возвращаемый тип void"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a void return type"
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
@@ -37427,12 +37476,12 @@ msgstr "использование режима %qs для перечислим
 msgid "mode %qs applied to inappropriate type"
 msgstr "режим %qs применен к неподходящему типу"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "атрибут section для данной платформы не поддерживается"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "атрибут section для %q+D недопустим"
@@ -37442,18 +37491,18 @@ msgstr "атрибут section для %q+D недопустим"
 msgid "section attribute argument not a string constant"
 msgstr "аргумент атрибута секции не строковая константа"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "атрибут section недопустим для локальных переменных"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "атрибут section, заданный для %q+D, противоречит предшествующей декларации"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "секция %q+D не может быть переопределена"
@@ -37551,7 +37600,7 @@ msgstr "аргумент %qE - не идентификатор"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "'readonly' атрибут свойства %qD конфликтует с предшествующей декларацией"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "inline функция %q+D объявлена weak"
@@ -37602,13 +37651,13 @@ msgstr "игнорирование %qD атрибута в non-inline прост
 msgid "%qE attribute is only applicable on functions"
 msgstr "%qE атрибут применим только к функциям"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "атрибут %qs допустим только для функций"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is only applicable on functions"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -37620,12 +37669,12 @@ msgstr "%qE атрибут применим только к функциям"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "аргумент атрибута %qE не строковая константа"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -37727,24 +37776,24 @@ msgstr "атрибут %qE игнорируется, поскольку %qT уж
 msgid "visibility argument not a string"
 msgstr "аргумент атрибута visibility не является текстовой строкой"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "атрибут %qE для типов игнорируется"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %qE argument not a string"
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "аргумент атрибута %qE не является строковой константой"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD повторно декларирован с другим атрибутом видимости"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD был объявлен %qs, что подразумевает значение видимости по умолчанию"
@@ -37762,7 +37811,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "%qE: атрибут допустим только для функций"
@@ -37844,7 +37893,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "атрибут %qE требует возвращаемый тип void"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -37926,7 +37975,7 @@ msgstr "%qD не совместим с %qD"
 msgid "%qE argument is not a function"
 msgstr "аргумент %qE не функция"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "сообщение для атрибута deprecated не является строковой константой"
@@ -37998,7 +38047,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "атрибут %qE для типов игнорируется"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "%qE атрибут требует строковый аргумент"
@@ -38172,15 +38221,15 @@ msgid "requested position is less than zero"
 msgstr "заданная позиция меньше нуля"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "аргумент атрибута %qE не строковая константа"
@@ -38483,7 +38532,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "присваивание, используемое как логическое выражение, рекомендуется "
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "неверное употребление спецификатора %<restrict%>"
@@ -38665,8 +38714,8 @@ msgstr "слишком мало аргументов функции для ис
 msgid "missing sentinel in function call"
 msgstr "отсутствует sentinel в вызове функции"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "некорректная опция %qs для атрибута %<optimize%>"
@@ -39746,7 +39795,7 @@ msgstr "неподдерживаемая нестандартная конкат
 msgid "traditional C rejects string constant concatenation"
 msgstr "традиционный Си не поддерживает конкатенацию строковых констант"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -39805,7 +39854,7 @@ msgstr "%<depend(source)%> клаузула задана вместе с %<depen
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "%<ordered%> клаузула с параметром не может быть задана в %qs конструкции"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "некорректный тип итерационной переменной %qE"
@@ -39820,17 +39869,17 @@ msgstr "%<_Atomic%> итерационная переменная %qE"
 msgid "%qE is not initialized"
 msgstr "%qE не инициализирован"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "отсутствует управляющий предикат"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "некорректный управляющий предикат"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "отсутствует инкрементальное выражение"
@@ -39840,7 +39889,7 @@ msgstr "отсутствует инкрементальное выражение
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "некорректное инкрементальное выражение"
@@ -39941,20 +39990,20 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an function argument"
 msgid "%qD is not a function argument"
 msgstr "%qD не является аргументом функции"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "битовое поле %qE в %qs клаузуле"
@@ -39964,8 +40013,8 @@ msgstr "битовое поле %qE в %qs клаузуле"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE не имеет отображаемый тип в предложении %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%> %qE в %qs клаузуле"
@@ -40533,7 +40582,7 @@ msgstr "некорректное расположение для %<pragma %s%>,
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "некорректный синтаксис %<#pragma %s%>, директива проигнорирована"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "мусор в конце директивы %<#pragma %s%>"
@@ -40606,8 +40655,8 @@ msgstr "некорректно употреблять %<#pragma%>"
 msgid "wrong type argument to %s"
 msgstr "неверный аргумент типа для %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -41094,17 +41143,17 @@ msgstr "декрементация функции %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "функция %qD использована как выходной операнд %<asm%>"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "присваивание позиции в памяти %qE, доступной только на чтение"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "инкрементация позиции в памяти %qE, доступной только на чтение"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "декрементация позиции в памяти %qE, доступной только на чтение"
@@ -41381,7 +41430,7 @@ msgstr[0] "передача аргумента %i в restrict-квалифици
 msgstr[1] ""
 msgstr[2] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr "это условие имеет идентичные ветвления"
@@ -42416,7 +42465,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "Встроенная функция %s требует опцию -mvsx"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -43129,7 +43178,7 @@ msgstr "Передача аргумента %d функции %qE с отлич
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate definition of '%s'"
 msgid "duplicate definition of %qs"
@@ -43183,7 +43232,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "тип %qT не имеет известный размер"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored because %qT is already defined"
 msgid "variables of type %qT cannot have thread-local storage duration"
@@ -43243,7 +43292,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qE не является переменной в предложении %<aligned%>"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -43350,21 +43399,21 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "Аргумент AltiVec передан в функцию без прототипа"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, fuzzy, gcc-internal-format
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr "передача параметров для аргументов типа %qT изменилась в GCC 7.1"
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, fuzzy, gcc-internal-format
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr "передача параметров для аргументов типа %qT изменилась в GCC 7.1"
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, fuzzy, gcc-internal-format
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
@@ -43413,226 +43462,226 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, fuzzy, gcc-internal-format
 #| msgid "unknown flag passed in -moverride=%s (%s)"
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr "неизвестный флаг переданный в -moverride=%s (%s)"
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "атрибут %qs проигнорирован"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid format of %s"
 msgid "invalid format for %<sve_width%>"
 msgstr "некорректный формат %s"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%h value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "некорректное значение %%h"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "строка настройки отсутствует в опции (%s)"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "неизвестная опция настройки (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 #| msgid "Specify the register allocation order"
 msgid "specify a system register with a small string length"
 msgstr "Порядок выделения регистров"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "streaming functions require the ISA extension %qs"
 msgstr "Встроенная функция %s требует опцию -mvsx"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is an invalid argument to -mcpu="
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "%qs некорректный аргумент для -mcpu="
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to built-in function %s"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "некорректный аргумент встроенной функции %s"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march=%s switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "ключ -mcpu=%s несовместим с ключом -march=%s"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "the %qs architecture does not support %<-mfp32%>"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "архитектура %qs не поддерживает %<-mfp32%>"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "%<-mpcommit%> was deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "ключ %<-mpcommit%> устарел"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs with -f%s"
 msgid "code model %qs with %<-f%s%>"
 msgstr "модель кода %qs с -f%s"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in x32 mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "модель кода %qs не поддерживается в режиме x32"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%qs) for %<target(\"arch=\")%> attribute"
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "некорректное значение (%qs) для %<target(\"arch=\")%> атрибута"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid feature modifier in %<-march=%s%>"
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "некорректный модификатор возможности в %<-march=%s%>"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 #| msgid "valid arguments to %<target(\"arch=\")%> attribute are: %s"
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "допустимые аргументы для %<target(\"arch=\")%> атрибута: %s"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 #| msgid "invalid feature modifier in %<-march=%s%>"
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "некорректный модификатор возможности в %<-march=%s%>"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 #| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute"
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "некорректное значение (%qs) для %<target(\"tune=\")%> атрибута"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -43640,223 +43689,223 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr "аргумент атрибута %<target%> не строка"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %<target%> argument not a string"
 msgid "attribute %<target_version%> has multiple values"
 msgstr "аргумент атрибута %<target%> не строка"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %<target%> argument not a string"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "аргумент атрибута %<target%> не строка"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "missing %<=%> (after %<getter%> attribute)"
 msgid "missing value in %<target_version%> attribute"
 msgstr "отсутствует %<=%> (после атрибута %<getter%>)"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 #| msgid "invalid feature modifier in %<-march=%s%>"
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "некорректный модификатор возможности в %<-march=%s%>"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
 #
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "Virtual function multiversioning not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "мультиверсионность виртуальной функции не поддерживается"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "multiversioning needs ifunc which is not supported on this target"
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "мультиверсионность требует ifunc, что не поддерживается на этой платформе"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%qD был ранее декларирован здесь"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 #, fuzzy
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr "передача параметров для аргументов типа %qT изменилась в GCC 7.1"
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 #, fuzzy
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr "передача параметров для аргументов типа %qT изменилась в GCC 7.1"
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 #, fuzzy
 #| msgid "parameter passing for argument of type %qT changed in GCC 7.1"
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr "передача параметров для аргументов типа %qT изменилась в GCC 7.1"
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "проход %wd вне диапазона %wd - %wd"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported simdlen %d"
 msgid "unsupported simdlen %wd"
 msgstr "неподдерживаемая simdlen %d"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument type to builtin function"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "неподдерживаемый тип аргумента для внутренней функции"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument type to builtin function"
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "неподдерживаемый тип аргумента для внутренней функции"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "Ключ -shared не поддерживается для VAX ELF"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "Ключ -shared не поддерживается для VAX ELF"
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "type attributes ignored after type is already defined"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "атрибуты типов игнорируются, если тип уже определен"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%q+D defined here"
 msgstr "метка %qD определена здесь"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer to a constant size type"
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "аргумент %d для %qE должен быть указателем на тип константного размера"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "аргумент %d %qE согласно прототипу будет передан с другой шириной"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be in the range %d...%d"
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "аргумент %d от %qE должен быть в диапазоне %d...%d"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "аргумент %d %qE согласно прототипу будет передан с другой шириной"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "аргумент %d %qE согласно прототипу будет передан с другой шириной"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "аргумент %d %qE согласно прототипу будет передан с другой шириной"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 #| msgid "invalid feature modifier in %<-march=%s%>"
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "некорректный модификатор возможности в %<-march=%s%>"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 #| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute"
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
@@ -44065,12 +44114,12 @@ msgstr ""
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -44208,24 +44257,24 @@ msgid "argument of %qE attribute ignored"
 msgstr ""
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "%qE атрибут применим только к переменным"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "alternatives not allowed in asm flag output"
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "альтернативы не допускается в выводе ассемблерного флага"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 #| msgid "unknown asm flag output %qs"
 msgid "unknown %<asm%> flag output %qs"
 msgstr "неизвестный вывод ассемблерного флага %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for asm flag output"
 msgid "invalid type for %<asm%> flag output"
@@ -44811,12 +44860,12 @@ msgstr "-fpie не поддерживается"
 msgid "%<-fPIE%> is not supported"
 msgstr "-fPIE не поддерживается"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr ""
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "%qs функция не может иметь аргументы"
@@ -44826,7 +44875,7 @@ msgstr "%qs функция не может иметь аргументы"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "%qs функция не может возвращать значение"
@@ -45184,7 +45233,7 @@ msgstr "вызов требует ifunc, которая не поддержив
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "некорректный аргумент встроенной функции"
@@ -45532,7 +45581,7 @@ msgstr "использование vector_length (%d), игнорировани
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr "использование vector_length (%d), игнорирование установок времени выполнения"
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "using num_workers (%d), ignoring %d"
 msgid "using %<num_workers (%d)%>, ignoring %d"
@@ -45726,178 +45775,178 @@ msgstr "Параметр для внутренней функции должен
 msgid "parameter to builtin not valid: %s"
 msgstr "Параметр для внутренней функции некорректен: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt service routine can't be called directly"
 msgid "interrupt service routine cannot be called directly"
 msgstr "программа обслуживания прерываний не может вызываться напрямую"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "последний аргумент должен быть 2-битным непосредственным"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "пятый аргумент должен быть 8-битным непосредственным"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "третий аргумент должен быть 8-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "последний аргумент должен быть 1-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "последний аргумент должен быть 3-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "последний аргумент должен быть 4-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "последний аргумент должен быть 1-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE требует isa опцию %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "последний аргумент должен быть 5-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "следующий за последним аргумент должен быть 8-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "последний аргумент должен быть 8-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "третий аргумент должен быть константой сравнения"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "некорректный режим сравнения"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "некорректный операнд округления"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "непосредственный аргумент должен быть 4-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "непосредственный аргумент должен быть 5-битным непосредственным"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "непосредственный аргумент должен быть 8-битным непосредственным"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 #| msgid "the forth argument must be scale 1, 2, 4, 8"
 msgid "the fourth argument must be one of enum %qs"
 msgstr "четвертый аргумент должен быть масштабом 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "селектор должен быть целой константой в диапазоне 0..%wi"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE требует неизвестную isa опцию"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE требует isa опцию %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "the third argument must be comparison constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "третий аргумент должен быть константой сравнения"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "вместо неверного второго аргумента %<__builtin_prefetch%> используется ноль"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid arguments"
 msgid "invalid third argument"
 msgstr "некорректные аргументы"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "вместо неверного третьего аргумента %<__builtin_prefetch%> используется ноль"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "вместо неверного третьего аргумента %<__builtin_prefetch%> используется ноль"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "second argument must be slice or string"
 msgid "second argument must be a const"
 msgstr "второй аргумент должен быть вырезкой или строкой"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "последний аргумент должен быть 32-битным непосредственным"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "последний аргумент должен быть непосредственным"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "последний аргумент должен быть масштабом 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "the next to last argument must be an 8-bit immediate"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -46327,8 +46376,8 @@ msgstr "%qs не есть допустимый базовый регистр в
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -46586,7 +46635,7 @@ msgstr "ABI для передачи структуры с элементом com
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "ABI для передачи структуры с элементом complex float изменен в GCC 4.4"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -46613,12 +46662,12 @@ msgstr "SSE регистровый аргумент с выключенным SS
 msgid "x87 register return with x87 disabled"
 msgstr "x87 регистровый возврат с выключенным x87"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "вызов %qD с SSE соглашением о вызовах без включения SSE/SSE2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr "это ошибка GCC, которую можно обойти добавлением атрибута used для вызываемой функции"
@@ -46629,42 +46678,42 @@ msgstr "это ошибка GCC, которую можно обойти доба
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "ABI для передачи параметров с %d-байтным выравниванием изменен в GCC 4.6"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not compatible with %qD"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "%qD не совместим с %qD"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 #| msgid "ms_hook_prologue attribute isn%'t compatible with -mfentry for 32-bit"
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "атрибут ms_hook_prologue несовместим с -mfentry для 32 бит"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "%qE атрибут не поддерживается на данной платформе"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "вложенные функции не поддерживаются для этой платформы"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support fastcall with nested function"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "-fsplit-stack не поддерживает fastcall с вложенной функцией"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support 2 register parameters for a nested function"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -46672,103 +46721,103 @@ msgstr "-fsplit-stack не поддерживает 2-регистровые п
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support 3 register parameters"
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "-fsplit-stack не поддерживает 3-регистровые параметры"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren't allowed in function with no_caller_saved_registers attribute"
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "%s инструкции не допускаются в функции с no_caller_saved_registers атрибутом"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren't allowed in %s service routine"
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "%s инструкции не допускаются в %s сервисной программе"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren't allowed in %s service routine"
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "%s инструкции не допускаются в %s сервисной программе"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported size for integer register"
 msgid "%<V%> modifier on non-integer register"
 msgstr "неподдерживаемый размер для целочисленного регистра"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "неподдерживаемый размер для целочисленного регистра"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "расширенные регистры не имеют верхних половин"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "некорректный размер операнда для расширенного регистра"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 #| msgid "non-integer operand used with operand code 'z'"
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "нецелый операнд использован с кодом операнда 'z'"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 #, fuzzy
 #| msgid "the mangling of %<va_list%> has changed in GCC 4.4"
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "разборка %<va_list%> изменилась в GCC 4.4"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "нет свободных low-регистров для выталкивания high-регистров"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 #| msgid "-mcmodel= is not supported on 32-bit systems"
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "-mcmodel= не поддерживается на 32-битных системах"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, fuzzy, gcc-internal-format
 #| msgid "HLE_ACQUIRE not used with ACQUIRE or stronger memory model"
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr "HLE_ACQUIRE не использовано с ACQUIRE или более сильной моделью памяти"
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, fuzzy, gcc-internal-format
 #| msgid "HLE_RELEASE not used with RELEASE or stronger memory model"
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr "HLE_RELEASE не использовано с RELEASE или более сильной моделью памяти"
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 #| msgid "-fdirectives-only is incompatible with -traditional"
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
@@ -46823,7 +46872,7 @@ msgstr "gp_offset (%ld) или end_offset (%ld) меньше нуля"
 msgid "argument %qd is not a constant"
 msgstr "аргумент %qd не константа"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -46835,7 +46884,7 @@ msgstr "нулевой указатель в вызове PRINT_OPERAND_ADDRESS"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: некорректный символ пунктуации '%c'"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -47000,51 +47049,51 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "аргумент атрибута %<target%> не строка"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, fuzzy, gcc-internal-format
 #| msgid "mudflap cannot be used together with link-time optimization"
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "mudflap нельзя использовать вместе с оптимизацией времени компоновки"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 #| msgid "readonly property can not be set"
 msgid "in attribute %qs priority cannot be empty"
 msgstr "readonly свойство на может быть установлено"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "value %qs is not supported by attribute %<target%>"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "значение %qs не поддерживается атрибутом %<target%>"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qs is not supported in target attribute"
@@ -47864,7 +47913,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr "MSP430 встроенные функции работают только внутри обработчиков прерываний"
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "некорректный встроенный code"
@@ -48106,89 +48155,89 @@ msgstr "ошибка открытия промежуточного ptx файл
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "опция %s не поддерживается вместе с -fopenacc"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, fuzzy, gcc-internal-format
 #| msgid "%<-march=%s%> is not compatible with the selected ABI"
 msgid "%<-march=%> must be specified"
 msgstr "ключ %<-march=%s%> несовместим с выбранным ABI"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr "статическая инициализация переменной %q+D в %<.shared%> памяти не поддерживается"
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr "невозможно породить невыровненные указатели в ptx ассемблере"
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr "PTX не поддерживает weak декларации (только weak определения)"
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "атрибут %qE требует возвращаемый тип void"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "%qE атрибут не допускается с классом памяти auto"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%<tile%> value must be positive"
 msgid "barrier value must be within [0,15]"
 msgstr "значение %<num_threads%> должно быть положительным"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "left argument must be a slice"
 msgid "complement argument must be constant"
 msgstr "левый аргумент должен быть вырезкой"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, fuzzy, gcc-internal-format
 #| msgid "using vector_length (%d), ignoring %d"
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr "использование vector_length (%d), игнорирование %d"
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, fuzzy, gcc-internal-format
 #| msgid "using vector_length (%d), ignoring runtime setting"
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr "использование vector_length (%d), игнорирование установок времени выполнения"
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, fuzzy, gcc-internal-format
 #| msgid "using vector_length (%d), ignoring %d"
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr "использование vector_length (%d), игнорирование %d"
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "в данной конфигурации определения алиасов не поддерживаются"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -48445,359 +48494,359 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "несоответствие в числе аргументов для встроенной функции %qF. Ожидалось %d, получено %d"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "тип %qT не имеет известный размер"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "тип %qT не имеет известный размер"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "арифметическая операция над указателем на неполный тип"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type %qT"
 msgid "fields cannot have RVV type %qT"
 msgstr "поле %qD имеет неполный тип %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "function parameters cannot have __fp16 type"
 msgid "array elements cannot have RVV type %qT"
 msgstr "параметры функции не могут иметь тип __fp16"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "невозможно разместить объект абстрактного типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "невозможно разместить объект абстрактного типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "невозможно разместить объект абстрактного типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 #| msgid "capture by copy of incomplete type %qT"
 msgid "capture by copy of RVV type %qT"
 msgstr "захват копированием неполного типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qE не является переменной в предложении %<aligned%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is disallowed in Java %<throw%> or %<catch%>"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "тип %qT запрещён в Java %<throw%> или %<catch%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %<firstprivate%>"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE не является переменной в предложении %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "Встроенная функция %s требует опцию -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mhtm option"
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "Встроенная функция %s требует опцию -mhtm"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mpaired option"
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "Встроенная функция %s требует опцию --mpaired"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "Встроенная функция %s требует опцию -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "Встроенная функция %s требует опцию -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized wide sub-instruction"
 msgid "unrecognized RVV builtin"
 msgstr "неопознанная широкая подинструкция"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin function %s requires the -mvsx option"
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "Встроенная функция %s требует опцию -mvsx"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to %<%s(%A)%>"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "нет соответствующей функции для вызова %<%s(%A)%>"
 
 #
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "unknown cpu %qs for -mtune"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "неизвестный процессор %qs для -mtune"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, fuzzy, gcc-internal-format
 #| msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "ABI для передачи структуры с элементом complex float изменен в GCC 4.4"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "Аргумент AltiVec передан в функцию без прототипа"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the V ISA extension"
 msgstr "Использовать расширения SPE ABI."
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 #| msgid "function attributes %qs and %qs have no effect on %qs function"
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "атрибуты функций %qs и %qs не воздействуют на %qs функцию"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "function attributes %qs and %qs have no effect on %qs function"
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "атрибуты функций %qs и %qs не воздействуют на %qs функцию"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument to %qE attribute is neither zero, nor one"
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "аргумент атрибута %qE не ноль и не один"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "атрибут %qE применен к неклассовому, неперечислимому типу %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "%qE атрибут требует целый константный аргумент"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, fuzzy, gcc-internal-format
 #| msgid "-mdiv requires -march to subsume the %<M%> extension"
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr "-mdiv требует -march, чтобы понять %<M%> расширение"
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support ARM mode"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "целевой процессор не поддерживает режим ARM"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs with -f%s"
 msgid "code model %qs with %qs"
 msgstr "модель кода %qs с -f%s"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, fuzzy, gcc-internal-format
 #| msgid "requested ABI requires -march to subsume the %qc extension"
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr "запрошенный ABI требует -march, чтобы понять %qc расширение"
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 не поддерживает комплексные типы"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, fuzzy, gcc-internal-format
 #| msgid "ABI requires -march=rv%d"
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "ABI требует -march=rv%d"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d is not between %d and %d"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d не между %d и %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qs функция не может иметь аргументы"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "bad value (%qs) for %<target(\"tune=\")%> attribute"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -49881,23 +49930,23 @@ msgstr "требования на память для локальных пер
 msgid "%<function_profiler%> support"
 msgstr "поддержка function_profiler"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "недопустимое использование va_start в функции обработки прерывания"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "оператор switch содержит слишком много (%lu) элементов"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "атрибут %<__BELOW100__%> применим только к переменным"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -50147,34 +50196,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%qD определена, но не используется"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "запрошены булевы регистры и ключ аппаратной плавающей математики"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "-f%s не поддерживается с командами CONST16"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC не поддерживается с командами CONST16"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "в секции .bss размещаются только неинициализированные данные"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -50269,7 +50318,7 @@ msgstr "атрибут %qs требует прототипы с именован
 msgid "%qs attribute only applies to variadic functions"
 msgstr "атрибут %qs применим только к вариантным функциям"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -50361,8 +50410,8 @@ msgstr "%qs не есть каталог"
 msgid "could not get size of source file"
 msgstr "не удалось записать файл отзыва %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "использование пустого (void) значения"
@@ -50862,7 +50911,7 @@ msgstr "по переключателю происходит переход в 
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE: определение с некорректным видом тега"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "%qE атрибут применен к %qD с void типом возврата"
@@ -51023,7 +51072,7 @@ msgstr "ISO C90 не поддерживает квалификаторы тип
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 не поддерживает конструкцию %<[*]%> в декларациях массивов"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -51034,7 +51083,7 @@ msgstr "%<this%> недопустим в данном контексте"
 msgid "%q+D is usually a function"
 msgstr "%q+D обычно является функцией"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "отсутствует предварительная декларация %qD"
@@ -51115,7 +51164,7 @@ msgstr "некорректная попытка разместить в реги
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "неинициализированная константа %qD не допускается в C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%q+D в declare target директиве не имеет отображаемого типа"
@@ -51322,7 +51371,7 @@ msgstr "класс хранения в декларации параметра %
 msgid "storage class specified for unnamed parameter"
 msgstr "класс хранения задан для неименованного параметра"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "класс хранения задан для имени типа"
@@ -51496,7 +51545,7 @@ msgstr "имя типа объявлено как функция, возвращ
 msgid "function definition has qualified void return type"
 msgstr "в определении функции задан квалифицированный void-тип возвращаемого значения"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "квалификаторы в описании типа возвращаемого значения функции "
@@ -51623,7 +51672,7 @@ msgstr "в ISO C функции с квалификаторами const и volat
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "элемент структуры или объединения не может иметь переменно модифицируемый тип"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "переменная или поле %qE объявлено void"
@@ -51842,7 +51891,7 @@ msgstr "определение типа в выражении %qs некорре
 msgid "%qT defined in underspecified object initializer"
 msgstr "неизвестное поле %qE в инициализаторе"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "декларация ничего не описывает"
@@ -51908,7 +51957,7 @@ msgstr "структура не содержит именованных элем
 msgid "struct has no members"
 msgstr "структура не содержит элементов"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -51980,7 +52029,7 @@ msgstr "повторная декларация %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -52041,7 +52090,7 @@ msgstr "в ISO C значения перечислимого типа огран
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "в ISO C значения перечислимого типа ограничены диапазоном типа %<int%>"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %qD given attribute noinline"
 msgid "inline function %qD given attribute %qs"
@@ -52194,12 +52243,12 @@ msgstr "аргумент %qD не соответствует встроенно
 msgid "argument %qD doesn%'t match prototype"
 msgstr "аргумент %qD не соответствует прототипу"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "в функции, которая должна возвращать значение, отсутствует оператор return"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "параметру %qD присвоено значение, но он не использован"
@@ -52284,7 +52333,7 @@ msgstr "%qE использован с %<register%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "два или более типа в декларации"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "GCC не поддерживает тип %<long long long%>"
@@ -52398,7 +52447,7 @@ msgstr "ISO C90 не поддерживает булевы типы"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C не поддерживает тип %<_Float%d%s%>"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<_Float%d%s%> не поддерживается для этой целевой машины"
@@ -52566,12 +52615,12 @@ msgstr "Фиксированная длина строки должна быть
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ не поддерживает %<__int%d%> для %qs"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr "%<#pragma omp declare reduction%> объединитель ссылается на переменную %qD, которая не %<omp_out%> и не %<omp_in%>"
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr "%<#pragma omp declare reduction%> инициализатор ссылается на переменную %qD, которая не %<omp_priv%> и не %<omp_orig%>"
@@ -52639,37 +52688,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs следует использовать вместе с %qs"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "сдвиг влево отрицательного значения"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "сдвиг влево на отрицательное число позиций"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "сдвиг вправо на отрицательное число позиций"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "величина сдвига влево больше или равна ширине данного типа"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "величина сдвига вправо больше или равна ширине данного типа"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "счетчик сдвига влево >= ширине элемента вектора"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "счетчик сдвига вправо >= ширине элемента вектора"
@@ -52690,7 +52739,7 @@ msgstr "противоречивый маркер управления верс
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "ожидался конец строки"
@@ -52700,7 +52749,7 @@ msgstr "ожидался конец строки"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C не допускает пустых единиц трансляции"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -52749,8 +52798,8 @@ msgid "unknown type name %qE"
 msgstr "неизвестное имя типа %qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "ожидались спецификаторы декларации"
@@ -52789,7 +52838,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "ожидалось %<;%>, идентификатор или %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "префиксные атрибуты для методов игнорируются"
@@ -52804,12 +52853,12 @@ msgstr "префиксные атрибуты для реализаций игн
 msgid "unexpected attribute"
 msgstr "неожиданный атрибут"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "за атрибутом %<fallthrough%> не следует %<;%>"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -52856,7 +52905,7 @@ msgstr "%<__auto_type%> требует инициализированной де
 msgid "%qs may only be used with a single declarator"
 msgstr "%<__auto_type%> может использоваться только с одним декларатором"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "ожидалось %<,%> или %<;%>"
@@ -52893,7 +52942,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "%<__RTL%> функция не может компилироваться с %<-flto%>"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "ожидался строковый литерал"
@@ -52924,7 +52973,7 @@ msgstr "выражение в статическом утверждении не
 msgid "static assertion failed: %E"
 msgstr "не выполнено статическое утверждение: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "нарушено статическое утверждение"
@@ -52980,8 +53029,8 @@ msgstr "использование режима %qs для перечислим
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "ожидался идентификатор"
@@ -53015,12 +53064,12 @@ msgstr "разборка __underlying_type"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "%q#D конфликтует с предыдущей декларацией"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "запятая в конце списка значений перечислимого типа"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -53106,25 +53155,25 @@ msgstr "ожидались спецификаторы декларации ил
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "parameter packs должны быть в конце списка параметров"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected OpenMP directive name"
 msgstr "ожидалось имя функции"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "ожидалось %<none%> или %<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%qE атрибуту требуются аргументы"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%qE attribute does not take any arguments"
@@ -53136,7 +53185,7 @@ msgstr "%qE атрибуту требуются аргументы"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 не поддерживает конструкцию %<[*]%> в декларациях массивов"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -53168,19 +53217,19 @@ msgstr "ISO C не поддерживает инициализацию подо
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "устаревший способ задания инициализатора без %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, fuzzy, gcc-internal-format
 #| msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "нет допустимых клаузул заданных в %<#pragma acc declare%>"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 #| msgid "%<ordered%> region must be closely nested inside a loop region with an %<ordered%> clause"
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "%<ordered%> область должна быть замкнуто вложена внутри области цикла с %<ordered%> клаузулой"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
@@ -53191,44 +53240,44 @@ msgstr "%<nowait%> предложение не может использоват
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%qs attribute does not take any arguments"
@@ -53260,7 +53309,7 @@ msgstr "ISO C90 запрещает смешение деклараций и ко
 msgid "expected %<}%> before %<else%>"
 msgstr "ожидалось %<}%> перед %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> без предшествующего %<if%>"
@@ -53275,7 +53324,7 @@ msgstr "метка в конце составного оператора"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "ожидался оператор"
@@ -53313,27 +53362,27 @@ msgstr "ISO C не поддерживает типы с насыщением"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "список выражений рассматривается как составное выражение в инициализаторе"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "ожидалась декларация"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "рекомендуется заключать в фигурные скобки пустое тело в операторе %<if%>"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "рекомендуется заключать в фигурные скобки пустое тело в операторе %<else%>"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "используйте фигурные скобки во избежание неоднозначной трактовки %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -53353,12 +53402,12 @@ msgstr "несколько переменных-итераторов в быст
 msgid "invalid iterating variable in fast enumeration"
 msgstr "некорректная переменная-итератор в быстром перечислении"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr "отсутствует условие цикла в цикле с %<GCC ivdep%> pragma"
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -53374,8 +53423,8 @@ msgstr "отсутствует составной объект в быстром
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "повторный cv-qualifier"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -53399,12 +53448,12 @@ msgstr "ISO C не поддерживает выражения ?: с пусты
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr ""
@@ -53589,7 +53638,7 @@ msgstr "ISO C90 не поддерживает %<__func__%> предопреде
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "ожидалось выражение"
@@ -53604,13 +53653,13 @@ msgstr "фигурные скобки внутри выражений допус
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C не поддерживает использование групп операторов в фигурных скобках внутри выражений"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "второй аргумент %<va_start%> не является последним явным аргументом"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -53758,7 +53807,7 @@ msgstr "оба аргумента %<__builtin___clear_cache%> должны бы
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "третий аргумент %<__builtin_prefetch%> должен быть константой"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "неверное число аргументов в вызове аргументов в вызове %<__builtin_shuffle%>"
@@ -53805,7 +53854,7 @@ msgstr "аргумент 3 в вызове функции %qE имеет тип
 msgid "rotate count is negative"
 msgstr "счетчик циклического сдвига влево отрицателен"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
@@ -53922,7 +53971,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -53962,13 +54011,13 @@ msgstr "ожидалась декларация метода objective-c"
 msgid "no type or storage class may be specified here,"
 msgstr "в этом месте не может указываться ни тип, ни класс хранения,"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "empty property attribute list"
 msgstr "неизвестный атрибут свойства"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -53980,61 +54029,61 @@ msgstr "отсутствует атрибут Code"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "неизвестный атрибут свойства"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "неизвестный атрибут свойства"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%> before %qE"
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "ожидалось %<=%> перед %qE"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected %qE selector name"
 msgstr "ожидался selection-statement"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, fuzzy, gcc-internal-format
 #| msgid "setter name must terminate with %<:%>"
 msgid "setter method names must terminate with %<:%>"
 msgstr "имя setter должно заканчиваться %<:%>"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma %s%> может использоваться только в составных операторах"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> должна быть в контексте файла"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp section%> может использоваться только в конструкции %<#pragma omp sections%>"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> может использоваться только в конструкции %<#pragma omp sections%>"
@@ -54045,12 +54094,12 @@ msgstr "%<#pragma omp section%> может использоваться толь
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma %s%> может использоваться только в составных операторах"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "for, while или do оператор ожидался"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> должна быть первой"
@@ -54060,11 +54109,11 @@ msgstr "%<#pragma GCC pch_preprocess%> должна быть первой"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "слишком много конструкций %qs"
@@ -54079,60 +54128,60 @@ msgstr "выражение должно быть целочисленным"
 msgid "%qD is not a variable"
 msgstr "%qD не переменная"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD не указательная переменная"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "collapse аргумент требует положительного константного целого выражения"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%> before %<#pragma%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "ожидалось %<none%> или %<shared%> перед %<#pragma%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant logical expression"
 msgstr "ожидалось целочисленное выражение"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "ожидалось %<data%>, %<update%>, %<enter%> или %<exit%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "ожидалось %<data%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "слишком много %<if%> клаузул"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "слишком много %<if%> клаузул без модификатора"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr "если какая-либо %<if%> клаузула имеет модификатор, то все %<if%> должны использовать модификатор"
@@ -54155,23 +54204,23 @@ msgstr "значение %<num_threads%> должно быть положите
 msgid "%<num_tasks%> value must be positive"
 msgstr "значение %<num_tasks%> должно быть положительным"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "значение %<grainsize%> должно быть положительным"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "значение %<priority%> должен быть неотрицательным"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "ожидалось целочисленное выражение"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %<decltype%>"
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
@@ -54183,105 +54232,105 @@ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "%qs выражение должно быть целочисленным"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "значение %qs должно быть положительным"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "слишком много %<static%> аргументов"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "неожиданный аргумент"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%<tile%> аргумент требует положительной целочисленной константы"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<self%> clauses"
 msgstr "слишком много %<if%> клаузул"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "ожидалось %<none%> или %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%>"
 msgid "expected %<concurrent%>"
 msgstr "ожидалось %<new%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "ordered аргумент требует положительного константного целого выражения"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> или идентификатор"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "заданы оба модификатора %<monotonic%> и %<nonmonotonic%>"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "расписание %<runtime%> не имеет параметра %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "расписание %<auto%> не имеет параметра %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "значение размера чанка должно быть положительным"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "некорректный тип планирования"
@@ -54291,40 +54340,40 @@ msgstr "некорректный тип планирования"
 msgid "%<num_teams%> value must be positive"
 msgstr "значение %<num_teams%> должно быть положительным"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "значение %<thread_limit%> должно быть положительным"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "%<aligned%> клаузула выражения выравнивания должна быть положительным константным целочисленным выражением"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "ожидалась %<,%> или %<)%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "дублирование %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 #| msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
@@ -54341,23 +54390,23 @@ msgstr "ожидалось %<class%> или %<typename%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "multiple ref-qualifiers"
 msgid "multiple linear modifiers"
 msgstr "несколько ref-квалификаторов"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "multiple ref-qualifiers"
 msgid "multiple %<step%> modifiers"
@@ -54368,7 +54417,7 @@ msgstr "несколько ref-квалификаторов"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "%<linear%> клаузула выражения шага должна быть целочисленным выражением"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -54383,343 +54432,343 @@ msgstr "%<safelen%> клаузула выражения должна быть п
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "%<simdlen%> клаузула выражения должна быть положительным константным целочисленным выражением"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "%qs feature modifier is incompatible with %s %s"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "модификатор %qs возможности несовместим с %s %s"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "некорректный depend вид"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid map kind"
 msgid "invalid doacross kind"
 msgstr "некорректный map вид"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<parallel%> or %<target%> %<if%> clause modifier"
 msgid "expected %<fallback%> modifier"
 msgstr "ожидался %<parallel%> или %<target%> модификатор %<if%> клаузулы"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "значение %<priority%> должен быть неотрицательным"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "illegal comma"
 msgstr "недопустимый операнд "
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<always%> modifiers"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<close%> modifiers"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses without modifier"
 msgid "too many %<iterator%> modifiers"
 msgstr "слишком много %<if%> клаузул без модификатора"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<mapper%> modifiers"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "ожидался идентификатор или %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<present%> modifiers"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "%<#pragma omp target%> с map-type отличном от %<to%>, %<from%>, %<tofrom%> или %<alloc%> на %<map%> клаузуле"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "некорректный map вид"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%> or %<typename%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "ожидалось %<class%> или %<typename%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, fuzzy, gcc-internal-format
 #| msgid "%<linear%> clause step expression must be integral"
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "%<linear%> клаузула выражения шага должна быть целочисленным выражением"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "некорректный dist_schedule вид"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "некорректный proc_bind вид"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "ожидалось %<;%>, %<,%> или %<)%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "ordered аргумент требует положительного константного целого выражения"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "литеральная широкая строка в %<asm%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown pointer size model %qs"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "неизвестная модель для размера указателя %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected string literal or constant integer expression"
 msgstr "ожидалось целочисленное выражение"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<)%> before %s'%c'"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "ожидалось %<:%> или %<)%> перед %s'%c'"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicated %<fr%> preference selector"
 msgstr "повторное %<if%> условие"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "ожидался строковый литерал"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate virt-specifier"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "повторный virt-specifier"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<mutable%>"
 msgid "duplicate %<target%> modifier"
 msgstr "повторное %<mutable%>"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "повторное %<if%> условие"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<simd%> or %<reduction%> or %<target%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "ожидалось %<simd%> или %<reduction%> или %<target%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected OpenACC parallelism."
 msgid "expected an OpenACC clause"
 msgstr "Неожиданный OpenACC параллелизм."
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs не является корректным для %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs должна быть первой клаузулой %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected label"
 msgid "expected an OpenMP clause"
 msgstr "ожидалась метка"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "нет допустимых клаузул заданных в %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "секция массива в %<#pragma acc declare%>"
 
 #
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "%qD должна быть глобальной переменной в %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "некорректная OpenACC клаузула в контексте файла"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "некорректное использование %<extern%> переменной %qD в %<#pragma acc declare%>"
 
 #
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "некорректное использование %<global%> переменной %qD в %<#pragma acc declare%>"
 
 #
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "%qD должна быть глобальной переменной в %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "переменная %qD использована более одного раза с %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "ожидалось %<data%> после %<#pragma acc %s%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma acc %s data%> не содержит клаузулу перемещения данных"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -54734,7 +54783,7 @@ msgstr "%qE не был декларирован"
 msgid "expected function name"
 msgstr "ожидалось имя функции"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD не ссылается на функцию"
@@ -54744,22 +54793,22 @@ msgstr "%qD не ссылается на функцию"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "за %<#pragma acc routine%> не следует немедленно декларация или определение функции"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "за %<#pragma acc routine%> не следует немедленно декларация или определение одиночной функции"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> должна быть применена до использования"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> должна быть применена до определения"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> должна содержать по крайней мере одну %<device%>, %<host%> или %<self%>клаузулу"
@@ -54786,7 +54835,7 @@ msgstr ""
 msgid "modified here"
 msgstr "объединение определено здесь"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 #| msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
@@ -54822,126 +54871,126 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "ожидалась клаузула %<depend%>, %<destroy%> или %<update%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> или идентификатор"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many atomic clauses"
 msgstr "слишком много конструкций %qs"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many memory order clauses"
 msgstr "слишком много конструкций %qs"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%<#pragma omp target update%> должна содержать хотя бы одну %<from%> или %<to%> клаузулу"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qs clause requires %qs clause"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp target update%> должна содержать хотя бы одну %<from%> или %<to%> клаузулу"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp target update%> должна содержать хотя бы одну %<from%> или %<to%> клаузулу"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp target update%> должна содержать хотя бы одну %<from%> или %<to%> клаузулу"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp target update%> должна содержать хотя бы одну %<from%> или %<to%> клаузулу"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after union definition"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "ожидалось %<;%> после определения объединения"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%> before string constant"
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr "ожидалось %<;%>, %<,%> или %<)%> перед строковой константой"
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "invalid form of %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "некорректный формат %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "ожидалось %<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "invalid form of %<#pragma omp atomic%>"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "некорректный формат %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "некорректный формат %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "некорректный оператор для %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> использует два различных выражения для памяти"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "%<depobj%> expression is not lvalue expression"
@@ -54953,29 +55002,29 @@ msgstr "выражение %qE не является константным вы
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "выражение %qE не является константным выражением"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "ожидалось %<data%>, %<update%>, %<enter%> или %<exit%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "ожидалась клаузула %<depend%>, %<destroy%> или %<update%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, fuzzy, gcc-internal-format
 #| msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgid "%<flush%> list specified together with memory order clause"
@@ -54986,36 +55035,36 @@ msgstr "%<nonmonotonic%> модификатор планирования зад
 msgid "expected %<(%> or end of line"
 msgstr "ожидалось %<(%> или конец строки"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp cancel%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp taskyield%> может использоваться только в составных операторах"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<while%> before %<decltype%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "ожидалось %<while%> перед %<decltype%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<#pragma omp scan%>"
 msgstr "ожидалась конструкция %<#pragma omp%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp cancel%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp taskyield%> может использоваться только в составных операторах"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "ожидался оператор for"
@@ -55023,72 +55072,72 @@ msgstr "ожидался оператор for"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "ожидался оператор for"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line before string constant"
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr "ожидалось %<(%> или конец строки перед строковой константой"
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "ожидалась декларация итерации или инициализация"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough perfectly nested loops"
 msgid "not enough nested loops"
 msgstr "недостаточно аккуратно вложенные циклы"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "%<ordered%> параметр клаузулы меньше чем %<collapse%>"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "итерационная переменная %qD не должна быть firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp ordered%> with %<depend> clause may only be used in compound statements"
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "ожидался %<for%> после %qs"
@@ -55099,7 +55148,7 @@ msgstr "ожидался %<for%> после %qs"
 msgid "expected a function name"
 msgstr "ожидалось имя функции"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected target-function call"
@@ -55111,50 +55160,50 @@ msgstr "ожидалось имя функции"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "за %<#pragma omp declare simd%> должна следовать декларация или определение функции"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "ожидалось %<point%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target data%> с map-type отличном от %<to%>, %<from%>, %<tofrom%> или %<alloc%> на %<map%> клаузуле"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target data%> must contain at least one %<map%> clause"
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp target data%> должна содержать хотя бы одну %<map%> клаузулу"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp target update%> должна содержать хотя бы одну %<from%> или %<to%> клаузулу"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target enter data%> with map-type other than %<to%> or %<alloc%> on %<map%> clause"
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target enter data%> с map-type отличном от %<to%> или %<alloc%> на %<map%> клаузуле"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target enter data%> должна содержать хотя бы одну %<map%> клаузулу"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<release%> or %<delete%> on %<map%> clause"
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp target exit data%> с map-type отличном от %<from%>, %<release%> или %<delete%> на %<map%> клаузуле"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target exit data%> должна содержать хотя бы одну %<map%> клаузулу"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target%> с map-type отличном от %<to%>, %<from%>, %<tofrom%> или %<alloc%> на %<map%> клаузуле"
@@ -55171,69 +55220,69 @@ msgstr "за %<#pragma omp declare simd%> должна следовать дек
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "за %<#pragma omp declare simd%> должна следовать декларация или определение функции"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected trait selector name"
 msgstr "ожидался selection-statement"
 
 #
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 #| msgid "unknown value %qs for 'tune' target %s"
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "неизвестное значение %s для ключа -mfpu"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 #| msgid "%<no-custom-%s%> does not accept arguments"
 msgid "selector %qs does not accept any properties"
 msgstr "%<no-custom-%s%> не принимает аргументы"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> может быть задан только внутри класса"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 #| msgid "%qs length expression must be positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression"
 msgstr "%qs выражение длины должно быть положительным константным целочисленным выражением"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<score%> argument must be non-negative"
 msgstr "значение %<priority%> должен быть неотрицательным"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "ожидался строковый литерал"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be integer expression"
 msgstr "ожидалось целочисленное выражение"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, fuzzy, gcc-internal-format
 #| msgid "property %qs already specified in %<@synthesize%>"
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "свойство %qs уже специфицировано в %<@synthesize%>"
 
 #
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "using parameters for %<linear%> step is not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "модель кода %<large%> пока не поддерживается"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected context selector set name"
@@ -55245,30 +55294,30 @@ msgstr "ожидался selection-statement"
 msgid "variant %qD is not a function"
 msgstr "%qs в %L не есть функция"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD redeclared as function"
 msgid "variant %qD is the same as base function"
 msgstr "переменная %qD повторно декларирована как функция"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "ожидалась клаузула %<depend%>, %<destroy%> или %<update%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<match%> clauses"
 msgstr "слишком много %<if%> клаузул"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 #| msgid "specified option %qs more than once"
 msgid "%qD is specified more than once"
@@ -55280,7 +55329,7 @@ msgstr "опция %qs задана более одного раза"
 msgid "%qD is not of pointer type"
 msgstr "%qD не указательная переменная"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -55293,19 +55342,19 @@ msgstr "ожидалось %<none%> или %<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%H%qs не является корректной для %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%> before %<#pragma%>"
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "ожидалось %<none%> или %<shared%> перед %<#pragma%>"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<point%>"
 msgid "expected %<interop%>"
 msgstr "ожидалось %<point%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma acc%> clause"
 msgid "expected %<match%> clause"
@@ -55329,13 +55378,13 @@ msgstr "модель кода %<large%> пока не поддерживаетс
 msgid "base function %qD declared here"
 msgstr "программа %qD декларирована здесь"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "аргумент %d для %qE должен быть указателем"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "%<long%> and %<short%> specified together for %qs"
 msgid "%<append_args%> specified here"
@@ -55346,7 +55395,7 @@ msgstr "%<long%> и %<short%> одновременно заданы для %qs"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgid "variant %qD and base %qD have incompatible types"
@@ -55358,7 +55407,7 @@ msgstr "  типы %qT и %qT имеют несовместимые cv-qualifier
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma omp declare simd%>, за которой не следует немедленно декларация функции или определение"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare simd%> not immediately followed by a single function declaration or definition"
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
@@ -55376,94 +55425,94 @@ msgstr "за %<#pragma omp declare simd%> должна следовать дек
 msgid "no declaration of base function %qs"
 msgstr "неявная декларация функции %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "определение функции не объявляет параметры"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, fuzzy, gcc-internal-format
 #| msgid "%qD specified both in declare target %<link%> and %<to%> clauses"
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD задан и в declare target %<link%> и в %<to%> клаузулах"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, fuzzy, gcc-internal-format
 #| msgid "%qD specified both in declare target %<link%> and %<to%> clauses"
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "%qD задан и в declare target %<link%> и в %<to%> клаузулах"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%>"
 msgstr "ожидалось %<catch%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "ожидалось %<none%> или %<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma omp end declare target%> без соответствующей %<#pragma omp declare target%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute with %s attribute at %L"
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%s атрибут конфликтует с %s атрибутом в %L"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma omp end declare target%> без соответствующей %<#pragma omp declare target%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%> or %<typename%>"
 msgid "expected %<declare%> or %<assumes%>"
@@ -55493,13 +55542,13 @@ msgstr "повторная декларация %qs %<#pragma omp declare reduct
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T был ранее декларирован здесь"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "unexpected clause"
 msgstr "ожидалось class-key"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "missing %<map%> clause"
@@ -55562,33 +55611,33 @@ msgstr "одним из аргументов вызова инициализат
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "ожидалось %<simd%> или %<reduction%> или %<target%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target data%> must contain at least one %<map%> clause"
 msgid "%<pragma omp requires%> requires at least one clause"
@@ -55606,173 +55655,173 @@ msgstr "%<_Atomic%> %qE в %<reduction%> клаузуле"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "тип элемента переменой длины в предложении массива %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<while%>"
 msgid "expected %<sizes%>"
 msgstr "ожидалось %<while%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%<tile%> argument needs positive integral constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%<tile%> аргумент требует положительной целочисленной константы"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "ожидалась клаузула %<depend%>, %<destroy%> или %<update%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> before %qE"
 msgid "expected %qs or %qs"
 msgstr "ожидалась %<(%> перед %qE"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp ordered%> с %<depend%> клаузулой может использоваться только в составных операторах"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp ordered%> с %<depend%> клаузулой может использоваться только в составных операторах"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected at least one assumption clause"
 msgstr "ожидалась конструкция %<#pragma omp%>"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected directive name"
 msgstr "ожидалось имя функции"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown asm flag output %qs"
 msgid "unknown assumption clause %qs"
 msgstr "неизвестный вывод ассемблерного флага %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected assumption clause"
 msgstr "ожидалось имя функции"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "ожидалась клаузула %<depend%>, %<destroy%> или %<update%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "неизвестное имя регистра: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE объявлена %<threadprivate%> после первого использования"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "автоматическая переменная %qE не может быть %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE имеет неполный тип"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%> без включения поддержки транзакционной памяти"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%> без включения поддержки транзакционной памяти"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%> без включения транзакционной памяти"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> внутри %<__transaction_relaxed%>"
@@ -55783,7 +55832,7 @@ msgstr "%<__transaction_cancel%> внутри %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "%<transaction_may_cancel_outer%> вызов функции не внутри внешней транзакции или %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> не внутри %<__transaction_atomic%>"
@@ -55798,7 +55847,7 @@ msgstr "нет закрывающей скобки"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD имеет неполный тип %qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "неправильное использование void-выражения"
@@ -55829,179 +55878,179 @@ msgstr "некорректное использование неполного t
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT и %qT - не связанные именованные адресные пространства"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "атрибут %qs применим только к вариантным функциям"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "с точки зрения ISO C типы функций не являются строго совместимыми"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and vector types"
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "недопустимо смешивание операндов плавающего десятичного и векторного типа"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and complex types"
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "недопустимо смешивание операндов плавающего десятичного и комплексного типа"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and other float types"
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "недопустимо смешивание операндов плавающего десятичного и другого плавающего типа"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, fuzzy, gcc-internal-format
 #| msgid "pointers to arrays with different qualifiers are incompatible in ISO C"
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "указатели на массивы с разными квалификаторами не совместимы в ISO C"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "типы не вполне совместимы"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "указуемые типы несовместимы в C++"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "типы возвращаемых значений функции несовместимы из-за %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, fuzzy, gcc-internal-format
 #| msgid "converting an array compound literal to a pointer is ill-formed in C++"
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "конвертация составного литерала-массива в указатель не годится в C++"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%Jinvalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "%Jнекорректное использование структуры с регулируемым элементом-массивом"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT не содержит элемент с именем %qE; имелось в виду %qE?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT не содержит элемента с именем %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "доступ к элементу %qE атомарной структуры %qE"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "доступ к элементу %qE атомарного объединения %qE"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qE указатель; имелось в виду использовать %<->%>?"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qE указатель; имелось в виду использовать %<->%>?"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "выборка элемента %qE из объекта, не являющегося структурой или объединением"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "доступ по указателю %<void *%>"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "индексируемый объект не является ни массивом, ни указателем, ни вектором"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "индекс массива не является целым значением"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "индексируемый элемент является указателем на функцию"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "индекс массива не является целым значением"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "в ISO C индексирование %<register%>-массивов запрещено"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "в ISO C индексирование не-lvalue массива запрещено"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "переменная %qD декларирована как ссылка, но не инициализирована"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "преобразование типов в инициализаторе недопустимо в C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "константа перечислимого типа определена здесь"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr "%<sizeof%> от массивного параметра функции %qE вернет размер от %qT"
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "вызываемый объект %qE не является функцией или указателем на функцию"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "вызываемый объект %qD не является функцией или указателем на функцию"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "вызываемый объект не является функцией или указателем на функцию"
@@ -56009,1956 +56058,1956 @@ msgstr "вызываемый объект не является функцией
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "вызов функции через несовместимый тип"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "вызов функции, имеющей квалифицированный void-тип возвращаемого значения"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "формальный параметр %d имеет неполный тип"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как целое, а не плавающее"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как целое, а не комплексное"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как комплексное, а не плавающее"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как плавающее, а не целое"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как комплексное, а не целое"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как плавающее, а не комплексное"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как %<float%>, а не %<double%>"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "передан аргумент %d функции %qE как %qT, а не %qT согласно прототипу"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан с другой шириной"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как unsigned"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "аргумент %d %qE согласно прототипу будет передан как signed"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to method %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "слишком много аргументов в вызове метода %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "слишком много аргументов в вызове функции %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "слишком много аргументов в вызове функции %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "неявная конверсия из %qT в %qT при передаче аргумента функции"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "слишком мало аргументов в вызове функции %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "слишком мало аргументов в вызове функции %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "слишком мало аргументов в вызове функции %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "сравнение со строковым литералом приводит к неопределенному поведению"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "сравнение указателя и нулевой символьной константы"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "вы хотели перейти по указателю?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "ноль как константа пустой указатель"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "сравнение между %qT и %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "указатель %<void *%> в операции вычитания"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "указатель на функцию в операции вычитания"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "арифметическая операция над указателем на неполный тип"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "арифметическая операция над указателем на пустой агрегат"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> над булевым выражением"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "имелось в виду использовать логическое not?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "в ISO C не поддерживается использование %<~%> для обозначения операции комплексного сопряжения"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "неверный тип аргумента для abs"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "неверный тип аргумента для унарного `!'"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "инкрементация значения перечислимого типа некорректна в C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "декрементация значения перечислимого типа некорректна в C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "инкремент булева выражения"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "декремент булева выражения"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "в ISO C операции %<++%> и %<--%> для комплексных типов не поддерживаются"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "неверный тип аргумента инкрементации"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "неверный тип аргумента декрементации"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "инкремент указателя на неполный тип %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "декремент указателя на неполный тип %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "взятие адреса от выражения типа %<void%>"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "некорректная попытка взять адрес битового поля %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "нельзя взять адрес от скаляра с обратным порядком памяти"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "адрес массива с обратным порядком скалярной памяти"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "запрошен адрес регистровой переменной %qD"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "глобальная регистровая переменная %qD использована во вложенной функции"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "регистровая переменная %qD использована во вложенной функции"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "запрошен адрес глобальной регистровой переменной %qD"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "запрошен адрес регистровой переменной %qD"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "не lvalue-массив в условном выражении"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "defining a type in a compound literal is invalid in C++"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "определение типа в составном литерале не допускается в C++"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "неявная конверсия из %qT в %qT для совместимости с другим результатом условного выражения"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "в ISO C запрещены условные выражения, где только одна из альтернатив имеет тип void"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "указатели на не связанные адресные пространства в условном выражении"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "указатель на массив теряет квалификатор в условном выражении"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to array loses qualifier in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "указатель на массив теряет квалификатор в условном выражении"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "в ISO C запрещены условные выражения, с альтернативами типа %<void *%> и указатель на функцию"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "несоответствие указательных типов в условном выражении"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "Ожидался тип выражения"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "Ожидался тип выражения"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "несоответствие типов указатель/целое в условном выражении"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "несоответствие типов в условном выражении"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute nodiscard"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "игнорирование возвращаемого значения от %qD, декларированной с атрибутом nodiscard"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute nodiscard"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "игнорирование возвращаемого значения от %qD, декларированной с атрибутом nodiscard"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring returned value of type %qT, declared with attribute nodiscard"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "игнорирование возвращаемого значения типа %qT, декларированного с атрибутом nodiscard"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring returned value of type %qT, declared with attribute nodiscard"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "игнорирование возвращаемого значения типа %qT, декларированного с атрибутом nodiscard"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "в вызове %qD, декларированной здесь"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "левый операнд операции `запятая' не имеет побочных эффектов"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "правый операнд comma выражения не имеет эффекта"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr "приведение типа добавляет квалификатор %q#v к типу функции"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "приведение типа отбрасывает квалификатор типа цели указателя"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "для надежности все промежуточные указатели в приведении типа от %qT к %qT должны быть снабжены квалификатором %<const%>"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "тип массива в операции приведения типов"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "тип функции в операции приведения типов"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "в ISO C приведение нескалярного типа к тому же типу запрещено"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 #| msgid "functional cast to array type %qT"
 msgid "useless cast to type %qT"
 msgstr "функциональное приведение к массивному типу %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "в ISO C приведение к типу объединения запрещено"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "приведение к типу объединения от типа, отсутствующего в объединении"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 #| msgid "cast to %s address space pointer from disjoint generic address space pointer"
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "приведение типа к указателю на адресное пространство %s от указателя на не связанное общее адресное пространство"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "cast to generic address space pointer from disjoint %s address space pointer"
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "приведение типа к указателю на общее адресное пространство от указателя на не связанное адресное пространство %s"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 #| msgid "cast to %s address space pointer from disjoint %s address space pointer"
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "приведение типа к указателю на адресное пространство %s от указателя на не связанное адресное пространство %s"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "приведение типа требует большего выравнивания, чем исходный тип"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "приведение указателя к целому другого размера"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "приведение вызова функции типа %qT к несоответствующему типу %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "приведение к типу указателя от целого другого размера"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C запрещает преобразование указателя на функцию к указателю на объект"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C запрещает преобразование указателя на объект к указателю на функцию "
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "определение типа в приведении типа некорректно в C++"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "присваивание выражению с массивным типом"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "преобразование перечислимого типа в присваивании некорректно в C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(где-то рядом с инициализацией для %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "инициализация символьного массива строкой в скобках"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "ожидался тип %qT, но аргумент имеет тип %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "built-in %qD declared here"
 msgstr "программа %qD декларирована здесь"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid " declared here"
 msgid "%e declared here"
 msgstr " объявлено здесь"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "преобразование перечислимого типа при передаче аргумента %d %qE недопустимо в C++"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "ожидался тип %qT, но аргумент имеет тип %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %q#T to %q#T"
 msgid "implicit conversion from %qT to %qT"
 msgstr "преобразование из %q#T в %q#T"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "передача аргумента %d функции %qE добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "присваивание добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "инициализация добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "возврат значения добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "передача аргумента %d %qE отменяет квалификатор %qv указуемого типа"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "присваивание отменяет квалификатор %qv указуемого типа"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "инициализация отменяет квалификатор %qv указуемого типа"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "возврат результата отменяет квалификатор %qv указуемого типа"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "в ISO C преобразование аргумента к типу объединения запрещено"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "неявная конверсия из %qT в %qT, запрещенная в C++"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "передача аргумента %d %qE по указателю на не замкнутое адресное пространство"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "присваивание по указателю на не замкнутое адресное пространство"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "инициализация по указателю на не замкнутое адресное пространство"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "возврат значения по указателю на не замкнутое адресное пространство"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "ожидался тип %qT, но аргумент имеет тип %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "аргументу %d %qE, вероятно, можно назначить атрибут format"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "левой части присваивания, вероятно, можно назначить атрибут format"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "левой части инициализации, вероятно, можно задать атрибут format"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "тип результата, вероятно, может быть задан с атрибутом format"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "в передаче аргумента %d %qE: несовместимый тип указателя"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "инкремент указателя на неполный тип %qT"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 #| msgid "invalid application of %qs to incomplete type %qT"
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "некорректное применение %qs к неполному типу %qT"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "инкремент указателя на неполный тип %qT"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "в ISO C передача аргумента %d функции %qE с преобразованием указателя на функцию в тип %<void *%> запрещена"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "в ISO C присваивание с преобразованием указателя на функцию в тип %<void *%> запрещено"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "в ISO C инициализация с преобразованием указателя на функцию в тип %<void *%> запрещена"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "в ISO C возврат результата с преобразованием указателя на функцию в тип %<void *%> запрещен"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "при передаче аргумента %d %qE: указуемые типы различаются знаковостью"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "в передаче аргумента %d %qE: несовместимый тип указателя"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "инкремент указателя на неполный тип %qT"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "в передаче аргумента %d %qE: несовместимый тип указателя"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "invalid application of %qs to incomplete type %qT"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "некорректное применение %qs к неполному типу %qT"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "return from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "несовместимый тип указателя при возврате результата функции"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "указатель на элементный тип %qT несовместим с объектным типом %qT"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "указатель на элементный тип %qT несовместим с объектным типом %qT"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "при передаче аргумента %d %qE целое преобразуется в указатель без приведения типа"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "при передаче аргумента %d %qE указатель преобразуется в целое без приведения типа"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "несовместимый тип аргумента %d функции %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "несовместимые типы в присваивании типу %qT значения типа %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "несовместимые типы при инициализации типа %qT, используя тип %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "несовместимые типы при возврате значения типа %qT вместо ожидаемого типа %qT"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "в традиционном C инициализация автоматических агрегатных переменных запрещена"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot appear in a typedef declaration"
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "%<constexpr%> не может встречаться в typedef декларации"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "индекс массива в инициализации не является целочисленным константным выражением"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "индекс массива в инициализации не является целочисленным константным выражением"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "инициализация регулируемого элемента-массива"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "слишком длинная строка инициализации для символьного массива"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "слишком длинная строка инициализации для символьного массива"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "инициализация массива несоответствующего типа строковой константой"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "некорректное использование массива, не являющегося левой частью присваивания"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "неверный инициализатор"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "элемент инициализатора не является константой"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "инициализация массива неконстантным выражением"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "элемент инициализатора не является константным выражением"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "Conversion from %qs to %qs at %L"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "Преобразование из %qs в %qs в %L"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "инициализирующий элемент не может быть вычислен во время компоновки"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "вектор скрытого типа не может быть инициализирован"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "избыточные фигурные скобки в конце инициализатора"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "фигурные скобки вокруг скалярного инициализатора"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "инициализация элемента регулируемого элемента-массива во вложенном контексте"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "отсутствуют фигурные скобки вокруг инициализатора"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "отсутствует инициализатор для поля %qD из %qT"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "избыточные элементы в скалярном инициализаторе"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "индекс массива в инициализаторе не для массива"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "имя поля в инициализаторе не для структуры или объединения"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "индекс массива в инициализации не целого типа"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "индекс массива в инициализации не является целочисленным константным выражением"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "неконстантный индекс массива в инициализаторе"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "индекс массива в инициализаторе - за границами массива"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "пустой диапазон индексов в инициализаторе"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "диапазон индексов массива в инициализаторе - за границами массива"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "инициализированное поле перезаписано"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "повторная инициализация поля с побочными эффектами"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "преобразование типов в инициализаторе недопустимо в C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "избыточные элементы в инициализаторе объединения"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "избыточные элементы в инициализаторе структуры"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "позиционная инициализация поля в %<struct%> декларированной с %<designated_init%> атрибутом"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "не статическая инициализация регулируемого элемента-массива в структуре"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "избыточные элементы в инициализаторе объединения"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "в традиционном C инициализация объединений запрещена"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "избыточные элементы в инициализаторе массива"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "избыточные элементы в инициализаторе вектора"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "избыточные элементы в инициализаторе скаляра"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "согласно ISO C, избыточный знак %<;%> после функции не допускается"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in output operand outside of a function"
 msgstr "тип переменного размера декларирован вне функции"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "выходной операнд %d должен содержать ограничитель %<&%>"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Cilk_spawn%> may only be used inside a function"
 msgid "%<-%> modifier used inside of a function"
 msgstr "%<friend%> может быть задан только внутри класса"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in input operand outside of a function"
 msgstr "тип переменного размера декларирован вне функции"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD не определено вне функции"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "в ISO C операторы вида %<goto *expr;%> запрещены"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "computed goto must be pointer type"
 msgstr "аргумент %d для %qE должен быть указателем"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "функция декларированная с атрибутом %<noreturn%> содержит оператор %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "оператор %<return%> без значения в функции, возвращающей не void-значение"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "оператор %<return%> <значение> в функции возвращающей void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "в ISO C запрещен оператор %<return%> с выражением в функции, возвращающей void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "функция возвращает адрес метки"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "функция возвращает адрес локальной переменной"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "в операторе switch задано не целое"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "в ISO C %<long%>-выражение в операторе switch не преобразуется в %<int%>"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "case-метка не является целочисленным константным выражением"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case-метка вне оператора switch"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "метка %<default%> вне оператора switch"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "оператор break вне цикла или оператора switch"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "некорректный выход из OpenMP структурного блока"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "оператор break использован с OpenMP для цикла"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "оператор continue вне цикла"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "оператор без побочного эффекта"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "оператор-выражение имеет неполный тип"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "результат сравнения всегда %<false%>, поскольку адрес %qD не может быть NULL"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "результат сравнения всегда %<true%>, поскольку адрес %qD не может быть NULL"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "результат сравнения всегда %<false%>, поскольку адрес %qD не может быть NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 #| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "результат сравнения всегда %<true%>, поскольку адрес %qD не может быть NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "сравнение векторов с разными типами элементов"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "сравнение векторов с разным числом элементов"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "сравнение между типами %qT и %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "невозможно найти целый тип того же размера, что и %qT"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "сравнение плавающих значений при помощи == или != не надежно"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "сравнение указателей на несвязанные адресные пространства"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "в ISO C сравнение указателя на функцию с указателем %<void *%> запрещено"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "сравнение различных указательных типов без приведения типов"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "сравнение указателя и целого"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "сравнение указателей на полный и неполный типы"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C разрешает сравнение указателей на функции только на равенство/неравенство"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "упорядоченное сравнение указателя с нулевым указателем"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "упорядоченное сравнение указателя с целочисленным нулем"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "неявная конверсия из %qT в %qT для совместимости с другим операндом бинарного выражения"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "массив, не приводимый к указателю, употреблен в контексте, где допустимо только скалярное значение"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "структурное значение употреблено в контексте, где допустимо только скалярное значение"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "объединение употреблено в контексте, где допустимо только скалярное значение"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "векторный тип использован в контексте, где допустимо только скалярное значение"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancel%> должна задавать одну из %<parallel%>, %<for%>, %<sections%> или %<taskgroup%> клаузул"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<parallel%> or %<target%> %<if%> clause modifier"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "ожидался %<parallel%> или %<target%> модификатор %<if%> клаузулы"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancellation point%> должна задавать одну из %<parallel%>, %<for%>, %<sections%> или %<taskgroup%> клаузул"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE не есть переменная в %qs клаузуле"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%<_Atomic%> %qD в %qs клаузуле"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD есть threadprivate переменная в %qs клаузуле"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "нижняя граница %qE секции массива не имеет целочисленный тип"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "длина %qE секции массива не имеет целочисленный тип"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer %qs in %s clause at %L"
 msgid "expected single pointer in %qs clause"
 msgstr "Указатель на процедуру %qs в %s клаузуле в %L"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "секция массива нулевой длины в %qs клаузуле"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr "для массивного типа с неизвестной границей должно быть задано выражение для длины"
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "отрицательная нижняя граница в секции массива в %qs клаузуле"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "отрицательная длина в секции массива в %qs клаузуле"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "нижняя граница %qE выше размера секции массива в %qs клаузуле"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "длина %qE выше размера секции массива в %qs клаузуле"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "верхняя граница %qE выше размера секции массива в %qs клаузуле"
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 #| msgid "for unknown bound array type length expression must be specified"
 msgid "for array function parameter length expression must be specified"
 msgstr "для массивного типа с неизвестной границей должно быть задано выражение для длины"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "для типа указателя должно быть задано выражение длины"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "секция массив не непрерывна в %qs клаузуле"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE не имеет тип указателя или массива"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "исключительная ситуация NULL имеет целый тип, а не тип указателя"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%>-qualified array type"
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "%<_Atomic%>-квалифицированный массивный тип"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD has incomplete type"
 msgid "iterator %qD has const qualified type"
 msgstr "параметр %qD имеет неполный тип"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "битовое поле %qD не целочисленного типа"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 #| msgid "condition expression refers to iteration variable %qD"
 msgid "begin expression refers to outer iterator %qD"
 msgstr "выражение условия ссылается на итерационную переменную %qD"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "condition expression refers to iteration variable %qD"
 msgid "end expression refers to outer iterator %qD"
 msgstr "выражение условия ссылается на итерационную переменную %qD"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "initializer expression refers to iteration variable %qD"
 msgid "step expression refers to outer iterator %qD"
 msgstr "выражение инициализатора ссылается на итерационную переменную %qD"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected pointer in %qs clause"
 msgstr "ожидался указатель"
 
 #
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "using parameters for %<linear%> step is not supported yet"
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "модель кода %<large%> пока не поддерживается"
 
 #
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 #| msgid "using parameters for %<linear%> step is not supported yet"
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "модель кода %<large%> пока не поддерживается"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD в %<reduction%> клаузуле есть массив нулевой длины"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE в %<reduction%> клаузуле"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qE in %qs clause"
 msgid "zero sized type %qT in %qs clause"
 msgstr "битовое поле %qE в %qs клаузуле"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qE in %qs clause"
 msgid "variable sized type %qT in %qs clause"
 msgstr "битовое поле %qE в %qs клаузуле"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE имеет недопустимый тип для %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "определенная пользователем редукция не найдена для %qE"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "тип элемента переменой длины в предложении массива %<reduction%>"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE должно быть %<threadprivate%> для %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, fuzzy, gcc-internal-format
 #| msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs"
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr "модификатор не должен задаваться в предложении %<linear%> для конструкций %<simd%> или %<for%>"
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr "линейное предложение применено к нецелой переменной без указателя с типом %qT"
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr "%<_Atomic%> %qD в предложении %<linear%>"
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "шаг предложения %<linear%> %qE не является ни константой, ни параметром"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE не является переменной в предложении %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD многократно встречается в предложениях данных"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD многократно встречается в предложениях сокращения"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE многократно встречается в предложениях данных"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD многократно встречается в предложениях данных"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD встречается в предложениях данных и сопоставления"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE не является переменной в предложении %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE не является переменной в предложении %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE не является переменной в предложении %<aligned%>"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "%qE в предложении %<aligned%> не является ни указателем, ни массивом"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%<_Atomic%> %qD в предложении %<aligned%>"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE многократно встречается в предложении %<aligned%>"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<depend%> clause"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE не является переменной в предложении %<depend%>"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in %<aligned%> clauses"
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE многократно встречается в предложении %<aligned%>"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE не является переменной в предложении %<aligned%>"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in %<aligned%> clauses"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE многократно встречается в предложении %<aligned%>"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name %qs cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "Имя %qs не может быть использовано как определенный оператор в %C"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "array must be initialized with a brace-enclosed initializer"
 msgid "traits array must be initialized with constants"
 msgstr "массив должен быть инициализирован инициализатором в фигурных скобках"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<depend%> clause"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE не является переменной в предложении %<depend%>"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "секция массива не имеет отображаемый тип в предложении %qs"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %qD"
 msgid "unsupported map expression %qE"
 msgstr "неподдерживаемый аргумент для %qD"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD многократно встречается в предложениях движения"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD многократно встречается в предложениях сопоставления"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD не имеет отображаемый тип в предложении %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE не является ни переменной, ни именем функции в предложении %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE многократно встречается в одной директиве %<declare target%><)%>"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD не является аргументом в %<uniform%> предложении"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE не является аргументом в %<uniform%> предложении"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qs variable is not a pointer"
 msgstr "источник не есть указатель"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "%qs переменная не является ни указателем, ни массивом"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %qs clauses on a task construct"
 msgstr "слишком много конструкций %qs"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "предложение %<inbranch%> несовместимо с %<notinbranch%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in motion clauses"
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD многократно встречается в предложениях движения"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD должен иметь список параметров %<void%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not const"
 msgid "%qD shall not be const"
 msgstr "%q#D не есть const"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE является предопределённым %qs для %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr "значение предложения %<simdlen%> больше значения %<safelen%> предложения"
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr "%<nonmonotonic%> модификатор планирования задан вместе с %<ordered%> предложением"
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr "шаг %<linear%> предложения является параметром %qD, который не указан в %<uniform%> предложении"
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "слишком много %<if%> клаузул с %qs модификатором"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "нельзя использовать %<va_arg%> с обратным порядком хранения"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "второй аргумент %<va_arg%> имеет неполный тип %qT"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "второй аргумент %<va_arg%> имеет неполный тип %qT"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "второй аргумент %<va_arg%> имеет неполный тип %qT"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "в C++ требуется расширенный тип, а не перечислимый тип в %<va_arg%>"
@@ -58258,263 +58307,258 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD should be initialized"
 msgid "%s should not be null"
 msgstr "%qD должен быть инициализирован"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE не имеет отображаемый тип в предложении %qs"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s:%d: Invalid state file; %s"
 msgid "%s: Invalid field type %s:"
 msgstr "%s:%d: Некорректный файл состояния; %s"
 
 #
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "invalid GIMPLE statement"
 msgid "Not valid for ACCEPT statement."
 msgstr "некорректный оператор GIMPLE"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
 #
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "invalid GIMPLE statement"
 msgid "Not valid for DISPLAY statement."
 msgstr "некорректный оператор GIMPLE"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 #| msgid "unknown '#pragma extern_model' model '%s'"
 msgid "unknown %<setop_t%> code %d"
 msgstr "неизвестная модель '#pragma extern_model' '%s'"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT разрешается в %qT, который не является классовым типом"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name %qs at %C is the name of the procedure"
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "Имя %qs в %C есть имя процедуры"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -58523,74 +58567,85 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "декларация производного типа"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown type name %qE"
 msgid "Unknown type %d"
 msgstr "неизвестное имя типа %qE"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qD is not compatible with %qD"
+msgid "%s:%d: Must not call here with %s"
+msgstr "%qD не совместим с %qD"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -58600,13 +58655,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "слишком много входных файлов"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "cannot read string table from %s"
 msgid "cannot get %<float%> value from %s"
@@ -58623,67 +58678,67 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr "%s: программа %s завершилась с кодом %d\n"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: wait: %s\n"
 msgid "%s: data item %s #"
 msgstr "%s: ждет: %s\n"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs value must be positive"
 msgid "%s: key must be field"
 msgstr "значение %qs должно быть положительным"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s\"%s\"%s is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s\"%s\"%s некорректно"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: would convert file '%s'\n"
 msgid "%s:%d: could not add '%s'"
 msgstr "%s: был бы преобразован файл '%s'\n"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling '%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s: компиляция '%s'\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -59159,7 +59214,7 @@ msgstr "нет подходящего %<operator %s%> для %qT"
 msgid "%q#D is private within this context"
 msgstr "%q#D private в данном контексте"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr "декларировано private здесь"
@@ -59169,7 +59224,7 @@ msgstr "декларировано private здесь"
 msgid "%q#D is protected within this context"
 msgstr "%q#D protected в данном контексте"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr "декларировано protected здесь"
@@ -59506,7 +59561,7 @@ msgstr "аргумент 3 в вызове функции %qE имеет тип
 msgid "constructor delegates to itself"
 msgstr "конструктор делегирует к себе"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr ""
 
@@ -59525,7 +59580,7 @@ msgstr ""
 msgid "call to non-function %qD"
 msgstr "вызов не функции %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "невозможно вызвать конструктор %<%T::%D%> непосредственно"
@@ -60148,7 +60203,7 @@ msgstr "элемент регулируемого массива %qD в друг
 msgid "next member %q#D declared here"
 msgstr "следующий элемент %q#D объявлен здесь"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "повторное определение %q#T"
@@ -60158,7 +60213,7 @@ msgstr "повторное определение %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -60293,7 +60348,7 @@ msgstr ""
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
@@ -60347,7 +60402,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -60385,923 +60440,923 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "исключительная ситуация типа %qT будет обработана"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute not available to functions with variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "атрибут %qE не доступен для функций с переменным числом аргументов"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D декларировано со спецификацией исключений"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "целочисленное выражение %qE не является константой"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D декларировано со спецификацией исключений"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s не поддерживает %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD called with unexpected %qs argument"
 msgstr "использование %qD без параметров шаблона"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %%:debug-level-gt"
 msgid "wrong number of arguments to %qs call"
 msgstr "неверное число аргументов для %%:debug-level-gt"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma message: %s"
 msgid "constexpr message: %.*s"
 msgstr "#pragma message: %s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E не есть константное выражение"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "доступ по пустому указателю"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %qE"
 msgid "the comparison reduces to %qE"
 msgstr "слишком много аргументов для %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, fuzzy, gcc-internal-format
 #| msgid "self-comparison always evaluates to false"
 msgid "%qE evaluates to false"
 msgstr "самосравнение всегда дает false"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "вызов внутренней функции %qE"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 #| msgid "modification of %qE is not a constant expression"
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "модификация %qE не есть константное выражение"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 #| msgid "originally defined here"
 msgid "originally declared %<const%> here"
 msgstr "исходное определение находится здесь"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "тип %qT не является базовым для типа %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 #| msgid "variable %D of type %<io%> must be uninitialized"
 msgid "virtual table pointer is used uninitialized"
 msgstr "переменная %D типа %<io%> должна быть инициализирована"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is an ambiguous base class of %qT"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "  %qT является неоднозначным базовым классом %qT"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "некорректный вызов элемента-функции %qD без объекта"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "ошибка при выполнении '%s': %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr ""
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "операнд с кодом 'o' - не константа"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, fuzzy, gcc-internal-format
 #| msgid "braced list index is not allowed with array notation"
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "-client_name нельзя использовать с -dynamiclib"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 #| msgid "original declaration appeared here"
 msgid "allocation performed here"
 msgstr "исходная декларация находится здесь"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "braced list index is not allowed with array notation"
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "-client_name нельзя использовать с -dynamiclib"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, fuzzy, gcc-internal-format
 #| msgid "Attempting to allocate already allocated variable"
 msgid "deallocation of already deallocated storage"
 msgstr "Попытка разместить уже размещенную переменную"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "декларация %qD перекрывает декларированную ранее локальную переменную"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD вызвана в константном выражении до завершения ее определения"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD вызвана в константном выражении"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD использована до своего определения"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "вызов имеет циклическую зависимость"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum)"
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "глубина конкретизации шаблона превышает максимум %d (используйте -ftemplate-depth=, чтобы увеличить максимум)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "reference to %qD is not a constant expression"
 msgstr "выражение %qE не является константным выражением"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "%qE не есть константное выражение"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "правый операнд выражения сдвига %q+E отрицателен"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 #| msgid "right operand of shift expression %q+E is >= than the precision of the left operand"
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "правый операнд выражения сдвига %q+E >= точности левого операнда"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "левый операнд выражения сдвига %q+E отрицателен"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "переполнение выражения сдвига %q+E"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr "вычисления включающие пустой указатель в %qE"
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "значение индекса массива %qE вне границ массива %qD типа %qT"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "значение индекса массива %qE вне границ массива %qD типа %qT"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "значение индекс массива %qE вне границ типа массива %qT"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "значение индекса массива %qE вне границ массива %qD типа %qT"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "доступ к неинициализированному элементу массива"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "доступ по пустому указателю в %qE"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE не есть константное выражение"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "mutable %qD не может использоваться в константном выражении"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "доступ к неинициализированному элементу %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 #| msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "обращение к элементу %qD вместо инициализированного элемента %qD в константном выражении"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "обращение к элементу %qD вместо инициализированного элемента %qD в константном выражении"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "вложенные функции не поддерживаются для этой платформы"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 #| msgid "accessing uninitialized member %qD"
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "доступ к неинициализированному элементу %qD"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 #| msgid "accessing value of %qE through a %qT glvalue in a constant expression"
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "обращение к значению %qE через %qT glvalue в константном выражении"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared here"
 msgid "%qT object created here"
 msgstr "%qT декларировано здесь"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D декларировано здесь"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "use of the value of the object being constructed in a constant expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "использование значения конструируемого объекта в константном выражении"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "allocated here"
 msgstr "объявлено здесь"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "the value of %qD is not usable in a constant expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "значение %qD не может использоваться в константном выражении"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "значение %qD не может использоваться в константном выражении"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD использована в своем собственном инициализаторе"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D не есть const"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D переменная"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD не была инициализирована константным выражением"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD не была декларирована %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD не имеет целый или перечислимый тип"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 #| msgid "modification of %qE is not a constant expression"
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "модификация %qE не есть константное выражение"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 #| msgid "modification of %qE is not a constant expression"
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "модификация %qE не есть константное выражение"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 #| msgid "a reinterpret_cast is not a constant expression"
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "reinterpret_cast не является константным выражением"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 #| msgid "modification of %qE is not a constant expression"
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "модификация %qE не есть константное выражение"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 #| msgid "Change of value in conversion from %qs to %qs at %L"
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "Изменение значения в преобразовании из %qs в %qs в %L"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 #| msgid "Change of value in conversion from %qs to %qs at %L"
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "Изменение значения в преобразовании из %qs в %qs в %L"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum)"
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "глубина конкретизации шаблона превышает максимум %d (используйте -ftemplate-depth=, чтобы увеличить максимум)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "inline assembly is not a constant expression"
 msgstr "элемент инициализатора не является константным выражением"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "некорректное использование %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "in C++11 destructors default to noexcept"
 msgid "destructor exited with an exception"
 msgstr "в C++11 деструкторы подразумевают noexcept"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "значение %qE типа %qT не есть константное выражение"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum)"
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "глубина конкретизации шаблона превышает максимум %d (используйте -ftemplate-depth=, чтобы увеличить максимум)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, fuzzy, gcc-internal-format
 #| msgid "capture of variable %qD with non-automatic storage duration"
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "capture переменной  %qD с неавтоматическим сроком хранения"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "временная нелитерального типа %qT в константном выражении"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "a reinterpret_cast is not a constant expression"
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "reinterpret_cast не является константным выражением"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "преобразование из указательного типа %qT в арифметический тип %qT в константном выражении"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "pointed-to object declared here"
 msgstr "программа %qD декларирована здесь"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "the value of %qD is not usable in a constant expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "значение %qD не может использоваться в константном выражении"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на не полностью инициализированную переменную"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%<reinterpret_cast<%T>(%E)%> не является константным выражением"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "выражение %qE не является константным выражением"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%<goto%> не есть константное выражение"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "размер массива %qD не является целочисленным константным выражением"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "оператор не является константным выражением"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "неожиданное выражение %qE вида %s"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "операнд с кодом 'B' - не константа"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 #| msgid "a reinterpret_cast is not a constant expression"
 msgid "contract predicate is false in constant expression"
 msgstr "reinterpret_cast не является константным выражением"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "оператор break вне цикла или оператора switch"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> used outside of class"
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%> использовано вне класса"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "%Jjump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "%Jпереход в выражение-оператор"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 #| msgid "statement cannot resolve address of overloaded function"
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "оператор не может разрешить адрес перегруженной функции"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на не полностью инициализированную переменную"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qE не есть константное выражение, поскольку оно ссылается на mutable подобъекты %qT"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "некорректное приведение rvalue выражения из типа %qT к типу %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from integer to pointer"
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "reinterpret_cast из целого в указатель"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "address-of объекта %qE с поточно-локальным или автоматическим хранением не есть константное выражение"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr ""
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "выражение %qE не является константным выражением"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "виртуальные функции не могут быть friend-функциями"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 #| msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "typeid-expression не есть константное выражение, поскольку %qE полиморфного типа"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "приведение к нецелочисленному типу %qT в константном выражении"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared %<thread_local%> in %<constexpr%> function"
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qD декларирована %<thread_local%> я %<constexpr%> функции"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared %<static%> in %<constexpr%> function"
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%qD декларирована %<static%> я %<constexpr%> функции"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "деление на ноль не есть константное выражение"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%<delete[]%> не есть константное выражение"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<this%> in a constant expression"
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "использование %<this%> в константном выражении"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "неконстантная инициализация массива"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "неожиданное AST вида %s"
@@ -61448,418 +61503,418 @@ msgstr "некорректный операнд в инструкции"
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD не указательная переменная"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not nothrow default constructible"
 msgstr "%q#T не имеет предоставленный пользователем подразумеваемый конструктор"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qD не указательная переменная"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qD не переменная"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not trivially default constructible"
 msgstr "%q#T не имеет предоставленный пользователем подразумеваемый конструктор"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not trivially copy constructible"
 msgstr "%qD не указательная переменная"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially destructible"
 msgstr "  %q+T имеет нетривиальный деструктор"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%qT does not have unique object representations, because"
 msgstr "%qE не имеет отображаемый тип в предложении %qs"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "  %q+T имеет нетривиальный деструктор"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an abstract class"
 msgstr "%q#T не является классом"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an aggregate"
 msgstr "%qT не является агрегатным типом"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an array"
 msgstr "%qT не является агрегатным типом"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT не является базовым для %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not a bounded array"
 msgstr "%qD не указательная переменная"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T не является классом"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a const type"
 msgstr "%qT не является классовым типом"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "type %qE has no default constructor to call"
 msgid "%qT is not default constructible, because"
 msgstr "тип %qE не имеет подразумеваемого конструктора для вызова"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not destructible, because"
 msgstr "%q+T не является литералом, поскольку:"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an empty class"
 msgstr "%q#T не является классом"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT не является шаблоном"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a final class"
 msgstr "%q#T не является классом"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "%qT is not a function"
 msgstr "%qs в %L не есть функция"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT не является шаблонным типом"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not invocable, because"
 msgstr "%q+T не является литералом, поскольку:"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not compatible with %qD"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qD не совместим с %qD"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a literal type"
 msgstr "%qT не является классовым типом"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD не является шаблонным элементом-функцией"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT не является элементом %qT"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT не является элементом %qT"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%q#T не имеет предоставленный пользователем подразумеваемый конструктор"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%q+T не является литералом, поскольку:"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%q+T не является литералом, поскольку:"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT не является типом указателя на объект"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT не является базовым для %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a POD type"
 msgstr "%qD не является типом"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "источник не есть указатель"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qT не является классовым типом"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT не является пространством имён"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT не является базовым для %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace or unscoped enum"
 msgid "%qT is not a scoped enum"
 msgstr "%qT не является пространством имен или unscoped enum"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT не является шаблонным типом"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a trivial type"
 msgstr "%qT не является классовым типом"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not trivially default constructible, because"
 msgstr "%q#T не имеет предоставленный пользователем подразумеваемый конструктор"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%qD не есть переменная в %qs клаузуле"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially copyable"
 msgstr "%q+T не является литералом, поскольку:"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially destructible, because"
 msgstr "%q+T не является литералом, поскольку:"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%qT is not an unbounded array"
 msgstr "%qT не имеет перечислимый тип"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "%qT is not a union"
 msgstr "%qs в %L не есть функция"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT не является базовым для %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT не является шаблонным типом"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "%qD is not a constant"
-msgid "%qT is not consteval-only"
-msgstr "%q#D не есть const"
+#| msgid "%qT is not a class type"
+msgid "%qT is not a structural type"
+msgstr "%qT не является классовым типом"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE нельзя использовать как функцию"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "декларация %q+#D недопустима,"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not captured"
 msgid "%qT is not destructurable"
 msgstr "%qD не захватывается"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "  %qT не является производным от %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "недопустимая константа"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, fuzzy, gcc-internal-format
 #| msgid "concept must have type %<bool%>"
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr "concept должен иметь тип %<bool%>"
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "noexcept-expression evaluates to %<false%> because of a call to %qD"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "noexcept-expression приводится к %<false%> из-за вызова %qD"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "constraints for %qD not satisfied"
 msgid "constraints not satisfied"
 msgstr "конструкторы не могут быть cv-квалифицированы"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -61894,52 +61949,52 @@ msgstr "asm-декларация не согласуется с предыдущ
 msgid "previous declaration with fewer contracts here"
 msgstr "предыдущая декларация с %qL привязкой"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD declared here"
 msgid "parameter declared here"
 msgstr "параметр шаблона %qD декларирован здесь"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "декларация %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "first declared here"
 msgstr " объявлено здесь"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -62018,7 +62073,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%qD было объявлено здесь"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "no member named %qE in %qT"
@@ -62102,91 +62157,91 @@ msgstr "квалифицированный тип %qT не соответств
 msgid "awaitable type %qT is not a structure"
 msgstr "квалифицированный тип %qT не соответствует имени деструктора ~%qT"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%s нельзя использовать в asm в таком контексте"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "функция декларированная с атрибутом %<noreturn%> содержит оператор %<return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "третий аргумент %<__builtin_prefetch%> должен быть константой"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "третий аргумент %<__builtin_prefetch%> должен быть константой"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %qD"
 msgid "no suspend point info for %qD"
 msgstr "прототип для %qD не был предварительно определен"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "дублирование %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "в конструкции case нельзя употреблять указатели"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, fuzzy, gcc-internal-format
 #| msgid "variable-length array bound is unknown"
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "граница массив переменной длины неизвестна"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -62213,79 +62268,85 @@ msgstr "%qD не является функцией шаблоном"
 msgid "%qs used outside of constant expressions"
 msgstr "%qE не есть константное выражение"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "ожидалась декларация"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to member function %q#D"
 msgid "taking address of an immediate function %qD"
 msgstr "слишком много аргументов для элемента-функции %q#D"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "modification of %qE is not a constant expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "модификация %qE не есть константное выражение"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 #| msgid "throw will always call terminate()"
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "throw будет всегда вызывать terminate()"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "in C++11 destructors default to noexcept"
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "в C++11 деструкторы подразумевают noexcept"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, fuzzy, gcc-internal-format
 #| msgid "in C++11 this throw will terminate because destructors default to noexcept"
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr "в C++11 это throw терминируется, поскольку деструкторы подразумевают noexcept"
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring attributes in template argument %qE"
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "игнорирование атрибутов аргумента шаблона %qE"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qE attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "некорректный аргумент атрибута %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in template-argument"
 msgid "use fold expression in the attribute argument instead"
 msgstr "lambda-выражение в аргументе шаблона"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD не является типом"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qD is not a class type"
 msgstr "%qT не является классовым типом"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have pointer or array type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qE не имеет тип указателя или массива"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qD does not have integral type"
 msgstr "%qD не имеет целый или перечислимый тип"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -62328,7 +62389,7 @@ msgstr "преобразование к неконстантной ссылки
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr ""
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "преобразование %qT в %qT не снимает указатель"
@@ -62728,7 +62789,7 @@ msgstr "из предыдущей декларации %qF"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "редекларация %qD отличается в %<constexpr%> от предыдущей декларации"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "предыдущая декларация %qD"
@@ -62966,13 +63027,13 @@ msgstr "подразумеваемый аргумент задан для пар
 msgid "previous specification in %q#D here"
 msgstr "предыдущая спецификации в %q#D здесь"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "конфликтующая декларация %q+#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared here without exporting"
@@ -63189,7 +63250,7 @@ msgstr "  пропускает инициализацию %q#D"
 msgid "  enters %<template for%> statement"
 msgstr "  входит в %<constexpr%> оператор if"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -63237,561 +63298,561 @@ msgstr "%<typename %T::%D%> именует %q#T, который не являе
 msgid "template parameters do not match template %qD"
 msgstr "параметры шаблона не соответствуют шаблону %qD"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "-faligned-new=%d is not a power of two"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "-faligned-new=%d не есть степень двойки"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr ""
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "анонимная структура не внутри именованного типа"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "элемент %q+#D с конструктором недопустим в анонимном агрегатном типе"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "элемент %q+#D с деструктором недопустим в анонимном агрегатном типе"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "элемент %q+#D с операцией присваивания-копирования недопустим в анонимном агрегатном типе"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "атрибуты проигнорированы в декларации %q#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "атрибут для %q#T должен следовать за %qs ключевым словом"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "несколько типов в одной декларации"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "повторная декларация внутреннего типа C++ %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> можно задавать только для переменных или деклараций функций"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "отсутствует имя типа в typedef-декларации"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "в ISO C++ анонимные структуры запрещены"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "%<inline%> может задаваться только для функций"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%<virtual%> может задаваться только для функций"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> может быть задан только внутри класса"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> может быть задан только для конструкторов"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "класс хранения может быть задан только для объектов и функций"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%<const%> может задаваться только для объектов и функций"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%<volatile%> может задаваться только для объектов и функций"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%<__restrict%> может задаваться только для объектов и функций"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%<__thread%> может задаваться только для объектов и функций"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> в этой декларации отброшен"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot be used for type declarations"
 msgid "%qs cannot be used for type declarations"
 msgstr "%<constexpr%> не может использоваться для деклараций типов"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "атрибут игнорируется в явной конкретизации %q#T"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "никакой атрибут не может применяться к явной конкретизации"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "атрибут проигнорирован"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "атрибут, относящийся к спецификатору типа, игнорируется"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "игнорирование атрибутов примененных к классу %qT вне определения"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "игнорирование атрибутов примененных к зависимому типу %qT без ассоциированной декларации"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %qD is initialized (use decltype instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD инициализирован (используйте decltype взамен)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "декларация %q#D содержит %<extern%> и инициализирована"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "определение функции %q#D помечено %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q+#D не есть статический элемент данных %q#T"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "non-member-template декларация %qD"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "не соответствует декларации элемента шаблона здесь"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ не разрешает определять %<%T::%D%> как %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "повторная инициализация %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "декларация %q#D вне класса не является определением"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "переменная %q#D инициализирована, хотя имеет неполный тип"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "элементы массива %q#D имеют неполный тип"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "агрегатный тип %q#D неполон и не может быть определён"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "переменная %qD декларирована как ссылка, но не инициализирована"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "имя использовано в определенном в GNU-стиле инициализаторе массива"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "имя %qD использовано в определенном в GNU-стиле инициализаторе массива"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "нетривиально определенные инициализаторы не поддерживаются"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "C99 обозначение %qE не является целочисленным константным выражением"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "при инициализации не удалось определить размер %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "не задан размер массива для %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "массив %qD имеет нулевой размер"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "размер памяти %qD неизвестен"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "размер памяти %qD не константа"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "простите: семантики inline переменной %q#D являются неверными (запутаетесь с несколькими копиями)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "простите: семантики статических данных inline функции %q#D являются неверными (запутаетесь с несколькими копиями)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "это можно обойти, удалив инициализатор"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "неинициализированная константа %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "неинициализированная переменная %qD в %<constexpr%> функции"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr ""
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T не имеет предоставленный пользователем подразумеваемый конструктор"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "конструктор не является предоставленным пользователем, поскольку он явно подразумевался в теле класса"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "и неявно определенный конструктор не инициализирует %q#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "некорректный тип %qT является инициализатором для вектора типа %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "инициализатор для %qT должен быт заключен в фигурные скобки"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%<[%E] =%> использовано в определенном в GNU-стиле инициализаторе для класса %qT"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "запрос элемента %qD неоднозначен"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT не имеет нестатического элемента данных с именем %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD не является элементом %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "некорректный инициализатор для %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "C99 обозначение %qE вне инициализатора агрегата"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "избыточные элементы в инициализаторе для %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "фигурные скобки вокруг скалярного инициализатора для типа %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "фигурные скобки вокруг скалярного инициализатора для типа %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "отсутствуют фигурные скобки вокруг инициализатора %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type %qT"
 msgid "structured binding has incomplete type %qT"
 msgstr "поле %qD имеет неполный тип %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "элементы массива %q#T имеют неполный тип"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "составной литерал переменного размера"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D имеет неполный тип"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "в инициализаторе скалярного объекта %qD должен быть только один элемент"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "в C++98 %qD следует инициализировать при помощи конструктора, а не %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "массив %qD инициализируется строковой константой %qE, заключённой в скобки"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "инициализатор недопустим для статического элемента с конструктором"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "неконстантная инициализация внутри класса некорректна для статического элемента %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "неконстантная инициализация внутри класса некорректна для non-inline статического элемента %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(запрошена инициализация вне класса)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "запрошен адрес явной регистровой переменной %qD"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "ссылка %qD инициализируется собой"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "аргумент %d для %qE должен быть указателем"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "could not find variant declaration"
 msgstr "%<[*]%> не является декларацией"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to constructor %q#D"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "слишком мало аргументов для конструктора %q#D"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "%<declare variant%> on destructor %qD"
 msgstr "повторная декларация перечислимого типа %q+D"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "присваивание (а не инициализация) в декларации"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr ""
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "использован %<register%> спецификатор класса хранения"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "декларация %q#D не имеет инициализатора"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 #| msgid "initializer for %<decltype(auto) %D%> has function type (did you forget the %<()%> ?)"
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "инициализатор для %<decltype(auto) %D%> имеет тип функции (вы забыли %<()%> ?)"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -63799,124 +63860,124 @@ msgstr "тип результата %q#T неполный"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be defaulted"
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD не может быть подразумеваемым"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "перекрытие предыдущей декларации %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables in static storage"
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "атрибут %qE применим только к переменным в статической памяти"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "функция %q#D инициализирована как переменная"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "невозможна декомпозиция типа lambda замыкания %qT"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "lambda declared here"
 msgstr " объявлено здесь"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "невозможна декомпозиция типа класса %qT, так как он содержит анонимный элемент структуры"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr "невозможна декомпозиция типа класса %qT, так как он имеет анонимный элемент объединения"
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr ""
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT не вложен в %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr "невозможна декомпозиция типа класса %qT: и он и его базовый класс %qT имеют нестатические элементы данных"
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr "невозможна декомпозиция типа класса %qT: его базовые классы %qT и %qT имеют нестатические элементы данных"
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 #| msgid "cannot value-initialize array of unknown bound %qT"
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "невозможно инициализировать значение массива с неизвестной границей %qT"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "невозможна декомпозиция массива переменной длины %qT"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr ""
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "%<std::tuple_size<%T>::value%> не является целочисленным константным выражением"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "невозможна декомпозиция типа объединения %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "невозможна декомпозиция non-array non-class типа %qT"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr ""
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for structured binding declaration"
 msgid "array initializer for structured binding declaration in condition"
 msgstr "некорректный инициализатор для структурированной связывающей декларации"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
@@ -63924,7 +63985,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
@@ -63932,7 +63993,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
@@ -63940,1824 +64001,1836 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for structured binding declaration"
 msgid "in initialization of structured binding pack %qD"
 msgstr "некорректный инициализатор для структурированной связывающей декларации"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr ""
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "невозможна декомпозиция типа класса %qT без нестатических элементов данных"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr "нелокальная переменная %qD декларированная %<__thread%> требует динамической инициализации"
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "нелокальная переменная %qD декларированная %<__thread%> имеет нетривиальный деструктор"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr "C++11 %<thread_local%> допускает динамическую инициализацию и уничтожение"
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "при инициализации не удалось определить размер %qT"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "не задан размер массива в %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "нулевой размер массива %qT"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "деструктор чужого класса %qT не может быть элементом"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "конструктор чужого класса %qT не может быть элементом"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD декларирована как %<virtual%> переменная"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации переменной"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD декларирован как %<virtual%> параметр"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD декларирован как %<inline%> параметр"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации параметра"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD декларирован как %<virtual%> тип"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD декларирован как %<inline%> тип"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации типа"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD декларирован как %<virtual%> поле"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD декларирован как %<inline%> поле"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации поля"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D декларировано как friend"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D декларировано со спецификацией исключений"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "определение %qD вне пространства имён, объемлющего %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "статическая функция-член %q#D объявлена с квалификаторами типа"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "именованные возвращаемые значения больше не поддерживаются"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD не является функцией шаблоном"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "friend-декларация вне определения класса"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "определение явной специализации %qD в friend-декларации"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "некорректное использование идентификатора шаблона %qD в декларации первичного шаблона"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "аргументы по умолчанию не допускаются в декларации специализации friend-шаблона %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "не допускается использовать %<inline%> в декларации специализации friend-шаблона %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "декларация %q#D вне класса не является определением"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "недопустимая декларация %<::main%> как шаблона"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "недопустимая декларация %<::main%> как inline-функции"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "недопустимая декларация %<::main%> как статической функции"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "недопустимая декларация %<::main%> как статической функции"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "недопустимая декларация %<::main%> как шаблона"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "не-элемент-функция %qD не может иметь cv-квалификатор"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "статическая элемент-функция %qD не может иметь cv-квалификатор"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "статическая элемент-функция %qD не может иметь cv-квалификатор"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "non-member функция %qD не может иметь ref-квалификатор"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "статическая элемент-функция %qD не может иметь ref-квалификатор"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have ref-qualifier"
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "статическая элемент-функция %qD не может иметь ref-квалификатор"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD declared here"
 msgid "explicit object parameter declared here"
 msgstr "параметр шаблона %qD декларирован здесь"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "deduction guide %qD must be declared at namespace scope"
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "руководство вывода %qD должно декларироваться в контексте пространства имен"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "  declared here"
 msgstr " объявлено здесь"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 #| msgid "deduction guide %qD must be declared at namespace scope"
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "руководство вывода %qD должно декларироваться в контексте пространства имен"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "руководство вывода %qD не должно иметь тело функции"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "литеральный оператор с C-привязкой"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD имеет некорректный список аргументов"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "целый суффикс %qs перекрыт реализацией"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, fuzzy, gcc-internal-format
 #| msgid "floating point suffix %qs shadowed by implementation"
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "суффикс плавающей точки %qs перекрыт реализацией"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "суффиксы литеральных операторов без предшествующего %<_%> зарезервированы для будущей стандартизации"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD должен быть не-элемент-функцией"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> должна возвращать %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "определение неявно декларированного %qD"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "определение явно подразумеваемого %q+D"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q#D явно подразумевается здесь"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "нет элемента-функции %q#D в классе %qT"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "невозможно декларировать %<::main%> как глобальную переменную"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "non-template переменная не может быть %<concept%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "deduction guide %qD must be declared at namespace scope"
 msgid "concept must be defined at namespace scope"
 msgstr "руководство вывода %qD должно декларироваться в контексте пространства имен"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "именованные возвращаемые значения больше не поддерживаются"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "инициализация внутри класса статического элемента данных %q#D неполного типа"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "%<constexpr%> требуется для инициализации внутри класса статического элемента данных %q#D нецелого типа"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "инициализация внутри класса статического элемента данных %q#D нелитерального типа"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "некорректная инициализация внутри класса статического элемента данных нецелочисленного типа %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ запрещает инициализацию внутри класса неконстантного статического элемента %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ запрещает инициализацию элемента-константы %qD нецелочисленного типа %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "размер массива %qD имеет нецелочисленный тип %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "размер массива имеет нецелочисленный тип %qT"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "размер массива %qD не является целочисленным константным выражением"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "размер массива не является целочисленным константным выражением"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ запрещает массив нулевого размера %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ запрещает массивы нулевого размера"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ запрещает массив переменного размера %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ запрещает массивы переменного размера"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "используется массив переменного размера %qD"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "используется массив переменного размера"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "переполнение в размерности массива"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as array of %qT"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD декларировано как массив %qT"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "создание указателя на элемент ссылочного типа %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "декларация %qD как массива void"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "создание массива void"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "декларация %qD как массива функций"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "создание массива функций"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "декларация %qD как массива ссылок"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "создание массива ссылок"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "декларация %qD как массива элементов-функций"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "создание массива элементов-функций"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "декларация многомерного массива %qD должна определять границы для всех размерностей, кроме первой"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "в многомерном массиве должны быть определены границы для всех размерностей, кроме первой"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "используется массив переменного размера"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "некорректная спецификация возвращаемого типа в конструкторе"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "квалификаторы не допускаются в декларации конструктора"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "некорректная спецификация возвращаемого типа в деструкторе"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "квалификаторы не допускаются в декларации деструктора"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "тип результата задан для %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "квалификаторы не допускаются в декларации %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "возвращаемый тип задан для руководства вывода"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "квалификаторы не допускаются в декларации руководства вывода"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 #| msgid "decl-specifier in declaration of deduction guide"
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "decl-спецификатор в декларации руководства вывода"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "декларация безымянной переменной или поля с типом void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "декларация переменной или поля с типом void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "%<inline%> спецификатор некорректен для переменной %qD декларированной в контексте блока"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it has a base class"
 msgstr "тип не совместим со своим вариантом"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "тип не совместим со своим вариантом"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr "%qT как тип а не плоский %<decltype(auto)%>"
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "деструкторы не могут быть cv-квалифицированы"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together for %qs"
 msgid "%e and %e specified together"
 msgstr "%<signed%> и %<unsigned%> одновременно заданы для %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "недопустимое использование квалифицированного имени %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "недопустимое использование квалифицированного имени %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "недопустимое использование квалифицированного имени %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT не является классом или пространством имён"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "декларация %qD как не-функции"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "декларация %qD как не-элемента"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "декларатор отсутствует; используется зарезервированное слово %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "определение функции не объявляет параметры"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "декларация %qD как не-функции"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "декларация %qD как %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "декларация %qD как параметра"
 
 #
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, fuzzy, gcc-internal-format
 #| msgid "no classes specified"
 msgid "both %qs and %qs specified"
 msgstr "нет специфицированных классов"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot appear in a typedef declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%<constexpr%> не может встречаться в typedef декларации"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "два или более типа в декларации имени %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C++ не поддерживает плоские %<complex%> означающие %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ запрещает декларации %qs без типа"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int%d%> не поддерживается этой целевой платформой"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ не поддерживает %<__int%d%> для %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "%qs used with %qE"
 msgid "%qs specified with %qT"
 msgstr "%qs использован с %qE"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 #| msgid "%qs specified with %<typeof%>"
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qs указан с %<typeof%>"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs указан с %<decltype%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qs указан с %<typeof%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "спецификатор complex для %qs недопустим"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, fuzzy, gcc-internal-format
 #| msgid "template placeholder type %qT must be followed by a simple declarator-id"
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr "за типом заполнителя шаблона %qT должен следовать простой declarator-id"
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "элемент %qD не может быть декларирован и как %<virtual%> и как %<static%>"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both %<virtual%> and %<constexpr%>"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "элемент %qD не может быть декларирован и как %<virtual%> и как %<constexpr%>"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "typedef-декларация не допускается в декларации параметров"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "класс хранения задан для параметра шаблона %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "класс хранения в декларации параметра %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "a parameter cannot be declared %qs"
 msgstr "параметр не может быть декларирован %<constexpr%>"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> вне декларации класса"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr ""
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for structured binding declaration"
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "некорректный инициализатор для структурированной связывающей декларации"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr ""
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr "тип должен быть cv-qualified %<auto%> или ссылкой на cv-qualified %<auto%>"
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "в декларации %qs задано более одного класса хранения"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "для %qs задан класс хранения"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "вложенная функция %qs объявлена %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "имя %qs описано на верхнем уровне с классом хранения %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "имя %qs на уровне функции неявно имеет класс auto и объявлено %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "класс хранения не допускается в декларации friend-функции"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "Ожидалась открывающая скобка"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 #| msgid "Function %qs at %L cannot have an initializer"
 msgid "a function type cannot have an explicit object parameter"
 msgstr "Функция %qs в %L не может иметь инициализатор"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, fuzzy, gcc-internal-format
 #| msgid "a conversion function cannot have a trailing return type"
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "функция преобразования не может иметь завершающий тип возврата"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "  member function type %qT is not a valid template argument"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "  тип элемента-функции %qT не есть корректный аргумент шаблона"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD declared here"
 msgid "valid explicit object parameter declared here"
 msgstr "параметр шаблона %qD декларирован здесь"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "requires-клаузула для типа возврата"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "%qs функция использует %<auto%> спецификатор типа без завершающего типа возврата"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 #| msgid "deduced return type only available with -std=c++14 or -std=gnu++14"
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "выведенный тип возврата доступен только с -std=c++14 или -std=gnu++14"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "виртуальная функция не может иметь выведенный тип возврата"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "%qs функция с завершающим типом возврата имеет %qT в качестве своего типа а не обычный %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "%qs функция с завершающим типом возврата имеет %qT в качестве своего типа а не обычный %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "неверное употребление спецификатора %<restrict%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "%qs функция с завершающим типом возврата имеет %qT в качестве своего типа а не обычный %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "некорректное использование конструктора как шаблона"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr ""
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "руководство вывода для %qT должно иметь завершающий тип возврата"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr "хвостовой тип возврата %qT руководства вывода не есть специализация %qT"
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 #| msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "завершающий тип возврата доступен только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "%qs функция с завершающим типом возврата не декларирована с %<auto%> спецификатором типа"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "функция преобразования не может иметь завершающий тип возврата"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%>-qualified return type of %qD"
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "%<_Atomic%>-квалифицированный возвращаемый тип в %qD"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs объявлена как функция, возвращающая функцию"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs объявлена как функция, возвращающая массив"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "%<noreturn%> function returns non-void value"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "функция с атрибутом noreturn возвращает не-void значение"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "деструктор не может быть статической элементом-функцией"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "конструктор не может быть статической элементом-функцией"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "деструкторы не могут быть cv-квалифицированы"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "конструкторы не могут быть cv-квалифицированы"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "деструкторы не могут быть ref-квалифицированы"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "конструкторы не могут быть ref-квалифицированы"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "конструкторы не могут быть декларированы %<virtual%>"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "виртуальные функции не могут быть friend-функциями"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "friend-декларация вне определения класса"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t define friend function %qs in a local class definition"
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "невозможно определить friend-функцию %qs в определении локального класса"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "non-member function %qD cannot have cv-qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "не-элемент-функция %qD не может иметь cv-квалификатор"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "implicit templates may not be %<virtual%>"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "неявные шаблоны не могут быть %<virtual%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD должен быть нестатической элементом-функцией"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "деструкторы не могут иметь параметров"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "недопустимая декларация указателя на %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "недопустимая декларация ссылки на %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "недопустимая декларация указателя на элемент %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "невозможно декларировать ссылку на квалифицированный тип функции %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "невозможно декларировать указатель на квалифицированный тип функции %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "Недопустимо определять ссылку на %q#T, которая не будет определением типа или аргументом шаблона"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "идентификатор шаблона %qD использован как декларатор"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "элементы-функции неявно считаются friend-функциями своего класса"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "избыточная квалификация %<%T::%> элемента %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "недопустимая декларация элемента %<%T::%s%> внутри %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "не параметрический %qs не может содержать параметры"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "элемент данных не может иметь тип %qT модифицируемого размера"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "параметр не может иметь модифицированный тип `%T"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<explicit%> вне декларации класса"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<explicit%> в friend декларации"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "только декларации конструкторов и операторов преобразования могут быть %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "недопустимая декларация не-элемента %qs как %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "недопустимая декларация не объектного элемента %qs как %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "недопустимая декларация функции %qs как %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "недопустимая декларация статического %qs как %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "недопустимая декларация константного %qs как %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "ссылка %qs не может быть декларирована %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "typedef may not be a function definition"
 msgstr "типы нельзя определять в условиях"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "typedef may not be a member function definition"
 msgstr "типы нельзя определять в условиях"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%> не является декларацией"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef декларирован %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr "requires-клаузула для typedef"
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "typedef имя не может быть вложенным спецификатором имени"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ запрещает определять вложенный тип %qD с тем же именем, что и объемлющий класс"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "в декларации friend-класса использован квалификатор %<inline%>"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "параметры шаблона не могут быть friend"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "в friend-декларации требуется указание класса: %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "в friend-декларации требуется указание класса: %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "попытка сделать класс %qT \"другом\" глобальной области видимости"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "некорректные квалификаторы для типа функции, не являющейся элементом"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr "requires-клаузула для идентификатора типа"
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "абстрактный декларатор %qT использован в качестве декларатора"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "requires-клаузула в декларации нефункционального типа %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "недопустимое использование %<::%> в декларации параметра"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter to be of abstract type %qT"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "невозможно декларировать параметр с абстрактным типом %qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%<auto%> параметр недопустим в данном контексте"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "параметр декларирован %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "некорректное использование имени шаблона %qE без списка аргументов"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "нестатический элемент данных декларирован с заполнителем %qT"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ запрещает элемент регулируемый массив %qs"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C++ запрещает элементы регулируемые массивы"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "недопустимое использование %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "декларация функции %qD в неверном контексте"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "функция %qD декларирована %<virtual%> внутри объединения"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD не может быть декларирована %<virtual%>, поскольку она всегда статическая"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "ожидалось квалифицированное имя в friend декларации для деструктора %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "декларация %qD как элемента %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "a destructor cannot be %qs"
 msgstr "деструктор не может быть %<constexpr%>"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "ожидалось квалифицированное имя в friend декларации для конструктора %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "конструктор не может быть %<concept%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "concept не может быть элементом-функцией"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "ошибка открытия %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "специализация переменного шаблона %qD декларирована как функция"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr "переменный шаблон декларирован здесь"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "поле %qD имеет неполный тип %qT"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "имя %qT имеет неполный тип"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE не является ни функцией, ни элементом-функцией; не может быть декларировано как friend"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE не является ни функцией, ни элементом-функцией; не может быть декларировано как friend"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+#| msgid "%qE attribute applied to extern \"C\" declaration %qD"
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "атрибут %qE применен к extern \"C\" декларации %qD"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "определение явной специализации %qD в friend-декларации"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, fuzzy, gcc-internal-format
 #| msgid "an attribute that appertains to a type-specifier is ignored"
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "атрибут, относящийся к спецификатору типа, игнорируется"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "static data member %qE declared %<concept%>"
 msgid "static data member %qE declared %qs"
 msgstr "статический элемент данных %qE декларирован %<concept%>"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr ""
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member %qE declared %<constexpr%>"
 msgid "non-static data member %qE declared %qs"
 msgstr "нестатический элемент данных %qE объявлен как %<constexpr%>"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "некорректный класс хранения %<auto%> для функции %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "некорректный класс хранения %<register%> для функции %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "некорректный класс хранения %<__thread%> для функции %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "класс хранения %<thread_local%> недопустим для функции %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for function %qE"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "выравнивание задано для функции %qE"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "virt-спецификаторы в %qs не допускаются вне определения класса"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "%<static%> спецификатор некорректен для функции %qs декларированной вне глобального контекста"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "некорректно указано %<inline%> для функции %qs, объявленной вне глобальной области видимости"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "виртуальная функция %qs не является элементом класса"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs определен не в контексте класса"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs декларирован не в контексте класса"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "недопустимая декларация статического элемента-функции %qD"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "недопустимая декларация статической функции внутри другой функции"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "слово %<static%> недопустимо при определении (в отличие от объявления) статического элемента данных в классе"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "статический элемент %qD объявлен как %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "недопустимая явная extern-декларация элемента %q#D"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr ""
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "параметр не может быть декларирован %<constexpr%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%<extern%> декларация %qs с инициализацией"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "для %qs задан спецификатор %<extern%> и инициализатор"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "аргумент по умолчанию %qE использует %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "аргумент по умолчанию %qE использует локальную переменную %qD"
 
 #
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "некорректное использование cv-квалифицированного типа %qT в декларации параметра"
 
 #
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "некорректное использование типа %<void%> в декларации параметра"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%>-qualified parameter type %qT of %q+D"
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "%<_Atomic%>-квалифицированный параметр типа %qT для %q+D"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "некорректная декларация параметра %qD с типом метода"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "параметр %qD включает указатель на массив с неизвестной границей %qT"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "параметр %qD включает ссылку на массив с неизвестной границей %qT"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "некорректный конструктор; возможно, вы имели в виду %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "декларация %qD может не действовать в пространстве имён"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD можно не определять статической"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD должен быть нестатической элементом-функцией"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a non-member function"
 msgid "%qD must be a member function"
 msgstr "%qD должен быть не-элемент-функцией"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD должен быть либо нестатическим элементом-функцией или функцией-не-элементом"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD должен иметь аргумент типа класс или перечислимого типа"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ не поддерживает перегрузку операции ?:"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD не может иметь переменное число аргументов"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr ""
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr ""
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr ""
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr ""
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr ""
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr ""
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr ""
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD не может иметь аргументов по умолчанию"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to void will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "преобразование к void никогда не использует операцию преобразования типа"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a reference to the same type will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "преобразование к ссылке на тот же тип никогда не будет использовать операцию преобразования типа"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to the same type will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "преобразование к тому же типу никогда не будет использовать операцию преобразования типа"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a reference to a base class will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "преобразование к ссылке на базовый класс никогда не будет использовать операцию преобразования типа"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a base class will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "преобразование к базовому классу никогда не будет использовать операцию преобразования типа"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "пользовательский оператор %qD всегда вычисляет оба аргумента"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "префиксный %qD должен возвращать %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "постфиксный %qD должен возвращать %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD должен возвращать результат по значению"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "использование параметра шаблона %qT после %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "использование синонима специализации шаблона %qT после %qs"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "использование typedef-имени %qD после %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD ранее декларирован здесь"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "ссылка на %qT как на %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%qT ранее декларирован здесь"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "ссылка на %qT как на enum"
@@ -65769,101 +65842,101 @@ msgstr "ссылка на %qT как на enum"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "для %<%s %T%> нужен аргумент-шаблон"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "ссылка на %qD противоречива"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "function template %qD redeclared as a class template"
 msgid "class template %qD redeclared as non-template"
 msgstr "шаблон функции %qD редекларирован как шаблон класса"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD имеет то же имя, что и класс, в котором он(а) декларируется"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT не является шаблоном"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr "возможно вы хотите явно добавить %<%T::%>"
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "использование перечисления %q#D без предыдущей декларации"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "повторная декларация %qT как не-шаблона"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "некорректный производный тип union %qT"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT определен с многими непосредственными базами"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT определен с непосредственной виртуальной базой"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "базовый тип %qT не является ни структурой, ни классом"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "рекурсивный тип %qT не определён"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "некорректное дублирование базового типа %qT"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "scoped/unscoped рассогласование в enum %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "предыдущее определение здесь"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "рассогласование основного типа в enum %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "отличающийся основной тип в enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr ""
@@ -65872,89 +65945,95 @@ msgstr ""
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "ни один целочисленный тип не годится для представления всех значений перечислимого типа %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "значение перечислимого типа для %qD должно иметь целочисленный или unscoped перечислимый тип"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "значение перечислимого типа для %qD не является константой целого типа"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "увеличенное значение перечисления слишком велико для %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "увеличенное значение перечисления слишком велико для %<long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "переполнение в перечисляемых значениях для %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr ""
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "повторное определение %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "тип результата %q#T неполный"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> должен возвращать ссылку на %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "нет операторов возврата в функции возвращающей %qT"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "только плоский %<auto%> тип возврата может быть приведен к %<void%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "в функции, которая должна возвращать значение, отсутствует оператор return"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD уже определена в классе %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "enclosing %qs"
 msgid "using %qs"
 msgstr "объемлющая %qs"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D использовано до декларации"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "использование %qD до приведения %<auto%>"
@@ -66408,386 +66487,386 @@ msgstr "редекларация %q#D с другими ограничениям
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    включённом из %qs в %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d%R"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    включённом из %qs в %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    включённом из %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In static member function %qD"
 msgstr "В статической функции-члене %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In copy constructor %qs"
 msgid "In copy constructor %qD"
 msgstr "В конструкторе копирования %qs"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In constructor %qs"
 msgid "In constructor %qD"
 msgstr "В конструкторе %qs"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In destructor %qs"
 msgid "In destructor %qD"
 msgstr "В деструкторе %qs"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "В lambda функции"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "В статической функции-члене %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "В функции-члене %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "В функции %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "but %qE is a type"
 msgstr "%qE не тип"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "but %qE is an expression"
 msgstr "%qE не есть константное выражение"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD не переменная"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "параметр функции"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "but %qE is a function"
 msgstr "%qs в %L не есть функция"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "but %qE is a data member"
 msgstr "%q+#T содержит элементы данных типа указатель"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD не является шаблоном функции"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class template"
 msgid "but %qE is a class template"
 msgstr "%qE не является шаблоном класса"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable template"
 msgid "but %qE is a variable template"
 msgstr "%qD не есть переменный шаблон"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD является пространством имён"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an enumerator-name"
 msgid "but %qE is an enumerator"
 msgstr "%qD не является enumerator-name"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "  в конкретизации шаблона %qT"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 #| msgid "%s: In substitution of %qS:\n"
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s: В подстановке %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s: В конкретизации %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from %q#D\n"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "рекурсивно требуемый из %q#D\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "рекурсивно требуемый при подстановке %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "требуемый при подстановке %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "рекурсивно требуемый из %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "требуемый из %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr ""
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr ""
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 #| msgid "in expansion of macro %qs"
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "в расширении макроса %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required by the constraints of %q#D\n"
 msgstr "требуемый при подстановке %qS\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required for the satisfaction of %qE"
 msgstr "требуемый при подстановке %qS\n"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c required for gnat2scil"
 msgid "required for constraint satisfaction\n"
 msgstr "-c требуется для gnat2scil"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "отсутствуют аргументы"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr ""
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 #| msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "расширенные списки инициализации доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "explicit conversion operators only available with -std=c++11 or -std=gnu++11"
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "явные операции преобразования доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "вариантные шаблоны доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "lambda-выражения доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 auto only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 auto доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 #| msgid "scoped enums only available with -std=c++11 or -std=gnu++11"
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "scoped enums доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "сведенные к подразумеваемым и удаленные функции доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 #| msgid "override controls (override/final) only available with -std=c++11 or -std=gnu++11"
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "override controls (override/final) доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "инициализаторы нестатических элементов данных доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined literals only available with -std=c++11 or -std=gnu++11"
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "определенные пользователем литералы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 #| msgid "delegating constructors only available with -std=c++11 or -std=gnu++11"
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "делегирующие конструкторы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 #| msgid "inheriting constructors only available with -std=c++11 or -std=gnu++11"
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "наследуемые конструкторы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 #| msgid "c++11 attributes only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 атрибуты доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 #| msgid "ref-qualifiers only available with -std=c++11 or -std=gnu++11"
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-квалификаторы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "неполный тип %qT использован во вложенном спецификаторе имени"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "ссылка на %<%T::%D%> неоднозначна"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE; did you mean %qE?"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qT не содержит элемент с именем %qE; имелось в виду %qE?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD не является элементом %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE; did you mean %qE?"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qT не содержит элемент с именем %qE; имелось в виду %qE?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD не является элементом %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> не был декларирован"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> не был декларирован"
@@ -67018,7 +67097,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "элемент %qD - неинициализированная ссылка"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "массив должен быть инициализирован инициализатором в фигурных скобках"
@@ -67134,7 +67213,7 @@ msgstr "тип %qT не является непосредственной или
 msgid "type %qT is not a direct base of %qT"
 msgstr "тип %qT не является непосредственной базой %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -67335,45 +67414,45 @@ msgstr "в вызове оператора delete обнаружена возм
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "ни деструктор, ни специфический для класса оператор delete [] не будут вызваны, даже если они декларированы в определении класса"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "преждевременное завершение инициализатора"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "неизвестный размер массива в операторе delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "тип возвращаемого значения не полный"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "в вызове оператора delete обнаружена возможная проблема:"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined"
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "ни деструктор, ни специфический для класса оператор delete не будут вызваны, даже если они декларированы в определении класса"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "удаление объекта абстрактного типа класса %qT, имеющего невиртуальный деструктор, вызовет неопределенное поведение"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "удаление объекта полиморфного типа класса %qT, имеющего невиртуальный деструктор, может вызвать неопределенное поведение"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "тип, заданный в векторном delete, не является ни массивом, ни указателем"
@@ -67408,89 +67487,97 @@ msgstr "захват копированием неполного типа %qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> не было захвачено для этой lambda функции"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD increased in -fabi-version=9 (GCC 5.2)"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "выравнивание %qD увеличено в -fabi-version=9 (GCC 5.2)"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD increased in -fabi-version=9 (GCC 5.2)"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "выравнивание %qD увеличено в -fabi-version=9 (GCC 5.2)"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "некорректная директива #pragma %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable больше не поддерживается"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "#pragma implementation для %qs после включения файла"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "нет определения %qD"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 #| msgid "%<requires%> only available with -fconcepts"
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<requires%> доступно только с -fconcepts"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "нет декларации %qD в этой области видимости"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "нет декларации %qD в этой области видимости"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "%qD не имеет аргументов, зависящих от параметра-шаблона, поэтому должна быть доступна декларация %qD"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(с ключом %<-fpermissive%>, G++ примет данный код, но разрешение использовать недекларированные имена будет отменено в дальнейших версиях)"
@@ -67500,69 +67587,61 @@ msgstr "(с ключом %<-fpermissive%>, G++ примет данный код,
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, fuzzy, gcc-internal-format
 #| msgid "mangling typeof, use decltype instead"
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "разборка typeof, используйте decltype взамен"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, fuzzy, gcc-internal-format
 #| msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr "использование встроенной особенности %qE в сигнатуре функции; используйте библиотечные особенности взамен"
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, fuzzy, gcc-internal-format
-#| msgid "mangling typeof, use decltype instead"
-msgid "mangling type pack index"
-msgstr "разборка typeof, используйте decltype взамен"
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr "использование встроенной особенности %qE в сигнатуре функции; используйте библиотечные особенности взамен"
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "разборка %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "опущен средний операнд %<?:%> операнд не может быть разобран"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr "скорректированное имя для %qD изменится в C++17, так как спецификация исключительных ситуаций есть часть типа функции"
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of a thunk for %qD changes between -fabi-version=%d and -fabi-version=%d"
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "скорректированное имя thunk для %qD изменяется между -fabi-version=%d и -fabi-version=%d"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD changes between -fabi-version=%d and -fabi-version=%d"
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "скорректированное имя для %qD изменяется между -fabi-version=%d и -fabi-version=%d"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of the initialization guard variable for %qD changes between -fabi-version=%d and -fabi-version=%d"
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
@@ -67983,7 +68062,7 @@ msgstr "повторная декларация %q+D без привязки"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "конфликтующие спецификаторы в декларации %qs"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting type for imported declaration %#qD"
@@ -68001,468 +68080,468 @@ msgstr "конфликтующие спецификаторы в деклара
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "конфликтующие спецификаторы в декларации %qs"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "конфликтующие спецификаторы в декларации %qs"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for %q+#D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "задан несовместимый тип результата для %q+#D"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "конфликтующие спецификаторы в декларации %qs"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "конфликтующая декларация %q+#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "в декларации %q+D"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "нет подразумеваемого аргумента для %qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "type of mismatching field declared here"
 msgid "existing default declared here"
 msgstr "тип несовместного поля объявлен здесь"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument missing for parameter %P of %q+#D"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "отсутствует аргумент по умолчанию для параметра %P функции %q+#D"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of %q#D doesn%'t match"
 msgid "definition of %qD does not match"
 msgstr "extern декларация %q#D не соответствует"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "отсутствует определение"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "enumerator %qD does not match ..."
 msgstr "аргумент типа %qT не соответствует типу %qT"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "повторная декларация перечислимого типа %q+D"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
 #
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qD не является элементом типа %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of alias template %qD"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "специализация алиасного шаблона %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%qD редекларирован с другим доступом"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "декларация %qD может не действовать в пространстве имён"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD has TU-local template argument %qD"
 msgstr "использование %qD без параметров шаблона"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "%qD has TU-local template argument %qT"
 msgstr "%E не является корректным аргументом шаблона для типа %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not refer to a function"
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD не ссылается на функцию"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 #| msgid "instantiation of %q+D as type %qT"
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "конкретизация %q+D как типа %qT"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared %<constexpr%> outside its class"
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD объявлен как %<constexpr%> вне его класса"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "module %qs declared here"
 msgstr "программа %qD декларирована здесь"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %qD was here"
 msgid "macro definitions of %qE corrupted"
 msgstr "предыдущее определение %qD было здесь"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgid "inconsistent imported macro definition %qE"
 msgstr "  противоречивый вывод parameter pack с %qT и %qT"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 #| msgid "Can't delete module file %qs: %s"
 msgid "compiled module file is %qs"
 msgstr "Не удалось удалить файл модуля %qs: %s"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Display the compiler's version."
 msgid "compiled module is %sversion %s"
 msgstr "Показать версию компилятора."
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 версия %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "no %qs getter found"
 msgid "module %qs found"
 msgstr "не найден %qs getter"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, fuzzy, gcc-internal-format
 #| msgid "exception handling disabled, use -fexceptions to enable"
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "обработка прерываний отключена, задайте -fexceptions"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, fuzzy, gcc-internal-format
 #| msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "Комассивы выключены в %C, используйте %<-fcoarray=%> для включения"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 #| msgid "function attribute mismatch"
 msgid "fixed tree mismatch"
 msgstr "несовпадение атрибутов функции"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "выражение для границы стека не поддерживается"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to rename %s to state file %s [%s]"
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "не удалось переименовать %s в файл состояния %s [%s]"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to create map component '%s'"
 msgid "failed to read compiled module: %s"
 msgstr "не удалось создать map компонент '%s'"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q+#D conflicts with built-in declaration %q#D"
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "декларация %q+#D конфликтует с внутренней декларацией %q#D"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q+#D conflicts with built-in declaration %q#D"
 msgid "declaration %qD conflicts with builtin"
 msgstr "декларация %q+#D конфликтует с внутренней декларацией %q#D"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "декларация namespace %qD противоречит"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration of template %q+#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "конфликтующая декларация шаблона %q+#D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration of %q+#D with %qL linkage"
 msgid "conflicting declaration of %qD in global module"
 msgstr "конфликтующая декларация %q+#D с %qL привязкой"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared in module %qs"
 msgstr "предыдущая декларация здесь"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared in global module"
 msgstr "предыдущая декларация здесь"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %q#D declares a non-template function"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "friend декларация %q#D декларирует нешаблонную функцию"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "повторная декларация %q+D без привязки"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "creating %s"
 msgid "reading CMI %qs"
 msgstr "создание %s"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "определение метода вне контекста @implementation"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "module declared here"
@@ -68475,118 +68554,118 @@ msgstr " объявлено здесь"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs already declared"
 msgid "module already declared"
 msgstr "Символ %qs уже декларирован"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 #| msgid "module procedure"
 msgid "module already imported"
 msgstr "процедура модуля"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 #| msgid "module procedure"
 msgid "module %qs imported here"
 msgstr "процедура модуля"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown punctuation '%c'"
 msgid "unknown compiled module interface: %s"
 msgstr "неизвестный знак пунктуации '%c'"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, fuzzy, gcc-internal-format
 #| msgid "the \"%s\" debug format cannot be used with pre-compiled headers"
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "\"%s\" отладочный формат не может быть использован с прекомпилированными заголовками"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing."
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Традиционное препроцессирование."
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param name %qs"
 msgid "invalid header name %qs"
 msgstr "некорректное --param имя %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param name %qs"
 msgid "invalid module name %qs"
 msgstr "некорректное --param имя %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "ошибка записи %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "first error in %qD appeared here"
 msgstr "программа %qD декларирована здесь"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to create map component '%s'"
 msgid "failed to write compiled module: %s"
 msgstr "не удалось создать map компонент '%s'"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown header kind %qs"
@@ -68603,7 +68682,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "функция %q+D повторно декларирована с атрибутом noinline"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
@@ -68651,166 +68730,177 @@ msgstr "декларация %q#D перекрывает параметр"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "декларация %qD перекрывает элемент %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %qD but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "декларация параметра %q+D, не заданного в списке параметров"
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr ""
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D declared here"
 msgid "%q#D declared here with no linkage"
 msgstr "%q#D декларировано здесь"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here, later in the translation unit"
 msgid "%q#D declared here with internal linkage"
 msgstr "%qD декларировано здесь, позднее в единице трансляции"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D declared here"
 msgid "%q#D declared here with module linkage"
 msgstr "%q#D декларировано здесь"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> обозначает деструктор"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "using-декларация для не-элемента внутри класса"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class, namespace, or enumeration"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qE не класс, пространство имен или перечисление"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "non-member-template declaration of %qD"
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "non-member-template декларация %qD"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "using-декларация для не-элемента внутри класса"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "тип %qT не является непосредственной базой %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "did you mean to use logical not (%<!%>)?"
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr "имелось в виду использовать логическое отрицание (%<!%>)?"
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has not been declared in %qD"
 msgstr "%qE не был декларирован"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration of namespace %q+D"
 msgid "using-declaration may not name namespace %qD"
 msgstr "противоречивая декларация %q#D"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> обозначает конструктор в %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "декларация %qD вне пространства имён, объемлющего %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "явные квалификаторы в декларации %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD следовало объявить внутри %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%qD атрибут требует единственный NTBS аргумент"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "%qD атрибут не имеет смысла, поскольку элементы анонимного пространства имен получают локальные символы"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "игнорирование %qD атрибута в анонимном пространстве имен"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "игнорирование %qD атрибута в non-inline пространстве имен"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "атрибут %qD игнорируется"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "максимальное число %d пространств имен просмотрено для %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
@@ -68818,119 +68908,119 @@ msgstr[0] "предлагаемый вариант:"
 msgstr[1] "предлагаемые варианты:"
 msgstr[2] "предлагаемые варианты:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr ""
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr ""
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr ""
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %qD does not match %<#include <initializer_list>%>"
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "определение %qD не соответствует %<#include <initializer_list>%>"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "%<-fabi-version=1%> is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "%<-fabi-version=1%> больше не поддерживается"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<this%> недопустим в данном контексте"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 #| msgid "more than one 'crtl' directive"
 msgid "annotation on using directive"
 msgstr "более одной 'crtl' директивы"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr ""
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%qs в %L неоднозначно"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "использование пространства имён %qD здесь недопустимо; предполагается %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "повторная декларация %q+D без привязки"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "декларация %qD может не действовать в пространстве имён"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "ожидалось %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "%qD conflicts with used function"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%qD противоречит использованной функции"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "previous definition here"
 msgid "reachable %s definition here"
 msgstr "предыдущее определение здесь"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX вход в pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -68964,7 +69054,7 @@ msgstr "идентификатор %qE является ключевым сло
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr "LEXER_DEBUGGING_ENABLED_P не установлено в true"
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare simd%> not immediately followed by function declaration or definition"
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
@@ -69013,7 +69103,7 @@ msgstr "%<::%E%> не был декларирован"
 msgid "request for member %qE in non-class type %qT"
 msgstr "запрос элемента %qE в неклассовом типе %qT"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> не был декларирован"
@@ -69084,7 +69174,7 @@ msgstr "(возможно, пропущена точка с запятой по
 msgid "%qE is not a class template"
 msgstr "%qE не является шаблоном класса"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE не является шаблоном"
@@ -69407,1834 +69497,1845 @@ msgstr "вариантные шаблоны доступны только с -st
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "%<requires%> only available with -fconcepts"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "%<requires%> доступно только с -fconcepts"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected a reflection of a type"
 msgstr "ожидалось имя функции"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD не является шаблоном функции"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "non-class template %qT used without template arguments"
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "неклассовый шаблон %qT использован без аргументов шаблона"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class, namespace, or enumeration"
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qE не класс, пространство имен или перечисление"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "типы с фиксированной точкой не поддерживаются в C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ запрещает конструкции в фигурных скобках внутри выражений"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "операторы-выражения не допустимы вне функций и списков аргументов шаблона"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "lambda-выражения доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "ожидалось primary-expression"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> недопустим в данном контексте"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "декларация шаблона не может появляться в блоке"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "local variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "локальная переменная %qD недопустима в данном контексте"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "локальная переменная %qD недопустима в данном контексте"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "%<requires%> only available with -fconcepts"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "%<requires%> доступно только с -fconcepts"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<@end%> before end of line"
 msgid "expected %qs keyword before dependent template name"
 msgstr "ожидалось %<@end%> перед концом строки"
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "ожидалось id-выражение"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "область видимости %qT до %<~%> не является именем класса"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 #| msgid "%<auto%> parameter not permitted in this context"
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "%<auto%> параметр недопустим в данном контексте"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on destructor declaration"
 msgid "template-id not allowed for destructor in C++20"
 msgstr "квалификаторы не допускаются в декларации деструктора"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "декларация %<~%T%> как элемента %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef-имя %qD использовано как декларатор деструктора"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "ожидался unqualified-id"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD не является шаблоном"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "найдено %<:%> во вложенном спецификаторе имени, ожидалось %<::%>"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 #| msgid "decltype evaluates to %qT, which is not a class or enumeration type"
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "decltype обработано до %qT, что не является классом или перечислимым типом"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "идентификатор шаблона функции %qD в nested-name-specifier"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "function template-id %qD in nested-name-specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "идентификатор шаблона функции %qD в nested-name-specifier"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "идентификатор переменного шаблона %qD в nested-name-specifier"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "ожидался вложенный спецификатор имени"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "типы нельзя определять в приведении типов"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "типы нельзя определять в %<typeid%> выражении"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "неверное число аргументов для %<__builtin_addressof%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "неверное число аргументов для %<__builtin_launder%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "неверное число аргументов для %<__builtin_addressof%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "неверное число аргументов в вызове аргументов в вызове %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD declared here"
 msgid "selected function declared here"
 msgstr "параметр шаблона %qD декларирован здесь"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "в ISO C++ составные литеральные конструкции запрещены"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr "два последовательных %<[%> только введут атрибут"
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "типы нельзя определять в условиях"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "некорректное использование %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> не является элементом класса"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "нескалярный тип"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "typedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "typedef имя не может быть вложенным спецификатором имени"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new нельзя применять к ссылочному типу"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "'h' applied to non-register operand"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "'h' применено к нерегистровому операнду"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ не допускает %<alignof%> с не-типом"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "типы не могут быть определены в %<noexcept%> выражениях"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD не может иметь аргументов по умолчанию"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in a new-expression"
 msgid "types may not be defined in %qs expressions"
 msgstr "типы не могут быть определены в new-выражении"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_thread_pointer is not supported on this target"
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "__builtin_thread_pointer не поддерживается для этой платформы"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "типы не могут быть определены в new-выражении"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "граница массива не допускается после идентификатора типа в скобках"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "попробуйте убрать скобки вокруг идентификатора типа"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr "инициализация new-выражения для типа %<auto%> требует ровно один элемент"
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "ожидался список выражений или идентификатор типа"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "типы не могут быть определены в new-type-id"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "атрибуты игнорируются для конкретизации шаблона"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "выражение в деклараторе new должно иметь целый или перечислимый тип"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr ""
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "оператор %<>>%> трактуется в C++11 как две правые угловые скобки"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "рекомендуется окружать скобками выражение %<>>%>"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow ?: with omitted middle operand"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ не допускает ?: с опущенным средним операндом"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "типы нельзя определять в условиях"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 #| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda-выражения доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, fuzzy, gcc-internal-format
 #| msgid "the lambda has no capture-default"
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "lambda не имеет подразумеваемого захвата"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "ожидался конец capture-list"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "уже захваченное %qD в lambda выражении"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "cannot capture %qE by reference"
 msgid "%<this%> cannot be captured by reference"
 msgstr "невозможно захватить %qE по ссылке"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "вариантные шаблоны доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "lambda-захватывающие инициализаторы доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr "пустой инициализатор для lambda init-capture"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr ""
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "capture переменной  %qD с неавтоматическим сроком хранения"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<...%> in lambda capture"
 msgstr "слишком много %<if%> клаузул"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "явное by-copy capture %qD избыточно с by-copy capture умолчанием"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "явное by-reference capture %qD избыточно с by-reference capture умолчанием"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "задан аргумент по умолчанию для lambda-параметра"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute specified with a parameter"
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "%<fallthrough%> атрибут задан с параметром"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute specified with a parameter"
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "%<fallthrough%> атрибут задан с параметром"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 #| msgid "range-based %<for%> loops only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "диапазонные %<for%> циклы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 #| msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "завершающий тип возврата доступен только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%qD declared here"
+msgid "%q#E declared here"
+msgstr "%qD объявлено здесь"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "атрибуты в начале оператора игнорируются"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "ожидался помеченный оператор"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case-метка %qE вне оператора switch"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "требуется %<typename%> перед %qE, поскольку %qT зависимый контекст"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%E%> names the constructor, not the type"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%> именует конструктор, а не тип"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "lvalue required in asm statement"
 msgid "%<if consteval%> requires compound statement"
 msgstr "в операторе asm требуется lvalue-выражение"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 #| msgid "inheriting constructors only available with -std=c++11 or -std=gnu++11"
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "наследуемые конструкторы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "ожидался selection-statement"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "функция возвращает массив"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qE declared as a function"
 msgid "condition declares a function"
 msgstr "поле %qE описано как функция"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "типы нельзя определять в условиях"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "ожидался инициализатор"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 #| msgid "range-based %<for%> loops only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "диапазонные %<for%> циклы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "non-local variable %q#D uses local type %qT"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "нелокальная переменная %q#D использует локальный тип %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "range-based %<for%> выражение типа %qT имеет неполный тип"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "противоречивые begin/end типы в range-based %<for%> операторе: %qT и %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "ожидался iteration-statement"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 #| msgid "range-based %<for%> loops only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "диапазонные %<for%> циклы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "C99 designator %qE outside aggregate initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "C99 обозначение %qE вне инициализатора агрегата"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "function cannot be instrumented"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "функция не может быть инструментирована"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ не поддерживает вычисляемые goto"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "ожидался оператор перехода"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration"
 msgid "expected module-partition"
 msgstr "ожидалась декларация"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-name"
 msgid "expected module-name"
 msgstr "ожидалось template-name"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "декларация метода вне контекста @interface"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "using-декларация для не-элемента внутри класса"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "scope opened here"
 msgstr "структура определена здесь"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 #| msgid "volatile argument"
 msgid "private module fragment"
 msgstr "volatile аргумент"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "using-декларация для не-элемента внутри класса"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in exception-declarations"
 msgid "%qE may only occur once in an export declaration"
 msgstr "типы нельзя определять в exception-declarations"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "согласно ISO C, избыточный знак %<;%> после функции не допускается"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "согласно ISO C, избыточный знак %<;%> после функции не допускается"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr ""
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "%<auto%> parameter not permitted in this context"
 msgid "attributes are not permitted in this position"
 msgstr "%<auto%> параметр недопустим в данном контексте"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored"
 msgid "attributes may be inserted here"
 msgstr "атрибут проигнорирован"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "явная специализация не-шаблона %qT"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "явная конкретизация нешаблона %q#D"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "original declaration appeared here"
 msgid "export-declarations are not permitted here"
 msgstr "исходная декларация находится здесь"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> не в начале блока"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr "непеременная %qD в декларации с более чем одним декларатором с типом заполнителем"
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "противоречивый вывод для %qT: %qT и затем %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "смешивание деклараций и определений функций запрещено"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "типы нельзя определять в декларации for-диапазона"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "инициализатор в диапазонном %<for%> цикле"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "несколько деклараций в диапазонном %<for%> цикле"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for structured binding declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "некорректный инициализатор для структурированной связывающей декларации"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for structured binding declaration"
 msgid "annotation on structured binding"
 msgstr "некорректный инициализатор для структурированной связывающей декларации"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 #| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr ""
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "некорректный инициализатор для структурированной связывающей декларации"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray declaration at %C"
 msgid "for-range-declaration cannot be %qs"
 msgstr "Декларация комассива в %C"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "спецификаторы класса хранения не допускаются в декларациях параметров"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> использовано вне класса"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "Атрибут в %L не допускается в TYPE определении"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "%qs feature modifier is incompatible with %s %s"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "модификатор %qs возможности несовместим с %s %s"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> меняет смысл в C++11; пожалуйста удалите его"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "decl-specifier invalid in condition"
 msgid "%qD invalid in condition"
 msgstr "decl-specifier некорректен в условии"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD некорректно в lambda"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "decl-specifier invalid in condition"
 msgid "type-specifier invalid in lambda"
 msgstr "decl-specifier некорректен в условии"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "определение класса не должно содержать friend"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "шаблоны не могут быть %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in an exception-specification"
 msgid "types may not be defined in explicit-specifier"
 msgstr "типы нельзя определять в exception-specification"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "некорректная linkage-specification"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "типы нельзя определять в %<decltype%> выражениях"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "типы не могут быть определены в conversion-type-id"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "некорректное использование %<auto%> в операторе преобразования"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "использование %<auto%> в операторе преобразования элемента шаблона не может быть приведено"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "только конструкторы берут инициализаторы элементов"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr ""
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "mem-initializer для %qD следует за constructor delegation"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "constructor delegation следует за mem-initializer для %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "устаревший стиль инициализатора базового класса"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "ключевое слово %<typename%> запрещено в этом контексте (инициализатор квалифицированного элемента неявно является типом)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "неожиданное ключевое слово; удалите пробел между кавычками и суффикс идентификатором"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "неожиданное ключевое слово; удалите пробел между кавычками и суффикс идентификатором"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "ожидался суффикс-идентификатор"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "ожидалась пустая строка после ключевого слова %<operator%>"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "некорректный префикс кодировки в литеральном операторе"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "ожидался оператор"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "ключевое слово %<export%> не реализовано; игнорируется"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "ключевое слово %<export%> не реализовано; игнорируется"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 #| msgid "-mexr is used without -ms"
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "-mexr использовано без -ms"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "некорректный constrained type параметр"
 
 #
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "cv-qualified type параметр"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "некорректное использование %<auto%> в подразумеваемом аргументе шаблона"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "pack параметр шаблона %qD не может иметь аргумент по умолчанию"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "pack параметры шаблона не могут иметь аргументы по умолчанию"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "ожидался template-id"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "список аргументов шаблона не должен начинаться с %<<::%>"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(если вы используете %<-fpermissive%> или %<-std=c++11%> или %<-std=gnu++11%> G++ примет ваш код)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 #| msgid "invalid non-type template argument"
 msgid "invalid template-argument-list"
 msgstr "некорректный нетиповый аргумент шаблона"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "expected %<(%> after template-argument-list"
 msgstr "ожидался template-argument"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "ошибка разбора в списке аргументов шаблона"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "ожидалось template-name"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "не шаблон %qD использован как шаблон"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "используйте нотацию %<%T::template %D%> для указания о том, что это шаблон"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "ожидался pack параметр перед %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "ожидался template-argument"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "некорректный нетиповый аргумент шаблона"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 #| msgid "array notation expression cannot be used as a return value"
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "транзакционное выражение не может присутствовать в константном выражении"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "явная конкретизация не должна использовать %<inline%> спецификатор"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "явная конкретизация не должна использовать %<constexpr%> спецификатор"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "явная конкретизация не должна использовать %<constexpr%> спецификатор"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "специализация шаблона с привязкой C"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "ожидался спецификатор типа"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in lambda parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "использование %<auto%> в декларации lambda параметра доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "использование %<auto%> в декларации параметра доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "использование %<auto%> в декларации параметра доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in template argument"
 msgid "use of %<auto%> in template argument"
 msgstr "некорректное использование %<auto%> в аргументе шаблона"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "ожидался template-id для типа"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "ожидалось имя типа"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE не является именем типа"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "concept defined here"
 msgstr "объединение определено здесь"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "некорректное использование %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%> after %qE"
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "ожидалась %<,%> или %<)%> перед %qE"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, fuzzy, gcc-internal-format
 #| msgid "placeholder constraints not satisfied"
 msgid "unexpected placeholder in constrained result type"
 msgstr "ограничения заполнителя не удовлетворены"
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "декларация %qD ничего не декларирует"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "атрибуты игнорируются для неконкретизированного типа"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "атрибуты игнорируются для конкретизации шаблона"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "атрибуты игнорируются для elaborated-type-specifier, который не является forward декларацией"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD является шаблоном перечисления"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD не именует перечисление в %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "неименованный scoped enum не допускается"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in enum-base"
 msgstr "типы нельзя определять в приведении типов"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "ожидалось %<;%> или %<{%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "невозможно добавить enumerator список к конкретизации шаблона"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "вложенный спецификатор имени %qT для enum декларации не именует класс или пространство имен"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "декларация %qD в пространстве имен %qD, которое не включает %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "декларация %qD в %qD, который не объемлет %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "избыточная квалификация не допускается"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ запрещает пустой неименованный enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "opaque-enum-specifier без имени"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "opaque-enum-specifier должен использовать простой идентификатор"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, fuzzy, gcc-internal-format
 #| msgid "no unexpanded parameter packs in binary fold"
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr "нет нерасширенных пакетов параметров в бинарной свертке"
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type; did you mean %qs?"
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qE не является именем типа; имелось в виду %qs?"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD не есть namespace-name"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "ожидалось namespace-name"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "определение вложенного пространства имен не может иметь атрибуты"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "определение вложенного пространства имен не может быть inline"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "вход в пространство имен %qD"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<namespace%> определение здесь не допускается"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "использование %<auto%> в декларации параметра доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "идентификатор шаблона недопустим в using-декларации"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "использование %<auto%> в декларации параметра доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, fuzzy, gcc-internal-format
 #| msgid "access declarations are deprecated in favour of using-declarations; suggestion: add the %<using%> keyword"
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "декларациям доступа следует предпочесть using-declarations; предлагается: добавьте ключевое слово %<using%>"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<~auto%> доступно только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of dependent type %qT"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "некорректное использование зависимого типа %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qT не имеет перечислимый тип"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete type %q#T"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "некорректное использование неполного типа %q#T"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration here"
 msgid "opaque-enum-declaration here"
 msgstr "предыдущая декларация здесь"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "типы нельзя определять в алиасных декларациях шаблонов"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal before string constant"
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "ожидался строковый литерал перед строковой константой"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "повторный cv-qualifier"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "квалификаторы в описании типа возвращаемого значения функции "
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT не является пространством имён"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "use of parameter outside function body"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "использование параметра вне тела функции"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q#T"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "атрибуты проигнорированы в декларации %q#T"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "в декларации функции указаны имена параметров без типов"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 #| msgid "parenthesized initializer in array new"
 msgid "remove parentheses to default-initialize a variable"
 msgstr "инициализатор со скобками в new массива"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "в декларации функции указаны имена параметров без типов"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD redeclared as variable"
 msgid "add parentheses to declare a variable"
 msgstr "функция %qD повторно декларирована как переменная"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate stack for variable %q+D, naked function."
 msgid "cannot handle qualified name for variant function"
 msgstr "Невозможно выделить стек для переменной %q+D, naked функция."
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on constructor declaration"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "квалификаторы не допускаются в декларации конструктора"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on destructor declaration"
 msgid "declare variant directives are not allowed on destructors"
 msgstr "квалификаторы не допускаются в декларации деструктора"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "аргумент %qE - не идентификатор"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of function %qD in invalid context"
 msgid "no declaration of base function %qs in this scope"
 msgstr "декларация функции %qD в неверном контексте"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "ссылка на %qD противоречива"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "атрибуты не допускаются при определении функции"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "атрибуты не допускаются при определении функции"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "decltype cannot resolve address of overloaded function"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "decltype не может разрешить адрес перегруженной функции"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "атрибуты не допускаются при определении функции"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "function-definition здесь не допускается"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "спецификация asm не допускается при определении функции"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "атрибуты не допускаются при определении функции"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "ожидался конструктор, деструктор или преобразование типа"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "инициализатор задан для функции"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "атрибуты после инициализатора в скобках проигнорированы"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "не-функция %qD декларирована как неявный шаблон"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "граница массива не является целой константой"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "невозможно определить элемент зависимого typedef %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> не является типом"
@@ -71243,285 +71344,285 @@ msgstr "%<%T::%E%> не является типом"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "некорректная декларация"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "некорректное использование конструктора как шаблона"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "используйте %<%T::%D%> вместо %<%T::%D%> для именования конструктора в имени с квалификатором"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "квалифицированный идентификатор в декларации"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "ожидалась декларация"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD является пространством имён"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "невозможно сформировать указатель на элемент не класса %q#T"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "ожидался ptr-operator"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "повторный cv-qualifier"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "несколько ref-квалификаторов"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "повторный virt-specifier"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 #| msgid "missing template arguments after %qT"
 msgid "missing template arguments after %qE"
 msgstr "отсутствуют аргументы шаблона после %qT"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "missing template arguments"
 msgid "%qT not permitted in template argument"
 msgstr "отсутствуют аргументы шаблона"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "некорректное использование %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "типы нельзя определять в аргументах шаблона"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "некорректное использование %<auto%> в аргументе шаблона"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "ожидался type-specifier"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "ожидалось %<,%> или %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "типы нельзя определять в типах параметров"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "спецификаторы класса хранения не допускаются в декларациях параметров"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "не параметрический %qs не может содержать параметры"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "аргументы по умолчанию разрешены только для параметров функций"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "parameter pack %qD не может иметь подразумеваемый аргумент"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "pack параметр шаблона не может иметь аргумент по умолчанию"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "parameter pack не может иметь подразумеваемый аргумент"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter pack cannot have a default argument"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "pack параметр шаблона не может иметь аргумент по умолчанию"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 #| msgid "inheriting constructors only available with -std=c++11 or -std=gnu++11"
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "наследуемые конструкторы доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 #| msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "расширенные списки инициализации доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ не поддерживает C99 назначенные инициализаторы"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr ""
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "ожидалось class-name"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "ожидалось %<;%> после определения класса"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "ожидалось %<;%> после определения структуры"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "ожидалось %<;%> после определения объединения"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate virt-specifier"
 msgid "duplicate %qD specifier"
 msgstr "повторный virt-specifier"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "ожидалось %<{%> или %<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "global квалификация имени класса некорректна"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "квалифицированное имя не именует класс"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "некорректное имя класса в декларации %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "определение явной специализации %qD в friend-декларации"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "перед явной специализацией должно быть %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "шаблон функции %qD редекларирован как шаблон класса"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "невозможно разрешить typename type"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "предыдущее определение %q#T"
@@ -71529,290 +71630,290 @@ msgstr "предыдущее определение %q#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, fuzzy, gcc-internal-format
 #| msgid "no unexpanded parameter packs in binary fold"
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr "нет нерасширенных пакетов параметров в бинарной свертке"
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "ожидалось class-key"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "ожидалось %<class%> или %<typename%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "в C++03 class-key должен использоваться при декларировании friend"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "вариантные шаблоны доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "в декларации friend нет имени класса или функции"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr "класс хранения для анонимного агрегата в контексте класса недопустим"
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 #| msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "расширенные списки инициализации доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "битовое поле %qD не целочисленного типа"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "спецификатор pure в определении функции"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "случайная %<,%> в конце декларации элемента"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "ожидалось %<;%> в конце декларации элемента"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "некорректный спецификатор pure (только %<= 0%> допускается)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "инициализатор в фигурных скобках здесь не допускается"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "method attributes must be specified at the end"
 msgid "attributes on base specifiers are ignored"
 msgstr "атрибуты метода должны задаваться в конце"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "%<virtual%> задано более одного раза в base-спецификаторе"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "более одного спецификатора access в base-спецификаторе"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "ключевое слово %<typename%> запрещено в этом контексте (базовый класс неявно является типом)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "типы нельзя определять в exception-specification"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr ""
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "динамические спецификации исключительных ситуаций считаются устаревшими в C++11"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "некорректное использование %<auto%> в спецификации исключительной ситуации"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "типы нельзя определять в exception-declarations"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> в пустой декларации"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD не может иметь аргументов по умолчанию"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected attribute before %qs token"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "неожиданный атрибут перед лексемой %qs"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "атрибутный using префикс использован вместе с scoped attribute token"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "ожидался идентификатор для имени атрибута"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 #| msgid "%<fallthrough%> attribute specified multiple times"
 msgid "attribute %qs specified multiple times"
 msgstr "%<fallthrough%> атрибут задан несколько раз"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "ожидался атрибут перед %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "не параметрический %qs не может содержать параметры"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected goto expression"
 msgid "expected conditional-expression"
 msgstr "ожидалось goto выражение"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %qs"
 msgid "%qs is only available with %qs"
 msgstr "%qs несовместим с %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "атрибут %qE для %qE проигнорирован"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "атрибуты игнорируются для неконкретизированного типа"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 #| msgid "%<concept%> only available with -fconcepts"
 msgid "contracts are only available with %qs"
 msgstr "%<concept%> доступно только с -fconcepts"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "вариантные шаблоны доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 #| msgid "c++11 attributes only available with -std=c++11 or -std=gnu++11"
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 атрибуты доступны только с -std=c++11 или -std=gnu++11"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "expression must be integral"
 msgid "expression must be enclosed in parentheses"
 msgstr "выражение должно быть целочисленным"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "заданная позиция не является целой константой"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not an integer constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "запрошенное выравнивание не является целочисленной константой"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "специализация элемента %<%T::%E%> требует %<template<>%> синтаксис"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "некорректная декларация %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "недостаточно списков параметров шаблонов"
@@ -71821,448 +71922,448 @@ msgstr "недостаточно списков параметров шабло
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "слишком много списков параметров шаблонов"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on constructor declaration"
 msgid "template-id not allowed for constructor in C++20"
 msgstr "квалификаторы не допускаются в декларации конструктора"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "именованные возвращаемые значения больше не поддерживаются"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "некорректная декларация шаблона элемента в локальном классе"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "шаблон с привязкой C"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "некорректная явная специализация"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "шаблонная декларация %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "декларация шаблона класса не должна декларирован ничего иного"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "явная специализация шаблона не может иметь класс хранения"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%> должно быть %<> >%> внутри списка аргументов вложенного шаблона"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "ошибочное использование %<>>%>, используйте %<>%> для завершения списка аргументов шаблона"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "ошибочное использование %<>>%>, используйте %<>%> для завершения списка аргументов шаблона"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "аргумент %<sizeof...%> должен быть окружен скобками"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "некорректное использование %qD в спецификации привязки"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "%qs used with %qE"
 msgid "%qD specifier conflicts with %qs"
 msgstr "%qs использован с %qE"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> перед %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 #| msgid "%qs specified with %<typeof%>"
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%qs указан с %<typeof%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 не поддерживает %<long long%>"
 
 #
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "заданы и %<__thread%> и %<thread_local%>"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "дублирование %qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "дублирование %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "ожидалось %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "ожидалось %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "ожидалось %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "ожидалось %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "ожидалось %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "ожидалось %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "ожидалось %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "ожидалось %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "ожидалось %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "ожидалось %<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "ожидалось %<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "ожидалось %<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "ожидалось %<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "ожидалось %<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "ожидалось %<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>"
 msgid "expected %<auto%>"
 msgstr "ожидалось %<data%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "ожидалось %<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "ожидалось %<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "ожидалось %<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "ожидалось %<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "ожидалось %<__transaction_atomic%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "ожидалось %<__transaction_relaxed%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<@end%>"
 msgid "expected %<co_yield%>"
 msgstr "ожидалось %<@end%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "ожидалось %<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "ожидалось %<...%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "ожидалось %<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "ожидалось %<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "ожидалось %<:%> или %<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "ожидалось %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "%qs tag использован в именовании %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T был ранее декларирован здесь"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "недопустимая декларация ссылки на %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared with greater visibility than its base %qT"
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT объявлен с большей областью видимости, чем родитель %qT"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "replace the class-key with %qs"
 msgstr "ожидалось class-key"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%qT defined as %qs here"
 msgstr "метка %qD определена здесь"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared here"
 msgid "%qT first declared as %qs here"
 msgstr "%qT декларировано здесь"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD редекларирован с другим доступом"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "в C++98 %<template%> (для снятия неоднозначности) допускается только внутри шаблонов"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "конец файла в аргументе по умолчанию"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "неверное положение %<@%D%> конструкции Objective-C++"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "objective-c++ получатель сообщения ожидался"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "ожидались objective-c++ аргумент(ы) сообщения"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "в конструкции %<@encode%> в качестве аргумента должен быть задан тип"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "некорректное Objective-C++ имя селектора"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "ожидалась objective-c++ декларация метода"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "атрибуты метода должны задаваться в конце"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "случайное %qs между Objective-C++ методами"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "некорректный тип для instance переменной"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "ожидался идентификатор после %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "атрибуты нельзя задавать до %<@%D%> Objective-C++ ключевого слова"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "префиксные атрибуты игнорируются до %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "некорректный тип для property"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "unknown property attribute %qE"
 msgstr "неизвестный атрибут свойства"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected integer expression list"
 msgstr "ожидалось целочисленное выражение"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "%<wait%> выражение должно быть целочисленным"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "некорректный reduction-инициализатор"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in parameter types"
 msgid "types may not be defined in iterator type"
@@ -72272,189 +72373,189 @@ msgstr "типы нельзя определять в типах парамет
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable больше не поддерживается"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "скобочная инициализация не допускается в OpenMP %<for%> цикле"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, fuzzy, gcc-internal-format
 #| msgid "%<ordered%> clause with parameter may not be specified on %qs construct"
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "%<ordered%> клаузула с параметром не может быть задана в %qs конструкции"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "итерационная переменная %qD не должна быть reduction"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp end declare target%> без соответствующей %<#pragma omp declare target%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare simd%> must be followed by function declaration or definition"
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "за %<#pragma omp declare simd%> должна следовать декларация или определение функции"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qD is not a C pointer"
 msgstr "%qD не указательная переменная"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "ожидалось %<target%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "некорректная клаузула инициализатора"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "ожидалось id-выражение (аргументы)"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr "один из аргументов вызова инициализатора должен быть %<omp_priv%> или %<&omp_priv%>"
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "типы не могут определяться в declare reduction списке типов"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr "предекларированный арифметический тип %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr "функциональный или массивный тип %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr "тип ссылки %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "const, volatile or __restrict qualified type %qT in %<#pragma omp declare reduction%>"
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "const, volatile или __restrict квалифицированный тип %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in parameter types"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "типы нельзя определять в типах параметров"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<simd%> or %<reduction%> or %<target%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "ожидалось %<simd%> или %<reduction%> или %<target%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr "%<#pragma acc routine%> именует множество перегрузок"
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD не ссылается на функцию в контексте пространства имен"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "OpenACC directives at %C may not appear in PURE procedures"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "OpenACC директивы в %C не могут появляться в PURE процедурах"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, fuzzy, gcc-internal-format
 #| msgid "atomic_cancel"
 msgid "%<atomic_cancel%>"
 msgstr "atomic_cancel"
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "внешний %<__transaction_cancel%> не внутри внешнего %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  либо %<transaction_may_cancel_outer%> функция"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "malformed #pragma GCC coprocessor"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "некорректный синтаксис #pragma GCC coprocessor"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp cancel%> may only be used in compound statements"
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp taskyield%> может использоваться только в составных операторах"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma GCC ivdep%> must be inside a function"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "%<#pragma GCC ivdep%> должна быть внутри функций"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "межмодульные оптимизации не реализованы для C++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "стандартные преобразования в данном контексте недопустимы"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "неявные шаблоны не могут быть %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -72946,17 +73047,23 @@ msgstr "используйте %<template<>%> для явной специали
 msgid "redeclaration of %qD with different constraints"
 msgstr "редекларация %q#D с другими ограничениями"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "storage class specified for template parameter %qs"
+msgid "local class in lambda in template parameter list"
+msgstr "класс хранения задан для параметра шаблона %qs"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT не является шаблонным типом"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "спецификаторы шаблона не заданы в декларации %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
@@ -72964,7 +73071,7 @@ msgstr[0] "редекларировано с %d параметром шабло
 msgstr[1] "редекларировано с %d параметрами шаблона"
 msgstr[2] "редекларировано с %d параметрами шаблона"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
@@ -72972,131 +73079,131 @@ msgstr[0] "предыдущая декларация %qD использовал
 msgstr[1] "предыдущая декларация %qD использовала %d параметра шаблона"
 msgstr[2] "предыдущая декларация %qD использовала %d параметра шаблона"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "параметр шаблона %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "редекларирован здесь как %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "redeclared here"
 msgstr "объявлено здесь"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration %q#D with different constraints"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "редекларация %q#D с другими ограничениями"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "исходная декларация находится здесь"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration %q#D with different constraints"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "редекларация %q#D с другими ограничениями"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%E не является корректным аргументом шаблона для типа %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "это должно быть адресом функции с внешней привязкой"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "это должно быть именем функции с внешней привязкой"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%E не является корректным аргументом шаблона для типа %qT, поскольку %qD не имеет привязки"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%E не является корректным аргументом шаблона для типа %qT, поскольку %qD не имеет внешней привязки"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "это должно быть указателем на элемент вида %<&X::Y%>"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr ""
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "  couldn't deduce template parameter %qD"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  невозможно вывести параметр шаблона %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  типы %qT и %qT имеют несовместимые cv-qualifiers"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  несоответствие типов %qT и %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "  параметр шаблона %qD не есть parameter pack, но аргумент %qD таковым является"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "  аргумент шаблона %qE не соответствует указателю на элемент константе %qE"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE не эквивалентно %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  противоречивый вывод parameter pack с %qT и %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  выведены конфликтующие типы для параметра %qT (%qT и %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  выведены конфликтующие значения для нетипового параметра %qE (%qE и %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "  тип массива переменного размера %qT не есть корректный аргумент шаблона"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  тип элемента-функции %qT не есть корректный аргумент шаблона"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
@@ -73104,7 +73211,7 @@ msgstr[0] ""
 msgstr[1] ""
 msgstr[2] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
@@ -73112,352 +73219,352 @@ msgstr[0] "  кандидат ожидает %d аргумент, %d предо
 msgstr[1] "  кандидат ожидает %d аргумента, %d предоставлено"
 msgstr[2] "  кандидат ожидает %d аргументов, %d предоставлено"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  невозможно преобразовать %qE (типа %qT) к типу %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT является неоднозначным базовым классом %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT не является производным от %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  параметры шаблона для шаблона аргумента шаблона несовместимы с другими выведенными аргументами шаблона"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "  can't deduce a template for %qT from non-template type %qT"
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  невозможно вывести шаблон для %qT из нешаблонного типа %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr ""
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE не есть корректный аргумент шаблона типа %qT, поскольку %qE не переменная"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE не есть корректный аргумент шаблона типа %qT, поскольку %qD не имеет внешней привязки"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE не есть корректный аргумент шаблона типа %qT, поскольку %qD не имеет привязки"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "адрес %qD не есть корректный аргумент шаблона"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "адрес %qT подобъекта %qD не есть корректный аргумент шаблона"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "адрес %qD не есть корректный аргумент шаблона, так как он не имеет статический срок хранения"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD не есть корректный аргумент шаблона, поскольку %qD переменная, а не адрес переменной"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE не есть корректный аргумент шаблона для %qT, поскольку не является адресом переменной"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE не есть корректный аргумент шаблона для типа %qT, поскольку строковые литералы не могут быть использованы в этом контексте"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 #| msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "  аргумент шаблона %qE не соответствует указателю на элемент константе %qE"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE не есть корректный аргумент шаблона для типа %qT из-за конфликтов в cv-qualification"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE не есть корректный аргумент шаблона для типа %qT, поскольку он не есть lvalue"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D не есть корректный аргумент шаблона для типа %qT, поскольку ссылочная переменная не имеет постоянного адреса"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE не есть корректный аргумент шаблона для типа %qT, поскольку он является указателем"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "попробуйте задать %qE"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE не есть корректный аргумент шаблона для типа %qT, поскольку он имеет тип %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "игнорирование атрибутов аргумента шаблона %qT"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "игнорирование атрибутов аргумента шаблона %qE"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "injected-class-name %qD использовано как шаблон аргумента шаблона"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "некорректное использование деструктора %qE в качестве типа"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "для того чтобы сослаться на тип параметра шаблона, используйте конструкцию %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "несоответствия типа/значения в аргументе %d в списке параметров шаблона для %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  ожидалась константа типа %qT, а обнаружено %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for template parameter for class enclosing %qD"
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "подразумеваемый аргумент для параметра шаблона для класса включающего %qD"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  ожидался шаблон класса, а обнаружено %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  ожидался тип, обнаружено %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  ожидался тип, обнаружено %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  ожидался шаблон класса, обнаружено %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  ожидался шаблон типа %qD, обнаружено %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "несоответствие ограничений в аргументе %d в списке параметров шаблона для %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr ""
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "ошибка при преобразовании аргумента шаблона %qE из %qT в %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "некорректный аргумент шаблона %d"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "неправильное число аргументов шаблона (%d, а должно быть %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "неправильное число аргументов шаблона (%d, а должно быть по крайней мере %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr "предоставлено для %qD"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "pack expansion аргумент для non-pack параметра %qD алиасного шаблона %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "pack expansion аргумент для non-pack параметра %qD concept %qD"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr "так что любая конкретизация с непустым пакетом параметров была бы синтаксически некорректной"
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D не является шаблоном функции"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "не-шаблонный тип %qT использован как шаблон"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "для декларации шаблона %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "template constraint failure"
 msgid "template constraint failure for %qD"
 msgstr "нарушение ограничения шаблона"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "использование некорректного переменного шаблона %qE"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "глубина конкретизации шаблона превышает максимум %d (используйте -ftemplate-depth=, чтобы увеличить максимум)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "score argument must be constant integer expression"
 msgstr "ordered аргумент требует положительного константного целого выражения"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L must be nonnegative"
 msgid "score argument must be non-negative"
 msgstr "%qs в %L должен быть неотрицательным"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 #| msgid "%qs length expression must be positive constant integer expression"
 msgid "property must be constant integer expression or string literal"
 msgstr "%qs выражение длины должно быть положительным константным целочисленным выражением"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be constant integer expression"
 msgstr "ожидалось целочисленное выражение"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "instantiating erroneous template"
 msgstr "  в конкретизации шаблона %qT"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "original declaration appeared here"
 msgid "first error appeared here"
 msgstr "исходная декларация находится здесь"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr ""
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr "свертка пустого расширения над %O"
 
 #
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a potential constant expression"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE не есть потенциальное константное выражение"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr ""
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "создание указателя на элемент-функцию не классового типа %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mismatched arguments"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -73476,128 +73583,128 @@ msgstr "несовпадающие аргументы"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "переменная %qD имеет тип функции"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "некорректный тип параметра %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "в декларации %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "функция возвращает массив"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "функция возвращает функцию"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%<locus%> is not defined as a type"
 msgid "%qE is not usable in a splice type"
 msgstr "имя %<locus%> не определено как тип"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE не является переменной в предложении %qs"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "создание ссылки на void"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "формирование указателя на ссылочный тип %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "формирование ссылки на ссылочный тип %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "формирование указателя на квалифицированный тип функции %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "формирование ссылки на квалифицированный тип функции %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "создание указателя на элемент не классового типа %qT"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "создание указателя на элемент ссылочного типа %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "создание указателя на элемент типа void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "создание массива элементов типа %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "%q+D рассматривается как массив из одного элемента"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT не является типом class, struct или union"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT разрешается в %qT, который не является перечислимым типом"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT разрешается в %qT, который не является классовым типом"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT разрешается в %qT, который не является перечислимым типом"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected a reflection of a type template"
 msgstr "ожидался selection-statement"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "использование %qs в шаблоне"
@@ -73605,210 +73712,210 @@ msgstr "использование %qs в шаблоне"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<~%T%> as member of %qT"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "декларация %<~%T%> как элемента %qT"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "квалифицированный тип %qT не соответствует имени деструктора ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "зависимое имя %qE разбирается как не тип, но конкретизация дает тип"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "задайте %<typename %E%>, если подразумевается тип"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "элемент инициализатора не является константным выражением"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "некорректное использование pack expansion expression"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "используйте %<...%> для расширения argument pack"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "пустой инициализатор в lambda init-capture"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD не декларирован в этом контексте, и не было найдено деклараций при зависимом от аргументов поиске в точке конкретизации"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "декларации в зависимой базе %qT не найдены при неквалифицированном поиске"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "используйте %<this->%D%>"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "используйте %<%T::%D%>"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qD декларировано здесь, позднее в единице трансляции"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_choose_expr%>"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "неверное число аргументов в вызове %<__builtin_choose_expr%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qE attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "для атрибута %qE задано неверное число аргументов"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT не является классом или пространством имён"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD не является классом или пространством имён"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "использование некорректного поля %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT есть/использует неименованный тип"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "аргумент шаблона для %qD использует локальный тип %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT есть переменно модифицированный тип"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "целочисленное выражение %qE не является константой"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  при конкретизации %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "неоднозначная конкретизация шаблона для %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "неоднозначная конкретизация шаблона класса для %q#D"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr ""
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "явная конкретизация нешаблона %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD не является статическим элементом данных шаблона класса"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "нет подходящего шаблона для %qD"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "тип %qT для явной конкретизации %qD не соответствует декларированному типу %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "явная конкретизация %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "повторная явная конкретизация %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ 1998 запрещает использование %<extern%> в явной конкретизации"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "класс хранения %qD в конкретизации шаблона"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "явная конкретизация неклассового шаблона %qD"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "явная конкретизация типа %qT, не являющегося шаблоном"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "явная конкретизация %q#T до определения шаблона"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ запрещает использование %qE в явных конкретизациях"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "повторная явная конкретизация %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr ""
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -73821,556 +73928,619 @@ msgstr "virt-спецификаторы в %qs не допускаются вн
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "явная конкретизация %qD без определения"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "глубина конкретизации шаблона превышает максимум %d при конкретизации %q+D, возможно при генерации виртуальной таблицы (задайте -ftemplate-depth=, чтобы увеличить максимум)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template non-type parameter"
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T не является корректным типом для нетипового параметра шаблона"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "некорректный нетиповый параметр шаблона"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T не является корректным типом для нетипового параметра шаблона"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr ""
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "a concept cannot be a member function"
 msgid "a concept cannot be constrained"
 msgstr "concept не может быть элементом-функцией"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace or unscoped enum"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT не является пространством имен или unscoped enum"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "определение %q#T внутри списка параметров шаблона"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "non-class template %qT used without template arguments"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "неклассовый шаблон %qT использован без аргументов шаблона"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda шаблоны доступны только с -std=c++14 или -std=gnu++14"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "use #include instead"
 msgid "use %qD directly instead"
 msgstr "используйте директиву #include"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr "невозможно вывести аргументы шаблона для инициализации копированием %qT, поскольку он имеет неявное руководство вывода или декларированные пользователем конструкторы"
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "вывод аргумента шаблона класса потерпел неудачу:"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "явные руководства вывода не рассматриваются для copy-инициализации"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared here"
 msgid "explicit deduction guide declared here"
 msgstr "в вызове функции %qD определенной здесь"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 #| msgid "class template argument deduction failed:"
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "вывод аргумента шаблона класса потерпел неудачу:"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr "direct-list-initialization %<auto%> требует ровно один элемент"
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr "для вывода к %<std::initializer_list%> используйте copy-list-initialization (то есть добавьте %<=%> перед %<{%>)"
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "не удается вывести возвращаемый тип lambda из %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "невозможно вывести %qT из %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "ограничения заполнителя не удовлетворены"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "выведенный инициализатор не удовлетворяет ограничениям заполнителя"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "выведенный тип возврата не удовлетворяет ограничениям заполнителя"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "выведенный тип выражения не удовлетворяет ограничениям заполнителя"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new нельзя применять к ссылочному типу"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new нельзя применять к типу функции"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of template template parameter %qT"
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "некорректное использование шаблона параметра шаблона %qT"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "new нельзя применять к типу функции"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new нельзя применять к типу функции"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new нельзя применять к типу функции"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "incorrect number of arguments to function %qE"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "неправильное число аргументов в вызове функции %qE"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qT не является пространством имён"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "ошибка при выполнении '%s': %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "ожидалось %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "ошибка при выполнении '%s': %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  ожидался тип, обнаружено %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT не является типом указателя на объект"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT must be a function type"
 msgstr "%qD не является шаблоном функции"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "ожидался template-argument"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, fuzzy, gcc-internal-format
 #| msgid "transaction_wrap argument is not a function"
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "аргумент transaction_wrap - не функция"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "недопустимая декларация битового поля %qD с типом функции"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "enum constant defined here"
 msgid "%<consteval%> block defined here"
 msgstr "константа перечислимого типа определена здесь"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid non-type template argument"
 msgid "invalid %<access_context%> argument"
 msgstr "некорректный нетиповый аргумент шаблона"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<decltype%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "ожидалось %<decltype%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "неожиданный аргумент"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "incorrect number of arguments to function %qE"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "неправильное число аргументов в вызове функции %qE"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "задан несовместимый тип результата для %q+#D"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "задан несовместимый тип результата для %q+#D"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown metafunction %qD"
 msgstr "неизвестная функция %qs в спецификации"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "splice argument must be an expression of type %qs"
 msgstr "аргумент decltype должен быть выражением"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot call function %qD"
+msgid "cannot splice a null reflection"
+msgstr "невозможно вызвать функцию %qD"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "недопустимое использование %<::%> в декларации параметра"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared %<constexpr%>"
 msgid "add %<constexpr%>"
 msgstr "%qD не была декларирована %<constexpr%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "стандартные преобразования в данном контексте недопустимы"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared %qs"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "определение функции декларировано %qs"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "ожидалось boolean выражение"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "ключевое слово %<typename%> не допускается вне шаблонов"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 #| msgid "expected constructor, destructor, or type conversion"
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "ожидался конструктор, деструктор или преобразование типа"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "использование пространства имён %qD в качестве выражения"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "недопустимая явная extern-декларация элемента %q#D"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "invalid cast to abstract class type %qT"
+msgid "invalid class member access of type template %qE"
+msgstr "некорректное приведение к типу абстрактного класса %qT"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can%'t use %qs as a call-used register"
+msgid "cannot use %qE to access a class member"
+msgstr "нельзя использовать '%qs' как регистр, не сохраняемый при вызовах"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 #| msgid "use of local variable with automatic storage from containing function"
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "использование локальной переменной с автоматическим хранением из объемлющей функции"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 #| msgid "cast to non-integral type %qT in a constant expression"
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "приведение к нецелочисленному типу %qT в константном выражении"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD не является шаблоном функции"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t specify %<-D%> without %<--main%>"
@@ -74723,618 +74893,618 @@ msgstr "некорректное определение квалифициров
 msgid "invalid base-class specification"
 msgstr "некорректная спецификация базового класса"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "невозможно захватить элемент %qD анонимного объединения"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD не захватывается"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "lambda не имеет подразумеваемого захвата"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr "lambda в локальном классе %q+T не может захватывать переменные из объемлющего контекста"
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "использование локальной переменной с автоматическим хранением из объемлющей функции"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "использование параметра из внутренней функции"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "использование параметра вне тела функции"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr "отсутствуют аргументы шаблона"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "параметр шаблона %qD типа %qT не допускается в целочисленном константном выражении, поскольку он не целого или перечислимого типа"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "использование шаблона класса %qT в качестве выражения"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "запрос элемента %qD неоднозначен в сетке множественного наследования"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD не может появляться в константном выражении"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "тип %qE неизвестен"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT не имеет перечислимый тип"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "размер массива имеет нецелочисленный тип %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "pack index is not an integral constant"
 msgstr "граница массива не является целой константой"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "%Kargument %i value %qE is negative"
 msgid "pack index %qE is negative"
 msgstr "%Kаргумент %i значение %qE отрицательное"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter pack __bases only valid in template declaration"
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "Parameter pack __bases допустим только в декларации шаблона"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "невозможно применить %<offsetof%> к деструктору %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "невозможно применить %<offsetof%> к элементу-функции %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr ""
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr ""
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "constructor priorities are not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "приоритеты конструкторов не поддерживаются"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "определенный пользователем reduction поиск неоднозначен"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr ""
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "%qE в %<reduction%> клаузуле есть массив нулевого размера"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE имеет const тип для %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr "определенная пользователем редукция в конструкторским инициализатором для базового класса %qT"
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, fuzzy, gcc-internal-format
 #| msgid "function or array type in %<#pragma omp declare reduction%>"
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "функциональный или массивный тип в %<#pragma omp declare reduction%>"
 
 #
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "%qD должна быть глобальной переменной в %<#pragma acc declare link%>"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "ожидалось целочисленное выражение"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, fuzzy, gcc-internal-format
 #| msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs"
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr "модификатор не должен задаваться в предложении %<linear%> для конструкций %<simd%> или %<for%>"
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr "linear клаузула с %qs модификатором применена к нессылочной переменной с %qT типом"
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr "linear клаузула применена к нецелой, неуказательной переменной с %qT типом"
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "выражение линейного шага должно быть целочисленным"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr "%<this%> допускается в OpenMP только в %<declare simd%> клаузулах"
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD не есть переменная в клаузуле %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD не есть переменная в клаузуле %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD не есть переменная в клаузуле %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "%<gang%> статическое выражение должно быть целочисленным"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%<gang%> статическое значение должно быть положительным"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "%<gang%> числовое выражение должно быть целочисленным"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "%<vector%> выражение длины должно быть целочисленным"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "%<worker%> числовое выражение должно быть целочисленным"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<gang%> числовое значение должно быть положительным"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "%<vector%> значение длины должно быть положительным"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "%<worker%> числовое значение должно быть положительным"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "schedule chunk size выражение должно быть целочисленным"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "%qs выражение длины должно быть целочисленным"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "%qs выражение длины должно быть положительным константным целочисленным выражением"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "%<async%> выражение должно быть целочисленным"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "%<thread_limit%> выражение должно быть целочисленным"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "%<device%> идентификатор должен быть целочисленным"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "%<dist_schedule%> выражение размера чанка должно быть целочисленным"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD не есть переменная в %<aligned%> клаузуле"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr "%qE в %<aligned%> клаузуле не указатель, не массив и не ссылка на указатель или массив"
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD появляется более одного раза в %<aligned%> клаузулах"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "%<aligned%> клаузула выражения выравнивания должна быть целочисленной"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %<depend%> clause"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD не есть переменная в %<depend%> клаузуле"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in %<aligned%> clauses"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD появляется более одного раза в %<aligned%> клаузулах"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qE не является переменной в предложении %<aligned%>"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %<aligned%> clause"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD не есть переменная в %<aligned%> клаузуле"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in %<aligned%> clauses"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD появляется более одного раза в %<aligned%> клаузулах"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name %qs cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "Имя %qs не может быть использовано как определенный оператор в %C"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length traits arrays are not supported"
 msgstr "используется массив переменного размера"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %<depend%> clause"
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD не есть переменная в %<depend%> клаузуле"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "шаблон %qE в клаузуле %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr "перегрузка имени функции %qE в клаузуле %qs"
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "%<grainsize%> выражение должно быть целочисленным"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "%<priority%> выражение должно быть целочисленным"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "%<wait%> expression must be integral"
 msgid "%<hint%> expression must be integral"
 msgstr "%<wait%> выражение должно быть целочисленным"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 #| msgid "%qs length expression must be positive constant integer expression"
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%qs выражение длины должно быть положительным константным целочисленным выражением"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "%<wait%> expression must be integral"
 msgid "%<filter%> expression must be integral"
 msgstr "%<wait%> выражение должно быть целочисленным"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "%qs переменная не является ни указателем, ни массивом, ни ссылкой на указатель или массив"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "%qs переменная не является ни указателем, ни массивом, ни ссылкой на указатель или массив"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tile%> аргумент требует целочисленный тип"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD не есть переменная файла, пространства имен или контекста блока"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%<threadprivate%> %qE директива не в %qT определении"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "разность между %qE и %qD не имеет целый тип"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<#pragma omp simd%> использована с итерационной переменной класса %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic update%> использует два различных выражения для памяти"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "выражение %qE не является константным выражением"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "выражение %qE не является константным выражением"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "выражение %qE не является константным выражением"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %s"
 msgid "static assertion failed: %.*s"
 msgstr "неудача static assertion: %s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "неконстантное условие для static assertion"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "аргумент decltype должен быть выражением"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "decltype cannot resolve address of overloaded function"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "decltype не может разрешить адрес перегруженной функции"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT не является классовым типом"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT не является шаблонным типом"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "вызов %<__builtin_next_arg%> без аргумента"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "вызов %<__builtin_next_arg%> без аргумента"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a field reference"
 msgid "%qs argument %qT is a reference"
 msgstr "аргумент должен ссылкой на поле"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class template"
 msgid "%qD is not a class or alias template"
 msgstr "%qE не является шаблоном класса"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "операнд выражения свертки не имеет нерасширенных пакетов параметров"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "оба аргумента в бинарной свертке имеют нерасширенные пакеты параметров"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr "нет нерасширенных пакетов параметров в бинарной свертке"
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_call_with_static_chain%> must be a pointer type"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -75343,375 +75513,375 @@ msgstr "второй аргумент %<__builtin_call_with_static_chain%> до
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "array notation cannot be used with function type"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "new нельзя применять к типу функции"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "квалификаторы %qV не могут быть применены к %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr " объявлено здесь"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, fuzzy, gcc-internal-format
 #| msgid "alignment of %qD increased in -fabi-version=9 (GCC 5.2)"
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "выравнивание %qD увеличено в -fabi-version=9 (GCC 5.2)"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%qT is a floating-point type"
 msgstr "%qT не имеет перечислимый тип"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "%qT не является шаблонным типом"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT не является базовым для %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q+#T содержит элементы данных типа указатель"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "сравнение между %qT и %qT"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs не является файлом данных gcov"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class %qT has cv qualifiers"
 msgid "base class %qT is not public"
 msgstr "базовый класс %qT имеет квалификаторы cv"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not captured"
 msgid "%qD is not public"
 msgstr "%qD не захватывается"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qD is mutable"
 msgstr "%qD не переменная"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD has a non-structural type"
 msgstr "%qD не является типом"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "%qE атрибут может применяться только к функциям или к классовым или перечислимым типам"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "аргумент атрибута %qE не строковая константа"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "%qE атрибут может применяться только к функциям или к классовым или перечислимым типам"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to Java class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "%qE атрибут может применяться только к определениям Java классов"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to Java class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "%qE атрибут может применяться только к определениям Java классов"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%qE attribute takes no arguments"
 msgstr "%qE атрибуту требуются аргументы"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute doesn't apply to functions"
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "%qE атрибут не применим к функциям"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "некорректная декларация функции"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT не имеет перечислимый тип"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> применено к битовому полю"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qD не имеет целый или перечислимый тип"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "%qE on unnamed bit-field"
 msgstr "выравнивание задано для безымянного битового поля"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %qD but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "декларация параметра %q+D, не заданного в списке параметров"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "заданный init_priority не является целой константой"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "%qE атрибут может использоваться только для определений объектов типа class на уровне файла"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "заданный init_priority вне диапазона"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "заданный init_priority зарезервировано для внутреннего использования"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr ""
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "%qE атрибуту требуются аргументы"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "аргументы для %qE атрибута должны быть узкими строковыми литералами"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "аргументы для %qE атрибута должны содержать корректные идентификаторы"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%c%> не является корректным символом для идентификатора"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%c%> не является корректным символом в идентификаторе"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "атрибут %qE применен к неклассовому, неперечислимому типу %qT"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "атрибут %qE применен к %qT после его определения"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "игнорирование %qE атрибута, примененного к конкретизации шаблона %qT"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "игнорирование %qE атрибута, примененного к специализации шаблона %qT"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "атрибут %qE применен к нефункции, непеременной %qD"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "атрибут %qE применен к extern \"C\" декларации %qD"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 #| msgid "Warn if a comparison always evaluates to true or false."
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "Предупреждать, если результат сравнения всегда истина или всегда ложь."
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "%qE атрибут применим только к переменным"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "annotation on unnamed bit-field"
 msgstr "выравнивание задано для безымянного битового поля"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "параметр функции"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "функция возвращает значение не строкового типа"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -75920,830 +76090,836 @@ msgstr "%q#T не содержит элемента с именем %qE; име
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%q#T не содержит элемента с именем %qE; имелось в виду %qE?"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> не является элементом %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD не является элементом %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD не является шаблонным элементом-функцией"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT не является типом указателя на объект"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "некорректное использование индексирования массива к указателю на элемент"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "некорректное использование унарной %<*%> к указателю на элемент"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "некорректное использование неявного преобразования к указателю на элемент"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr "левый операнд %<->*%> должен быть указателем на класс, но является указателем на элемент типа %qT"
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "отсутствует индекс массива"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "индексируемый массив объявлен как %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "индексируемый объект не является ни массивом, ни указателем"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "не задан объект при использовании %qE"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "Generate default single-precision SH4 code."
 msgid "no default version in scope"
 msgstr "Генерировать код SH4 с одинарной точностью по умолчанию."
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ запрещает использование %<::main%> из программы"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "необходимо использовать %<.*%> или %<->*%> для вызова pointer-to-member функции в %<%E (...)%>, например %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE нельзя использовать как функцию"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE нельзя использовать как функцию"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD нельзя использовать как функцию"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "выражение нельзя использовать как функцию"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "слишком много аргументов для конструктора %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "слишком мало аргументов для конструктора %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "слишком много аргументов для элемента-функции %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "слишком мало аргументов для элемента-функции %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "слишком много аргументов для функции %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "слишком мало аргументов для функции %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "слишком много аргументов для метода %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "слишком мало аргументов для метода %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "для функции задано слишком много аргументов"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "слишком мало аргументов функции"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "параметр %P %qD имеет неполный тип %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "параметр %P имеет неполный тип %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "адрес %qD никогда не будет NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "адрес %qD никогда не будет NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the compiler can assume that the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "компилятор может предположить, что адрес %qD не может быть NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "компилятор может предположить, что адрес %qD не может быть NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "операнды для ?: имеют разные типы %qT и %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "conversion between distinct pointer types %qT and %qT lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "преобразование между различными указательными типами %qT и %qT без приведения типов"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %qT and %qT"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "сравнение между типами %qT и %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "сравнение между различными указательными типами %qT и %qT без приведения типов"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "complex arguments must have floating-point type"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "complex аргументы должны иметь плавающие типы"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "приведение вызова функции типа %qT к несоответствующему типу %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "преобразование из указательного типа %qT в арифметический тип %qT в константном выражении"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types when assigning to type %qT from type %qT"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "несовместимые типы в присваивании типу %qT значения типа %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "предполагается приведение к типу %qT из перегруженной функции"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL в арифметическом выражении"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ не поддерживает сравнение между указателем и целым"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "типы операндов %qT и %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "упорядоченное сравнение указателя с целочисленным нулем"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "аргумент неупорядоченного сравнения - не плавающее значение"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr ""
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "некорректные операнды типов %qT и %qT для бинарной операции %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ не поддерживает использование указателя %<void *%> в вычитании"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ не поддерживает использование указателя на функцию в вычитании"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ не поддерживает использование указателя на метод в вычитании"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "некорректное использование указателя на неполный тип в вычислениях с указателями"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr ""
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "некорректное использование %qE для образования указателя на элемент-функцию"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  qualified-id требуется"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "нельзя использовать скобки вокруг %qE для образования указателя на элемент-функцию"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a cast to a non-lvalue expression"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ не поддерживает взятие адреса от приведения к не-lvalue-выражению"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(указатель на элемент можно получить только при помощи %<&%E%>)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "адрес от временной переменной"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ не поддерживает взятие адреса от функции %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "нельзя создать указатель на элемент-ссылку %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "попытка взять адрес битового поля"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 #| msgid "%<~%> on an expression of type bool"
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<~%> от выражения типа bool"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr "имелось в виду использовать логическое отрицание (%<!%>)?"
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ запрещает инкрементирование enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ запрещает декрементирование enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "невозможно инкрементировать указатель на неполный тип %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "невозможно декрементировать указатель на неполный тип %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ запрещает инкрементирование указателя типа %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ запрещает декрементирование указателя типа %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr "использование операнда типа %qT в %<operator--%> запрещено"
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr "использование операнда типа %qT в %<operator++%> устарело"
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "нельзя взять адрес от %<this%>, поскольку это rvalue-выражение"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "запрошен адрес для %qD, которая декларирована как %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "list-initializer для неклассового типа не должен быть заключен в скобки"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "список выражений рассматривается как составное выражение в инициализаторе"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "список выражений рассматривается как составное выражение в mem-initializer"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "список выражений рассматривается как составное выражение в функциональном приведении типов"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "%s - список выражений рассматривается как составное выражение"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "нет контекста для разрешения типа %qE"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "приведение от типа %qT к типу %qT отбрасывает квалификаторы"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 #| msgid "static_cast from type %qT to type %qT casts away qualifiers"
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "static_cast от типа %qT к типу %qT отбрасывает квалификаторы"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from type %qT to type %qT casts away qualifiers"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "reinterpret_cast от типа %qT к типу %qT отбрасывает квалификаторы"
 
 #
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr ""
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr ""
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "некорректное применение static_cast от типа %qT к типу %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "тип класса %qT неполный"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "некорректное приведение rvalue выражения из типа %qT к типу %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr ""
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr ""
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "приведение указателя на функцию к указателю на объект условно поддерживается"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "некорректное приведение из типа %qT к типу %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "некорректное применение const_cast с типом %qT, не являющимся ни указателем, ни ссылкой, ни  указателем на элемент данных"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "некорректное применение const_cast с типом %qT, являющимся указателем или ссылкой на функцию"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "некорректное применение const_cast от rvalue-выражения типа %qT к типу %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "некорректное применение const_cast от типа %qT к типу %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ не поддерживает приведение к типу массива %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "некорректное приведение к типу функции %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "ошибка преобразования %qE из типа %qT в тип %qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  в вычислении %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "присваивание массиву из списка инициализатора"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "несовместимые типы в присваивании %qT -> %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "массив использован как инициализатор"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "некорректное присваивание массива"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   в преобразовании указателя на элемент-функцию"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "преобразование указателя к элементу через виртуальную базу %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   в преобразовании указателя на элемент"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "некорректное преобразование к типу %qT от типа %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr ""
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr ""
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr ""
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr ""
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr ""
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "параметр %qP %qD мог быть кандидатом для атрибута формата"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "параметр мог быть кандидатом для атрибута формата"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "цель преобразования могла быть кандидатом для атрибута формата"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "цель инициализации могла быть кандидатом для атрибута формата"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "левая часть присваивания могла быть кандидатом для атрибута формата"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "при передаче аргумента %P от %qD"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "возврат ссылки на временную переменную"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "возврат ссылки на временную переменную"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "возвращена ссылка на локальную переменную %qD"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "возвращен адрес метки %qD"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "возвращен адрес локальной переменной %qD"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
 #
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "not enough values in return statement"
 msgid "redundant move in return statement"
 msgstr "недостаточно значений в операторе возврата"
 
 #
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "not enough values in return statement"
 msgid "redundant move in initialization"
 msgstr "недостаточно значений в операторе возврата"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "возвращен результат деструктора"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "возврат в обработчике try-блока конструктора"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "возврат результата конструктора"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "return без значения в функции, возвращающей %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr "возврат списка инициализатора"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "противоречивые типы %qT и %qT выведены для возвращаемого типа lambda"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "противоречивый вывод для auto return type: %qT и затем %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> не должен возвращать NULL, если только он не декларирован %<throw()%> (или задан ключ -fcheck-new)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for %q#D"
 msgid "not eliding copy on return from %qD"
 msgstr "некорректный ковариантный тип результата для %q#D"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "using temporary as lvalue"
 msgid "using rvalue as lvalue"
@@ -77165,19 +77341,19 @@ msgstr "не удается открыть файл протокола %<vtv_set
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "не удается открыть файл протокола %<vtv_count_data.log%>: %m"
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute before %qE"
 msgid "unknown attribute %qs"
 msgstr "неизвестный атрибут свойства перед %qE"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "%q+D declared weak after being used"
 msgstr "%q+D декларировано как friend"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, fuzzy, gcc-internal-format
 #| msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<__simd__%> attribute"
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
@@ -77207,47 +77383,47 @@ msgstr "отсутствует инициализатор для поля %qD и
 msgid "the address of %qD will never be %<null%>"
 msgstr "адрес %qD никогда не будет NULL"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "недопустимая декларация указателя на %q#T"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code."
 msgid "nested function missing body"
 msgstr "Сохранять имена функций в объектном коде."
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qE не является ни функцией, ни элементом-функцией; не может быть декларировано как friend"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qs used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "регистровая переменная %qs использована во вложенной функции"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "forming reference to reference type %qT"
 msgid "forward reference to frame of %qs"
@@ -77338,36 +77514,36 @@ msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "некорректный аргумент встроенной функции %s"
 
 #
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can't open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "ошибка открытия %s на запись: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "при открытии выходного файла %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for reading: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "ошибка открытия %s на чтение: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "при открытии файла зависимостей %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -77475,7 +77651,7 @@ msgstr "неизвестная модель генерации кода TLS %qs"
 msgid "%qs is not an associative array"
 msgstr "%qD не указательная переменная"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -77492,25 +77668,25 @@ msgstr "обычно %qD является нестатической функц
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs не является корректным для %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from %q#D\n"
 msgid "recursive reference %qs"
 msgstr "рекурсивно требуемый из %q#D\n"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "переполнение при вычислении константного выражения"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not an expression"
 msgstr "%qE не есть константное выражение"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "type %qs is not an expression"
@@ -77613,18 +77789,18 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "%<dynamic_cast%> not permitted with -fno-rtti"
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<dynamic_cast%> не разрешено с -fno-rtti"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -77961,8 +78137,8 @@ msgstr "Ссылка на массив в %C не может иметь боль
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "Комассивы выключены в %C, используйте %<-fcoarray=%> для включения"
@@ -78246,7 +78422,7 @@ msgstr "Список имен %qs не может быть аргументом
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "%<I%> в %L и %<J%> в %L не могут обе быть BOZ литеральными константами"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid exponent-letter %<q%> in real-literal-constant at %C"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -78327,7 +78503,7 @@ msgstr "%qs аргумент %qs встроенной функции в %L до
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть INTEGER или PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть константой"
@@ -78471,7 +78647,7 @@ msgstr "ENTRY оператор в %C не может появляться вну
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "%qs и %qs аргументы %qs встроенной функции в %L должны иметь одинаковый тип"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "Различные виды типов в %L"
@@ -78487,7 +78663,7 @@ msgstr "NULL указатель в %L не разрешен в качестве
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "%qs аргумент %qs встроенной функции в %L не должен быть коиндексирован"
@@ -78631,8 +78807,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "errmsg= аргумент в %L должен быть подразумеваемого вида character переменной"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "Комассивы выключены в %L, используйте %<-fcoarray=%> для включения"
@@ -78744,9 +78920,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "ENTRY оператор в %C не может появляться внутри внутренней подпрограммы"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "%qs встроенная функция с KIND аргументом в %L"
@@ -78761,12 +78937,12 @@ msgstr "%qs аргумент %qs встроенной функции в %L им
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "%qs аргумент %qs встроенной функции в %L должен иметь ранг %d или быть скаляром"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть числовым или LOGICAL"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "Типы аргументов %qs встроенной функции в %L должны соответствовать (%s/%s)"
@@ -78866,648 +79042,648 @@ msgstr "%qs аргумент %qs встроенной функции в %L до
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Встроенная функция %qs в %L должна иметь по крайней мере два аргумента"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Отсутствует %qs аргумент для %s встроенной функции в %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Повторяющийся аргумент %qs в %L для встроенной функции %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Неизвестный аргумент %qs в %L для встроенной функции %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different type kinds at %L"
 msgid "Different character kinds at %L"
 msgstr "Различные виды типов в %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "%<a%d%> аргумент %qs встроенной функции в %L должен быть %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "%qs встроенная функция с CHARACTER аргументом в %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "%<a1%> аргумент %qs встроенной функции в %L должен быть INTEGER, REAL или CHARACTER"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "%<a1%> аргумент %qs встроенной функции в %L должен быть INTEGER, REAL или CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Разная форма по измерению 1 для аргументов %qs и %qs в %L для встроенной функции matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Разная форма по измерению 2 для аргументов %qs и %qs в %L для встроенной функции matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть ранга 1 или 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть интероперабельной сущностью данных: %s"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть INTEGER или REAL"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть INTEGER"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "FROM аргумент для MOVE_ALLOC в %L не должен быть коиндексирован"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "TO аргумент для MOVE_ALLOC в %L не должен быть коиндексирован"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "TO аргументы в MOVE_ALLOC в %L должны быть полиморфными, если FROM является полиморфным"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "FROM и TO аргументы MOVE_ALLOC встроенной функции в %L должны иметь одинаковый ранг %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "FROM и TO аргументы MOVE_ALLOC встроенной функции в %L должны иметь одинаковый коранг %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr "Аргументы FROM и TO в %L нарушают ограничения синонимии (F2003 12.4.1.7)"
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "Аргумент %<S%> NEAREST в %L не должен быть нулем"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть POINTER, ALLOCATABLE или процедурным указателем"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "NULL встроенная функция с размещаемым MOLD в %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must have a type of either REAL or INTEGER"
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "%qs аргумент %qs встроенной функции в %L должен иметь тип либо REAL либо INTEGER"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть формальной переменной"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть OPTIONAL формальной переменной"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "%qs аргумент %qs встроенной функции в %L не должен быть подобъектом %qs"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "Аргумент RANK встроенной функции в %L должен быть объектом данных"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The A argument at %L of CO_REDUCE shall not be polymorphic"
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "A аргумент в %L для CO_REDUCE не должен быть полиморфным"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The stat= argument at %L must be a kind=4 integer variable"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "stat= аргумент в %L должна быть kind=4 integer переменной"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DTIO dummy argument at %L must be a scalar"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "DTIO формальный аргумент в %L должен быть скаляром"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "%<shape%> аргумент %<reshape%> встроенной функции в %L должен быть массивом константного размера"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "%qs аргумент %qs встроенной функции в %L пуст"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "%<shape%> аргумент %<reshape%> встроенной функции в %L имеет больше чем %d элементов"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "%qs аргумент %qs встроенной функции в %L имеет отрицательный элемент (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "%qs аргумент %qs встроенной функции в %L имеет неверное число элементов (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "%qs аргумент %qs встроенной функции в %L имеет измерение вне диапазона (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "%qs аргумент %qs встроенной функции в %L имеет некорректную перестановку измерений (измерение %qd дублировано)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Без дополнения не хватает элементов во встроенной функции RESHAPE source в %L, чтобы соответствовать форме"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "%qs аргумент %qs встроенной функции в %L не может быть типа %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть расширяемого типа"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "SELECTED_REAL_KIND с аргументом не %<P%> и не %<R%> в %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "%qs встроенная функция с RADIX аргументом в %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "%<source%> аргумент %<shape%> встроенной функции в %L не должен быть массивом предполагаемого размера"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "%qs аргумент %qs встроенной функции в %L не должен быть процедурой"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "%qs аргумент %qs встроенной функции в %L не должен быть TYPE(*)"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "%qs аргумент %qs встроенной функции в %L не должен быть массивом предполагаемого размера"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr "is_c_interoperable(): gfc_simplify_expr потерпело неудачу"
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть интероперабельной сущностью данных: %s"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr "Аргумент C_PTR_1 в %L для C_ASSOCIATED должен иметь тип TYPE(C_PTR) или TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1: %s instead of %s"
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr "Аргумент C_PTR_2 в %L для C_ASSOCIATED должен иметь тот же тип, что и C_PTR_1: %s вместо %s"
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr "Аргумент CPTR в %L для C_F_POINTER должен иметь тип TYPE(C_PTR)"
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Аргумент FPTR в %L для C_F_POINTER должен быть указателем"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "FPTR аргумент в %L для C_F_POINTER должен быть полиморфным"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "Аргумент FPTR в %L для C_F_POINTER не должен быть коиндексирован"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Неожиданный SHAPE аргумент в %L для C_F_POINTER со скалярным FPTR"
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr "Ожидался SHAPE аргумент для C_F_POINTER с массивным FPTR в %L"
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "SHAPE аргумент в %L для C_F_POINTER должен иметь тот же размер, что и RANK FPTR"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "FPTR аргумент в %L для C_F_POINTER должен быть полиморфным"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Неожиданный SHAPE аргумент в %L для C_F_POINTER со скалярным FPTR"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "SHAPE аргумент в %L для C_F_POINTER должен иметь тот же размер, что и RANK FPTR"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr "Полиморфный FPTR в %L для C_F_POINTER"
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD is not a function returning a pointer"
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "%qD не является шаблоном функции"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Noninteroperable array FPTR at %L to C_F_POINTER: %s"
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Неинтероперабельный массив FPTR в %L для C_F_POINTER: %s"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr "Аргумент CPTR в %L для C_F_PROCPOINTER должен иметь тип TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "Аргумент FPTR в %L для C_F_PROCPOINTER должен быть указателем на процедуру"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "Аргумент FPTR в %L для C_F_PROCPOINTER должен быть коиндексирован"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr "Неинтероперабельный указатель на процедуру в %L для C_F_PROCPOINTER"
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "Аргумент X в %L для C_FUNLOC не должен быть коиндексирован"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "Результат функции %qs в %L не годится как X аргумент для C_FUNLOC"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr "Аргумент X в %L для C_FUNLOC должен быть процедурой или указателем на процедуру"
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Неинтероперабельная процедура в %L для C_FUNLOC"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "Аргумент X в %L для C_LOC не должен быть коиндексирован"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "X аргумент в %L для C_LOC не должен быть полиморфным"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "Аргумент X в %L для C_LOC должен иметь POINTER или TARGET атрибут"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "Аргумент X в %L для C_LOC не должен быть строкой нулевого размера"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "Аргумент в %L для C_LOC не должен быть полиморфным"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "Неинтероперабельный массив в %L как аргумент для C_LOC: %s"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr "Массив неинтероперабельного типа в %L для C_LOC, который является неразмещаемым и не подразумеваемого и не явного размера"
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "Секция массива в %L для C_LOC"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "не двойной точности REAL аргумент для %s встроенной функции в %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть меньше чем ранг %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "%qs аргумент %qs встроенной функции в %L не есть корректный индекс измерения"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be default real"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть подразумеваемым вещественным"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "'%s' аргумент для IMAGE_INDEX должен быть массивом ранга один в %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "Число элементов массива SUB аргумента для IMAGE_INDEX в %L должно быть %d (коранг) а не %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Слишком много аргументов %s в %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, fuzzy, gcc-internal-format
 #| msgid "DIM argument without COARRAY argument not allowed for THIS_IMAGE intrinsic at %L"
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "DIM аргумент без COARRAY аргумента не допускается для THIS_IMAGE встроенной функции в %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "STAT= argument to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "STAT= аргумент для %s в %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "%<MOLD%> аргумент %<TRANSFER%> встроенной функции в %L не должен быть %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "%<MOLD%> аргумент %<TRANSFER%> встроенной функции в %L не должен быть %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "%<MOLD%> аргумент %<TRANSFER%> встроенной функции в %L не должен быть %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 #, fuzzy
 #| msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld"
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "Встроенная функция TRANSFER в %L имеет частично неопределенный результат: исходный размер %ld < размера результата %ld"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "%qs аргумент %qs встроенной функции в %L должен иметь тот же ранг, что и %qs или быть скаляром"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "%qs и %qs аргументы %qs встроенной функции в %L должны иметь идентичную форму."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "COUNT аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Аргумент ATANH в %L должен быть внутри диапазона от -1 до 1"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Размер %qs аргумента %qs встроенной функции в %L слишком мал (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Слишком много аргументов %s в %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr "fe_runtime_error цепочка должна быть null-терминирована"
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "fe_runtime_error: Неправильное число аргументов (%d вместо %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "COUNT аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "COUNT аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr "Вещественный COUNT_RATE аргумент для SYSTEM_CLOCK в %L"
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "COUNT_RATE аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "COUNT_RATE аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "COUNT_MAX аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "COUNT_MAX аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "COUNT аргумент для SYSTEM_CLOCK в %L имеет неподразумеваемый вид"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть вида не шире чем подразумеваемый вид (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "ATOM argument at %L of the %s intrinsic function shall be a coarray or coindexed"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "ATOM аргумент в %L для %s встроенной функции должен быть комассивом или коиндексированным"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть INTEGER или LOGICAL"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr "Встроенная функция NULL в %L не может быть фактическим аргументом для STORAGE_SIZE, так как она возвращает неассоциированный указатель"
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "Максимальный уровень расширения достигнут с типом %qs в %L"
@@ -79578,12 +79754,12 @@ msgstr "Неиспользуемая инициализационная цепо
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "Инициализация в %C не для указательной переменной"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Начальный индекс подстроки в %L меньше единицы"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "Конечный индекс подстроки в %L превышает длину строки"
@@ -79634,2116 +79810,2116 @@ msgstr ""
 msgid "Simplification error"
 msgstr ""
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Ассоциированная с хостом переменная %qs не должна быть в DATA операторе в %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "инициализация переменной из common блока %qs в DATA операторе в %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Символ %qs должен быть PARAMETER в DATA операторе в %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Некорректный инициализатор %s в Data операторе в %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%<concept%> cannot appear in a typedef declaration"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%<concept%> не может встречаться в typedef декларации"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "Инициализация в %C не допускается в PURE процедуре"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "DATA оператор в %C не может появляться внутри INTERFACE"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "DATA оператор в %C не допускается в PURE процедуре"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "Пустой старомодный список инициализатора в %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "Repeat spec некорректна в скалярном инициализаторе в %C"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "Repeat spec должна быть integer в %C"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Ожидалась константа данных после repeat spec в %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "Конец скалярного инициализатора ожидался в %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "Недостаточно элементов в инициализаторе массива в %C"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "Слишком много элементов в инициализаторе массива в %C"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Синтаксическая ошибка в старомодном списке инициализатора в %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "Массив предполагаемой размерности в %C не должен иметь коизмерения"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Некорректная INTENT спецификация в %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "отложенный параметр типа в %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr "Скалярное INTEGER выражение ожидалось в %L"
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Старый стиль длины строки в %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Синтаксическая ошибка в спецификации длины строки в %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Процедура %qs в %C уже определена в %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr ""
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Имя %qs в %C уже определено как обобщенный интерфейс в %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr ""
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Процедура %qs в %L должна иметь BIND(C) атрибут, чтобы быть C-совместимой"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "Переменная %qs в %L является формальным аргументом BIND(C) процедуры %qs, но не является C-совместимой, поскольку производный тип %qs не является C-совместимым"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "Переменная %qs в %L является формальным аргументом BIND(C) процедуры %qs, но не является C-совместимой, поскольку та полиморфна"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Переменная %qs в %L является формальным аргументом BIND(C) процедуры %qs, но может не быть C-совместимой"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L cannot have the POINTER attribute because procedure '%s' is BIND(C)"
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "Переменная '%s' в %L не может иметь POINTER атрибут поскольку процедура '%s' является BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 #| msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "LOGICAL формальная переменная %qs в %L с не-C_Bool видом в BIND(C) процедуре %qs"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Character аргумент %qs в %L должен быть длины 1, поскольку процедура %qs является BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Character аргумент %qs в %L должен быть длины 1, поскольку процедура %qs является BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Character аргумент %qs в %L должен быть длины 1, поскольку процедура %qs является BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "Character аргумент %qs в %L должен быть длины 1, поскольку процедура %qs является BIND(C)"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, fuzzy, gcc-internal-format
 #| msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Character аргумент %qs в %L должен быть длины 1, поскольку процедура %qs является BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Переменная %qs в %L с ALLOCATABLE атрибутом в процедуре %qs с BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Переменная %qs в %L с POINTER атрибутом в процедуре %qs с BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "Переменная %qs в %L не может иметь оба атрибута OPTIONAL и VALUE, поскольку процедура %qs является BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Переменная %qs в %L с OPTIONAL атрибутом в процедуре %qs являющейся BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Массив предполагаемого размера %qs в %L как формальный аргумент в BIND(C) процедуре %qs в %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Символ %qs в %C декларирован так же, как тип в %L"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "Переменная %qs в common блоке %qs в %C должна быть декларирована с C совместимым видом, поскольку common блок %qs является BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "CHARACTER длина должна быть константой в %L"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "CHARACTER выражение в %L усекается (%ld/%ld)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "CHARACTER элементы конструктора массива в %L должны иметь одинаковую длину (%ld/%ld)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Инициализатор не допускается для PARAMETER %qs в %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "PARAMETER в %L остался без инициализатора"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Переменная %qs в %C с инициализатором уже появлялась в DATA операторе"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Невозможно инициализировать parameter массив в %L с элементами переменной длины"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Несоответствие рангов в ссылке на массив в %L (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't initialize implied-shape array at %L with scalar"
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "Невозможно инициализировать массив выводимой формы в %L с помощью скаляра"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs at %L already is initialized at %L"
 msgid "Bad shape of initializer at %L"
 msgstr "%qs в %L уже инициализирован в %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Too many elements in array initializer at %C"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "Слишком много элементов в инициализаторе массива в %C"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Неконстантная нижняя граница декларации выводимой формы в %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "%<I%> at %L and %<J%>' at %L cannot both be BOZ literal constants"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "%<I%> в %L и %<J%> в %L не могут обе быть BOZ литеральными константами"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Компонент в %C должен иметь атрибут POINTER"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Компонент %qs с CLASS в %C должен быть размещаемым или указателем"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Компонент-массив структуры в %C должен иметь явную или отложенную форму"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Компонент %qs в %C уже декларирован в %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Компонент-массив указателей структуры в %C должен иметь отложенную форму"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Размещаемый компонент структуры в %C должен иметь отложенную форму"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Компонент-массив структуры в %C должен иметь явную форму"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "NULL() инициализация в %C неоднозначна"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "NULL() инициализация в %C не может иметь MOLD"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Инициализация указателя в %C не допускается в PURE процедуре"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Ошибка в инициализации указателя в %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "не-NULL инициализация указателя в %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Некорректный символ в имени в %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 #| msgid "Non-PARAMETER symbol %qs at %L can't be implied-shape"
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Не-PARAMETER символ %qs в %L не может быть выводимой формы"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Массив выводимой формы в %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be of INTEGER type, found %s"
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Индекс массива в %L должен быть INTEGER типа, найдено %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %C is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr "%qs в %C есть переопределение декларации в соответствующем интерфейсе для MODULE PROCEDURE %qs"
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy %qs at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Формальный параметр %qs в %L не может иметь инициализатор"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Повторная спецификация массива для Cray указателя в %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "Couldn't set pointee array spec."
 msgid "Cannot set pointee array spec."
 msgstr "Невозможно установить спецификацию указуемого массива"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Старомодная инициализация в %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "некорректная старомодная инициализация для компонента производного типа в %C"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Синтаксическая ошибка в старомодной инициализации %s в %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Инициализация в %C не для указательной переменной"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Инициализация указателя в %C требует %<=>%>, не %<=%>"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Ожидалось инициализационное выражение в %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Инициализация переменной в %C не допускается в PURE процедуре"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Инициализация размещаемого компонента в %C не допускается"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of allocatable component at %C is not allowed"
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "Инициализация размещаемого компонента в %C не допускается"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External %qs at %L cannot have an initializer"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Внешняя %qs в %L не может иметь инициализатор"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Старомодная декларация типа %s*%d не поддерживается в %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Нестандартная декларация типа %s*%d в %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Отсутствует правая скобка в %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Явное инициализационное выражение в %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Ожидалось скалярное инициализационное выражение в %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Вид %d не поддерживается для типа %s в %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "C вид параметра типа задан для типа %s, но тип в %L есть %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Отсутствует правая скобка или запятая в %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Вид %d не поддерживается для CHARACTER в %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Синтаксическая ошибка в CHARACTER декларации в %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, fuzzy, gcc-internal-format
 #| msgid "RECORD at %C is an extension, enable it with -fdec-structure"
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "RECORD в %C является расширением, включите его посредством -fdec-structure"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Имя структуры ожидалось после RECORD в %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Выражение в %L должно быть INTEGER типа, найдено %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "BYTE тип в %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "BYTE тип использованный в %C не доступен на целевой машине"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Предполагаемый тип в %C не допускается для компонентов"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "Предполагаемый тип в %C"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "TYPE с intrinsic-type-spec в %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid type-spec at %C"
 msgid "Malformed type-spec at %C"
 msgstr "Некорректная спецификация типа в %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "DOUBLE COMPLEX в %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Имя типа %qs в %C неоднозначно"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "CLASS оператор в %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "Имя типа %qs в %C конфликтует с ранее декларированной сущностью в %L, которая имеет то же имя"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Повторный IMPLICIT NONE оператор в %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT NONE with spec list at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "IMPORT NONE со списком спецификаций в %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Отсутствует символьный диапазон в IMPLICIT в %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Буквы должны быть в алфавитном порядке в IMPLICIT операторе в %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "IMPLICIT оператор в %C следует за IMPLICIT NONE (тип) оператором"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Пустой IMPLICIT оператор в %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "IMPORT оператор в %C допустим только в INTERFACE теле"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "F2008: C1210 IMPORT оператор в %C не допускается в теле интерфейса процедуры модуля"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "IMPORT оператор в %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 #| msgid "Name %qs at %C is the name of the procedure"
 msgid "import-name %qs at %C is in the local scope"
 msgstr "Имя %qs в %C есть имя процедуры"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "Невозможно IMPORT %qs из единицы компиляции уровня хоста в %C - не существует."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "%qs уже IMPORTed из единицы компиляции уровня хоста в %C."
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Синтаксическая ошибка в IMPORT операторе в %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "F2008: C1210 IMPORT оператор в %C не допускается в теле интерфейса процедуры модуля"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "F2008: C1210 IMPORT оператор в %C не допускается в теле интерфейса процедуры модуля"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Ожидается список именованных сущностей в %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Отсутствует спецификатор коизмерения в %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Отсутствует спецификатор измерения в %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Повторный %s атрибут в %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "ALLOCATABLE атрибут в %C в TYPE определении"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "ALLOCATABLE атрибут в %C в TYPE определении"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute %s at %L in a TYPE definition"
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут %s в %L в TYPE определении"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "ALLOCATABLE атрибут в %C в TYPE определении"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Атрибут в %L не допускается в TYPE определении"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Атрибут в %L не допускается в TYPE определении"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Атрибут %s в %L в TYPE определении"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%s атрибут в %L не допускается вне спецификационной части модуля"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "ASYNCHRONOUS атрибут в %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "CONTIGUOUS атрибут в %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "PROTECTED в %C допускается только в спецификационной части модуля"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "PROTECTED атрибут в %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "VALUE атрибут в %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "VOLATILE атрибут в %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr "match_attr_spec(): Некорректный атрибут"
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Несколько идентификаторов задано с одним NAME= спецификатором в %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "Неявно декларированная BIND(C) функция %qs в %L может не быть C совместимой"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "Переменная %qs в common блоке %qs в %L может не быть C совместимого вида хотя common блок %qs есть BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "Декларация типа %qs at %L не является C совместимой, но является BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "Переменная %qs в %L может не быть C совместимого вида, но является BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "Переменная %qs в common блоке %qs в %L не может быть декларирована с BIND(C), поскольку она не является глобальной"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Переменная %qs в %L не может иметь оба атрибута POINTER и BIND(C)"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "Переменная %qs в %L не может иметь оба атрибута ALLOCATABLE и BIND(C)"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Возвращаемый тип BIND(C) функции %qs в %L не может быть массивом"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "Return type of BIND(C) function %qs at %L cannot be a character string"
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Возвращаемый тип BIND(C) функции %qs в %L не может быть character строкой"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %L is marked PRIVATE but has been given the binding label %qs"
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "Символ %qs в %L помечен как PRIVATE, но получил связывающую метку %qs"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Требуется имя либо сущности либо common блока для оператора спецификации атрибутов в %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Отсутствует имя сущности или common блока для оператора спецификации атрибутов в %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Отсутствует символ"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "BIND(C) оператор в %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "CLASS переменная %qs в %L не может иметь PARAMETER атрибут"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Производный тип в %C не был ранее определен и поэтому не может появляться в определении производного типа"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Синтаксическая ошибка в декларации анонимной структуры в %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Синтаксическая ошибка в декларации данных в %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "MODULE префикс в %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "MODULE PROCEDURE в %C должна быть в generic module interface"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "IMPURE процедура в %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE и IMPURE не должны оба появляться в %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "ELEMENTAL префикс в MODULE интерфейсе отсутствует в %L"
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "PURE префикс в MODULE PROCEDURE интерфейсе отсутствует в %L"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "RECURSIVE префикс в MODULE PROCEDURE интерфейсе отсутствует в %L"
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Left parenthesis required after %<*%>"
 msgid "A type parameter list is required at %C"
 msgstr "Левая скобка требуется после %<*%>"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "Аргумент альтернативного возврата в %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Имя %qs в %C есть имя процедуры"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Неожиданный мусор в списке формальных аргументов в %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Повторяющийся символ %qs в списке формальных аргументов в %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 #| msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "Несоответствие в MODULE PROCEDURE именах формальных аргументов (%s/%s) в %C"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr "Несоответствие в MODULE PROCEDURE именах формальных аргументов (%s/%s) в %C"
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Несоответствие в числе MODULE PROCEDURE формальных аргументов в %C"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "RESULT переменная в %C должна отличаться от имени функции"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Неожиданный мусор после декларации функции в %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "BIND(C) атрибут в %L не может быть специфицирован для внутренней процедуры"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "BIND(C) атрибут в %C требует интерфейс с BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "BIND(C) процедура с NAME не может иметь POINTER атрибут в %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Формальным процедура в %C не может иметь BIND(C) атрибут с NAME"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Процедура %qs в %L уже имеет базовый тип %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Синтаксическая ошибка в операторе PROCEDURE в %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Ожидалось %<::%> после атрибутов связывания в %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "NOPASS или явный интерфейс требуются в %C"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Компонент указатель на процедуру в %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Синтаксическая ошибка в компоненте указателя на процедуру в %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE в %C должна быть в generic интерфейсе"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "двойное двоеточие в MODULE PROCEDURE операторе в %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "PROCEDURE оператор в %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Ожидался список формальный аргументов в определении функции в %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "BIND(C) атрибут в %L может использоваться только для переменных или common блоков"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, fuzzy, gcc-internal-format
 #| msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr "Несоответствие в MODULE PROCEDURE именах формальных аргументов (%s/%s) в %C"
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "ENTRY оператор в %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "ENTRY оператор в %C не может появляться внутри PROGRAM"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "ENTRY оператор в %C не может появляться внутри MODULE"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "ENTRY оператор в %C не может появляться внутри SUBMODULE"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "ENTRY оператор в %C не может появляться внутри BLOCK DATA"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "ENTRY оператор в %C не может появляться внутри INTERFACE"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "ENTRY оператор в %C не может появляться внутри STRUCTURE блока"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "ENTRY оператор в %C не может появляться внутри DERIVED TYPE блока"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "ENTRY оператор в %C не может появляться внутри IF-THEN блока"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "ENTRY оператор в %C не может появляться внутри DO блока"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "ENTRY оператор в %C не может появляться внутри SELECT блока"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "ENTRY оператор в %C не может появляться внутри FORALL блока"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "ENTRY оператор в %C не может появляться внутри WHERE блока"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "ENTRY оператор в %C не может появляться внутри внутренней подпрограммы"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Неожиданный ENTRY оператор в %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "ENTRY оператор в %C не может появляться внутри внутренней процедуры"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Отсутствуют обязательные скобки перед BIND(C) в %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "ENTRY оператор в %C не может появляться внутри внутренней процедуры"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Alternate return cannot appear in operator interface at %L"
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "Альтернативный возврат не может появляться в интерфейсе оператора в %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Некорректный C идентификатор в NAME= спецификаторе в %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Синтаксическая ошибка в NAME= спецификаторе для связывающей метки в %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "NAME= спецификатор в %C должен быть константным выражением"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr "NAME= спецификатор в %C должен быть скаляром подразумеваемого character вида"
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Отсутствует закрывающая скобка для связывающей метки в %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Связывающее имя не допускается в BIND(C) в %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "Для формальной процедуры %s связывающее имя не допускается в BIND(C) в %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "NAME не допускается в BIND(C) для ABSTRACT INTERFACE в %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Неожиданный END оператор в %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "END оператор вместо %s оператора в %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "%s оператор ожидался в %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "Ожидается %s оператор в %L"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Ожидалось имя блока от %qs в %s операторе в %L"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Ожидалось завершающее имя в %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Ожидалась метка %qs для %s оператора в %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Отсутствует спецификация массива в %L в DIMENSION операторе"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Измерения специфицированы для %s в %L после его инициализации"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Отсутствует спецификация массива в %L в CODIMENSION операторе"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Спецификация массива должна быть отложенной в %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Неожиданный символ в списке переменных в %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "Ожидалась %<(%> в %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Ожидалось имя переменной в %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Cray указатель в %C должен быть целым"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Cray указатель в %C имеет %d байт точности; адреса памяти требуют %d байт"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Ожидалась \",\" в %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "Couldn't set Cray pointee array spec."
 msgid "Cannot set Cray pointee array spec."
 msgstr "Невозможно установить Cray спецификацию указуемого массива"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Повторная спецификация массива для Cray указателя в %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Ожидалась \")\" в %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "Ожидалась %<,%> или окончание оператора в %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT не допускается внутри BLOCK в %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "OPTIONAL не допускается внутри BLOCK в %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer declaration at %C requires -fcray-pointer flag"
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Декларация Cray указателя в %C требует -fcray-pointer флаг"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "CONTIGUOUS оператор в %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "Спецификация доступа %s оператора в %C уже была специфицирована"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "PROTECTED оператор в %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Синтаксическая ошибка в PROTECTED операторе в %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "PRIVATE оператор в %C допустим только в спецификационной части модуля"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "PUBLIC оператор в %C допустим только в спецификационной части модуля"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Ожидалось имя переменной в %C в PARAMETER операторе"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Ожидался = знак в PARAMETER операторе в %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Ожидалось выражение в %C в PARAMETER операторе"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Инициализация уже инициализированной переменной в %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr "PARAMETER без '()' в %C"
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Неожиданные символы в PARAMETER операторе в %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Ожидался список сущностей в AUTOMATIC операторе в %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Синтаксическая ошибка в AUTOMATIC операторе в %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Ожидался список сущностей в STATIC операторе в %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Синтаксическая ошибка в STATIC операторе в %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Общий SAVE оператор в %C следует за предыдущим SAVE оператором"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "SAVE оператор в %C следует за общим SAVE оператором"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 #| msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "Извините, !$ACC DECLARE в %L не допускается в конструкции BLOCK"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Синтаксическая ошибка в SAVE операторе в %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "VALUE не допускается внутри BLOCK в %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "VALUE оператор в %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Синтаксическая ошибка в VALUE операторе в %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "VOLATILE оператор в %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "Задание VOLATILE для комассивной переменной %qs в %C, которая является use-/host-associated"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Синтаксическая ошибка в VOLATILE операторе в %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "ASYNCHRONOUS оператор в %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Синтаксическая ошибка в ASYNCHRONOUS операторе в %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "MODULE PROCEDURE декларация в %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE в %C должна быть в generic module interface"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "Встроенная процедура в %L не может быть MODULE PROCEDURE"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Неоднозначный символ в TYPE определении в %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Символ %qs в %C не был ранее определен"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "%qs в EXTENDS выражении в %C не есть производный тип"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "%qs не может быть расширено в %C, поскольку оно BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qs не может быть расширено в %C, поскольку оно SEQUENCE тип"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Производный тип в %C может быть только PRIVATE в спецификационной части модуля"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Производный тип в %C может быть только PUBLIC в спецификационной части модуля"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "ABSTRACT тип в %C"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Не удалось создать тип структуры '%s' в %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Определение типа %qs в %C уже было определено в %L"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "Мусор после MAP оператора в %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Мусор после UNION оператора в %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%s в %C является DEC расширением, включите его посредством %<-fdec-structure%>"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Имя структуры ожидалось в декларации невложенной структуры в %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Мусор после невложенного STRUCTURE оператора в %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Имя структуры %qs в %C не может быть тем же, что у встроенного типа"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Ожидалось :: в TYPE определении в %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CONTAINS block in derived type definition at %C"
 msgid "Mangled derived type definition at %C"
 msgstr "CONTAINS блок в определении производного типа в %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Имя типа в %qs в %C не может быть тем же, что у встроенного типа"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Имя производного типа %qs в %C уже имеет базовый тип в %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr ""
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Формальный аргумент %qs в %L не может быть OPTIONAL"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "Определение производного типа %qs at %C уже было определено"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Cray указуемое в %C не может быть массивом предполагаемой формы"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "ENUM и ENUMERATOR в %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Перечислитель превосходит целый тип C в %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L не инициализирован целым выражением"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "ENUM оператор определения ожидался до %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Синтаксическая ошибка в ENUMERATOR определении в %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Повторный спецификатор доступа в %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Связывающие атрибуты уже специфицировали passing, некоректный NOPASS в %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Связывающие атрибуты уже специфицировали passing, некоректный PASS в %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Повторный POINTER атрибут в %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Повторный NON_OVERRIDABLE в %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "Повторный DEFERRED в %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Ожидался спецификатор доступа в %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Ожидался связывающий атрибут в %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NON_OVERRIDABLE and DEFERRED can't both appear at %C"
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE и DEFERRED не могут оба появляться в %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "POINTER атрибут требуется для компонента указателя на процедуру в %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Имя интерфейса ожидалось после %<(%> в %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "%<)%> ожидалась в %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Интерфейс должен быть специфицирован для DEFERRED связывания в %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDURE(interface) at %C следует декларировать DEFERRED"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Ожидалось связывающее имя в %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "PROCEDURE список в %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%<=> target%> некорректно для DEFERRED связывания в %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "%<::%> требуется в PROCEDURE связывании с явной целью в %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Ожидалась цель связывания после %<=>%> в %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "Тип %qs, содержащий DEFERRED связывание в %C, не есть ABSTRACT"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Уже есть процедура со связывающим именем %qs для производного типа %qs в %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "Ожидалось %<::%> в %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Ожидалось generic имя или дескриптор оператора в %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Некорректная форма GENERIC оператора в %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "Ожидалось %<=>%> в %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Range specification at %L can never be matched"
 msgid "The access specification at %L not in a module"
 msgstr "Спецификации диапазона в %L невозможно найти соответствие"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Уже есть не-generic процедура со связывающим именем %qs для производного типа %qs в %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "Спецификация доступа %s оператора в %C уже была специфицирована"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "Спецификация доступа %s оператора в %C уже была специфицирована"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding %qs"
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "Связывание в %C должно иметь тот же доступ, что и уже определенное связывание %qs"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected module procedure name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Ожидалось имя модульной процедуры в %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 #| msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%qs уже определено как конкретное связывание для generic %qs в %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after UNION statement at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Мусор после UNION оператора в %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "GENERIC в %C должно быть внутри производного типа CONTAINS"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Уже есть не-generic процедура со связывающим именем %qs для производного типа %qs в %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "Связывание в %C должно иметь тот же доступ, что и уже определенное связывание %qs"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Ожидалось конкретное связывающее имя в %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%qs уже определено как конкретное связывание для generic %qs в %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Мусор после GENERIC связывания в %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "FINAL декларация в %C должна быть внутри секции CONTAINS производного типа"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "Декларация производного типа с FINAL в %C должна быть в спецификационной части модуля"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "Пустое FINAL в %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Ожидалось имя модульной процедуры в %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "Ожидалась %<,%> в %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Неизвестное имя процедуры %qs в %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr ""
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Неизвестный атрибут в !GCC$ ATTRIBUTES операторе в %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Синтаксическая ошибка в !GCC$ ATTRIBUTES операторе в %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr ""
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in !$ACC DECLARE list at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Синтаксическая ошибка в !$ACC DECLARE списке в %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in !$ACC DECLARE list at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Синтаксическая ошибка в !$ACC DECLARE списке в %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in !$ACC DECLARE list at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -81893,414 +82069,414 @@ msgstr "IMPURE процедура в %C"
 msgid "IM part_ref at %C"
 msgstr "MODULE префикс в %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "аргументы элементной функции в %C ненадлежащие"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Числовые или CHARACTER операнды требуются в выражении в %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Оператор конкатенации в выражении в %L должен иметь два CHARACTER операнда"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Оператор конкатенации в выражении в %L должен конкатенировать строки одного вида"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "LOGICAL операнды требуются в выражении в %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Только встроенные операторы могут использоваться в выражении в %L"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Числовые операнды требуются в выражении в %L"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Некорректное инициализационное выражение для ALLOCATABLE компонента %qs в конструкторе структуры в %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Переменная предполагаемой или отложенной character длины %qs в константном выражении в %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационная встроенная функция %qs в %L не разрешена в инициализационном выражении"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Вычисление нестандартного инициализационного выражения в %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "Функция %qs в инициализационном выражении в %L должна быть встроенной функцией"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "Встроенная функция %qs в %L не разрешена в инициализационном выражении"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "PARAMETER %qs использован в %L до завершения его определения"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "Массив предполагаемого размера %qs в %L не разрешен в инициализационном выражении"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Массив предполагаемой формы %qs в %L не разрешен в инициализационном выражении"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Массив предполагаемой формы %qs в %L не разрешен в инициализационном выражении"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "Отложенный массив %qs в %L не разрешен в инициализационном выражении"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Массив %qs в %L является переменной, которая не сводится к константному выражению"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "Массив предполагаемой формы %qs в %L не разрешен в инициализационном выражении"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Parameter %qs at %L не был декларирован или является переменной, которая не сводится к константному выражению"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "check_init_expr(): Неизвестный тип выражения"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Спецификационная функция %qs в %L не может быть оператор-функцией"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Спецификационная функция %qs в %L не может быть внутренней функцией"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Спецификационная функция %qs в %L должна быть PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Спецификационная функция %qs в %L не может быть RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Формальный аргумент %qs не допускается в выражении в %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Формальный аргумент %qs в %L не может быть OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Формальный аргумент %qs в %L не может быть INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Переменная %qs не может появляться в выражении в %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "check_restricted(): Неизвестный тип выражения"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Выражение в %L должно быть INTEGER типа, найдено %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "Функция %qs в %L должна быть PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Выражение в %L должно быть скалярным"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Несовместимые ранги в %s (%d и %d) в %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Иная форма для %s в %L по измерению %d (%d и %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "использование параметра шаблона %qT после %qs"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "Присваивание полиморфному комассиву в %L не допускается"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs в %L не есть VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Некорректный нулевой шаг в %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Несовместимые ранги %d и %d в присваивании в %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Тип переменной UNKNOWN в присваивании в %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL появляется в правой части присваивания в %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Функция с POINTER-значением появляется в правой части присваивания в %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Несовместимые типы в DATA операторе в %L; попытка преобразования %s в %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Цель указательного присваивания не есть POINTER в %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "%qs в указательном присваивании в %L не может быть l-value, поскольку это процедура"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Ожидалась спецификация границ для %qs в %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Спецификация границ для %qs в указательном присваивании в %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "Шаг не может присутствовать в %L"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Указательный объект в %L не должен иметь коиндекс"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Некорректное присваивание указателя на процедуру в %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Результат функции %qs некорректен как процедурная цель в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Абстрактный интерфейс %qs некорректен в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Оператор-функция %qs некорректна в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Внутренняя процедура %qs некорректна в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Встроенная функция %qs в %L некорректна в присваивании указателя на процедуру"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Невстроенная элементная процедура %qs некорректна в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "Несоответствие в присваивании указателя на процедуру в %L: несоответствие в соглашении о вызове"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Несоответствие интерфейсов в присваивании указателя на процедуру в %L: %qs не есть подпрограмма"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Явный интерфейс требуются для компонента %qs в %L: %s"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Явный интерфейс требуются для %qs в %L: %s"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Несоответствие интерфейсов в присваивании указателя на процедуру в %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr "Цель указателя на процедуру %qs в %L должна быть встроенной функцией, host или use ассоциированной, на нее должна быть ссылка или она должна иметь EXTERNAL атрибут"
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Цель указательного присваивания не есть POINTER в %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr "Data-pointer-object в %L должен быть неограниченно полиморфным или иметь тип с BIND или SEQUENCE атрибутами, чтобы быть совместимым с неограниченно полиморфной целью"
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Разные типа в присваивании указателя в %L; попытка присвоить %s в %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Разные виды типовых параметров в присваивании указателя в %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Разные ранги в присваивании указателя в %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "Цель переотображения ранга меньше чем размер указателя (%ld < %ld) в %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "Цель переотображения ранга должна быть ранга 1 или просто непрерывна в %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Цель, переотображающая ранг, не ранга 1 в %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The assumed-rank array at %C shall not have a codimension"
 msgid "The assumed rank data-target at %L must be contiguous"
@@ -82309,209 +82485,209 @@ msgstr "Массив предполагаемой размерности в %C 
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "Целевые данные в %L не должны иметь коиндекс"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "Целевое выражение в присваивании указателя в %L должна выдавать указательный результат"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "Цель инициализации указателя в %L должна иметь TARGET атрибут"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NAME= specifier at %C should be a constant expression"
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "NAME= спецификатор в %C должен быть константным выражением"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Цель присваивания указателя не TARGET и не POINTER в %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Некорректная цель в присваивании указателя в PURE процедуре в %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Присваивание указателя с индексом вектора в правой части в %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Цель присваивания указателя имеет PROTECTED атрибут в %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "Указатель в %L в присваивании указателя может пережить цель указателя"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "Цель инициализации указателя в %L не должна быть ALLOCATABLE"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "Цель инициализации указателя в %L должна иметь TARGET атрибут"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Цель инициализации указателя в %L должна иметь SAVE атрибут"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "Цель инициализации указателя на процедуру в %L не может быть указателем на процедуру"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Внутренняя процедура %qs некорректна в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Внутренняя процедура %qs некорректна в присваивании указателя на процедуру в %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008: Указательные функции в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Non-variable выражение в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "Именованная константа %qs в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%qs в контексте определения переменных (%s) в %L не есть переменная"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Non-POINTER в контексте ассоциации указателей (%s) в %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "Тип недоступен в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "Named constant %qs in variable definition context (%s) at %L"
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "Именованная константа %qs в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "Формальный аргумент %qs с INTENT(IN) в контексте ассоциации указателей (%s) в %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "Формальный аргумент %qs с INTENT(IN) в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs is PROTECTED and can not appear in a pointer association context (%s) at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Переменная %qs является PROTECTED и не может появляться в контексте ассоциации указателей (%s) в %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs is PROTECTED and can not appear in a variable definition context (%s) at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "Переменная %qs является PROTECTED и не может появляться в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs can not appear in a variable definition context (%s) at %L in PURE procedure"
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Переменная %qs не может появляться в контексте определения переменных (%s) в %L"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L associated to vector-indexed target can not be used in a variable definition context (%s)"
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "%qs в %L ассоциированное с векторно индексированной целью не может использоваться в контексте определения переменных (%s)"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L associated to expression can not be used in a variable definition context (%s)"
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "%qs в %L ассоциированное с выражением не может использоваться в контексте определения переменных (%s)"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L associated to expression can not be used in a variable definition context (%s)"
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "%qs в %L ассоциированное с выражением не может использоваться в контексте определения переменных (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 #| msgid "Associate-name %qs can not appear in a variable definition context (%s) at %L because its target at %L can not, either"
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Имя ассоциации %qs не может появляться в контексте определения переменных (%s) в %L, поскольку его цель в %L также не может"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "Элементы с одинаковым значением в %L и %L в векторном индексе в контексте определения переменной (%s)"
@@ -82534,7 +82710,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr "Некорректный идентификатор в copy_walk_reduction_arg"
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -82600,42 +82776,42 @@ msgstr "Переменная %qs в %L установлена в неопред
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "Переменная %qs в %L не определяется внутри цикла, начинающегося в %L, как INTENT(OUT) аргумент для подпрограммы %qs"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "Переменная %qs в %L установлена в неопределенное значение внутри цикла, начинающегося в %L, как INTENT(OUT) аргумент для функции %qs"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "Переменная %qs в %L не определяется внутри цикла, начинающегося в %L, как INTENT(OUT) аргумент для функции %qs"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr "Код для переразмещения размещаемого массива в %L будет добавлен"
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr "Скаляризация, использующая DIMEN_RANGE, не реализована"
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "%s between %L and %L"
@@ -82762,12 +82938,12 @@ msgstr "Первый аргумент определенного присваи
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Второй аргумент определенного присваивания в %L должен быть INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Первый аргумент интерфейса оператора в %L должен быть INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Второй аргумент интерфейса оператора в %L должен быть INTENT(IN)"
@@ -83212,310 +83388,316 @@ msgstr "Фактический аргумент для %qs должен быть
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "Фактический аргумент секция массива с векторными индексами в %L несовместим с INTENT(OUT), INTENT(INOUT), VOLATILE или ASYNCHRONOUS атрибутом формального аргумента %qs"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Фактический аргумент предполагаемой формы в %L несовместим с non-assumed-shape формальным аргументом %qs из-за VOLATILE атрибута"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Фактический аргумент секция массива в %L несовместим с non-assumed-shape формальным аргументом %qs из-за VOLATILE атрибута"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "Фактический аргумент pointer-array в %L требует assumed-shape или pointer-array формальный аргумент %qs из-за VOLATILE атрибута"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of assumed type"
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "Фактический аргумент предполагаемого типа в %L требует, чтобы формальный аргумент %qs был предполагаемого типа"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Отсутствует спецификация альтернативного возврата в вызове подпрограммы в %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Отсутствует фактический аргумент для аргумента %qs в %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "compare_actual_expr(): Некорректный код компонента"
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr "check_some_aliasing(): Несоответствие списка"
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr "check_some_aliasing(): поврежденные данные"
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Один и тот же фактический аргумент ассоциирован с INTENT(%s) аргументом %qs и INTENT(%s) аргументом %qs в %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr "check_intents(): Несоответствие списка"
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Аргумент процедуры в %L локален в PURE процедуре и имеет POINTER атрибут"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Коиндексированный фактический аргумент в %L в процедуре PURE передан в аргумент INTENT(%s)"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Коиндексированный фактический аргумент в %L в PURE процедуре передан в POINTER формальный аргумент"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Коиндексированный полиморфный фактический аргумент в %L передан в полиморфный формальный аргумент %qs"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr ""
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Процедура %qs вызванная в %L не декларирована явно"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Процедура %qs вызвана с неявным интерфейсом в %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Указательный объект %qs в %L должен иметь явный функциональный интерфейс или быть декларированным как массив"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Размещаемый объект %qs в %L должен иметь явный функциональный интерфейс или быть декларированным как массив"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Размещаемая функция %qs в %L должна иметь явный функциональный интерфейс"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Explicit interface required for component %qs at %L: %s"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Явный интерфейс требуются для компонента %qs в %L: %s"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Аргумент с ключевым словом требует явный интерфейс для процедуры %qs в %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Аргумент предполагаемого типа %s в %L требует явный интерфейс"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Фактический аргумент LOCK_TYPE или с LOCK_TYPE компонентом в %L требует явный интерфейс для процедуры %qs"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Фактический аргумент EVENT_TYPE или с EVENT_TYPE компонентом в %L требует явный интерфейс для процедуры %qs"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "MOLD аргумент в NULL требуется в %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Аргумент предполагаемого типа %s в %L требует явный интерфейс"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Аргумент предполагаемого ранга требует явный интерфейс в %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Компонент указатель на процедуру %qs вызван с неявным интерфейсом в %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "Аргумент с ключевым словом требует явный интерфейс для компонента указателя на процедуру %qs в %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "MOLD= требуется в NULL() аргументе в %L: Неоднозначность между конкретными функциями %s и %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "Не удается найти символ %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Сущность %qs в %L уже присутствует в интерфейсе"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "gfc_add_interface(): Некорректный тип интерфейса"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 #| msgid "Can't overwrite GENERIC %qs at %L"
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "Не удалось перебить GENERIC %qs в %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%qs в %L перебивает связывание процедуры декларированной NON_OVERRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "%qs в %L не должно быть DEFERRED, поскольку это перебивает не-DEFERRED связывание"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%qs в %L перебивает PURE процедуру и должна также быть PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%qs в %L перебивает ELEMENTAL процедуру и должна также быть ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%qs в %L перебивает не-ELEMENTAL процедуру и не должна быть ELEMENTAL, также"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%qs в %L перебивает SUBROUTINE и должна также быть SUBROUTINE"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%qs в %L перебивает FUNCTION и должна также быть FUNCTION"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Несоответствие результатов для перебивающей процедуры %qs в %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%qs в %L перебивает PUBLIC процедуру и не должна быть PRIVATE"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "Формальный аргумент %qs от %qs в %L должен именоваться %qs, чтобы подходить соответствующему аргументу перебиваемой процедуры"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Несоответствие аргументов для перебивающей процедуры %qs в %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "%qs в %L должен иметь то же число формальных аргументов, что и перебиваемая процедура"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%qs в %L перебивает NOPASS связывание и должен также быть NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%qs в %L перебивает связывание с PASS и должен также быть PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "Passed-object формальный аргумент от %qs в %L должен быть на той же позиции, что и passed-object формальный аргумент перебиваемой процедуры"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "DTIO формальный аргумент в %L должен быть типа %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "DTIO формальный аргумент в %L должен быть KIND = %d"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "DTIO формальный аргумент в %L должен быть скаляром"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "DTIO формальный аргумент в %L должен быть ASSUMED SHAPE ARRAY"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr ""
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "DTIO формальный аргумент в %L должен иметь INTENT %s"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "Альтернативный возврат в %L не допускается в DTIO процедуре"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "DTIO процедура %qs в %L должна быть подпрограммой"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Слишком мало формальных аргументов в DTIO процедуре %qs в %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "Слишком много формальных аргументов в DTIO процедуре %qs в %L"
@@ -83716,7 +83898,7 @@ msgstr "Преобразование из %s в %s в %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -84300,7 +84482,7 @@ msgstr "NAMELIST %qs в READ операторе в %L содержит симв
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "NAMELIST объект %qs в списке имен %qs в %L является полиморфным и требует определенную процедуру ввода/вывода"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "NAMELIST объект %qs в списке имен %qs в %L с ALLOCATABLE или POINTER компонентами"
@@ -84482,12 +84664,12 @@ msgstr "Переполнение при вычислении целочисле
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -85019,7 +85201,7 @@ msgstr "STOP код в %L должен быть default character KIND=%d"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "STOP код в %L должен быть default integer KIND=%d"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -85545,97 +85727,97 @@ msgstr "Ожидалось имя блока %qs SELECT конструкции 
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "SUBMODULE декларация в %C не может появляться внутри другой области видимости"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "ошибка разбора в SELECT TYPE операторе в %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "Селектор в SELECT TYPE в %C не есть именованная переменная; используйте associate-name=>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOCK statement at %C"
 msgid "SELECT RANK statement at %C"
 msgstr "LOCK оператор в %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parse error in SELECT TYPE statement at %C"
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "ошибка разбора в SELECT TYPE операторе в %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Неожиданный CASE оператор в %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Синтаксическая ошибка в CASE спецификации в %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Неожиданный TYPE IS оператор в %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr "Спецификация типа не должна специфицировать sequence производный тип или тип с BIND атрибутом в SELECT TYPE в %C [F2003:C815]"
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Синтаксическая ошибка в TYPE IS спецификации в %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Синтаксическая ошибка в CLASS IS спецификации в %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "Неожиданный END оператор в %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "FORALL шаговое выражение в %L должно быть скаляром %s"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE specification at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "Синтаксическая ошибка в CASE спецификации в %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "ELSEWHERE оператор в %C не заключен в WHERE блок"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "Метка %qs в %C не соответствует WHERE метке %qs"
@@ -86692,7 +86874,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAFELEN clause at %L requires a scalar INTEGER expression"
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
@@ -86731,12 +86913,12 @@ msgstr "%<nonmonotonic%> модификатор планирования зад
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Неожиданный мусор после $OMP FLUSH оператора в %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr "Переопределение предопределенной %s !$OMP DECLARE REDUCTION в %L"
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr "Переопределение предопределенной !$OMP DECLARE REDUCTION в %L"
@@ -87257,7 +87439,7 @@ msgstr "Неожиданный мусор после NOWAIT клаузулы в
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "%s клаузула в %L требует скалярное INTEGER выражение"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "INTEGER выражение клаузулы %s в %L должен быть положительным"
@@ -87277,7 +87459,7 @@ msgstr "Cray pointer object %qs производного типа в %s клау
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Cray pointee object %qs производного типа в %s клаузуле в %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "POINTER объект %qs полиморфного типа в %s клаузуле в %L"
@@ -87307,17 +87489,17 @@ msgstr "Массив предполагаемого ранга %qs в %s кла
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "POINTER объект %qs в %s клаузуле в %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Cray pointer object %qs в %s клаузуле в %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Cray pointee object %qs в %s клаузуле в %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "ALLOCATABLE объект %qs в %s клаузуле в %L"
@@ -87443,8 +87625,8 @@ msgstr "параметр ORDERED клаузулы меньше чем COLLAPSE 
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "IF клаузула в %L требует скалярное LOGICAL выражение"
@@ -87528,7 +87710,7 @@ msgstr "Объект %qs не есть переменная в %L"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "Объект %qs не есть переменная в %L"
@@ -87553,7 +87735,7 @@ msgstr "LINEAR клаузула задана вместе с ORDERED клауз
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "Символ %qs присутствует в нескольких клаузулах в %L"
@@ -87596,7 +87778,7 @@ msgstr "Символ %qs присутствует и в FROM и в TO клауз
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE многократно встречается в предложении %<aligned%>"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -87930,636 +88112,646 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr "!$OMP DECLARE REDUCTION %s не найден для типа %s в %L"
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr "модификатор LINEAR клаузулы использован в DO или SIMD конструкции в %L"
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr "модификатор LINEAR клаузулы использован в DO или SIMD конструкции в %L"
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "LINEAR переменная %qs должна быть INTEGER в %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "LINEAR формальный аргумент %qs с VALUE атрибутом с %s модификатором в %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%qs в LINEAR клаузуле в %L требует скалярное integer выражение линейного шага"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%qs в LINEAR клаузуле в %L требует скалярное integer выражение линейного шага или формальный аргумент заданный в UNIFORM клаузуле"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "переменная %s клаузулы %qs в %L не POINTER и не массив"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the value of %qD is not usable in a constant expression"
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "значение %qD не может использоваться в константном выражении"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "chunk_size из DIST_SCHEDULE клаузулы в %L требует скалярного INTEGER выражения"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Несовместимое использование TILE и COLLAPSE в %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s must contain at least one MAP clause at %L"
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "%s должен содержать хотя бы одну MAP клаузулу в %L"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%s должен содержать хотя бы одну MAP клаузулу в %L"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "SIZES requires constant expression at %L"
 msgstr "TILE требует константное выражение в %L"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The event variable at %L shall not be coindexed"
 msgid "The event handle at %L must not be an array element"
 msgstr "event переменная в %L не должен быть коиндексирована"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The event variable at %L shall not be coindexed"
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "event переменная в %L не должен быть коиндексирована"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "%<nowait%> предложение не может использоваться вместе с %<copyprivate%>"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp target data%> must contain at least one %<map%> clause"
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr "%<#pragma omp target data%> должна содержать хотя бы одну %<map%> клаузулу"
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Ожидалось скалярное инициализационное выражение в %C"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC оператор должен устанавливать скалярную переменную встроенного типа в %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "!$OMP ATOMIC оператор должен устанавливать скалярную переменную встроенного типа в %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "!$OMP ATOMIC с ALLOCATABLE переменной в %L"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC READ оператор должен читать из скалярной переменной встроенного типа в %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr в !$OMP ATOMIC WRITE присваивании var = expr должно быть скалярным и не может ссылаться на var в %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC оператор должен устанавливать скалярную переменную встроенного типа в %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC CAPTURE capture statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC CAPTURE capture оператор должен устанавливать скалярную переменную встроенного типа в %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "!$OMP ATOMIC CAPTURE capture оператор читает не из той переменной, в которую update оператор пишет в %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, fuzzy, gcc-internal-format
 #| msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "!$OMP ATOMIC CAPTURE capture оператор читает не из той переменной, в которую update оператор пишет в %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr в !$OMP ATOMIC WRITE присваивании var = expr должно быть скалярным и не может ссылаться на var в %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "!$OMP ATOMIC присваивание должно быть var = var op expr или var = expr op var в %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP ATOMIC var = var op expr не эквивалентно математически var = var op (expr) в %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "expr в !$OMP ATOMIC присваивании var = var op expr должно быть скалярным и не может ссылаться на var в %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "!$OMP ATOMIC присваивание встроенные IAND, IOR или IEOR должны иметь два аргумента в %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "!$OMP ATOMIC присваивание встроенные должны быть MIN, MAX, IAND, IOR или IEOR в %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "!$OMP ATOMIC аргументы встроенных функций кроме одного не должны ссылаться на %qs в %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "!$OMP ATOMIC аргументы встроенных должны быть скалярами в %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Первый или последний !$OMP ATOMIC аргумент встроенной функции должен быть %qs в %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "!$OMP ATOMIC присваивание должно иметь оператор или встроенную в правой части в %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Неожиданное !$OMP ATOMIC выражение в %L"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr "модификатор LINEAR клаузулы использован в DO или SIMD конструкции в %L"
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%s не может быть DO WHILE или DO без управления циклом в %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr "%s не может быть DO CONCURRENT циклом в %L"
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "%s итерационная переменная должна быть типа integer в %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "%s итерационная переменная не должна быть THREADPRIVATE в %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "%s итерационная переменная присутствует в клаузуле отличной от PRIVATE и LASTPRIVATE в %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "%s итерационная переменная присутствует в клаузуле отличной от PRIVATE и LASTPRIVATE в %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s iteration variable must be of type integer at %L"
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "%s итерационная переменная должна быть типа integer в %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "iteration variable %qE should not be reduction"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "итерационная переменная %qE не должна быть редукцией"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad kind expression for function %qs at %L"
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "Некорректное выражение вида для функции %qs в %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "condition expression refers to iteration variable %qD"
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "выражение условия ссылается на итерационную переменную %qD"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "not enough DO loops for collapsed %s at %L"
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "недостаточно DO циклов для сжатого %s в %L"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "%s !$ACC LOOP циклы не идеально вложены в %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "%s !$ACC LOOP циклы не идеально вложены в %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "%qs length expression must be positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "%qs выражение длины должно быть положительным константным целочисленным выражением"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "значение %<priority%> должен быть неотрицательным"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "property must be a logical expression at %L"
 msgstr "выражение %qE не является константным выражением"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Repeat spec must be an integer at %C"
 msgid "property must be an integer expression at %L"
 msgstr "Repeat spec должна быть integer в %C"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expression %qE is not a constant expression"
 msgid "property must be a constant logical expression at %L"
 msgstr "выражение %qE не является константным выражением"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs length expression must be positive constant integer expression"
 msgid "property must be a constant integer expression at %L"
 msgstr "%qs выражение длины должно быть положительным константным целочисленным выражением"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr "Директива %s не может задаваться внутри %s области в %L"
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$ACC LOOP не может быть DO WHILE или DO без управления циклом в %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "%s не может быть DO CONCURRENT циклом в %L"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "!$ACC LOOP итерационная переменная должна быть типа integer в %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "!$ACC LOOP %s циклы не образуют прямоугольное итерационное пространство в %L"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "%s !$ACC LOOP циклы не идеально вложены в %L"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "недостаточно DO циклов для %s !$ACC LOOP в %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr "Мозаичный цикл не может быть распараллелен по совокупностям, исполнителям и векторам одновременно в %L"
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "TILE требует константное выражение в %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "Секции массивов: %qs не допускается в !$ACC DECLARE в %L"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C"
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Синтаксическая ошибка в !$ACC ROUTINE ( NAME ) в %C"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C"
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Синтаксическая ошибка в !$ACC ROUTINE ( NAME ) в %C"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr "OMP TARGET UPDATE в %L требует хотя бы одну TO или FROM клаузулу"
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr "!$OMP DECLARE SIMD должна ссылаться на объемлющую процедуру %qs в %L"
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "ожидалось целочисленное выражение"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ORDERED clause argument not constant positive integer at %C"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Аргумент ORDERED клаузулы не есть положительная целая константа в %C"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Переменная отличная от OMP_PRIV или OMP_ORIG использована в INITIALIZER клаузуле от !$OMP DECLARE REDUCTION в %L"
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Переменная отличная от OMP_OUT или OMP_IN использована в объединителе от !$OMP DECLARE REDUCTION в %L"
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr "Некорректный оператор для !$OMP DECLARE REDUCTION %s в %L"
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr "CHARACTER длина в !$OMP DECLARE REDUCTION %s не константа в %L"
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Вызов подпрограммы с альтернативными возвратами в объединителе от !$OMP DECLARE REDUCTION в %L"
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Вызов подпрограммы с альтернативными возвратами в INITIALIZER клаузуле от !$OMP DECLARE REDUCTION в %L"
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr "Один из фактических аргументов подпрограммы в INITIALIZER клаузуле от !$OMP DECLARE REDUCTION должен быть OMP_PRIV в %L"
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr "Отсутствует INITIALIZER клаузула для !$OMP DECLARE REDUCTION производного типа без подразумеваемого инициализатора в %L"
@@ -89244,63 +89436,63 @@ msgstr "%<GCC unroll%> директива не запускает цикл в %C
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr "%<GCC unroll%> директива не запускает цикл в %C"
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Внутренняя процедура %qs в %C уже неоднозначна"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Неожиданный %s оператор в CONTAINS секции в %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "CONTAINS оператор без FUNCTION или SUBROUTINE оператора в %L"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C after the first executable statement"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "DATA оператор в %C после первого выполняемого оператора"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "CONTAINS оператор в %C уже во внутренней программной единице"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Глобальное связывающее имя %qs в %L уже используется как %s в %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Глобальное имя %qs в %L уже используется как %s в %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Глобальное связывающее имя %qs в %L уже используется в %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Глобальное имя %qs в %L уже используется в %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "Пустой BLOCK DATA в %C конфликтует с предыдущим BLOCK DATA в %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Неожиданный %s оператор в BLOCK DATA в %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Неожиданный %s оператор в MODULE в %C"
@@ -89308,7 +89500,7 @@ msgstr "Неожиданный %s оператор в MODULE в %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Две главные программы в %L и %C"
@@ -89787,1144 +89979,1144 @@ msgstr "Символ %qs должен быть PARAMETER в DATA операто
 msgid "%qs at %C is not a variable"
 msgstr "%qs в %C не является переменной"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs в %L имеет ABSTRACT тип %qs"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "ABSTRACT тип %qs использован в %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "Интерфейс %qs в %L объявлен в более позднем PROCEDURE операторе"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "Интерфейс %qs в %L не может быть generic"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Интерфейс %qs в %L не может быть оператором-функцией"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Встроенная процедура %qs не допускается в операторе PROCEDURE в %L"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "Интерфейс %qs в %L должен быть явным"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROCEDURE %qs в %L не может быть использована в качестве своего собственного интерфейса"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Спецификатор альтернативного возврата в элементной подпрограмме %qs в %L не допускается"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Спецификатор альтернативного возврата в функции %qs в %L не допускается"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Ссылающийся на себя аргумент %qs в %L не допускается"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Формальная процедура %qs PURE процедуры в %L должна также быть PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Аргумент %qs pure функции %qs в %L с VALUE атрибутом, но без INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "Аргумент %qs pure функции %qs в %L должен быть INTENT(IN) или VALUE"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Аргумент %qs pure подпрограммы %qs в %L с VALUE атрибутом, но без INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Аргумент %qs pure подпрограммы %qs в %L должен иметь свой INTENT специфицированным или иметь VALUE атрибут"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "INTENT(OUT) argument %qs pure процедуры %qs в %L не может быть полиморфным"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Комассивный формальный аргумент %qs в %L для элементной процедуры"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Аргумент %qs элементной процедуры в %L должен быть скаляром"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Аргумент %qs элементной процедуры в %L не может иметь ALLOCATABLE атрибут"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Аргумент %qs элементной процедуры в %L не может иметь POINTER атрибут"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "Формальная процедура %qs не допускается в элементной процедуре %qs в %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Аргумент %qs pure подпрограммы %qs в %L должен иметь свой INTENT специфицированным или иметь VALUE атрибут"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function '%s' at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Аргумент '%s' функции-оператора '%s' в %L должен быть скаляром"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Аргумент с character значением %qs оператор функции в %L должен иметь константную длину"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Внутренняя процедура %qs в %L имеет то же имя, что и объемлющая процедура"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Внутренняя функция %qs в %L не имеет IMPLICIT тип"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Результат %qs внутренней функции %qs в %L не имеет IMPLICIT тип"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Процедура модуля с character значением %qs в %L не должна быть предполагаемой длины"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Внутренняя функция с character значением %qs в %L не должна быть предполагаемой длины"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Функция %s в %L имеет входы с несоответствующими спецификациями массивов"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function %s at %L has entries with mismatched array specifications"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "Функция %s в %L имеет входы с несоответствующими спецификациями массивов"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "Функция %s at %L с входами, возвращающими переменные с разными длинами строк"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "FUNCTION результат %s не может быть массивом в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "ENTRY результат %s не может быть массивом в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "FUNCTION результат %s не может быть POINTER в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "ENTRY результат %s не может быть POINTER в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "FUNCTION результат %s не может быть POINTER в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "ENTRY результат %s не может быть POINTER в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "FUNCTION результат %s не может быть типа %s в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "ENTRY результат %s не может быть типа %s в FUNCTION %s в %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Символ %qs в %C уже в COMMON блоке"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Символ %qs в %C уже в COMMON блоке"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COMMON block /%s/ not found at %C"
 msgid "COMMON block at %L"
 msgstr "COMMON блок /%s/ не найден в %C"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "Переменная %qs в %L находится в COMMON, но допустима только инициализация в BLOCK DATA"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "Инициализированная переменная %qs в %L находится в безымянном COMMON, но инициализация допустима только в именованных common блоках"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, fuzzy, gcc-internal-format
 #| msgid "%qs in cannot appear in COMMON at %L [F2008:C5100]"
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "%qs не может появляться в COMMON в %L [F2008:C5100]"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 #| msgid "Allocate-object at %L also appears at %L"
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Allocate-object в %L также появляется в %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "Переменная производного типа %qs в COMMON в %L не имеет ни SEQUENCE ни BIND(C) атрибута"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "Переменная производного типа %qs в COMMON в %L имеет окончательный компонент, который является размещаемым"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "Переменная производного типа %qs в COMMON в %L не может иметь подразумеваемый инициализатор"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr "В Fortran 2003 COMMON %qs блок в %L есть глобальный идентификатор и должен поэтому иметь то же связывающее имя, что и одноименный COMMON блок в %L: %s против %s"
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "COMMON блок %qs в %L использует тот же глобальный идентификатор, что и сущность в %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "Fortran 2008: COMMON блок %qs со связывающей меткой в %L, разделяющий идентификатор с глобальной не-COMMON-блок сущностью в %L"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "COMMON блок в %L со связывающей меткой %qs использует тот же глобальный идентификатор, что и сущность в %L"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "COMMON блок %qs в %L использован как PARAMETER в %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block %qs at %L can not have the EXTERNAL attribute"
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "COMMON блок %qs в %L не может иметь EXTERNAL атрибут"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "COMMON блок %qs в %L является также встроенной процедурой"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "COMMON блок %qs в %L, который является также результатом функции"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "COMMON блок %qs в %L, который является также глобальной процедурой"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr "У параметра KIND %qs в конструкторе PDT в %C отсутствует значение"
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Ранг элемента в конструкторе структуры в %L не соответствует рангу компонента (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Элемент в конструкторе структуры в %L для компонента указателя %qs есть %s, но должен быть %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "Unequal character lengths (%ld/%ld) in %s at %L"
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Неравные character длины (%ld/%ld) в %s в %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "NULL в конструкторе структуры в %L применяется к компоненту %qs, который не является ни POINTER ни ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Несоответствие интерфейса для компонента указателя на процедуру %qs в конструкторе структуры в %L: %s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %L"
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Слишком много компонентов в конструкторе структуры в %L"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 #| msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Ранг элемента в конструкторе структуры в %L не соответствует рангу компонента (%d/%d)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Элемент в конструкторе структуры в %L для компонента указателя %qs должен быть POINTER или TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Присваивание указателя с индексом вектора в правой части в %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Некорректное выражение в конструкторе структуры для компонента указателя %qs в %L в PURE процедуре"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Верхняя граница в последнем измерении должна появляться в ссылке на массив предполагаемого размера %qs в %L"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%qs в %L неоднозначно"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "GENERIC процедура %qs не допускается как фактический аргумент в %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Тип специфицированный для встроенной функции %qs в %L игнорируется"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Встроенная подпрограмма %qs в %L не должна иметь спецификатор типа"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "%qs декларированная INTRINSIC в %L не существует"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "Встроенная %qs декларированная INTRINSIC в %L недоступна в установках текущего стандарта кроме %s. Используйте подходящую %<-std=*%> опцию или включите %<-fall-intrinsics%>, чтобы использовать её."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, fuzzy, gcc-internal-format
 #| msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Не-RECURSIVE процедура %qs в %L возможно вызывает себя рекурсивно.  Объявите её RECURSIVE или используйте %<-frecursive%>"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Не-RECURSIVE процедура %qs в %L возможно вызывает себя рекурсивно.  Объявите её RECURSIVE или используйте %<-frecursive%>"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Метка %d используемая в %L нигде не определяется"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure %qs is used as actual argument at %L"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Внутренняя процедура %qs использована как фактический аргумент в %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Оператор функция %qs в %L не допускается в качестве фактического аргумента"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Встроенная %qs в %L не допускается в качестве фактического аргумента"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Внутренняя процедура %qs использована как фактический аргумент в %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL не-INTRINSIC процедура %qs не допускается в качестве фактического аргумента в %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Невозможно найти конкретную INTRINSIC процедуру для ссылки %qs в %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Символ %qs в %L неоднозначен"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Аргумент по значению в %L нечислового типа"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "Аргумент по значению в %L не может быть массивом или секцией массива"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Аргумент по значению в %L не допускается в этом контексте"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Передача внутренней процедуры в %L по расположению не допускается"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "Компонент указатель на ELEMENTAL процедуру %qs не допускается в качестве фактического аргумента в %L"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Коиндексированный фактический аргумент в %L с окончательным компонентом указателем"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %L with assumed-shape dummy argument '%s' must have an explicit interface"
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "Процедура '%s' в %L с формальным аргументом массивом предполагаемой формы '%s' должна иметь явный интерфейс"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (12.4.1.5)"
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "%qs в %L есть массив и OPTIONAL; ЕСЛИ ОН ОПУЩЕН, он не может быть фактическим аргументом ELEMENTAL процедуры кроме случая, когда есть обязательный аргумент того же ранга (12.4.1.5)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "Фактический аргумент в %L для INTENT(%s) формального параметра %qs ELEMENTAL подпрограммы %qs есть скаляр, но другой фактический аргумент является массивом"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Несоответствие возвращаемого типа функции %qs в %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Несоответствие интерфейса в глобальной процедуре %qs в %L: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "Нет конкретной функции для generic %qs в %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Generic функция %qs в %L несовместима с конкретным встроенным интерфейсом"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Функция %qs в %L есть INTRINSIC, но не является совместимой со встроенной"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Не удается разрешить конкретную функцию %qs в %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Функция %qs в %L не имеет IMPLICIT тип. Может имелось в виду %qs?"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Функция %qs в %L не имеет IMPLICIT тип"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "Ссылка на impure функцию %qs в %L внутри DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "Ссылка на impure функцию %qs в %L внутри FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "Ссылка на impure функцию %qs в %L внутри DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Ссылка на impure функцию %qs в %L внутри PURE процедуры"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after NOWAIT clause at %C"
 msgid "Unexpected junk after %qs at %L"
 msgstr "Неожиданный мусор после NOWAIT клаузулы в %C"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs в %L не есть функция"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ABSTRACT INTERFACE %qs не должна фигурировать в %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "Функция %qs декларирована CHARACTER(*) и не может использоваться в %L, поскольку это не формальный аргумент"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function %qs at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Отсутствует список аргументов в функции %qs в %C"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "resolve_function(): некорректный тип функции"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "Определенная пользователем не-ELEMENTAL функция %qs в %L не допускается в WORKSHARE конструкции"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "ENTRY %qs в %L не может вызываться рекурсивно, поскольку функция %qs не есть RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Функция %qs в %L не может вызываться рекурсивно, поскольку она не есть RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "builtin %qF is deprecated."
 msgid "Using function %qs at %L is deprecated"
 msgstr "внутренняя функция %qF устарела."
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block %qs at %L can not have the EXTERNAL attribute"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "COMMON блок %qs в %L не может иметь EXTERNAL атрибут"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Вызов подпрограммы %qs в DO CONCURRENT блоке в %L не есть PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Вызов подпрограммы %qs в FORALL блоке в %L не есть PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Вызов подпрограммы %qs в DO CONCURRENT блоке в %L не есть PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Вызов подпрограммы %qs в %L не есть PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Нет конкретной подпрограммы для generic %qs в %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Generic подпрограмма %qs в %L несовместима с интерфейсом встроенной подпрограммы"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Подпрограмма %qs в %L есть INTRINSIC, но несовместима со встроенной"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Не удается разрешить конкретную подпрограмму %qs в %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "%qs в %L имеет тип, который несовместим с CALL в %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "ENTRY %qs в %L не может вызываться рекурсивно, поскольку подпрограмма %qs не есть RECURSIVE"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "SUBROUTINE %qs в %L не может вызываться рекурсивно, поскольку она не есть RECURSIVE"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "resolve_subroutine(): некорректный тип функции"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 #| msgid "builtin %qF is deprecated."
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "внутренняя функция %qF устарела."
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Формы для операндов в %L и %L не являются подобными"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "logical_to_bitwise(): Некорректная встроенная функция"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "CHARACTER(*) функция %qs в %L не может иметь значение указатель"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "always_inline function might not be inlinable"
 msgid "Impure function at %L might not be evaluated"
 msgstr "always_inline функция, возможно, не годится для подстановки"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "Аргумент по значению в %L не может быть массивом или секцией массива"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "результат сравнения `беззнаковое выражение >=0' всегда истина"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Некорректный контекст для NULL() указателя в %%L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Операнд унарного числового оператора %%<%s%%> в %%L есть %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Операнды бинарного числового оператора %%<%s%%> в %%L есть %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Противоречивые ранги для оператора в %%L и %%L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Операнды оператора конкатенации строк в %%L есть %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Операнды логического оператора %%<%s%%> в %%L есть %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of user operator %%<%s%%> at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Операнд пользовательского оператора %%<%s%%> в %%L есть %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "COMPLEX величины не могут сравниваться в %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Противоречивые ранги для оператора в %%L и %%L"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "Некорректный вид для %s в %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "Некорректный вид для %s в %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Логические в %%L должны сравниваться посредством %s вместо %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Операнды оператора сравнения %%<%s%%> в %%L есть %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "unknown type name %qE; did you mean %qs?"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "неизвестное имя типа %qE; имелось в виду %qs?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator %%<%s%%> at %%L"
 msgid "Unknown operator %qs at %L"
 msgstr "Неизвестный оператор %%<%s%%> в %%L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator %%<%s%%> at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Операнд пользовательского оператора %%<%s%%> в %%L есть %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Операнды пользовательского оператора %%<%s%%> в %%L есть %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "resolve_operator(): Некорректная встроенная функция"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Coindex of codimension %d must be a scalar at %L"
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Коиндекс коразмерности %d должен быть скаляром в %L"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to %qs at %L must have the same declared type"
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "Фактический аргумент для %qs в %L должен иметь тот же декларированный тип"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "Allocate-object в %L и source-expr в %L должны иметь одинаковый вид параметра типа"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "Source-expr в %L и allocate-object в %L должны иметь одинаковую форму"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Ссылка на массив в %L вне диапазона (%ld < %ld) в измерении %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Ссылка на массив в %L вне диапазона (%ld < %ld) в коизмерении %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Ссылка на массив в %L вне диапазона (%ld > %ld) в измерении %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Ссылка на массив в %L вне диапазона (%ld > %ld) в коизмерении %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Некорректный нулевой шаг в %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Нижняя ссылка на массив в %L вне диапазона (%ld < %ld) в измерении %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Нижняя ссылка на массив в %L вне диапазона (%ld > %ld) в измерении %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Верхняя ссылка на массив в %L вне диапазона (%ld < %ld) в измерении %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Верхняя ссылка на массив в %L вне диапазона (%ld > %ld) в измерении %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "check_dimension(): Некорректная ссылка на массив"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Самая правая верхняя граница секции массива предполагаемой формы не задана в %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Несоответствие рангов в ссылке на массив в %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Несоответствие коиндексных рангов в ссылке на массив в %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Коиндекс коразмерности %d должен быть скаляром в %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Индекс массива в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Индекс массива в %L должен быть INTEGER типа, найдено %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "REAL индекс массива в %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Аргумент dim в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Аргумент dim в %L должен быть INTEGER типа"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Некорректная форма ссылки на массив в %C"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr "find_array_spec(): неиспользуемый as(1)"
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr "find_array_spec(): неиспользуемый as(2)"
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Индекс массива в %L является массивом ранга %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Аргумент dim в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Выражение в %L должно быть INTEGER типа, найдено %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "Аргумент dim в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "Аргумент dim в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Выражение в %L должно быть INTEGER типа, найдено %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "Выражение в %L должно быть скалярным"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Начальный индекс подстроки в %L должен быть типа INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Начальный индекс подстроки в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "Конечный индекс подстроки в %L должен быть типа INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "Конечный индекс подстроки в %L должен быть скаляром"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "Конечный индекс подстроки в %L слишком велик"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "resolve_ref(): Некорректная ссылка на массив"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Компонент справа от частичной ссылки с ненулевым рангом не должен иметь POINTER атрибут в %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Компонент справа от частичной ссылки с ненулевым рангом не должен иметь ALLOCATABLE атрибут в %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Две или больше частичные ссылки с ненулевым рангом не должны быть заданы в %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, fuzzy, gcc-internal-format
 #| msgid "expression_rank(): Two array specs"
 msgid "gfc_expression_rank(): Two array specs"
 msgstr "expression_rank(): Две спецификации массива"
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "Illegal coarray index"
 msgstr "недопустимый операнд "
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутом может использоваться только как фактический аргумент"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "Переменная предполагаемого типа %s в %L может использоваться только как фактический аргумент"
@@ -90933,12 +91125,12 @@ msgstr "Переменная предполагаемого типа %s в %L м
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Переменная предполагаемого типа %s в %L как фактический аргумент для inquiry функции должна быть первым аргументом"
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "Переменная предполагаемого ранга %s в %L может использоваться только как фактический аргумент"
@@ -90947,431 +91139,431 @@ msgstr "Переменная предполагаемого ранга %s в %L
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Переменная предполагаемого ранга %s в %L как фактический аргумент для inquiry функции должна быть первым аргументом"
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутом не должна иметь ссылку на подобъект"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "Переменная предполагаемого типа %s в %L не должна иметь ссылку на подобъект"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "Переменная предполагаемого ранга %s в %L не должна иметь ссылку на подобъект"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_variable_attr(): Bad array reference"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "gfc_variable_attr(): Некорректная ссылка на массив"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "Переменная %qs, использованная в спецификационном выражении, фигурирует в %L до ENTRY оператора, в котором она является параметром"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "Переменная %qs используется в %L до оператора ENTRY, в котором она является параметром"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Полиморфный подобъект коиндексированного объекта в %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Коиндексированный объект с полиморфным размещаемым подкомпонентом в %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "%qs matching variant is deprecated."
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%qs соответствующий вариант устарел."
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "Некорректная ссылка на массив в %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Error in type-spec at %L"
 msgid "Error in typebound call at %L"
 msgstr "Ошибка в спецификации типа в %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Передаваемый объект в %L должен быть скаляром"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "Базовый объект для вызова компонента указателя на процедуру в %L имеет ABSTRACT тип %qs'"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "Базовый объект для вызова type-bound процедуры в %L имеет ABSTRACT тип %qs"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Базовый объект для вызова NOPASS type-bound процедуры в %L должен быть скаляром"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "Не найдено подходящего конкретного связывания для вызова GENERIC %qs в %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%qs в %L должна быть SUBROUTINE"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs в %L должна быть FUNCTION"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "gfc_resolve_expr(): Некорректный тип выражения"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "'%s' в %L должна быть скаляром"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s в %L должен быть integer"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s в %L должна быть INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "Шаговое выражение в DO цикле в %L не может быть нулевым"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "DO цикл в %L будет выполнен ноль раз"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr "DO цикл в %L является неопределенным, так как он переполняется"
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr "DO цикл в %L является неопределенным, так как он теряет значимость"
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Ожидалось имя переменной в %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Переменной %qs в %L не была присвоена метка формата"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "SAVE атрибут в %L не может быть специфицирован в PURE процедуре"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array %qs in %s clause at %L"
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Массив предполагаемого размера %qs в %s клаузуле в %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, fuzzy, gcc-internal-format
 #| msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "ALLOCATABLE объект %qs в %s клаузуле в %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed argument not permitted in '%s' call at %L"
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr "Коиндексированный аргумент не разрешен в '%s' вызове в %L"
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "Coarrays not supported in %s clause at %L"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Комассивы не поддерживаются в %s клаузуле в %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed argument not permitted in '%s' call at %L"
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr "Коиндексированный аргумент не разрешен в '%s' вызове в %L"
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected intrinsic type %qs at %L"
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Неожиданный встроенный тип %qs в %L"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of %qs in %s statement at %L"
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "Ожидалось имя блока от %qs в %s операторе в %L"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "переменная %qD определена, но не используется"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "FORALL индекс-имя в %L должно быть скалярным INTEGER"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "FORALL стартовое выражение в %L должно быть скалярным INTEGER"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "FORALL конечное выражение в %L должно быть скалярным INTEGER"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "FORALL шаговое выражение в %L должно быть скаляром %s"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "FORALL шаговое выражение в %L не может быть нулевым"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "FORALL индекс %qs не может появляться в спецификации триплета в %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Allocate-object в %L должен быть ALLOCATABLE или POINTER"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Коиндексированный размещаемый объект в %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Allocate-object at %L also appears at %L"
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "Allocate-object в %L также появляется в %L"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "Source-expr в %L должно быть скалярным или иметь тот же ранг, что и allocate-object в %L"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "Source-expr в %L и allocate-object в %L должны иметь одинаковую форму"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Только встроенные операторы могут использоваться в выражении в %L"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "Тип сущности в %L есть тип несовместимый с source-expr в %L"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "Allocate-object в %L и source-expr в %L должны иметь одинаковый вид параметра типа"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "Source-expr в %L не должно быть типа LOCK_TYPE и не должно иметь LOCK_TYPE компонент, если allocate-object в %L является комассивом"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "Source-expr в %L не должно быть типа EVENT_TYPE и не должно иметь EVENT_TYPE компонент, если allocate-object в %L является комассивом"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "Размещение %s ABSTRACT базового типа в %L требует type-spec или source-expr"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "Размещение %s в %L с type-spec требует того же character-length параметра, что и в декларации"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Спецификация массива требуется в ALLOCATE операторе в %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Спецификация массива или SOURCE= выражение со значением массивом требуется в ALLOCATE операторе в %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Спецификация комассива требуется в ALLOCATE операторе в %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Некорректная спецификация комассива в ALLOCATE операторе в %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Некорректная спецификация массива в ALLOCATE операторе в %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "%qs не должно появляться в спецификации массива в %L в том же ALLOCATE операторе где оно само размещается"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '*' in coindex specification in ALLOCATE statement at %L"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "Ожидалась '*' в спецификации коиндекса в ALLOCATE операторе в %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "Stat-variable в %L должна быть скалярной INTEGER переменной"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Stat-variable в %L не должна быть %sd в том же %s операторе"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "ERRMSG в %L бесполезно без STAT тега"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "ERRMSG переменная в %L должна быть стандартной скалярной CHARACTER переменной"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "Переменная Errmsg в %L не должна быть %sd в том же операторе %s"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "Allocate-object в %L также появляется в %L"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "Allocate-object в %L есть подобъект объекта в %L"
@@ -91380,320 +91572,320 @@ msgstr "Allocate-object в %L есть подобъект объекта в %L"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "CASE метка в %L перекрывается с CASE меткой в %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "Выражение в CASE операторе в %L должно быть типа %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Выражение в CASE операторе в %L должно быть вида %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Выражение в CASE операторе в %L должно быть скаляром"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Выражение выбора в вычисляемом GOTO операторе в %L должно быть скалярным integer выражением"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Аргумент SELECT оператора в %L не может быть %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Аргумент SELECT оператора в %L не может быть скалярным выражением"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Выражение в CASE операторе в %L не находится в диапазоне %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "За DEFAULT CASE в %L не может следовать второй DEFAULT CASE в %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Логический диапазон в CASE операторе в %L не допускается"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "Константное логическое значение в CASE операторе повторяется в %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Спецификации диапазона в %L невозможно найти соответствие"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Логический SELECT CASE блок в %L имеет более двух случаев"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function %qs at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "Не удается разрешить конкретную функцию %qs в %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "Встроенная функция %qs в %L некорректна в присваивании указателя на процедуру"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type %qs cannot be used as a variable at %C"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Производный тип %qs не может быть использован как переменная в %C"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 #| msgid "Associate-name %qs at %L is used as array"
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "Имя ассоциации %qs в %L используется как массив"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "Селектор в %L не может быть NULL()"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "Селектор в %L не имеет типа"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Имя ассоциации %qs в %L используется как массив"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr "CLASS селектор в %L требует временной переменной, которая пока не реализована"
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Селектор должен быть полиморфным в SELECT TYPE операторе в %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "Селектор в %L не должен быть коиндексирован"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "TYPE IS в %L перекрывается с TYPE IS в %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Производный тип %qs в %L должен быть расширяемым"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Производный тип %qs в %L должен быть расширением %qs"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Неожиданный встроенный тип %qs в %L"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "Спецификация типа в %L должна специфицировать, что каждый параметр длины типа является предполагаемым"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Двойной CLASS IS блок в SELECT TYPE операторе в %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Некорректный контекст для NULL () встроенной в %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "DTIO %s процедура в %L должна быть рекурсивной"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "Элемент передачи данных в %L не может быть полиморфным, если только он не обрабатывается определенной процедурой ввода/вывода"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "Элемент передачи данных в %L не может иметь POINTER компоненты, если только он не обрабатывается определенной процедурой ввода/вывода"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "Элемент передачи данных в %L не может иметь компоненты указатели на процедуру"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "Элемент передачи данных в %L не может иметь ALLOCATABLE компоненты если только он не обрабатывается определенной процедурой ввода/вывода"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "Элемент передачи данных в %L не может иметь PRIVATE компоненты"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "Элемент передачи данных в %L не может иметь PRIVATE компоненты, если только он не обрабатывается определенной процедурой ввода/вывода"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Элемент передачи данных в %L не может быть полной ссылкой на массив предполагаемого размера"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "Lock переменная в %L должна быть скаляром типа LOCK_TYPE"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "Event переменная в %L должна быть скаляром типа EVENT_TYPE"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "Аргумент event переменная в %L должен быть комассивом или коиндексированным"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "Аргумент event переменная в %L должен быть комассивом, но не коиндексированным"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "STAT= аргумент в %L должна быть скалярной INTEGER переменной"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "ERRMSG= аргумент в %L должна быть скалярной CHARACTER переменной"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "ACQUIRED_LOCK= аргумент в %L должна быть скалярной LOGICAL переменной"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "UNTIL_COUNT= аргумент в %L должен быть скалярным INTEGER выражением"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "STAT= аргумент в %L должна быть скалярной INTEGER переменной"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be a character string of default kind"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "%s тег в %L должен быть строкой символов подразумеваемого вида"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Imageset аргумент в %L должен быть скалярным или ранга 1 INTEGER выражением"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Imageset аргумент в %L должен быть между 1 и num_images()"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Оператор в %L не есть корректный оператор цели перехода для оператора перехода в %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Переход в %L может вызвать зацикливание"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "GOTO оператор в %L покидает CRITICAL конструкцию для метки в %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "GOTO оператор в %L покидает DO CONCURRENT конструкцию для метки в %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
@@ -91702,221 +91894,221 @@ msgstr "GOTO оператор в %L покидает CRITICAL конструкц
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Метка в %L не находится в том же блоке, что GOTO оператор в %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "WHERE маска в %L имеет противоречивую форму"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "WHERE цель присваивания в %L имеет противоречивую форму"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Non-ELEMENTAL определенное пользователем присваивание в WHERE в %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Неподдерживаемый оператор внутри WHERE в %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Присваивание FORALL индексной переменной в %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "FORALL с индексом %qs не используется в левой части присваивания в %L и поэтому может вызвать множественное присваивание этому объекту"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "BLOCK construct at %C"
 msgid "FORALL construct at %L"
 msgstr "BLOCK конструкция в %C"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "FORALL имя индекса в %L должно быть скалярной переменной типа integer"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Внешняя FORALL конструкция уже имеет индекс с этим именем %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Ожидалось имя переменной в %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "WHERE/ELSEWHERE клаузула в %L требует LOGICAL массив"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "gfc_resolve_blocks(): Некорректный тип блока"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have procedure pointer components"
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "Элемент передачи данных в %L не может иметь компоненты указатели на процедуру"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "Не удалось преобразовать %s в %s в %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER expression will be truncated in assignment (%ld/%ld) at %L"
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "CHARACTER выражение будет усечено в присваивании (%ld/%ld) в %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Коиндексированное выражение в %L присваивается переменной производного типа с POINTER компонентом в PURE процедуре"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Присваивание коиндексированной переменной в %L в PURE процедуре"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "Присваивание полиморфному комассиву в %L не допускается"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Присваивание размещаемой полиморфной переменной в %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "Присваивание размещаемой полиморфной переменной в %L требует %<-frealloc-lhs%>"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for '=' operator"
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "Неразмещаемая переменная не должна быть полиморфной во встроенном присваивании в %L - проверьте, что имеется соответствующая конкретная подпрограмма для '=' оператора"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "Коиндексированная переменная не должна иметь размещаемых окончательных компонентов в присваивании в %L"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr "TODO: type-bound определенные присваивания в %L не выполнены, так как несколько ссылок на части массива появятся в промежуточных выражениях."
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "Присваивание указателя на процедуру в %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "Результат функции в левой части присваивания в %L должен иметь pointer атрибут."
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "ASSIGNED GOTO оператор в %L требует INTEGER переменной"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Переменной %qs не присвоили целевую метку в %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Alternate RETURN оператор в %L требует SCALAR-INTEGER спецификатор возврата"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Ожидалось инициализационное выражение в CASE в %C"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "ASSIGN оператор в %L требует скалярную подразумеваемого INTEGER переменную"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "Некорректный NULL в %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Оператор арифметического IF в %L требует скалярное REAL или INTEGER выражение"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "gfc_resolve_code(): Нет выражения в DO WHILE"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Условие выхода из DO WHILE цикла в %L должно быть скалярным LOGICAL выражением"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "FORALL клаузула маски в %L требует скалярное LOGICAL выражение"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_resolve_code(): Некорректный код оператора"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter %qs declared at %L"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Неиспользуемый параметр %qs декларирован в %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Переменная %qs со связывающей меткой %qs в %L использует тот же глобальный идентификатор, что и сущность в %L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "Переменная %qs из модуля %qs со связывающей меткой %qs в %L использует тот же глобальный идентификатор, что и сущность в %L из модуля %qs"
@@ -91924,62 +92116,62 @@ msgstr "Переменная %qs из модуля %qs со связывающе
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Процедура %qs со связывающей меткой %qs в %L использует тот же глобальный идентификатор, что и сущность в %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "Длина строки в %L слишком велика"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Размещаемый массив %qs в %L должен иметь отложенную форму или предполагаемый ранг"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Скалярный объект %qs в %L не может быть ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Указатель на массив %qs at %L должен иметь отложенную форму или предполагаемый ранг"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Массив %qs at %L не может иметь отложенную форму"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "Тип %qs CLASS переменной %qs at %L не является расширяемым"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "CLASS переменная %qs в %L должна быть формальным параметром, размещаемой или указателем"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Тип %qs не может быть host ассоциированным в %L, поскольку он блокирован несовместимым объектом с тем же именем декларированным в %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Выведенный SAVE для переменной модуля %qs в %L необходим из-за подразумеваемой инициализации"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Сущность %qs в %L имеет параметр отложенного типа и требует либо POINTER либо ALLOCATABLE атрибут"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -91987,1015 +92179,1015 @@ msgstr "CLASS переменная %qs в %L не может иметь PARAMETE
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Массив из модуля или главной программы %qs в %L должен иметь константную форму"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "Сущность с предполагаемой character длиной в %L должна быть формальным аргументом или PARAMETER"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "%qs в %L должна иметь константную character длину в этом контексте"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "COMMON переменная %qs в %L должна иметь константную character длину"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Размещаемая %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Внешняя %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Формальный параметр %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Встроенная %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Результат функции %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Автоматический массив %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s в %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Оператор функция с character значением %qs в %L должна иметь константную длину"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "%qs имеет PRIVATE тип и не может быть формальным аргументом %qs, который PUBLIC в %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Процедура %qs в PUBLIC интерфейсе %qs в %L берет формальные аргументы %qs, который PRIVATE"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Функция %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Внешний объект %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "ELEMENTAL функция %qs в %L должна иметь скалярный результат"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "Оператор функция %qs в %L не может иметь pointer или allocatable атрибут"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*) функция %qs в %L не может иметь значение массив"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "CHARACTER(*) функция %qs в %L не может иметь значение указатель"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*) функция %qs в %L не может быть pure"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "CHARACTER(*) функция %qs в %L не может быть рекурсивной"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "CHARACTER(*) функция %qs в %L"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "Указатель на процедуру %qs в %L не должен быть элементным"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Формальная процедура %qs в %L не должна быть элементной"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "Переменная результата функции %s в %L элементной функции %qs не должна иметь атрибут ALLOCATABLE или POINTER"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Коиндексированный объект с полиморфным размещаемым подкомпонентом в %L"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "PROCEDURE атрибут конфликтует с SAVE атрибутом в %qs в %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "PROCEDURE атрибут конфликтует с INTENT атрибутом в %qs в %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "PROCEDURE атрибут конфликтует с RESULT атрибутом в %qs в %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "EXTERNAL атрибут конфликтует с FUNCTION атрибутом в %qs в %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "Результат указатель на процедуру %qs в %L оказался без pointer атрибута"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Несоответствие в ELEMENTAL атрибуте между MODULE PROCEDURE в %L и ее интерфейсом в %s"
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Несоответствие в PURE атрибуте между MODULE PROCEDURE в %L и ее интерфейсом в %s"
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Несоответствие в RECURSIVE атрибуте между MODULE PROCEDURE в %L и ее интерфейсом в %s"
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr "%s между MODULE PROCEDURE декларацией в MODULE %qs и декларацией в %L в (SUB)MODULE %qs"
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "Interface %qs at %L must be explicit"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Интерфейс %qs в %L должен быть явным"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "FINAL процедура %qs в %L не есть SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "FINAL процедура в %L должна иметь ровно один аргумент"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Аргумент FINAL процедуры в %L должен быть типа %qs"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "Аргумент FINAL процедуры в %L не должен быть POINTER"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "Аргумент FINAL процедуры в %L не должен быть ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "Аргумент FINAL процедуры в %L не должен быть OPTIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "Аргумент FINAL процедуры в %L не должен быть INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Нескалярная FINAL процедура в %L должна иметь аргумент предполагаемой формы"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "FINAL процедура %qs декларированная в %L имеет тот же ранг (%d), что и %qs"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, fuzzy, gcc-internal-format
 #| msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one"
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Только массивные FINAL процедуры декларированные для производного типа %qs определенного в %L, предлагают также скалярный тип"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, fuzzy, gcc-internal-format
 #| msgid "%qs and %qs can't be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "%qs и %qs не могут быть смешанными FUNCTION/SUBROUTINE для GENERIC %qs в %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "%qs и %qs для GENERIC %qs в %L неоднозначны"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "Неопределенное конкретное связывание %qs как цели GENERIC %qs в %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "GENERIC %qs в %L должен нацеливаться на конкретное связывание, %qs также GENERIC"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC %qs at %L can't overwrite specific binding with the same name"
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "GENERIC %qs в %L не может перебить конкретное связывание с тем же именем"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Type-bound operator at %L can't be NOPASS"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Type-bound оператор в %L не может быть NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "%qs должна быть процедурой модуля или внешней процедурой с явным интерфейсом в %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Процедура %qs с PASS(%s) в %L не имеет аргумента %qs"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Процедура %qs с PASS в %L должна иметь по крайней мере один аргумент"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Неполиморфный passed-object формальный аргумент %qs в %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Аргумент %qs от %qs с PASS(%s) в %L должен быть производного типа %qs"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Аргумент %qs от %qs с PASS(%s) в %L должен быть производного типа %qs"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Passed-object формальный аргумент %qs в %L должен быть скаляром"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Passed-object формальный аргумент %qs в %L не должен быть ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Passed-object формальный аргумент %qs в %L не должен быть POINTER"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Процедура %qs в %L имеет то же имя, что и компонент %qs"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Процедура %qs в %L имеет то же имя, что и унаследованный компонент %qs"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "Производный тип %qs декларированный в %L должен быть ABSTRACT, поскольку %qs есть DEFERRED и не перебивается"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Комассивный компонент %qs в %L должен быть размещаемым с отложенной формой"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Компонент %qs в %L типа TYPE(C_PTR) или TYPE(C_FUNPTR) не должен быть комассивом"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "Компонент %qs в %L с комассивным компонентом должен быть неуказательным, неразмещаемым скаляром"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "Компонент %qs в %L имеет CONTIGUOUS атрибут, но не является указателем на массив"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Компонент %qs типа BIND(C) в %L должен иметь единичную длину"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Компонент указателя на процедуру %qs с PASS(%s) в %L не имеет аргумента %qs"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Компонент указателя на процедуру %qs с PASS в %L должен иметь по крайней мере один аргумент"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Аргумент %qs от %qs с PASS(%s) в %L должен быть производного типа %qs"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Аргумент %qs от %qs с PASS(%s) в %L должен быть скаляром"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Аргумент %qs от %qs с PASS(%s) в %L не может иметь POINTER атрибут"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "Аргумент %qs от %qs с PASS(%s) в %L не может быть ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Компонент %qs от %qs в %L имеет то же имя, что и унаследованная type-bound процедура"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Character длина компонента %qs должна быть константным спецификационным выражением в %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Выражение в %L должно быть INTEGER типа, найдено %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "Character компонент %qs от %qs в %L с отложенной длиной должен быть POINTER или ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "компонент %qs имеет PRIVATE тип и не может быть компонентом %qs, который PUBLIC в %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Полиморфный компонент %s в %L в SEQUENCE или BIND(C) типе %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Компонент %s SEQUENCE типа декларированный в %L не имеет SEQUENCE атрибут"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Конфликтующие инициализаторы в объединении в %L и %L"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "Поскольку расширяющий тип %qs в %L имеет комассивный компонент, родительский тип %qs должен также иметь его"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Нерасширяемый производный тип %qs в %L не должен быть ABSTRACT"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Generic имя %qs функции %qs в %L то же, что и имя производного типа в %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type %qs at %L must be extensible"
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Производный тип %qs в %L должен быть расширяемым"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to create map component '%s'"
 msgid "Failed to build PDT class component at %L"
 msgstr "не удалось создать map компонент '%s'"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Массив предполагаемого размера %qs в списке имен %qs в %L не допускается"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "NAMELIST массивный объект %qs с предполагаемой формой в списке имен %qs в %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "NAMELIST массивный объект %qs с неконстантной формой в списке имен %qs в %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "NAMELIST объект %qs с неконстантной character длиной в списке имен %qs в %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST объект %qs был декларирован PRIVATE и не может быть членом PUBLIC списка имен %qs в %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "NAMELIST объект %qs имеет use-associated PRIVATE компоненты и не может быть членом списка имен %qs в %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST объект %qs имеет PRIVATE компоненты и не может быть членом PUBLIC списка имен %qs в %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "PROCEDURE атрибут конфликтует с NAMELIST атрибутом в %qs в %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Parameter массив %qs at %L не может быть автоматическим или отложенной формы"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Неявно типизированный PARAMETER %qs в %L не соответствует более позднему IMPLICIT типу"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Несовместимый производный тип в PARAMETER в %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "CLASS переменная %qs в %L не может иметь PARAMETER атрибут"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "Expecting constant expression near %L"
 msgstr "TILE требует константное выражение в %L"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Сущность %qs в %L имеет параметр отложенного типа и требует либо POINTER либо ALLOCATABLE атрибут"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr "Простите, размещаемые/указательные компоненты в комассивах полиморфных (CLASS) типов в %L не поддерживаются"
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "PROTECTED атрибут конфликтует с EXTERNAL атрибутом в %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "PROCEDURE атрибут конфликтует с PROTECTED атрибутом в %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "%qs в %L имеет CONTIGUOUS атрибут, но не является указателем на массив или массивом предполагаемой формы или предполагаемого ранга"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Массив предполагаемого размера в %L должен быть формальным аргументом"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Массив предполагаемой формы в %L должен быть формальным аргументом"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Массив предполагаемой формы в %L должен быть формальным аргументом"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr "Массив предполагаемого ранга в %L не может иметь VALUE или CODIMENSION атрибут"
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Символ в %L не является DUMMY переменной"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "%qs в %L не может иметь VALUE атрибут, поскольку он не является формальным аргументом"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Character формальная переменная %qs в %L с VALUE атрибутом должна иметь константную длину"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "C совместимая character формальная переменная %qs в %L с VALUE атрибутом должна иметь длину один"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Производный тип %qs в %L имеет тип %qs, который не был определен"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутов должна быть формальным аргументом"
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутом должна быть типа TYPE(*) или числового встроенного типа"
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутом не может иметь ALLOCATABLE, CODIMENSION, POINTER или VALUE атрибут"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутом не может иметь INTENT(OUT) атрибут"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "Переменная %s в %L с NO_ARG_CHECK атрибутом должна быть или скаляром или массивом предполагаемого размера"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "Предполагаемый тип переменной %s в %L разрешен только для формальных переменных"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Переменная предполагаемого типа %s в %L не может иметь ALLOCATABLE, CODIMENSION, POINTER или VALUE атрибут"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "Переменная предполагаемого типа %s в %L не может иметь INTENT(OUT) атрибут"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "Переменная предполагаемого типа %s в %L не должна быть массивом явной формы"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "Переменная %qs at %L не может быть BIND(C), поскольку она не COMMON блок и не декларирована на уровне модуля"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "PUBLIC %s %qs в %L PRIVATE производного типа %qs"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "Переменная %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должна быть комассивом"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "INTENT(OUT) формальный аргумент %qs в %L имеет ASSUMED SIZE и поэтому не может иметь подразумеваемый инициализатор"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Формальный аргумент %qs в %L типа LOCK_TYPE не должен быть INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Формальный аргумент %qs в %L типа EVENT_TYPE не должен быть INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Результат функции %qs в %L не должен быть комассивом или иметь комассивный компонент"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Переменная %qs в %L типа TYPE(C_PTR) или TYPE(C_FUNPTR) не должна быть комассивом"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "Переменная %qs в %L с комассивным компонентом должна быть неуказательным, неразмещаемым скаляром, который не есть комассив"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "Переменная %qs в %L является комассивом и не является ни ALLOCATABLE, ни SAVE, ни формальным аргументом"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape"
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "Комассивная переменная %qs в %L не должна иметь коизмерения с отложенной формой"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Размещаемая комассивная переменная %qs в %L должна иметь отложенную форму"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "Переменная %qs в %L является INTENT(OUT) и может поэтому не быть размещаемым комассивом или иметь комассивные компоненты"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Комассивная формальная переменная %qs в %L не допускается в BIND(C) процедуре %qs"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "LOGICAL формальная переменная %qs в %L с не-C_Bool видом в BIND(C) процедуре %qs"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "LOGICAL результирующая переменная %qs в %L с не-C_Bool видом в BIND(C) процедуре %qs"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist %qs can not be an argument to subroutine or function at %L"
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Список имен %qs не может быть аргументом для подпрограммы или функции в %L"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Threadprivate в %L не является SAVEd"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "Цель инициализации указателя в %L должна иметь SAVE атрибут"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable %qs at %L cannot have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Размещаемая %qs в %L не может иметь инициализатор"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr "!$OMP DECLARE TARGET переменная %qs в %L не есть SAVEd"
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting list of named entities at %C"
 msgid "Expecting definable entity near %L"
 msgstr "Ожидается список именованных сущностей в %C"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "BLOCK DATA элемент %qs в %L должен быть в COMMON"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "DATA массив %qs в %L должен быть указан в предыдущей декларации"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "DATA элемент %qs в %L не может иметь коиндекс"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "DATA элемент %qs в %L является указателем и поэтому должен быть полным массивом"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Аргумент %qs элементной процедуры в %L не может иметь ALLOCATABLE атрибут"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Неконстантная секция массива в %L в DATA операторе"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "DATA оператор в %L имеет больше переменных чем значений"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Неконстантная секция массива в %L в DATA операторе"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "начало implied-do цикла в %L не может быть упрощено до константного значения"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "окончание implied-do цикла в %L не может быть упрощено до константного значения"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "шаг implied-do цикла в %L не может быть упрощен до константного значения"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "шаг implied-do цикла в %L не может быть упрощен до константного значения"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "DATA оператор в %L имеет больше значений чем переменных"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Метка %d в %L определена, но не используется"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Метка %d в %L определена, но не может быть использована"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Переменная производного типа %qs в %L должна иметь SEQUENCE атрибут, чтобы быть EQUIVALENCE объектом"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Переменная производного типа %qs в %L не может иметь ALLOCATABLE компоненты, чтобы быть EQUIVALENCE объектом"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Переменная производного типа %qs в %L с подразумеваемой инициализацией не может быть в EQUIVALENCE с переменной в COMMON"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Переменная производного типа %qs в %L с указательным(и) компонент(ами) не может быть EQUIVALENCE объектом"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Синтаксическая ошибка в EQUIVALENCE операторе в %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Все или никакие объекты в EQUIVALENCE установленной в %L должны иметь PROTECTED атрибут"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Именованная константа %qs at %L не может быть EQUIVALENCE объектом"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Синтаксическая ошибка в EQUIVALENCE операторе в %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Массив %qs at %L с неконстантными границами не может быть EQUIVALENCE объектом"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Компонент структуры %qs at %L не может быть EQUIVALENCE объектом"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Подстрока в %L имеет нулевую длину"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "PUBLIC функция %qs в %L PRIVATE типа %qs"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY %qs в %L не имеет IMPLICIT тип"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Процедура пользовательского оператора %qs в %L должна быть FUNCTION"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Процедура пользовательского оператора %qs в %L не может быть предполагаемой character длиной"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Процедура пользовательского оператора %qs в %L должна иметь по крайней мере один аргумент"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Первый аргумент интерфейса оператора в %L не может быть необязательным"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Второй аргумент интерфейса оператора в %L не может быть необязательным"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Интерфейс оператора в %L должен иметь не более двух аргументов"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "Внутренняя процедура %qs в %L PURE процедуры должна также быть PURE"
@@ -93016,102 +93208,102 @@ msgstr "Несуществующий include каталог %qs"
 msgid "%qs is not a directory"
 msgstr "%qs не есть каталог"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$ACC в %C начинает закомментированную строку, поскольку за ним не следует пробел и это не строка продолжения"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP в %C начинает закомментированную строку, поскольку за ним не следует пробел и это не строка продолжения"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Строка усечена в %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Лимит в %d строк продолжения превышен в операторе в %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr "Некорректное OpenACC продолжение в %C: ожидалось !$ACC, получено !$OMP"
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr "Некорректное OpenMP продолжение в %C: ожидалось !$OMP, получено !$ACC"
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Отсутствует %<&%> в продолженной символьной константе в %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Неподходящий символ табуляции в %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "%<&%> не допускается сам по себе в строке %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Неподходящий символ табуляции в колонке %d строки %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "файл %qs покидается без входа"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "Некорректная директива препроцессора"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file %qs"
 msgid "Cannot open file %qs"
 msgstr "Ошибка открытия файла %qs"
 
 #
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open included file %qs"
 msgstr "ошибка открытия включаемого файла '%s'"
 
 #
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "ошибка открытия включаемого файла '%s'"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "input file %qs is the same as output file"
 msgid "Included file %qs is not a regular file"
@@ -93286,221 +93478,221 @@ msgstr "Если первый аргумент %L ATAN2 нулевой, то в
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim(): Некорректный тип"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "в gfc_simplify_exp(): Некорректный тип"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor(): Некорректный вид"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Аргумент IACHAR в %L должен быть длины один"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Аргумент IACHAR функции в %L вне диапазона 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "Сумма второго и третьего аргументов IBITS превышает битовый размер в %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr "IBITS: Некорректный бит"
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Аргумент ICHAR в %L должен быть длины один"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Второй аргумент %s отрицателен в %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "Абсолютная величина второго аргумента %s превышает битовый размер в %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "Абсолютная величина второго аргумента ISHFTC превышает BIT_SIZE первого аргумента в %C"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "Абсолютная величина SHIFT должна быть меньше или равна SIZE в %C"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "DIM аргумент в %L вне границ"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "Аргумент LOG в %L не может быть меньше или равен нулю"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "Complex аргумент LOG в %L не может быть нулевым"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "gfc_simplify_log: некорректный тип"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "Аргумент LOG10 в %L не может быть меньше или равен нулю"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr "simplify_min_max(): Некорректный тип в списке аргументов"
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr ""
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_simplify_mod(): Некорректные аргументы"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Аргумент %<S%> NEAREST в %L не должен быть нулем"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr "gfc_simplify_modulo(): Некорректные аргументы"
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Результат NEAREST есть NaN в %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "Аргумент NCOPIES встроенной функции REPEAT отрицателен в %L"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "Аргумент NCOPIES встроенной функции REPEAT слишком велик в %L"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Переформированный массив слишком велик в %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Результат SCALE переполняет свой вид в %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be of rank %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "%qs аргумент %qs встроенной функции в %L должен быть ранга %d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Некорректный тип в gfc_simplify_sign"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "в gfc_simplify_sin(): Некорректный тип"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr "Неудача при получении длины константного массива."
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "Число элементов (%d) в конструкторе массива в %L требует увеличения допустимой %d верхней границы.  См. опцию %<-fmax-array-constructor%>"
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Упрощение SPREAD в %C пока не реализовано"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Аргумент SQRT в %L имеет отрицательное значение"
 
 #
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "Некорректный аргумент SQRT в %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "Вне границ в IMAGE_INDEX в %L для измерения %d, SUB имеет %ld и COARRAY нижняя граница есть %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "Вне границ в IMAGE_INDEX в %L для измерения %d, SUB имеет %ld и COARRAY верхняя граница есть %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "Символ %qs в строке в %L не может быть преобразован в символьный вид %d"
@@ -93845,75 +94037,75 @@ msgstr "Разделяемая DO терминирующая метка %d в %C
 msgid "Labeled DO statement at %L"
 msgstr "LOCK оператор в %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Имя %qs в %C является неоднозначной ссылкой на %qs из модуля %qs"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Имя %qs в %C является неоднозначной ссылкой на %qs из текущей программной единицы"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Символ %qs в %C уже был host ассоциирован"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr "verify_bind_c_derived_type(): Данный символ неожиданно оказался NULL"
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Производный тип %qs декларированный в %L должен иметь BIND атрибут, чтобы быть C совместимым"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %L has PRIVATE components"
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Производный тип '%s' в %L имеет PRIVATE компоненты"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "Производный тип %qs с BIND(C) атрибутом в %L пуст и может быть недоступен для C парного процессора"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Компонент %qs в %L не может иметь POINTER атрибут, поскольку он является элементом BIND(C) производного типа %qs в %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "Компонент указатель на процедуру %qs в %L не может быть элементом BIND(C) производного типа %qs в %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Компонент %qs в %L не может иметь ALLOCATABLE атрибут, поскольку он является элементом BIND(C) производного типа %qs в %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "Компонент %qs в производном типе %qs в %L может не быть C совместимым хотя производный тип %qs есть BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "Компонент %qs в производном типе %qs в %L может не быть C совместимым"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Производный тип %qs в %L не может иметь SEQUENCE атрибут, поскольку он есть BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "Символ %qs используется до своего типизирования в %L"
@@ -93943,29 +94135,35 @@ msgstr "Перекрывающиеся неравные инициализато
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Перекрывающиеся неравные инициализаторы в EQUIVALENCE в %C"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "Массив %qs в %L является переменной, которая не сводится к константному выражению"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Создание временного массива в %L для аргумента %qs"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "Некорректный тип выражения при проходе (%d)"
@@ -94070,117 +94268,117 @@ msgstr "Присваивание значения отличного от 0 и 1
 msgid "non-constant initialization expression at %L"
 msgstr "неконстантное инициализационное выражение в %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Selector at %L has no type"
 msgid "%s at %L has no default type"
 msgstr "Селектор в %L не имеет типа"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "встроенная переменная, которая не является процедурой"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "Возвращаемое значение функции %qs в %L не установлено"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "Параметр отложенного типа пока не поддерживается"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "backend декларация для переменной модуля %qs уже существует"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Неиспользуемая PRIVATE переменная модуля %qs декларирована в %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "%qs в %L не может иметь VALUE атрибут, поскольку он не является формальным аргументом"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "Компонент %qs в %L имеет CONTIGUOUS атрибут, но не является указателем на массив"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Формальный аргумент %qs в %L был декларирован INTENT(OUT), но не был установлен"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "Формальный аргумент производного типа %qs в %L был декларирован INTENT(OUT), но не был установлен и не имеет подразумеваемого инициализатора"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Неиспользуемый формальный аргумент %qs в %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Неиспользуемая переменная модуля %qs, которая была явно импортирована в %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Неиспользуемая переменная %qs декларирована в %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Неиспользуемый параметр %qs декларирован в %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Неиспользуемый параметр %qs, который был явно импортирован в %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Возвращаемое значение %qs функции %qs декларированное в %L не установлено"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr "Извините, !$ACC DECLARE в %L не допускается в конструкции BLOCK"
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "DW_LOC_OP %s not implemented"
 msgid "Unsigned not yet implemented"
 msgstr "DW_LOC_OP %s не реализован"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -94212,12 +94410,12 @@ msgstr "Простите, коиндексированный доступ к н
 msgid "Unknown intrinsic op"
 msgstr "Неизвестная встроенная операция"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Неизвестная функция списка аргументов в %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -94233,12 +94431,12 @@ msgstr "Встроенная функция %qs (%d) не опознана"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "%<dim%> аргумент встроенной функции %s в %L не есть корректный индекс измерения"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "Простите, event компонент производного типа в %L пока не поддерживается"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "event переменная в %L не должен быть коиндексирована"
@@ -94263,202 +94461,202 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr "неявное отображение массива предполагаемого размера %qD"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "optional argument"
 msgid "optional class parameter"
 msgstr "необязательный аргумент"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "Ожидался тип выражения"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "ожидалось выражение"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "Used here"
 msgstr "объявлено здесь"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Некорректный код оператора"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, fuzzy, gcc-internal-format
 #| msgid "Either all or none of the upper bounds must be specified at %L"
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "Все или никакие верхние границы должны быть специфицированы в %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name %qs at %C is the name of the procedure"
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Имя %qs в %C есть имя процедуры"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The stat= argument at %L must be a kind=4 integer variable"
 msgid "The base name at %L must not be an entry name"
 msgstr "stat= аргумент в %L должна быть kind=4 integer переменной"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Interface %qs at %L may not be generic"
 msgid "The base name at %L must not be a generic name"
 msgstr "Интерфейс %qs в %L не может быть generic"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "Цель инициализации указателя на процедуру в %L не может быть указателем на процедуру"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ELEMENTAL procedure '%s' at %L must have an explicit interface"
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "ELEMENTAL процедура '%s' в %L должна иметь явный интерфейс"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "Can't convert %qs to %qs at %L"
 msgid "Cannot find symbol %qs at %L"
 msgstr "Не удалось преобразовать %qs в %qs в %L"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "Процедура %qs в %s в %L не функция и не подпрограмма"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "variant %qs at %L is the same as base function"
 msgstr "%qs в %L не есть функция"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when there is a conversion between pointers that have incompatible types."
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "Предупреждать о преобразованиях указателей к несовместимым типам."
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "Ожидался список аргументов в %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L exceeds the string length"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Конечный индекс подстроки в %L превышает длину строки"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Альтернативный возврат в %L без * формального аргумента"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function '%s' at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Аргумент '%s' функции-оператора '%s' в %L должен быть скаляром"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Аргумент %qs элементной процедуры в %L не может иметь ALLOCATABLE атрибут"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "specified option %qs more than once"
 msgid "%qs at %L is specified more than once"
 msgstr "опция %qs задана более одного раза"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe not supported"
 msgid "%<need_device_addr%> not yet supported"
@@ -94815,7 +95013,7 @@ msgstr "close: %s"
 msgid "two or more sections for %s"
 msgstr "две или более секции для %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr "минимальный размер раздела не может быть больше чем максимальный размер раздела"
@@ -95168,34 +95366,34 @@ msgstr "массив использован как инициализатор"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not an integer constant"
 msgid "requested alignment is not a constant"
 msgstr "запрошенное выравнивание не является целочисленной константой"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a positive power of 2"
 msgid "requested alignment is not a power of 2"
 msgstr "запрошенное выравнивание не является положительной степенью 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "выравнивание слишком велико"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -98573,10 +98771,6 @@ msgstr ""
 #~ msgid "non-pointer argument to %<__builtin_launder%>"
 #~ msgstr "неуказательный аргумент для %<__builtin_launder%>"
 
-#, gcc-internal-format
-#~ msgid "cannot call function %qD"
-#~ msgstr "невозможно вызвать функцию %qD"
-
 #, gcc-internal-format
 #~ msgid "left rotate count >= width of type"
 #~ msgstr "счетчик циклического сдвига влево >= ширины типа"
@@ -100745,6 +100939,10 @@ msgstr ""
 #~ msgid "%<#pragma grainsize%> must be inside a function"
 #~ msgstr "#pragma GCC optimize не допускается внутри функций"
 
+#~| msgid "%q#D is not const"
+#~ msgid "%qD is not a constant"
+#~ msgstr "%q#D не есть const"
+
 #~| msgid "%<num_threads%> value must be positive"
 #~ msgid "%<num_gangs%> value must be positive"
 #~ msgstr "значение %<num_threads%> должно быть положительным"
@@ -101114,9 +101312,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "нестатический метод %q+D перекрывает статический метод"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D использовано до декларации"
-
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "В %+D: перекрытие диапазонов переменных и исключений в %d"
 
--- a/src/gcc/po/sr.po
+++ b/src/gcc/po/sr.po
@@ -6,7 +6,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 4.2.1\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2007-08-19 12:00+0200\n"
 "Last-Translator: Caslav Ilic <caslav.ilic@gmx.net>\n"
 "Language-Team: Serbian <gnu@prevod.org>\n"
@@ -1394,13 +1394,13 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 #| msgid "Specify ABI to use"
 msgid "Specify the PTX ISA version to use."
 msgstr "Наведите АБИ који се користи"
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers"
 msgid "Initialize ptx registers."
@@ -2325,13 +2325,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2833,7 +2833,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Претпостави да је циљни ЦПУ постављен на велику крајност"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 #| msgid "Assume target CPU is configured as little endian"
 msgid "Assume target CPU is configured as little endian."
@@ -2918,7 +2918,7 @@ msgstr "Користи потпрограме за прологе и епило
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 #| msgid "Specify the register allocation order"
@@ -2958,7 +2958,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 #| msgid "Omit the frame pointer in leaf functions"
 msgid "Omit the frame pointer in leaf functions."
@@ -3071,7 +3071,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -3118,7 +3118,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5682,7 +5682,7 @@ msgstr "Подржи уграђене ММИкс и ССЕ функције и 
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -6077,7 +6077,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "Претпостављена цена за ију gettr"
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -6416,219 +6416,224 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "The register used to access the thread pointer:"
 msgstr "Наведите како приступати показивачу нити"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "Specify the thread pointer register."
 msgstr "Наведите како приступати показивачу нити"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 #| msgid "Specify bit size of immediate TLS offsets"
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Наведите битску величину непосредних ТЛС помака"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule given CPU"
 msgid "Use features of architecture ARCH."
 msgstr "Користи могућности и распоређуј за дати ЦПУ"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule code for given CPU"
 msgid "Use features of and optimize for CPU."
 msgstr "Користи могућности и распоређуј кôд за дати ЦПУ"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "Generate code that conforms to the given ABI"
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Створи кôд који поштује дати АБИ"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate a call to abort if a noreturn function returns"
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Створи позив за прекидање ако се неповратна функција врати"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "%qs is deprecated"
 msgid "This option is deprecated."
@@ -12464,7 +12469,7 @@ msgstr "Укључи векторизацију петљи на стаблима
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -20062,91 +20067,91 @@ msgstr "Поштуј стандард Ц-а ИСО 1990"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "argument must be passed by copying"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 #| msgid "incompatible types in return"
 msgid "callee does not return"
 msgstr "несагласни типови у повратку"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "променљива %qD има функцијски тип"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "ISO C forbids nested functions"
 msgid "nested function"
 msgstr "ИСО Ц забрањује угњеждене функције"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "inconsistent number of popped arguments"
 msgstr "долазна ивица се не поклапа са бројем ПХИ аргумената"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s не подржава split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "variable size arguments"
 msgstr "неисправан типски аргумент"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr ""
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "gimplification failed"
 msgid "tail call production failed"
@@ -20280,12 +20285,12 @@ msgstr "операнд уз ‘%%l’ није етикета"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "лоша употреба реалне константе"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -21755,13 +21760,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "ово је ија:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "Disable indexed addressing"
 msgid "unable to reload address in "
 msgstr "Искључи индексно адресирање"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "не могу да створим поновљена учитавања за:"
 
@@ -22024,7 +22029,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sГГЦова хеуристика: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<анонимно>"
@@ -22415,11 +22420,11 @@ msgstr "неисправан операнд за кôд ‘%c’"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand for '%%%c'"
@@ -22427,9 +22432,9 @@ msgstr "неисправан операнд за кôд ‘%c’"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid punctuation %qc in constraint"
 msgid "invalid vector constant"
@@ -22481,77 +22486,77 @@ msgstr "неисправан кôд операнда ‘%c;’"
 msgid "invalid address mode"
 msgstr "неисправна адреса"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "неисправно претварање из %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "неисправно претварање у тип %qT из типа %qT"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "pointers are not permitted as case values"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "показивачи нису дозвољени као вредности случаја"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr ""
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -22568,13 +22573,13 @@ msgid "invalid %%r value"
 msgstr "неисправна %%r вредност"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "неисправна %%R вредност"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "неисправна %%N вредност"
@@ -22589,7 +22594,7 @@ msgstr "неисправна %%P вредност"
 msgid "invalid %%h value"
 msgstr "неисправна %%h вредност"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "неисправна %%L вредност"
@@ -22604,7 +22609,7 @@ msgstr "неисправна %%m вредност"
 msgid "invalid %%M value"
 msgstr "неисправна %%M вредност"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "неисправна %%U вредност"
@@ -22970,7 +22975,7 @@ msgstr "неочекиван операнд"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -23219,150 +23224,150 @@ msgstr "неисправна ија:"
 msgid "Expected register or constant integer."
 msgstr "акумулатор није целобројна константа"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "неисправан УНСПЕЦ као операнд"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "неисправна употреба %<restrict%>"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid use of asm flag output"
 msgstr "неисправна л-вредност у излазу асемблера %d"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code 'O'"
 msgstr "неисправан операнд за кôд ‘%c’"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code 'z'"
 msgstr "неисправан операнд за кôд ‘%c’"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "неисправан операнд за кôд ‘%c’"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "неисправан операнд за кôд ‘%c’"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "операнд није ни константа ни условни кôд, неисправан кôд аргумента ‘c’"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "неисправан кôд операнда ‘%c;’"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "неисправна ограничења за операнд"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "%Hinvalid controlling predicate"
 msgid "invalid vector immediate"
 msgstr "%Hнеисправан контролишући предикат"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "непознат режим ије"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "неисправно претварање из %<__fpreg%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "неисправно претварање из %<__fpreg%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "неисправно претварање у %<__fpreg%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "неисправно претварање у тип %qT из типа %qT"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -23447,9 +23452,9 @@ msgstr "‘%s’ није исправно име класе"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, fuzzy, c-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of '%%%c'"
@@ -23519,7 +23524,7 @@ msgid "insn contains an invalid address !"
 msgstr "неисправна адреса"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "неисправна адреса"
 
@@ -23597,7 +23602,7 @@ msgstr "неисправна ија ротације"
 msgid "invalid %%H value"
 msgstr "неисправна %%H вредност"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "неисправна %%d вредност"
@@ -23655,34 +23660,34 @@ msgstr "неподржана комбинација: %s"
 msgid "unsupported memory expression:"
 msgstr "очекиван је целобројни израз"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%c operand"
 msgid "invalid vector operand"
 msgstr "неисправан %%c операнд"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "неисправан операнд за модификатор ‘b’"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -23747,7 +23752,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "неисправна %%H вредност"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "неисправна %%D вредност"
@@ -23788,7 +23793,7 @@ msgstr "неисправан %%J кôд"
 msgid "invalid %%k value"
 msgstr "неисправна %%k вредност"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "неисправна %%K вредност"
@@ -23819,18 +23824,18 @@ msgstr "неисправна %%T вредност"
 msgid "invalid %%u value"
 msgstr "неисправна %%u вредност"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "неисправна %%v вредност"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%H value"
 msgid "invalid %%V value"
 msgstr "неисправна %%H вредност"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "неисправна %%x вредност"
@@ -24068,28 +24073,28 @@ msgstr "неисправан %%s операнд"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "реална константа није прихватљив непосредни операнд"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "‘B’ операнд није константа"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "‘B’ операнд има више постављених битова"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "‘o’ операнд није константа"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "‘B’ операнд није константа"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: непознат кôд"
@@ -24153,24 +24158,24 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr "не могу да емулирам %qs"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "лоша проба"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "неисправна маска"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "неисправна %%t/%%b вредност"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "нема регистара у адреси"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "помак адресе није константа"
 
@@ -24202,7 +24207,7 @@ msgstr ""
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 #, fuzzy
 #| msgid "<anonymous>"
 msgid "({anonymous})"
@@ -24229,8 +24234,8 @@ msgstr "<анонимно>"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "очекивано је %<;%>"
@@ -24259,7 +24264,7 @@ msgstr "очекивано је %<:%> или %<...%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<)%>"
@@ -24268,7 +24273,7 @@ msgstr "очекивано је %<{%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<]%>"
@@ -24291,13 +24296,13 @@ msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "очекивано је %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<[%>"
@@ -24307,7 +24312,7 @@ msgstr "очекивано је %<{%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -24324,14 +24329,14 @@ msgstr "очекивано је %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<:%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<while%>"
@@ -24342,7 +24347,7 @@ msgstr "очекивано је %<{%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<,%>"
@@ -24355,20 +24360,20 @@ msgid "expected %<.%>"
 msgstr "очекивано је %<{%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@end%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<>%>"
 msgstr "очекивано је %<{%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<,%> or %<)%>"
@@ -24379,14 +24384,14 @@ msgstr "очекивано је %<,%> или %<;%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "очекивано је %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<)%> or %<,%>"
@@ -24394,35 +24399,35 @@ msgstr "очекивано је %<,%> или %<;%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<}%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<else%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "очекивано је %<#pragma omp section%> или %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 #, fuzzy
 #| msgid "<anonymous>"
 msgid "(anonymous)"
 msgstr "<анонимно>"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<<%>"
@@ -24453,7 +24458,7 @@ msgstr "кандидат 1:"
 msgid "  after user-defined conversion:"
 msgstr "тип %qs има кориснички дефинисан конструктор"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 #, fuzzy
 #| msgid "candidate 1:"
 msgid "candidate is:"
@@ -24578,7 +24583,7 @@ msgstr "шаблонски параметар %q+#D"
 msgid "<statement>"
 msgstr "очекивана је наредба"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown src"
 msgid "<unknown>"
@@ -24608,320 +24613,362 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 #, fuzzy
 #| msgid "parse error"
 msgid "<expression error>"
 msgstr "грешка у рашчлањивању"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 #, fuzzy
 #| msgid "Bad operator"
 msgid "<unknown operator>"
 msgstr "Лош оператор"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "акумулатор није целобројна константа"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "floating constant misused"
 msgid "reflect_constant failed"
 msgstr "лоша употреба реалне константе"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "акумулатор није целобројна константа"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "reflection does not have template arguments"
 msgstr "делимична специјализација %qT не специјализује ниједан шаблонски аргумент"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a function or function type"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "Argument of %s at %L is not a valid type"
 msgid "operators argument is not a valid operator"
 msgstr "Аргумент у %s код %L није исправног типа"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%qE нема класни тип"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "декларација пријатеља не именује ни класу ни функцију"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr ""
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "разрешавање показивача на непотпун тип"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment"
 msgid "reflection not suitable for alignment_of"
 msgstr "Не подешавај равнање уписивих података"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "invalid cast to function type %qT"
 msgid "alignment_of on function type"
 msgstr "неисправно претапање у функцијски тип %qT"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 #| msgid "incompatible types in assignment"
 msgid "reflection with incomplete type in alignment_of"
 msgstr "несагласни типови у додели"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "разрешавање показивача на непотпун тип"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "gimplification failed"
 msgid "reflect_function failed"
 msgstr "гимплификација није успела"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "argument to '-Xassembler' is missing"
 msgid "value member missing"
 msgstr "недостаје аргумент за ‘-Xassembler’"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "Unexpected end of module"
 msgid "unexpected value of value member"
 msgstr "Неочекиван крај модула"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr ""
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "Function does not return a value"
 msgid "reflection does not represent a template"
 msgstr "Функција не враћа вредност"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qs attribute"
 msgid "invalid argument to can_substitute"
 msgstr "неисправан аргумент за атрибут %qs"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "new cannot be applied to a reference type"
 msgid "type is not object or reference type"
 msgstr "new се не може применити на упућивачки тип"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%qs is not a valid output file"
 msgid "name is not a valid identifier"
 msgstr "%qs није исправна излазна датотека"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "име регистра није наведено за %q+D"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 #, fuzzy
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "битско поље %qD неинтегралног типа"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "равнање се не може навести за %q+D"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr ""
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "негативан десни помак"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a power of 2"
 msgid "alignment is not power of two"
 msgstr "захтевано равнање није степен двојке"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "caller edge count is negative"
 msgid "alignment is negative"
 msgstr "број ивица позивача је негативан"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "function does not return string type"
+msgid "reflection does not have non-array object type"
+msgstr "функција не враћа податак типа ниске"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "cast to union type from type not present in union"
+msgid "current scope does not represent a function"
+msgstr "претапање у унијски тип из типа који не чини унију"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "декларација пријатеља не именује ни класу ни функцију"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qs"
 msgid "incomplete parent class"
 msgstr "непотпуна имплементација класе %qs"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qT is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qT није ни класа ни именски простор"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "%qD has incomplete type"
 msgid "not a complete class type"
 msgstr "%qD има непотпун тип"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "%q+#D cannot be overloaded"
 msgid "value cannot be extracted"
@@ -24981,54 +25028,54 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "кандидати су:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "погрешан тип аргумента уз унарно минус"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "погрешан тип аргумента уз унарно плус"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "погрешан тип аргумента уз битски комплемент"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "погрешан тип аргумента за abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "погрешан тип аргумента за конјугацију"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 #| msgid "wrong type argument to unary plus"
 msgid "in argument to unary !"
 msgstr "погрешан тип аргумента уз унарно плус"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -25048,70 +25095,70 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "Линија одсечена код %C"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, fuzzy, c-format
 #| msgid "different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "различити облици аргумената ‘%s’ и ‘%s’ код %L за сопствено ‘dot_product’"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, fuzzy, c-format
 #| msgid "different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "различити облици аргумената ‘%s’ и ‘%s’ код %L за сопствено ‘dot_product’"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, fuzzy, c-format
 #| msgid "different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "различити облици аргумената ‘%s’ и ‘%s’ код %L за сопствено ‘dot_product’"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "bad string constant"
 msgid "BOZ literal constant"
 msgstr "лоша константна ниска"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "expression statement has incomplete type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "наредба израза има непотпун тип"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "%qs expects a constant argument"
 msgid "Procedure unexpected as argument"
 msgstr "%qs очекује константан аргумент"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr ""
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "типови нису сасвим сагласни"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -25181,7 +25228,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 #| msgid "Array assignment"
 msgid "array assignment"
@@ -25192,17 +25239,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -25386,11 +25433,11 @@ msgstr "блоковско IF"
 msgid "implied END DO"
 msgstr "имплицитно END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "додела"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "додела показивача"
 
@@ -25398,167 +25445,167 @@ msgstr "додела показивача"
 msgid "simple IF"
 msgstr "једноставно IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 #, fuzzy
 #| msgid "elemental subroutine"
 msgid "elemental procedure"
 msgstr "елементални потпрограм"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "allocatable argument"
 msgstr "неисправан типски аргумент"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 #| msgid "no arguments"
 msgid "asynchronous argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 #| msgid "no arguments"
 msgid "optional argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "pointer assignment"
 msgid "pointer argument"
 msgstr "додела показивача"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 #| msgid "no arguments"
 msgid "target argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "value argument"
 msgstr "неисправан типски аргумент"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-shape argument"
 msgstr "неисправан типски аргумент"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 #| msgid "no arguments"
 msgid "assumed-rank argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 #| msgid "no arguments"
 msgid "coarray argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "parametrized derived type argument"
 msgstr "неисправан типски аргумент"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "без аргумената"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-type argument"
 msgstr "неисправан типски аргумент"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 #, fuzzy
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "result with non-constant character length"
 msgstr "‘%s’ код %L мора имати константну знаковну дужину у овом контексту"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 #| msgid "Perform variable tracking"
 msgid "iterator variable"
 msgstr "Изврши праћење променљивих"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 #, fuzzy
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "Start expression in DO loop"
 msgstr "Израз за корак у петљи DO код %L не може бити нула"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 #| msgid "invalid expression as operand"
 msgid "End expression in DO loop"
 msgstr "неисправан израз као операнд"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 #, fuzzy
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "Step expression in DO loop"
 msgstr "Израз за корак у петљи DO код %L не може бити нула"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 #, fuzzy
 #| msgid "DEALLOCATE "
 msgid "DEALLOCATE object"
 msgstr "DEALLOCATE "
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 #, fuzzy
 #| msgid "ALLOCATE "
 msgid "ALLOCATE object"
 msgstr "ALLOCATE "
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -25567,31 +25614,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 #, fuzzy
 #| msgid "assignment of read-only location"
 msgid "Assignment of scalar to unallocated array"
@@ -25659,27 +25706,27 @@ msgstr "Аргумент NCOPIES уз сопствено REPEAT негатива
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Аргумент NCOPIES уз сопствено REPEAT негативан је"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -25790,7 +25837,7 @@ msgid "expected boolean type"
 msgstr "Очекиван је тип израза"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 #| msgid "Expected integer"
 msgid "expected integer"
@@ -25872,7 +25919,7 @@ msgstr "без аргумената"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments for format"
 msgid "too many arguments"
@@ -26367,7 +26414,7 @@ msgstr "подршка профилисања за ВиксВоркс"
 msgid "target OS does not support unaligned accesses"
 msgstr "циљни формат не подржава бесконачност"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 #| msgid "profiling is still experimental for this target"
 msgid "profiling is not yet implemented for this architecture"
@@ -26632,13 +26679,13 @@ msgstr "У функцији %qs:"
 msgid "Global declarative %s for %s"
 msgstr "глобална декларација %q+#D"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -26819,13 +26866,13 @@ msgstr "%qs је превазиђено"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown autovec preference %qs"
 msgstr "непознато име регистра: %s"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr ""
@@ -27309,8 +27356,8 @@ msgstr "Атрибут %s коси се са атрибутом %s код %L"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "previous declaration here"
@@ -27330,7 +27377,7 @@ msgstr "атрибутска директива %qs игнорисана"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "атрибутска директива %qs игнорисана"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments specified for %qE attribute"
@@ -27342,7 +27389,7 @@ msgstr "погрешан број аргумената наведне за ат
 msgid "expected %i or more, found %i"
 msgstr "очекивано је %<(%> или крај линије"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %i, found %i"
@@ -27428,12 +27475,12 @@ msgstr "атрибути типа игноришу се пошто је тип 
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -27560,142 +27607,142 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "ивица %s->%s нема одговарајући call_stmt"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 #| msgid "no corresponding deallocation function for `%D'"
 msgid "corresponding source location"
 msgstr "нема одговарајуће функције за ослобађање меморије за ‘%D’"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "location is after end of function"
 msgstr "декларација %qs као низа функција"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 #| msgid "';' expected"
 msgid "Not expected TAG."
 msgstr "Очекивано је ‘;’"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "can't open input file: %s"
 msgid "cannot open profile file %s"
 msgstr "не могу да отворим улазну датотеку: %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "аргумент типа %qT не поклапа се са %qT"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "can't create repository information file %qs"
 msgid "cannot read summary information from %s"
 msgstr "не могу да направим датотеку са подацима складишта %qs"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize %qT from %qT"
 msgid "cannot read string table from %s"
 msgstr "%qT се не може успоставити из %qT"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read function profile from %s"
 msgstr "не могу да нађем датотеку за класу %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read module profile from %s"
@@ -27707,7 +27754,7 @@ msgstr "не могу да нађем датотеку за класу %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "померај ван граница константне ниске"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qE declared here"
@@ -27822,7 +27869,7 @@ msgstr "константан аргумент ван опсега за %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "недостаје аргумент за „%s“"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -27905,12 +27952,12 @@ msgstr "%Hпоследњи аргумент за %D није целобројн
 msgid "cannot tail-call: %s"
 msgstr "не могу да нађем класу %qs"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "позив функције има скупинску вредност"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 #| msgid "Pass arguments on the stack"
 msgid "passing too large argument on stack"
@@ -28603,355 +28650,355 @@ msgstr "основни блокови нису положени надовезу
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "број об. белешки у ланцу ија (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 #| msgid "caller edge count is negative"
 msgid "caller edge count invalid"
 msgstr "број ивица позивача је негативан"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing dimension specification at %C"
 msgid "missing direct call for speculation %i"
 msgstr "Недостаје одредница димензија код %C"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Use control speculation"
 msgid "missing ref for speculation %i"
 msgstr "Направи спекулацију контроле"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "помоћно поље постављено за ивицу %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline clone count is not compatible"
 msgstr "елемент успостављача није константан"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr ""
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 #| msgid "Assume symbols might be invalid"
 msgid "local symbols must be defined"
 msgstr "Претпостави да симболи могу бити неважећи"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "%D renamed after being referenced in assembly"
 msgid "inline clone is referenced by assembly"
 msgstr "%D преименован пошто је поменут у асемблеру"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr ""
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr ""
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "aux field set for edge %s->%s"
 msgid "aux field set for indirect edge from %s"
 msgstr "помоћно поље постављено за ивицу %s->%s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "PIC code generation is not compatible with fast indirect calls"
 msgid "edge count is not compatible with function count"
 msgstr "стварање ПИЦ кôда није сагласно са брзим посредним позивима"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "PIC code generation is not compatible with fast indirect calls"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "стварање ПИЦ кôда није сагласно са брзим посредним позивима"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "показивач inlined_to је погрешан"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "вишеструки уткани позивачи"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "показивач inlined_to постављен за неуткане позиваче"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "caller edge count does not match BB count"
 msgstr "долазна ивица се не поклапа са бројем ПХИ аргумената"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "indirect call count does not match BB count"
 msgstr "долазна ивица се не поклапа са бројем ПХИ аргумената"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "показивач inlined_to постављен али нема претходника"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "показивач inlined_to упућује на самог себе"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "дељени call_stmt:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "ивица показује на погрешну декларацију:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "недостаје графпоз ивица за call_stmt:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "reference to dead statement"
 msgstr "очекивана је наредба"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "ивица %s->%s нема одговарајући call_stmt"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "ивица %s->%s нема одговарајући call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node није успело"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to '-%s' is missing"
 msgid "%s: section %s.%d is missing"
@@ -29796,17 +29843,17 @@ msgstr "укупна величина локалних променљивих п
 msgid "impossible constraint in %<asm%>"
 msgstr "немогуће ограничење у %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "променљива %q+D може бити продрмана са %<longjmp%> или %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "аргумент %q+D може бити продрман са %<longjmp%> или %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "функција враћа скупинску вредност"
@@ -30559,7 +30606,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -30601,7 +30648,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qD defined here"
@@ -30624,24 +30671,24 @@ msgstr "Одредба мора бити упућивач"
 msgid "function may return address of local variable"
 msgstr "функција враћа адресу на локалну променљиву"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "функција враћа адресу на локалну променљиву"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -31563,7 +31610,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr ""
@@ -31636,223 +31683,223 @@ msgstr ""
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid memory model %qs for %qD"
 msgstr "неисправан режим показивача %qs"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for %q+D"
 msgid "invalid memory model %wi for %qD"
 msgstr "неисправно име регистра за %q+D"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for %q+D"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "неисправно име регистра за %q+D"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array %qs is negative"
 msgid "argument %i value %s is negative"
 msgstr "величина низа %qs је негативна"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of %q+D"
 msgid "referencing argument %u of type %qT"
 msgstr "у прослеђивању аргумента %P за %q+D"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared with attribute noinline"
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "функција %q+D поново декларисана са атрибутом неуткане"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "неисправан тип вектора за атрибут %qE"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "in a call to function %qD"
 msgstr "позив не-функције %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "in a call with type %qT"
 msgstr "  у позиву %qD"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "assignment"
 msgid "assigned here"
 msgstr "додела"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "равнање се не може навести за %q+D"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %q+D"
 msgid "pointer used after %qD"
 msgstr "неупотребљен параметар %q+D"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD here"
 msgstr "  у позиву %qD"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "неисправан режим показивача %qs"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "претпостављам показивач на члан %qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "неисправан режим показивача %qs"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qD declared here"
 msgstr "%q+D декларисано овде"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "cannot create temporary file"
 msgid "unnamed temporary defined here"
 msgstr "не могу да направим привремену датотеку"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  у позиву %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -32727,276 +32774,276 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "неисправан аргумент за атрибут %qs"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 #| msgid "initializer specified for non-virtual method %q+D"
 msgid "contains additional virtual method %qD"
 msgstr "успостављач наведен за невиртуелни метод %q+D"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "a different type is defined in another translation unit"
 msgstr "Различити типови у додели показивача код %L"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in initialization"
 msgid "the incompatible type defined in another translation unit"
 msgstr "несагласни типови у успостављању"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in return"
 msgid "the incompatible type is defined here"
 msgstr "несагласни типови у повратку"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 #| msgid "Array reference out of bounds"
 msgid "array types have different bounds"
 msgstr "Упућивач низа ван граница"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "return value type mismatch"
 msgstr "неслагање типа успостављача поља"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "implicit this pointer type mismatch"
 msgstr "неслагање типа успостављача поља"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Type/rank mismatch in argument '%s' at %L"
 msgid "type mismatch in parameter %i"
 msgstr "Неслагање типа/ранга у аргументу ‘%s’ код %L"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "type %qT should match type %qT"
 msgstr "тип %qT није изведен из типа %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "has different parameters in another translation unit"
 msgstr "Различите врсте типова параметара у додели показивача код %L"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "Array bound mismatch"
 msgid "memory layout mismatch"
 msgstr "Неслагање граница низа"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "the extra base is defined here"
 msgstr "%q+#D претходно дефинисано овде"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
@@ -33005,7 +33052,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
@@ -33014,7 +33061,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
@@ -33023,7 +33070,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
@@ -33032,7 +33079,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
@@ -33041,7 +33088,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
@@ -33050,47 +33097,47 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -33111,7 +33158,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid punctuation %qc in constraint"
 msgid "invalid jump function in LTO stream"
@@ -33358,12 +33405,12 @@ msgstr ""
 msgid "unable to find a register to spill"
 msgstr "не могу да нађем регистар за просипање у класи %qs"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "неусаглашена ограничења операнда у %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr ""
@@ -33759,7 +33806,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -35250,25 +35297,25 @@ msgstr "имплицитно подигнути регистри морају б
 msgid "output operand %d must use %<&%> constraint"
 msgstr "излазни операнд %d мора користити ограничење %<&%>"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data: [%u] Лош next_regno за празан ланац (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data: Петља у regno ланцу (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data: [%u] Лош oldest_regno (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -36286,188 +36333,188 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "константа није поново израчуната када се ADDR_EXPR промени"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "споредни ефекти нису поново израчунати када се ADDR_EXPR промени"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "адреса узета, али бит ADDRESSABLE није постављен"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr ""
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid position or size operand to %qs"
 msgstr "неисправна ограничења за операнд"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in %qs reference"
 msgstr "неслагање типова у условном изразу"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "претапање из показивача у целобројни различите величине"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "неисправан операнд за %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "%s:profile mismatch for '%s'\n"
 msgid "type mismatch in %qs"
 msgstr "%s:неслагање профила за ‘%s’\n"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid shift operand"
 msgid "invalid %qs offset operator"
 msgstr "неисправан операнд помака"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands to binary %s"
 msgid "invalid address operand in %qs"
 msgstr "неисправни операнди за бинарно %s"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands to binary %s"
 msgid "invalid offset operand in %qs"
 msgstr "неисправни операнди за бинарно %s"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "неисправна употреба %qD"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "једноставно IF"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "употребљена вредност структурног типа где се захтева скалар"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "invalid expression for min lvalue"
 msgstr "неисправан израз као операнд"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "invalid function in gimple call"
 msgstr "неисправно претапање у функцијски тип %qT"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 #| msgid "function not inlinable"
 msgid "non-function in gimple call"
 msgstr "функција се не може уткати"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 #| msgid "invalid storage class for function %qs"
 msgid "invalid pure const state for function"
 msgstr "неисправна складишна класа за функцију %qs"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PC in line number table"
 msgid "invalid LHS in gimple call"
 msgstr "неисправан ПЦ у табели бројева линија"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion in gimple call"
 msgstr "неисправно претварање у %<__fpreg%>"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PC in line number table"
 msgid "invalid static chain in gimple call"
 msgstr "неисправан ПЦ у табели бројева линија"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -36478,667 +36525,667 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_next_arg%> позвано без аргумената"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to builtin function"
 msgid "invalid argument to gimple call"
 msgstr "неисправан аргумент за уграђену функцију"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operands in gimple comparison"
 msgstr "неисправан операнд у инструкцији"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid method declaration, return type required"
 msgid "invalid vector comparison resulting type"
 msgstr "Неисправна декларација метода, неопходан је повратни тип"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operand in unary operation"
 msgstr "неисправан операнд у инструкцији"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid vector types in nop conversion"
 msgstr "неисправан тип вектора за атрибут %qE"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid type expression"
 msgid "invalid types in nop conversion"
 msgstr "Неисправан типски израз"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "invalid types in address space conversion"
 msgstr "неисправан израз као операнд"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid type expression"
 msgid "invalid types in fixed-point conversion"
 msgstr "Неисправан типски израз"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid types in conversion to floating-point"
 msgstr "неисправно претварање у %<__fpreg%>"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid types in conversion to integer"
 msgstr "неисправно претварање у %<__fpreg%>"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in %qs expression"
 msgstr "неслагање типова у условном изразу"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid types for %qs"
 msgstr "неисправан апстрактни тип за %q+D"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid type for %qs"
 msgstr "неисправан апстрактни тип за %q+D"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, fuzzy, gcc-internal-format
 #| msgid "Elemental binary operation"
 msgid "non-register as LHS of binary operation"
 msgstr "Елементална бинарна операција"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands to binary %s"
 msgid "invalid operands in binary operation"
 msgstr "неисправни операнди за бинарно %s"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid non-vector operands to %qs"
 msgstr "неисправан операнд за %%R"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "неисправан режим показивача %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in binary expression"
 msgstr "неслагање типова у условном изразу"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operands in ternary operation"
 msgstr "неисправан операнд у инструкцији"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid mask type in %qs"
 msgstr "неисправан апстрактни тип за %q+D"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "'&' not allowed by itself in line %d"
 msgid "not allowed type combination in %qs"
 msgstr "‘&’ не може бити само у линији %d"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option argument %qs"
 msgid "invalid position or size in %qs"
 msgstr "неисправан аргумент опције %qs"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr ""
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for %qs"
 msgid "insertion out of range in %qs"
 msgstr "константан аргумент ван опсега за %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr ""
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "invalid version number `%s'"
 msgid "non-trivial conversion in %qs"
 msgstr "неисправан број верзије ‘%s’"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid array assignment"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "неисправна додела низа"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "Missing return statement"
 msgid "%qs LHS in clobber statement"
 msgstr "Недостаје наредба повратка"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, fuzzy, gcc-internal-format
 #| msgid "Missing return statement"
 msgid "%qs LHS in assignment statement"
 msgstr "Недостаје наредба повратка"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands to binary %s"
 msgid "invalid operand in %qs"
 msgstr "неисправни операнди за бинарно %s"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %qs size argument in load"
 msgstr "неисправан типски аргумент"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for %q+D"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "неисправно име регистра за %q+D"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register in the move instruction"
 msgid "non-register as LHS with vector constructor"
 msgstr "неисправан регистар у инструкцији премештања"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect sharing of tree nodes"
 msgid "incorrect number of vector %qs elements"
 msgstr "нетачно дељење чворова стабла"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 #| msgid "PHI def is not a GIMPLE value"
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "ПХИ дефиниција није ГИМПЛЕ вредност"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr ""
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operand in return statement"
 msgstr "неисправан операнд у инструкцији"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid init statement"
 msgid "invalid conversion in return statement"
 msgstr "Неисправна успостављачка наредба"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "goto destination is neither a label nor a pointer"
 msgstr "индексирана вредност није ни низ ни показивач"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%s code"
 msgid "invalid operand to switch statement"
 msgstr "неисправан операнд за %%s кôд"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "Generate code for huge switch statements"
 msgid "non-integral type switch statement"
 msgstr "Створи кôд за огромне наредбе прекидача"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "%<default%> label not within a switch statement"
 msgid "invalid default case label in switch statement"
 msgstr "етикета %<default%> није у оквиру наредбе прекидача"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "invalid case label in switch statement"
 msgstr "етикета случаја није у оквиру наредбе прекидача"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid init statement"
 msgid "invalid case range in switch statement"
 msgstr "Неисправна успостављачка наредба"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type precision mismatch in switch statement"
 msgstr "етикета случаја није у оквиру наредбе прекидача"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type mismatch for case label in switch statement"
 msgstr "етикета случаја није у оквиру наредбе прекидача"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "case labels not sorted in switch statement"
 msgstr "етикета случаја није у оквиру наредбе прекидача"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "label context is not the current function declaration"
 msgstr "имена параметара (без типова) у декларацији функције"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, fuzzy, gcc-internal-format
 #| msgid "format string has invalid operand number"
 msgid "incorrect setting of landing pad number"
 msgstr "форматирајућа ниска има неисправан број операнада"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%p code"
 msgid "invalid comparison code in gimple cond"
 msgstr "неисправан операнд за %%p кôд"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid labels in gimple cond"
 msgstr "неисправна л-вредност у излазу асемблера %d"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%j code"
 msgid "invalid %<PHI%> result"
 msgstr "неисправан %%j кôд"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr ""
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid IACC argument"
 msgid "invalid %<PHI%> argument"
 msgstr "неодговарајући аргумент за IACC"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "несагласни типови у додели"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_stmts failed"
 msgid "%<verify_gimple%> failed"
 msgstr "verify_stmts није успело"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qF throws different exceptions"
 msgid "local declaration from a different function"
 msgstr "декларација %qF баца различите изузетке"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "bb_for_stmt (phi) is set to a wrong basic block"
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "bb_for_stmt (phi) постављено на погрешан основни блок"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, fuzzy, gcc-internal-format
 #| msgid "from this location"
 msgid "PHI node with location"
 msgstr "на овој локацији"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "нетачно дељење чворова стабла"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, fuzzy, gcc-internal-format
 #| msgid "bb_for_stmt (stmt) is set to a wrong basic block"
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "bb_for_stmt (stmt) постављено на погрешан основни блок"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "наредба означена за бацање, али не чини то"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "наредба означена за бацање усред блока"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, fuzzy, gcc-internal-format
 #| msgid "verify_stmts failed"
 msgid "verify_gimple failed"
 msgstr "verify_stmts није успело"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY_BLOCK has a statement list associated with it"
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK има придружену листу наредби"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, fuzzy, gcc-internal-format
 #| msgid "EXIT_BLOCK has a statement list associated with it"
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK има придружену листу наредби"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "пропад до излаза из об. %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "сувишна група витичастих заграда на крају успостављача"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "сувишна група витичастих заграда на крају успостављача"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%H%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%H%qE није успостављено"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr ""
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 #| msgid "%<else%> label does not match edge at end of bb %d"
 msgid "label %qD to block does not match in bb %d"
 msgstr "етикета %<else%> не поклапа ивицу на крају об. %d"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "контролни ток усред основног блока %d"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "control flow in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "контролни ток усред основног блока %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "пропадна ивица после контролне наредбе у об. %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "true/false edge after a non-COND_EXPR in bb %d"
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "ивица тачно/нетачно после не-COND_EXPR у об. %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "погрешне заставице излазне ивице на крају об. %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "експлицитно goto на крају об. %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "повратна ивица не показује на излаз у об. %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, fuzzy, gcc-internal-format
 #| msgid "found default case not at end of case vector"
 msgid "found default case not at the start of case vector"
 msgstr "нађен подразумевани случај који није на крају вектора случаја"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "етикете случајева нису сортиране: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "сувишна излазна ивица %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "недостаје ивица %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<noreturn%> function does return"
 msgid "%<noreturn%> function does return"
 msgstr "%H%<noreturn%> функција ипак враћа"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcontrol reaches end of non-void function"
 msgid "control reaches end of non-void function"
 msgstr "%Hконтрола стиже до краја функције непразног типа"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "%Hигноришем повратну вредност из %qD декларисану уз атрибут warn_unused_result"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of function declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -37336,13 +37383,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "неисправан тип вектора за атрибут %qE"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -37895,7 +37942,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -38335,12 +38382,12 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
@@ -38348,19 +38395,19 @@ msgstr ""
 msgid "previous declaration of %qD"
 msgstr "претходна декларација %q+D"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with previous using declaration %q#D"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D се коси са претходном декларацијом употребе %q#D"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "collect2 version %s"
 msgid "%qD conflicts for version %qB"
 msgstr "collect2 верзија %s"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%Jconflicts with previous declaration here"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -38445,7 +38492,7 @@ msgstr "Стави податке успостављене на нулу у од
 msgid "no initializers are allowed in section %qs"
 msgstr "не може се успостављати пријатељска функција %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "име регистра није наведено за %q+D"
@@ -38606,7 +38653,7 @@ msgstr "слаби упућивач %q+D на крају циља самог с
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "слаби упућивач %q+D мора имати статичку повезивост"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "alias definitions not supported in this configuration"
@@ -38653,62 +38700,62 @@ msgstr "Користи распоред пакованог стека"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "неисправан шаблонски аргумент %d"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "неисправан шаблонски аргумент %d"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "%qE attribute argument has type %qT"
 msgstr "подразумевани аргумент за %q#D има тип %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "подразумевани аргумент за %q#D има тип %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "аргумент атрибута %qs није целобројна константа"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "аргумент атрибута %qs није целобројна константа"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "подразумевани аргументи су дозвољени само за параметре функција"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "подразумевани аргументи су дозвољени само за параметре функција"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "подразумевани аргументи су дозвољени само за параметре функција"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -38724,13 +38771,13 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for field of type %qT"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "атрибут %qE се игнорише за поље типа %qT"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr ""
@@ -38962,13 +39009,13 @@ msgstr "не могу да користим режим %qs за бројевне
 msgid "mode %qs applied to inappropriate type"
 msgstr "режим %qs примењен на неодговарајући тип"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attributes are not supported for this target"
 msgid "section attributes are not supported for this target"
 msgstr "%Jатрибути одељка нису подржани за овај циљ"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "атрибут одељка није допуштен за %q+D"
@@ -38979,19 +39026,19 @@ msgstr "атрибут одељка није допуштен за %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "section attribute cannot be specified for local variables"
 msgstr "%Jатрибут одељка се не може навести за локалне променљиве"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "одељак за %q+D коси се са претходном декларацијом"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be overloaded"
 msgid "section of %q+D cannot be overridden"
@@ -39092,7 +39139,7 @@ msgstr "чистачки аргумент није идентификатор"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "областа података за %q+D коси се са претходном декларацијом"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "inline function %q+D declared weak"
@@ -39147,13 +39194,13 @@ msgstr "атрибут %qs примењује се само на променљ
 msgid "%qE attribute is only applicable on functions"
 msgstr "атрибут %qs примењује се само на функције"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to function types"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "атрибут %qs је примењив само на функцијске типове"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -39165,12 +39212,12 @@ msgstr "атрибут %qs примењује се само на променљ
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -39275,23 +39322,23 @@ msgstr "атрибут %qE се игнорише јер је %qT већ дефи
 msgid "visibility argument not a string"
 msgstr "видљивост аргумента није ниска"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "атрибут %qE се игнорише на типовима"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD поново декларисано са другачијом видљивошћу"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different visibility"
 msgid "%qD was declared %qs which implies default visibility"
@@ -39311,7 +39358,7 @@ msgstr "Ознака %s код %L мора бити типа %s или %s"
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applies only to functions"
@@ -39390,7 +39437,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -39479,7 +39526,7 @@ msgstr "%qD није декларисано у %qD"
 msgid "%qE argument is not a function"
 msgstr "чистачки аргумент није функција"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "deprecated message is not a string"
@@ -39552,7 +39599,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "атрибут %qE се игнорише на типовима"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires a single NTBS argument"
 msgid "%qE attribute requires a string argument"
@@ -39722,15 +39769,15 @@ msgid "requested position is less than zero"
 msgstr "захтевани положај је мањи од нуле"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr ""
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%qE attribute argument not a string constant"
@@ -40025,7 +40072,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "предлажем заграде око израза употребљеног као истинитосна вредност"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "неисправна употреба %<restrict%>"
@@ -40214,8 +40261,8 @@ msgstr "недовољно променљивих аргумената да би
 msgid "missing sentinel in function call"
 msgstr "недостаје стражар у позиву функције"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -41320,7 +41367,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr "традиционални Ц одбија надовезивање константних ниски"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -41376,7 +41423,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid type for iteration variable %qE"
 msgid "invalid type for iteration variable %qE"
@@ -41394,19 +41441,19 @@ msgstr "%Hнеисправан тип променљиве итерације %q
 msgid "%qE is not initialized"
 msgstr "%H%qE није успостављено"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, fuzzy, gcc-internal-format
 #| msgid "%Hmissing controlling predicate"
 msgid "missing controlling predicate"
 msgstr "%Hнедостаје контролишући предикат"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid controlling predicate"
 msgid "invalid controlling predicate"
 msgstr "%Hнеисправан контролишући предикат"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 #| msgid "%Hmissing increment expression"
 msgid "missing increment expression"
@@ -41417,7 +41464,7 @@ msgstr "%Hнедостаје израз увећања"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid increment expression"
 msgid "invalid increment expression"
@@ -41520,19 +41567,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is not a function argument"
 msgstr "%qD није шаблон функције"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -41543,8 +41590,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "%<_Atomic%> %qE in %qs clause"
@@ -42116,7 +42163,7 @@ msgstr "неисправна константа у %<#pragma pack%> — игно
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "лоше формирано %<#pragma pack%> — игноришем"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, fuzzy, gcc-internal-format
 #| msgid "junk at end of #pragma %s"
 msgid "junk at end of %<#pragma %s%>"
@@ -42195,8 +42242,8 @@ msgstr "ија премештања није обрађена"
 msgid "wrong type argument to %s"
 msgstr "погрешан тип аргумента за abs"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -42732,19 +42779,19 @@ msgstr "премало аргумената за функцију %qs"
 msgid "function %qD used as %<asm%> output"
 msgstr "само-за-читање локација употребљена као %<asm%> излаз"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, fuzzy, gcc-internal-format
 #| msgid "assignment of read-only location"
 msgid "assignment of read-only location %qE"
 msgstr "додела само-за-читање локацији"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, fuzzy, gcc-internal-format
 #| msgid "increment of read-only location"
 msgid "increment of read-only location %qE"
 msgstr "увећање само-за-читање локације"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, fuzzy, gcc-internal-format
 #| msgid "decrement of read-only location"
 msgid "decrement of read-only location %qE"
@@ -43047,7 +43094,7 @@ msgstr[1] "прослеђивање аргумента %d од %qE одбацу
 msgstr[2] "прослеђивање аргумента %d од %qE одбацује одредбе са циљног типа показивача"
 msgstr[3] "прослеђивање аргумента %d од %qE одбацује одредбе са циљног типа показивача"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -44059,7 +44106,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -44760,7 +44807,7 @@ msgstr "прослеђивање аргумента %d за %qE из разли
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate initialization of %qD"
 msgid "duplicate definition of %qs"
@@ -44813,7 +44860,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "тип %q+D нема познату величину"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -44869,7 +44916,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -44972,19 +45019,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "алтивек аргумент прослеђен непрототипизираној функцији"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -45031,196 +45078,196 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "атрибут %qs се игнорише"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on %<__fpreg%>"
 msgid "invalid format for %<sve_width%>"
 msgstr "неисправна операција на %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%H value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "неисправна %%H вредност"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown spec function '%s'"
 msgid "unknown tuning option (%s)"
 msgstr "непозната функција навода ‘%s’"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 #| msgid "Specify the register allocation order"
 msgid "specify a system register with a small string length"
 msgstr "Одредите редослед резервисања регистара"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs није исправно за %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "неисправан аргумент за %<__builtin_frame_address%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid argument %qs for %<instanceof%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "Неисправан аргумент %qs за %<instanceof%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march= switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "прекидач -mcpu=%s коси се са -march="
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "%s не подржава %s"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%qs је превазиђено"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %s not supported in PIC mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "модела кôда %s није подржан у ПИЦ режиму"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
@@ -45228,24 +45275,24 @@ msgstr ""
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "лоше формирано %<#pragma init%>"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -45254,211 +45301,211 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr "аргумент алијаса није ниска"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "alias argument not a string"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "аргумент алијаса није ниска"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qs attribute"
 msgid "missing value in %<target_version%> attribute"
 msgstr "неисправан аргумент за атрибут %qs"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "израз ограничења стека није подржан"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_eh_return not supported on this target"
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "__builtin_eh_return није подржан на овом циљу"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+#D претходно декларисано овде"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported simdlen %wd"
 msgstr "неподржана комбинација: %s"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "-fPIC is not currently supported on the 68000 or 68010"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "-fPIC тренутно није подржано на 68000 и 68010"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 #| msgid "-fPIC is not currently supported on the 68000 or 68010"
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "-fPIC тренутно није подржано на 68000 и 68010"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid argument type %qs to %qs"
 msgid "unsupported argument type %qT for simd"
 msgstr "Неисправан тип аргумента %qs за %qs"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "опција -shared тренутно није подржана за ВАКСов ЕЛФ"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "type attributes ignored after type is already defined"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "атрибути типа игноришу се пошто је тип већ дефинисан"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q+D defined here"
 msgstr "%q+D декларисано овде"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "прослеђивање аргумента %d за %qE са различитом ширином, због прототипа"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "прослеђивање аргумента %d за %qE са различитом ширином, због прототипа"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "прослеђивање аргумента %d за %qE са различитом ширином, због прототипа"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "прослеђивање аргумента %d за %qE са различитом ширином, због прототипа"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -45665,12 +45712,12 @@ msgstr "аргумент атрибута %qs није „ilink1“ или „il
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
@@ -45817,23 +45864,23 @@ msgid "argument of %qE attribute ignored"
 msgstr "атрибут %qE се игнорише"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "%qE attribute only applies to variables"
 msgstr "атрибут %qs примењује се само на променљиве"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr ""
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid type for %<asm%> flag output"
@@ -46425,13 +46472,13 @@ msgstr "-pipe није подржано"
 msgid "%<-fPIE%> is not supported"
 msgstr "-pipe није подржано"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 #| msgid "-G and -static are mutually exclusive"
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-G и -static су међусобно искључиви"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%qs function cannot have arguments"
@@ -46442,7 +46489,7 @@ msgstr "%qD не може имати подразумеване аргумент
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "%qs function cannot return a value"
@@ -46807,7 +46854,7 @@ msgstr "Уткане функције Ц-а 99 нису подржане; кор
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to builtin function"
 msgid "invalid argument to built-in function"
@@ -47156,7 +47203,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -47342,193 +47389,193 @@ msgstr "аргумент за %qs мора бити двобитна неозн
 msgid "parameter to builtin not valid: %s"
 msgstr "Аргумент за -ffpe-trap није исправан: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt Service Routines cannot be coded in Thumb mode"
 msgid "interrupt service routine cannot be called directly"
 msgstr "сервисне рутине прекида не могу бити кодиране у режиму Тамба"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 2-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 #| msgid "shift must be an immediate"
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "помак мора бити непосредни"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the third argument must be an 8-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be an 1-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 3-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be a 4-bit unsigned literal"
 msgid "the last argument must be a 4-bit immediate"
 msgstr "аргумент 3 мора бити четворобитна неозначена константа"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 1-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 5-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be an 8-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the third argument must be comparison constant"
 msgstr "трећи аргумент за %<__builtin_prefetch%> мора бити константа"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect insn:"
 msgid "incorrect comparison mode"
 msgstr "нетачна ија:"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect sharing of tree nodes"
 msgid "incorrect rounding operand"
 msgstr "нетачно дељење чворова стабла"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be a 4-bit unsigned literal"
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "аргумент 3 мора бити четворобитна неозначена константа"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "селектор мора бити целобројна константа у опсегу 0..%wi"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "неисправан други аргумент за %<__builtin_prefetch%>; користим нулу"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid third argument"
 msgstr "неисправан типски аргумент"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "неисправан трећи аргумент за %<__builtin_prefetch%>; користим нулу"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "неисправан трећи аргумент за %<__builtin_prefetch%>; користим нулу"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_expect%> must be a constant"
 msgid "second argument must be a const"
 msgstr "други аргумент за %<__builtin_expect%> мора бити константа"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 32-bit immediate"
 msgstr "аргумент 1 мора бити петобитна означена константа"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 #| msgid "mask must be an immediate"
 msgid "last argument must be an immediate"
 msgstr "маска мора бити непосредна"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "argument to %qs must be a 2-bit unsigned literal"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -47964,8 +48011,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "-fstack-protector not supported for this target"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -48233,7 +48280,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -48260,13 +48307,13 @@ msgstr "ССЕ регистарски аргумент уз искључене 
 msgid "x87 register return with x87 disabled"
 msgstr "враћање из регистра x87 када је x87 искључено"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, fuzzy, gcc-internal-format
 #| msgid "Calling %qD with attribute sseregparm without SSE/SSE2 enabled"
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "Позивање %qD са атрибутом sseregparm без укључених ССЕ/ССЕ2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -48276,40 +48323,40 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "тврдња: %s је доделом сагласно са %s"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "ограничења стека нису подржана на овом циљу"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "%s not supported for nested functions"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%s није подржано за угњеждене функције"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "%s not supported for nested functions"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -48317,95 +48364,95 @@ msgstr "%s није подржано за угњеждене функције"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 #| msgid "%s functions limited to %d register parameters"
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "%s функције ограничене на %d регистарских параметара"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported operand size for extended register"
 msgid "unsupported size for integer register"
 msgstr "неподржана величина операнда за проширени регистар"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "проширени регистри немају високе половине"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "неподржана величина операнда за проширени регистар"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr ""
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "нема доступних ниских регистара за подизање високих регистара"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "модела кôда %<large%> још увек није подржан"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 #| msgid "%<-G%> is incompatible with %<-mabicalls%>"
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
@@ -48464,7 +48511,7 @@ msgstr "gp_offset (%ld) или end_offset (%ld) мањи је од нуле"
 msgid "argument %qd is not a constant"
 msgstr "аргумент %qd није константа"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -48476,7 +48523,7 @@ msgstr "PRINT_OPERAND_ADDRESS, нулти показивач"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: Непозната интерпункција „%c“"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -48638,48 +48685,48 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "%qs is not supported in target attribute"
@@ -49502,7 +49549,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 #| msgid "bad builtin fcode"
 msgid "bad builtin code"
@@ -49756,87 +49803,87 @@ msgstr "%s:не могу да отворим датотеку графа\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 #| msgid "passing floating point arguments in fp regs not yet supported"
 msgid "not generating patch area, nops not supported"
 msgstr "прослеђивање аргумената у покретном зарезу у ФП регистрима још увек није подржано"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute requires a void return type"
 msgstr "атрибут %qE се игнорише на типовима"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "атрибут __BELOW100__ није дозвољен са аутом. складишном класом"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "argument %qd is not a constant"
 msgid "complement argument must be constant"
 msgstr "аргумент %qd није константа"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "%Jдефиниције алијаса нису подржане у овој конфигурацији"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -50077,343 +50124,343 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %q+D does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "тип %q+D нема познату величину"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %q+D does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "тип %q+D нема познату величину"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "аритметика са показивачем на непотпун тип"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "fields cannot have RVV type %qT"
 msgstr "%qE није типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "не може се резервисати објекат апстрактног типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "не може се резервисати објекат апстрактног типа %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "не може се претворити из типа %qT у %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is disallowed in Java %<throw%> or %<catch%>"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "тип %qT је забрањен у јаванским %<throw%> и %<catch%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %<firstprivate%>"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE није променљива у одредби %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized gcc debugging option: %c"
 msgid "unrecognized RVV builtin"
 msgstr "непрепозната исправљачка опција: %c"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "уграђена функција %q+D декларисана као нефункција"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to %<%D(%A)%>"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "нема одговарајуће функције за позив %<%D(%A)%>"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "алтивек аргумент прослеђен непрототипизираној функцији"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not \"ilink1\" or \"ilink2\""
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "аргумент атрибута %qs није „ilink1“ или „ilink2“"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE није типа %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "атрибут %qs захтева целобројну константу као аргумент"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr ""
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in the %s bit mode"
 msgid "code model %qs with %qs"
 msgstr "модела кôда %qs није подржан у %s-битном режиму"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ИСО Ц 90 не подржава комплексне типове"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d is not between %d and 12"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d није између %d и 12"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs није исправно за %qs"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs није исправно за %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "%qs function cannot have different interrupt type"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -51501,23 +51548,23 @@ msgstr "потребна меморија за локалне променљив
 msgid "%<function_profiler%> support"
 msgstr "function_profiler подршка"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "не може се користити va_start у функцији прекида"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "наредба прекидача са %lu уноса је превелика"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "атрибут %<__BELOW100__%> примењује се само на променљиве"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -51769,34 +51816,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D дефинисано али неупотребљено"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "потребни су логички регистри за опцију покретног зареза"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "-f%s није подржано КОНСТ16 инструкцијама"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "ПИЦ је потребан али није подржан КОНСТ16 инструкцијама"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "само неуспостављене променљиве могу бити смештене у одељак .bss"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -51892,7 +51939,7 @@ msgstr "атрибут %qE захтева прототипове са имено
 msgid "%qs attribute only applies to variadic functions"
 msgstr "атрибут %qE је примењив само на варијадичке функције"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
@@ -51984,8 +52031,8 @@ msgstr ""
 msgid "could not get size of source file"
 msgstr "Смањи величину објектних датотека"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "празна вредност није игнорисана а требало би"
@@ -52505,7 +52552,7 @@ msgstr "скок у наредбени израз"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%H%qE дефинисан као погрешна врста ознаке"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to function types"
 msgid "%qE attribute applied to %qD with void return type"
@@ -52669,7 +52716,7 @@ msgstr "ИСО Ц 90 не подржава %<static%> или одредбе ти
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ИСО Ц 90 не подржава деклараторе низова %<[*]%>"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -52680,7 +52727,7 @@ msgstr "%<this%> се не може употребити у овом конте
 msgid "%q+D is usually a function"
 msgstr "%q+D је обично функција"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 #| msgid "no previous declaration for %q+D"
 msgid "no previous declaration for %qD"
@@ -52764,7 +52811,7 @@ msgstr "не могу да ставим објекат са непостојан
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "неуспостављена константа %qD"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -52986,7 +53033,7 @@ msgstr "складишна класа наведена за параметар %
 msgid "storage class specified for unnamed parameter"
 msgstr "складишна класа наведена за параметар %qs"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "складишна класа наведена за име типа"
@@ -53188,7 +53235,7 @@ msgstr "%qs декларисано као функција која враћа 
 msgid "function definition has qualified void return type"
 msgstr "дефиниција функције има одређен празан повратни тип"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "одредбе типова се игноришу на повратном типу функције"
@@ -53332,7 +53379,7 @@ msgstr "ИСО Ц забрањује константне или непосто
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "члан структуре или уније не може имати променљиво измењив тип"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "променљива или поље %qE декларисано празним"
@@ -53565,7 +53612,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr "непознато поље %qE наведено у успостављачу"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "декларација ништа не декларише"
@@ -53632,7 +53679,7 @@ msgstr "структура нема именованих чланова"
 msgid "struct has no members"
 msgstr "структура нема чланова"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "%Jflexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -53704,7 +53751,7 @@ msgstr "поновљена декларација %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -53766,7 +53813,7 @@ msgstr "ИСО Ц ограничава вредности набрајача н
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ИСО Ц ограничава вредности набрајача на опсег %<int%>"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %q+D given attribute noinline"
 msgid "inline function %qD given attribute %qs"
@@ -53934,12 +53981,12 @@ msgstr "аргумент %qD не одговара уграђеном прото
 msgid "argument %qD doesn%'t match prototype"
 msgstr "аргумент %qD не одговара прототипу"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "нема повратне наредбе у функцији која враћа непразан тип"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD is initialized"
 msgid "parameter %qD set but not used"
@@ -54030,7 +54077,7 @@ msgstr "%<__thread%> употребљено уз %<register%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "два или више типова података у наводиоцима декларације"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> је предуго за ГЦЦ"
@@ -54145,7 +54192,7 @@ msgstr "ИСО Ц 90 не подржава комплексне типове"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "%s не подржава %<%%%s%c%> формат за %s"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "%<_Float%d%s%> is not supported on this target"
@@ -54323,12 +54370,12 @@ msgstr "Фиксна дужина линије мора бити барем се
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ИСО Ц не подржава %<~%> за комплексну конјугацију"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -54390,39 +54437,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr ""
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "негативан леви помак"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "негативан леви помак"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "негативан десни помак"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "леви помак >= од ширине типа"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "десни помак >= од ширине типа"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "леви помак >= од ширине типа"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -54443,7 +54490,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr ""
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected end of line"
@@ -54455,7 +54502,7 @@ msgstr "Неочекиван крај модула"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ИСО Ц забрањује празну изворну датотеку"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -54504,8 +54551,8 @@ msgid "unknown type name %qE"
 msgstr "непознато име регистра: %s"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "очекивани су наводиоци декларације"
@@ -54544,7 +54591,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "очекиван је идентификатор или %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "prefix attributes are ignored for methods"
@@ -54562,13 +54609,13 @@ msgstr "атрибут се игнорише при извођењу шабло
 msgid "unexpected attribute"
 msgstr "Очекивано је име атрибутског бита"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "атрибут одељка није допуштен за %q+D"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -54616,7 +54663,7 @@ msgstr "додела (не успостављање) у декларацији"
 msgid "%qs may only be used with a single declarator"
 msgstr "%qs не може бити употребљено са константом"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "очекивано је %<,%> или %<;%>"
@@ -54653,7 +54700,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "%qE не може бити употребљено као функција"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "очекивана је дословна ниска"
@@ -54688,7 +54735,7 @@ msgstr "интегрални израз %qE није константа"
 msgid "static assertion failed: %E"
 msgstr "Тврдња КРИС-порта није прошла: "
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 #| msgid "CRIS-port assertion failed: "
 msgid "static assertion failed"
@@ -54748,8 +54795,8 @@ msgstr "не могу да користим режим %qs за бројевне
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "очекиван је идентификатор"
@@ -54782,12 +54829,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "одељак за %q+D коси се са претходном декларацијом"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "зарез на крају листе набрајања"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -54871,25 +54918,25 @@ msgstr "очекивани су наводиоци декларације или
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "Unclassifiable OpenMP directive at %C"
 msgid "expected OpenMP directive name"
 msgstr "Неразврстљива ОпенМП директива код %C"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires a single NTBS argument"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "атрибут %qs захтева тачно један НТБС аргумент"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qE attribute does not take any arguments"
@@ -54901,7 +54948,7 @@ msgstr "атрибут %qs захтева целобројну констант
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ИСО Ц 90 не подржава деклараторе низова %<[*]%>"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -54933,18 +54980,18 @@ msgstr "ИСО Ц 90 забрањује навођење подобјекта з
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "застарела употреба утврђеног успостављача без %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 #| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "уређена област мора бити блиско угњеждена унутар петље са одредбом уређености"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -54954,44 +55001,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute does not apply to types"
 msgid "%qs attribute does not take any arguments"
@@ -55025,7 +55072,7 @@ msgstr "%HИСО Ц 90 забрањује мешање декларација и
 msgid "expected %<}%> before %<else%>"
 msgstr "очекивано је %<,%> или %<}%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -55040,7 +55087,7 @@ msgstr "етикета на крају сложене наредбе"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "очекивана је наредба"
@@ -55076,31 +55123,31 @@ msgstr "ИСО Ц не подржава децимални покретни за
 msgid "declaration in the controlling expression must have an initializer"
 msgstr ""
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declaration"
 msgstr "празна декларација"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, fuzzy, gcc-internal-format
 #| msgid "%Hempty body in an if-statement"
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "%Hпразно тело у наредби if"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, fuzzy, gcc-internal-format
 #| msgid "%Hempty body in an else-statement"
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "%Hпразно тело у наредби else"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, fuzzy, gcc-internal-format
 #| msgid "%Hsuggest explicit braces to avoid ambiguous %<else%>"
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "%Hпредложи експлицитне витичасте заграде ради избегавања двосмисленог %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -55121,12 +55168,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr "неисправан регистар у инструкцији"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -55143,8 +55190,8 @@ msgstr "недостаје стражар у позиву функције"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "удвостручена кн-одредба"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, fuzzy, gcc-internal-format
 #| msgid "%J  first type here"
 msgid "first seen here"
@@ -55170,12 +55217,12 @@ msgstr "ИСО Ц забрањује изостављање средњег чл
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "first %<sizeof%> operand was declared here"
@@ -55373,7 +55420,7 @@ msgstr "ИСО Ц 90 не подржава деклараторе низова %
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "очекиван је израз"
@@ -55388,13 +55435,13 @@ msgstr "витичасто заграђена група унутар израз
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ИСО Ц забрањује витичасто заграђене групе унутар израза"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "други параметар за %<va_start%> није последњи именовани аргумент"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -55557,7 +55604,7 @@ msgstr "трећи аргумент за %<__builtin_prefetch%> мора бит
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "трећи аргумент за %<__builtin_prefetch%> мора бити константа"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
@@ -55602,7 +55649,7 @@ msgstr ""
 msgid "rotate count is negative"
 msgstr "негативно ротирање %s"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
@@ -55716,7 +55763,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -55759,12 +55806,12 @@ msgstr "Очекивана је декларација класе или суч
 msgid "no type or storage class may be specified here,"
 msgstr "складишна класа наведена за %qs"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -55775,61 +55822,61 @@ msgstr "недостаје атрибут Code"
 msgid "unknown property attribute %<%s%s%>"
 msgstr ""
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr ""
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected %qE selector name"
 msgstr "очекивано је име класе"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma omp flush%> може бити употребљено само у сложеним наредбама"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 #| msgid "%<continue%> must be in loop"
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<continue%> мора бити у оквиру петље"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp section%> може бити употребљено само у конструкцији %<#pragma omp sections%>"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> може бити употребљено само у конструкцији %<#pragma omp sections%>"
@@ -55840,13 +55887,13 @@ msgstr "%<#pragma omp section%> може бити употребљено сам
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma omp flush%> може бити употребљено само у сложеним наредбама"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "for, while or do statement expected"
 msgstr "очекивана је наредба for"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> мора бити прво"
@@ -55856,11 +55903,11 @@ msgstr "%<#pragma GCC pch_preprocess%> мора бити прво"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "превише %qs одредби"
@@ -55877,67 +55924,67 @@ msgstr "израз за num_threads мора бити интегрални"
 msgid "%qD is not a variable"
 msgstr "%qD није променљива у одредби %qs"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is not a pointer variable"
 msgstr "%qD није шаблон"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "collapse argument needs positive constant integer expression"
 msgstr "поређење означених и неозначених целобројних израза"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<none%> or %<present%>"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "очекивано је %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant logical expression"
 msgstr "очекиван је целобројни израз"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<data%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<if%> clauses"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<if%> clauses without modifier"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -55961,25 +56008,25 @@ msgstr "вредност %<num_threads%> мора бити позитивна"
 msgid "%<num_tasks%> value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<grainsize%> value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<priority%> value must be non-negative"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "очекиван је целобројни израз"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, or %<||%>"
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
@@ -55991,113 +56038,113 @@ msgstr "очекивано је %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%qs expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%qs value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<static%> arguments"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected element"
 msgid "unexpected argument"
 msgstr "Неочекивани елемент"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "аргумент атрибута %qs није целобројна константа"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<self%> clauses"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<concurrent%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered argument needs positive constant integer expression"
 msgstr "поређење уређености показивача са целобројном нулом"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, or %<||%>"
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "очекивано је %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%> или %<||%>"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, fuzzy, gcc-internal-format
 #| msgid "both %<long%> and %<void%> in declaration specifiers"
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "и %<long%> и %<void%> у наводиоцима декларације"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "распоред %<runtime%> не узима параметар %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, fuzzy, gcc-internal-format
 #| msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "распоред %<runtime%> не узима параметар %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "chunk size value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "неисправна врста распореда"
@@ -56108,41 +56155,41 @@ msgstr "неисправна врста распореда"
 msgid "%<num_teams%> value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<thread_limit%> value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "очекивано је %<,%> или %<;%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "удвостручено %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -56158,23 +56205,23 @@ msgstr "очекивано је %<none%> или %<shared%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "multiple inline callers"
 msgid "multiple linear modifiers"
 msgstr "вишеструки уткани позивачи"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr ""
@@ -56185,7 +56232,7 @@ msgstr ""
 msgid "%<linear%> clause step expression must be integral"
 msgstr "израз за величину одломка при распоређивању мора бити интегрални"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -56200,343 +56247,343 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "тврдња: %s је доделом сагласно са %s"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid depend kind"
 msgstr "неисправна врста распореда"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid doacross kind"
 msgstr "неисправна врста распореда"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %<fallback%> modifier"
 msgstr "очекивано је %<(%> или крај линије"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr ""
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<always%> modifiers"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<close%> modifiers"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "превише улазних датотека"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "превише улазних датотека"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "очекиван је идентификатор или %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "превише улазних датотека"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid map kind"
 msgstr "неисправна маска"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid dist_schedule kind"
 msgstr "неисправна врста распореда"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 #| msgid "invalid schedule kind"
 msgid "invalid proc_bind kind"
 msgstr "неисправна врста распореда"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "широка дословна ниска у %<asm%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "непознато име регистра: %s"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected string literal or constant integer expression"
 msgstr "очекиван је целобројни израз"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "очекивано је %<,%> или %<;%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "очекивана је дословна ниска"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "удвостручено %<restrict%>"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<target%> modifier"
 msgstr "удвостручено %<restrict%>"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "удвостручено %<restrict%>"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected an OpenACC clause"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs није исправно за %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "%qs must be the first clause of %qs"
 msgstr "%qT није угњеждена класа у %qT"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected an OpenMP clause"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<extern%> variable %q+D in %<for%> loop initial declaration"
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "декларација спољашње променљиве %q+D у почетној декларацији %<for%> петље"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<--%> on bool variable %qD"
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "неисправна употреба %<--%> на логичкој променљивој %qD"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs is used more than once in the argument list of method %qs"
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "Променљива %qs употребљена више од једном у листи аргумената метода %qs"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "очекивано је %<,%> или %<;%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -56553,7 +56600,7 @@ msgstr "%qD није декларисано"
 msgid "expected function name"
 msgstr "очекивано је име класе"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qD does not refer to a function"
@@ -56564,23 +56611,23 @@ msgstr "%q+D није функција,"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma align%> мора да се јави пре декларације %D, игноришем"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -56607,7 +56654,7 @@ msgstr ""
 msgid "modified here"
 msgstr "модификатор ‘E’"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr ""
@@ -56642,119 +56689,119 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "очекивано је %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many atomic clauses"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many memory order clauses"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr ""
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "очекивано је %<(%> или крај линије"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operator for %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "неисправан оператор за %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "unexpected %<else%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operator for %<#pragma omp atomic%>"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "неисправан оператор за %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operator for %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "неисправан оператор за %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "неисправан оператор за %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "%<depobj%> expression is not lvalue expression"
@@ -56766,30 +56813,30 @@ msgstr "листа израза %s узима се као сложени изр
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "очекивано је %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "очекивано је %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -56799,36 +56846,36 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "очекивано је %<(%> или крај линије"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp flush%> може бити употребљено само у сложеним наредбама"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<#pragma omp scan%>"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp flush%> може бити употребљено само у сложеним наредбама"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "очекивана је наредба for"
@@ -56836,72 +56883,72 @@ msgstr "очекивана је наредба for"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "очекивана је наредба for"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "очекивано је успостављање или декларација итерације"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough type information"
 msgid "not enough nested loops"
 msgstr "нема довољно података о типу"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, fuzzy, gcc-internal-format
 #| msgid "iteration variable %qs should not be firstprivate"
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "не би требало да променљива итерације %qs буде firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> може бити употребљено само у сложеним наредбама"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<for%> after %qs"
@@ -56913,7 +56960,7 @@ msgstr "очекивано је %<,%> или %<;%>"
 msgid "expected a function name"
 msgstr "очекивано је име класе"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "Save registers around function calls"
 msgid "expected target-function call"
@@ -56924,48 +56971,48 @@ msgstr "Сачувавај регистре око позива функција
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<point%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -56981,63 +57028,63 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma align%> мора да се јави пре декларације %D, игноришем"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "Expected attribute bit name"
 msgid "expected trait selector name"
 msgstr "Очекивано је име атрибутског бита"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> може бити наведено само унутар класе"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<score%> argument must be non-negative"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "очекивана је дословна ниска"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be integer expression"
 msgstr "очекиван је целобројни израз"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "модела кôда %<large%> још увек није подржан"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected context selector set name"
@@ -57049,29 +57096,29 @@ msgstr "очекивано је име класе"
 msgid "variant %qD is not a function"
 msgstr "%q+D није функција,"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs declared as a function"
 msgid "variant %qD is the same as base function"
 msgstr "поље %qs декларисано као функција"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<match%> clauses"
 msgstr "превише %qs одредби"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -57082,7 +57129,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr "%qT није типа показивач-на-објекат"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -57094,18 +57141,18 @@ msgstr "очекивано је %<none%> или %<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs није исправно за %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<interop%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<match%> clause"
@@ -57127,13 +57174,13 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "угњеждена функција %qs декларисана као %<extern%>"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 #| msgid "first argument of %q+D should be %<int%>"
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "први аргумент за %q+D треба да је %<int%>"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr ""
@@ -57143,7 +57190,7 @@ msgstr ""
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "elements of array %q#D have incomplete type"
 msgid "variant %qD and base %qD have incompatible types"
@@ -57154,7 +57201,7 @@ msgstr "елементи низа %q#D имају непотпун тип"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -57170,87 +57217,87 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr "имплицитна декларација функције %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "дефиниција функције не декларише параметре"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<match%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr ""
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<declare%> or %<assumes%>"
@@ -57279,13 +57326,13 @@ msgstr "декларација %qD као члана %qT"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q+#D претходно декларисано овде"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "unexpected clause"
 msgstr "очекивано је име класе"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "Missing super class name"
 msgid "missing %<map%> clause"
@@ -57350,33 +57397,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "очекивано је %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "очекивано је %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -57392,171 +57439,171 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "%qE има неисправан тип за %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<sizes%>"
 msgstr "очекивано је %<{%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "аргумент атрибута %qs није целобројна константа"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %qs or %qs"
 msgstr "очекивано је %<,%> или %<;%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%> може бити употребљено само у сложеним наредбама"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected at least one assumption clause"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected directive name"
 msgstr "очекивано је име класе"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown assumption clause %qs"
 msgstr "непознат машински режим %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected assumption clause"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "непознато име регистра: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE декларисано као нитно-локално после прве употребе"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "аутоматска променљива %qE не може бити нитно-локална"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "нитно-локално %qE има непотпун тип"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -57566,7 +57613,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -57583,7 +57630,7 @@ msgstr "%Hобухватајуће паралелно"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD има непотпун тип"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "неисправна употреба израза празног типа"
@@ -57616,180 +57663,180 @@ msgstr "неисправна употреба непотпуног typedef %qD"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "атрибут %qE је примењив само на варијадичке функције"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "функцијски типови нису истински сагласни у ИСО Ц-у "
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and vector types"
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "не могу се мешати операнди децималног реалног и векторског типа"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and complex types"
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "не могу се мешати операнди децималног реалног и комплексног типа"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and other float types"
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "не могу се мешати операнди децималног реалног и других реалних типова"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "типови нису сасвим сагласни"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "pointer target types incompatible in C++"
 msgstr "тип показивача на члан %qT није сагласан са типом објекта %qT"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "повратни типови функција нису сагласни услед %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%Jinvalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "%Jнеисправна употреба структуре са флексибилним чланским низом"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT нема члан по имену %qE"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT нема члан по имену %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "захтев за члан %qE у нечему што није ни структура ни унија"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "разрешавање %<void *%> показивача"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "индексирана вредност није ни низ ни показивач"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "индекс низа није целобројан"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "индексирана вредност је показивач на функцију"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "индекс низа није целобројан"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ИСО Ц забрањује %<register%> низове"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ИСО Ц 90 забрањује индексирање не-л-вредносног низа"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD декларисано као упућивач али није успостављено"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object %qE is not a function or function pointer"
 msgstr "позвани објекат %qE није функција"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object %qD is not a function or function pointer"
 msgstr "позвани објекат %qE није функција"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object is not a function or function pointer"
@@ -57798,2029 +57845,2029 @@ msgstr "позвани објекат %qE није функција"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "функција позвана кроз несагласан тип"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 #| msgid "function definition has qualified void return type"
 msgid "function with qualified void return type called"
 msgstr "дефиниција функције има одређен празан повратни тип"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "тип формалног параметра %d није потпун"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као целобројног уместо као реалног, због прототипа"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као целобројног уместо као комплексног, због прототипа"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као комплексног уместо као реалног, због прототипа"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као реалног уместо као целобројног, због прототипа"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као комплексног уместо као целобројног, због прототипа"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као реалног уместо као комплексног, због прототипа"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као %<float%> уместо као %<double%>, због прототипа"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као %qT уместо као %qT, због прототипа"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "прослеђивање аргумента %d за %qE са различитом ширином, због прототипа"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као неозначеног, због прототипа"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "прослеђивање аргумента %d за %qE као означеног, због прототипа"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "превише аргумената за функцију %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "превише аргумената за функцију %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "превише аргумената за функцију %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "премало аргумената за функцију %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "премало аргумената за функцију %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "премало аргумената за функцију %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, fuzzy, gcc-internal-format
 #| msgid "comparison with string literal results in unspecified behaviour"
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "поређење са дословном ниском резултује неодређеним понашањем"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "поређење између показивача и целобројног"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "casting %qT to %qT does not dereference pointer"
 msgid "did you mean to dereference the pointer?"
 msgstr "претапање %qT у %qT не разрешава показивач"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "zero as null pointer constant"
 msgstr "граница низа није целобројна константа"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "comparison between %qT and %qT"
 msgstr "поређење између %q#T и %q#T"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "показивачи типа %<void *%> употребљени у одузимању"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "показивач на функцију употребљен у одузимању"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "аритметика са показивачем на непотпун тип"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "аритметика са показивачем на непотпун тип"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 #| msgid "  in thrown expression"
 msgid "%<~%> on a boolean expression"
 msgstr "  у баченом изразу"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ИСО Ц не подржава %<~%> за комплексну конјугацију"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "погрешан тип аргумента за abs"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "погрешан тип аргумента уз унарни знак узвика"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 #| msgid "%Hmissing increment expression"
 msgid "increment of a boolean expression"
 msgstr "%Hнедостаје израз увећања"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 #| msgid "decrement of read-only location"
 msgid "decrement of a boolean expression"
 msgstr "умањење само-за-читање локације"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ИСО Ц не подржава %<++%> и %<--%> за комплексне типове"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "погрешан тип аргумента уз увећање"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "погрешан тип аргумента уз умањење"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "аритметика са показивачем на непотпун тип"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "аритметика са показивачем на непотпун тип"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of expression of type %<void%>"
 msgstr "узимање адресе привременог"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "не може се узети адреса битског поља %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "не може се узети адреса од %<this%>, јер је д-вредносни израз"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "затражена адреса регистарске променљиве %qD"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "затражена адреса регистарске променљиве %qD"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "глобална регистарска променљива %qD употребљена у угњежденој функцији"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "регистарска променљива %qD употребљена у угњежденој функцији"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "затражена адреса глобалне регистарске променљиве %qD"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "затражена адреса регистарске променљиве %qD"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "не-л-вредносни низ у условном изразу"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral mismatch in conditional expression: %qT vs %qT"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "неслагање набројивих у условном изразу: %qT пр. %qT"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ИСО Ц забрањује условне изразе са само једном празном страном"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "неслагање показивачких типова у условном изразу"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "неслагање показивачких типова у условном изразу"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "неслагање показивачких типова у условном изразу"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ИСО Ц забрањује условни израз између %<void *%> и функцијског показивача"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "неслагање показивачких типова у условном изразу"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "Очекиван је тип израза"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "Очекиван је тип израза"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "неслагање типова показивача или целобројних у условном изразу"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "неслагање типова у условном изразу"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "%Hигноришем повратну вредност из %qD декларисану уз атрибут warn_unused_result"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "%Hигноришем повратну вредност из %qD декларисану уз атрибут warn_unused_result"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "%Hигноришем повратну вредност из %qD декларисану уз атрибут warn_unused_result"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "%Hигноришем повратну вредност из %qD декларисану уз атрибут warn_unused_result"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "in call to %qD, declared here"
 msgstr "  %q+#D декларисано овде"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "леви операнд зарез-израза нема ефекта"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "right-hand operand of comma expression has no effect"
 msgstr "леви операнд зарез-израза нема ефекта"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 #| msgid "cast adds new qualifiers to function type"
 msgid "cast adds %q#v qualifier to function type"
 msgstr "претапање додаје нове одредбе функцијском типу"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "претапање одбацује одредбе са циљног типа показивача"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "претапање наводи низовни тип"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "претапање наводи функцијски тип"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ИСО Ц забрањује претапање нескалара у исти тип"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "useless cast to type %qT"
 msgstr "неисправно претапање у функцијски тип %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ИСО Ц забрањује претапање у унијски тип"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "претапање у унијски тип из типа који не чини унију"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "претапање увећава неопходно равнање циљног типа"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "претапање из показивача у целобројни различите величине"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "претапање из функцијског позива типа %qT у непоклапајући тип %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "претапање из целобројног у показивач различите величине"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ИСО Ц забрањује претварање показивача на функцију у показивач на објекат"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ИСО Ц забрањује претварање показивача на објекат у показивач на функцијски тип"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 #| msgid "can't convert from incomplete type %qT to %qT"
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "не може се претворити из непотпуног типа %qT у %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 #| msgid "assignment suppression"
 msgid "assignment to expression with array type"
 msgstr "потискивање доделе"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(близу успостављања за %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "низ успостављен константном ниском у заградама"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "Unexpected %s statement at %C"
 msgid "expected %e but argument is of type %e"
 msgstr "Неочекивана наредба %s код %C"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "built-in %qD declared here"
 msgstr "%q+D декларисано овде"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "%q+D declared here"
 msgid "%e declared here"
 msgstr "%q+D декларисано овде"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "циљеви показивача у прослеђивању аргумента %d за %qE разликују се у означености"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "expected %qT but argument is of type %qT"
 msgstr "формат %q.*s очекује тип %<%T%s%>, али аргумент %d је типа %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "implicit conversion from %qT to %qT"
 msgstr "неисправно претварање из %qT у %qT"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 #| msgid "passing argument %d of %qE makes qualified function pointer from unqualified"
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "прослеђивање аргумента %d од %qE прави одређени функцијски показивач од неодређеног"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 #| msgid "assignment makes qualified function pointer from unqualified"
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "додела прави одређени функцијски показивач од неодређеног"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 #| msgid "initialization makes qualified function pointer from unqualified"
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "успостављање прави одређени функцијски показивач од неодређеног"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 #| msgid "return makes qualified function pointer from unqualified"
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "повратак прави одређени функцијски показивач од неодређеног"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 #| msgid "passing argument %d of %qE discards qualifiers from pointer target type"
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "прослеђивање аргумента %d од %qE одбацује одредбе са циљног типа показивача"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 #| msgid "assignment discards qualifiers from pointer target type"
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "додела одбацује одредбе са циљног типа показивача"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 #| msgid "initialization discards qualifiers from pointer target type"
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "успостављање одбацује одредбе са циљног типа показивача"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 #| msgid "return discards qualifiers from pointer target type"
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "повратак одбацује одредбе са циљног типа показивача"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ИСО Ц забрањује претварање аргумента у унијски тип"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "прослеђивање аргумента %d од %qE из несагласног показивачког типа"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "претапање из показивача у целобројни различите величине"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, fuzzy, gcc-internal-format
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "успостављање из несагласног показивачког типа"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "тип %qT није изведен из типа %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "аргумент %d од %qE може бити кандидат за форматски атрибут"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "лева страна доделе може бити кандидат за форматски атрибут"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "лева страна успостављања може бити кандидат за форматски атрибут"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "повратни тип може бити кандидат за форматски атрибут"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "прослеђивање аргумента %d од %qE из несагласног показивачког типа"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ИСО Ц забрањује прослеђивање аргумента %d од %qE између функцијског показивача и %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ИСО Ц забрањује доделу између функцијског показивача и %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ИСО Ц забрањује успостављање између функцијског показивача и %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ИСО Ц забрањује повратак између функцијског показивача и %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "циљеви показивача у прослеђивању аргумента %d за %qE разликују се у означености"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "циљеви показивача у додели разликују се у означености"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in initialization differ in signedness"
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "циљеви показивача у успостављању разликују се у означености"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "циљеви показивача у прослеђивању аргумента %d за %qE разликују се у означености"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "прослеђивање аргумента %d од %qE из несагласног показивачког типа"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "не може се %s показивач на непотпуни тип %qT"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "додела из несагласног показивачког типа"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "успостављање из несагласног показивачког типа"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "успостављање из несагласног показивачког типа"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "creating pointer to member function of non-class type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "стварање показивача на чланску функцију некласног типа %qT"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "return from incompatible pointer type"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "повратак из несагласног показивачког типа"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "прослеђивање аргумента %d од %qE прави показивач од целобројног без претапања"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes pointer from integer without a cast"
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "додела прави показивач од целобројног без претапања"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes pointer from integer without a cast"
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "успостављање прави показивач од целобројног без претапања"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "прослеђивање аргумента %d од %qE прави показивач од целобројног без претапања"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "прослеђивање аргумента %d од %qE прави целобројни од показивача без претапања"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes integer from pointer without a cast"
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "додела прави целобројни од показивача без претапања"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes integer from pointer without a cast"
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "успостављање прави целобројни од показивача без претапања"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "прослеђивање аргумента %d од %qE прави целобројни од показивача без претапања"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "несагласни тип за аргумент %d у %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "несагласни типови у додели %qT у %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in initialization"
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "несагласни типови у успостављању"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "несагласни типови у додели %qT у %qT"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "традиционални Ц одбија аутоматску успостављање скупина"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, fuzzy, gcc-internal-format
 #| msgid "initializer for integer value is too complicated"
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr "успостављач за целобројну вредност је превише компликован"
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "успостављање флексибилног чланског низа"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "предугачка ниска успостављача за низ знакова"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "предугачка ниска успостављача за низ знакова"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "низ неподесног типа успостављен константном ниском"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "неисправна употреба не-л-вредносног низа"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "неисправан успостављач"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "елемент успостављача није константан"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "низ успостављен не-константним низовним изразом"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "initializer element is not a constant expression"
 msgstr "елемент успостављача није константан"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "претварање из %qT у %qT одбацује одредбе"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "елемент успостављача се не може израчунати при учитавању"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "непрозирни векторски типови не могу бити успостављени"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "сувишна група витичастих заграда на крају успостављача"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "витичасте заграде око скаларног успостављача"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "успостављање флексибилног чланског низа у угњежденом контексту"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "недостају витичасте заграде око успостављача"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "missing initializer for field %qD of %qT"
 msgstr "недостаје успостављач за члан %qD"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "сувишни елементи у скаларном инцијализатору"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "индекс низа у не-низовном успостављачу"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "име поља није у успостављачу слога или уније"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "индекс низа у успостављачу није целобројан"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer not of integer type"
 msgid "array index in initializer is not an integer constant expression"
 msgstr "индекс низа у успостављачу није целобројан"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "неконстантан индекс низа у успостављачу"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "индекс у успостављачу премашује границе низа"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "празан индексни опсег у успостављачу"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "индексни опсег у успостављачу премашује границе низа"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "успостављено поље пребрисано"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "успостављено поље са споредним ефектима пребрисано"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "сувишни елементи у успостављачу уније"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "сувишни елементи у успостављачу структуре"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "нестатичко успостављање флексибилног чланског низа"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "сувишни елементи у успостављачу уније"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "традиционални Ц одбија успостављање унија"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "сувишни елементи у успостављачу низа"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "сувишни елементи у успостављачу вектора"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "сувишни елементи у успостављачу скалара"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ИСО Ц не дозвољава додатно %<;%> изван функције"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in output operand outside of a function"
 msgstr "тип променљиве величине декларисан изван било које функције"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "излазни операнд %d мора користити ограничење %<&%>"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "label %qE referenced outside of any function"
 msgid "%<-%> modifier used inside of a function"
 msgstr "на етикету %qE упућено ван било које функције"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in input operand outside of a function"
 msgstr "тип променљиве величине декларисан изван било које функције"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD није дефинисано изван досега функције"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ИСО Ц забрањује %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "computed goto must be pointer type"
 msgstr "не могу да претворим у показивачки тип"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "функција декларисана са %<noreturn%> има наредбу %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> без вредности у функцији која не враћа празан тип"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> са вредношћу у функцији која враћа празан тип"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, fuzzy, gcc-internal-format
 #| msgid "%<return%> with a value, in function returning void"
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "%<return%> са вредношћу у функцији која враћа празан тип"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of label"
 msgstr "функција враћа адресу на локалну променљиву"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "функција враћа адресу на локалну променљиву"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "величина у прекидачу није целобројна"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "%<long%> израз у прекидачу не претвара се у %<int%> у ИСО Ц-у"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "case label is not an integer constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "етикета случаја није у оквиру наредбе прекидача"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "етикета %<default%> није у оквиру наредбе прекидача"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "наредба искакања није у оквиру петље или прекидача"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "неисправан излаз из структуираног блока ОпенМПа"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "наредба искакања употребљена са ОпенМПом за петљу"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "наредба настављања није у оквиру петље"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "наредба без ефекта"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "наредба израза има непотпун тип"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %q#T and %q#T"
 msgid "comparison between types %qT and %qT"
 msgstr "поређење између типова %q#T и %q#T"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "поређење реалних помоћу == или != није безбедно"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "поређењу различитих показивачких типова недостаје претапање"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ИСО Ц забрањује поређење %<void *%> и функцијског показивача"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "поређењу различитих показивачких типова недостаје претапање"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "поређење између показивача и целобројног"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "поређење потпуног и непотпуног показивача"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ИСО Ц забрањује поређена уређености показивача на функције"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with null pointer"
 msgstr "поређење уређености показивача са целобројном нулом"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "поређење уређености показивача са целобројном нулом"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "употребљен низ који се не може претворити у показивач где се захтева скалар"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "употребљена вредност структурног типа где се захтева скалар"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "употребљена вредност унијског типа где се захтева скалар"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "used vector type where scalar is required"
 msgstr "употребљена вредност структурног типа где се захтева скалар"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "превише %qs одредби"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "low bound %qE of array section does not have integral type"
 msgstr "величина у низовном new мора бити интегралног типа"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "length %qE of array section does not have integral type"
 msgstr "величина у низовном new мора бити интегралног типа"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected single pointer in %qs clause"
 msgstr "очекивана је дословна ниска"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, fuzzy, gcc-internal-format
 #| msgid "Copy array sections into a contiguous block on procedure entry"
 msgid "array section is not contiguous in %qs clause"
 msgstr "Копирај одељке низа у непрекидан блок при улазу у процедуру"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qE does not have pointer or array type"
 msgstr "%qE нема класни тип"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "баца се NULL, које има интегрални, а не показивачки тип"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qs has invalid type"
 msgid "iterator %qD has const qualified type"
 msgstr "битско поље %qs има неисправан тип"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "битско поље %qD неинтегралног типа"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 #| msgid "expression reference type error at %L"
 msgid "begin expression refers to outer iterator %qD"
 msgstr "грешка типа упућивача израза код %L"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "expression reference type error at %L"
 msgid "end expression refers to outer iterator %qD"
 msgstr "грешка типа упућивача израза код %L"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "expression reference type error at %L"
 msgid "step expression refers to outer iterator %qD"
 msgstr "грешка типа упућивача израза код %L"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected pointer in %qs clause"
 msgstr "очекивана је одредба %<#pragma omp%>"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in %s clause at %L"
 msgid "zero sized type %qT in %qs clause"
 msgstr "Низ претпостављене величине ‘%s’ у одредби ‘%s’ код %L"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "No variable %qs defined in type %qs"
 msgid "variable sized type %qT in %qs clause"
 msgstr "Променљива %qs није дефинисана у типу %qs"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE има неисправан тип за %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "No label definition found for %qs"
 msgid "user defined reduction not found for %qE"
 msgstr "Није нађена дефиниција етикете за %qs"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE мора бити нитно-локално за %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE није променљива у одредби %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE није променљива у одредби %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "тип уз векторско delete није ни показивачки ни низовни"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "Име ‘%s’ се не може употребити као дефинисани оператор код %C"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "array must be initialized with a brace-enclosed initializer"
 msgid "traits array must be initialized with constants"
 msgstr "успостављач низа мора бити нешто у витичастим заградама"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression in array specification at %C"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "Очекиван је израз у одредници низа код %C"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported map expression %qE"
 msgstr "неподржана комбинација: %s"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 #| msgid "%qE appears more than once in data clauses"
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE није променљива у одредби %qs"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "%s variable %qs is private in outer context"
 msgid "%qs variable is not a pointer"
 msgstr "%s променљива %qs је приватна у спољашњем контексту"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "тип уз векторско delete није ни показивачки ни низовни"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %qs clauses on a task construct"
 msgstr "превише %qs одредби"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, fuzzy, gcc-internal-format
 #| msgid "%<-G%> is incompatible with %<-mabicalls%>"
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "%<-G%> није сагласно са %<-mabicalls%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD мора узимати %<void%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared"
 msgid "%qD shall not be const"
 msgstr "%qD није декларисано"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE је предодређено као %qs за %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "први аргумент за %<va_arg%> није типа %<va_list%>"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "први аргумент за %<va_arg%> није типа %<va_list%>"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "први аргумент за %<va_arg%> није типа %<va_list%>"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -60126,258 +60173,253 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s or %s"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "Ознака %s код %L мора бити типа %s или %s"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: invalid file name: %s\n"
 msgid "%s: Invalid field type %s:"
 msgstr "%s: неисправно име датотеке: %s\n"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "is not a valid GIMPLE statement"
 msgid "Not valid for ACCEPT statement."
 msgstr "није исправна ГИМПЛЕ наредба"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "is not a valid GIMPLE statement"
 msgid "Not valid for DISPLAY statement."
 msgstr "није исправна ГИМПЛЕ наредба"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr ""
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT се разрешава до %qT, што није класни тип"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -60386,75 +60428,85 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "декларација изведеног типа"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unknown dest"
 msgid "Unknown type %d"
 msgstr "Непознато одредиште"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "Attempting an assignment of differing types."
 msgstr "циљеви показивача у додели разликују се у означености"
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr ""
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -60464,13 +60516,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "превише улазних датотека"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr ""
@@ -60486,67 +60538,67 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr "%s: %s изађе са статусом %d\n"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: wait: %s\n"
 msgid "%s: data item %s #"
 msgstr "%s: чекање: %s\n"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mask must be an immediate"
 msgid "%s: key must be field"
 msgstr "маска мора бити непосредна"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "spec '%s' has invalid '%%W%c"
 msgid "%s: %s %s has invalid encoding"
 msgstr "навод ‘%s’ има неисправно ‘%%W%c’"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: would convert file '%s'\n"
 msgid "%s:%d: could not add '%s'"
 msgstr "%s: претворио би датотеку ‘%s’\n"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "(%s %s %s %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "(%s %s %s %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling '%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s: компилујем ‘%s’\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -61037,7 +61089,7 @@ msgstr "нема погодног %<operator %s%> за %qT"
 msgid "%q#D is private within this context"
 msgstr "у овом контексту"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "declared private here"
@@ -61049,7 +61101,7 @@ msgstr "%q+D декларисано овде"
 msgid "%q#D is protected within this context"
 msgstr "у овом контексту"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "declared protected here"
@@ -61413,7 +61465,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr "конструктор не може бити виртуелан"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI"
@@ -61436,7 +61488,7 @@ msgstr "нема одговарајуће функције за позив %<%T:
 msgid "call to non-function %qD"
 msgstr "позив не-функције %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -62103,7 +62155,7 @@ msgstr "%Jфлексибилан члански низ у иначе празн
 msgid "next member %q#D declared here"
 msgstr "  %q+#D декларисано овде"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "поновна дефиниција %q#T"
@@ -62113,7 +62165,7 @@ msgstr "поновна дефиниција %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -62255,7 +62307,7 @@ msgstr "неисправан апстрактни повратни тип за 
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -62308,7 +62360,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr ""
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -62345,340 +62397,340 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "%Hбиће ухваћен изузетак типа %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qD не може имати променљив број аргумената"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D декларисано са одредницом изузетака"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "storage size not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "величина складишта није константна"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D декларисано са одредницом изузетака"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s не подржава %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr ""
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %qs call"
 msgstr "погрешан број аргумената наведне за атрибут %qs"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr ""
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr ""
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "%q+E is not a constant expression"
 msgstr "Недостаје или неисправан константан израз"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "позив не-функције %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer"
 msgstr "разрешавање %<void *%> показивача"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr ""
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to internal function %qE"
 msgstr "позив не-функције %qD"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 #| msgid "original label is here"
 msgid "originally declared %<const%> here"
 msgstr "првобитна етикета је овде"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "тип %qT није основни тип за тип %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr ""
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an ambiguous base of %qT"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT је двосмислена основа за %qT"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "чланска функција %qD не може се позвати без објекта"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qT"
 msgstr "не могу да извршим ‘%s’: %s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "декларација пријатеља не именује ни класу ни функцију"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "storage size not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "величина складишта није константна"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 #| msgid "allocating zero-element array"
 msgid "allocation performed here"
 msgstr "резервисање низа нулте дужине"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "декларација %qD заклања претходну локалну"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D was used with no declaration before its definition"
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%q+D је употребљено без декларације пре дефиниције"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD called in a constant expression"
 msgstr "%qD се не може јавити у константном изразу"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D was used with no prototype before its definition"
 msgid "%qD used before its definition"
 msgstr "%q+D је употребљено без прототипа пре дефиниције"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, fuzzy, gcc-internal-format
 #| msgid "protocol %qs has circular dependency"
 msgid "call has circular dependency"
 msgstr "протокол %qs има кружну зависност"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "дубина извођења шаблона премашује максимум од %d (употребите -ftemplate-depth-NN да повећате дубину) извођења %qD"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "reference to %qD is not a constant expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "преливање у константном изразу"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is negative"
 msgstr "негативан десни помак"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr ""
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "леви операнд зарез-израза нема ефекта"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "shift expression %q+E overflows"
 msgstr "интегрални израз %qE није константа"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized array element"
 msgstr "недостаје успостављач за члан %qD"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "разрешавање %<void *%> показивача"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
@@ -62686,578 +62738,578 @@ msgstr "разрешавање %<void *%> показивача"
 msgid "%qE is not a constant expression"
 msgstr "Недостаје или неисправан константан израз"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%qD се не може јавити у константном изразу"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized member %qD"
 msgstr "недостаје успостављач за члан %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr ""
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер је показивач"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr ""
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr ""
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "шаблонски параметар %qD типа %qT није дозвољен у интегралном константном изразу јер није интегралног или набројивог типа"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr ""
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%s се не може користити овде у асемблеру"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qT object created here"
 msgstr "%q+D декларисано овде"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q#D declared here"
 msgstr "%q+D декларисано овде"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "allocated here"
 msgstr "позвано одавде"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 #| msgid "array used as initializer"
 msgid "%qD used in its own initializer"
 msgstr "низ употребљен као успостављач"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%q#D is not const"
 msgstr "%q#T није класа"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D is private"
 msgid "%q#D is volatile"
 msgstr "%q+#D је приватно"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD се не може јавити у константном изразу"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD није декларисано у овом досегу"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 #| msgid "expression in new-declarator must have integral or enumeration type"
 msgid "%qD does not have integral or enumeration type"
 msgstr "израз у декларатору new мора имати интегрални или набројиви тип"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "декларација %q#D изван класе није дефиниција"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "inline assembly is not a constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "неисправна употреба %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D декларисано са одредницом изузетака"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral and non-enumeral type in conditional expression"
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "набројиви и ненабројиви тип у условном изразу"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "%s не може да се јави у константном изразу"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "шаблонски параметар %qD типа %qT није дозвољен у интегралном константном изразу јер није интегралног или набројивог типа"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr ""
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr ""
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%s не може да се јави у константном изразу"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "expression %qE is not a constant expression"
 msgstr "интегрални израз %qE није константа"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "%<goto%> is not a constant expression"
 msgstr "преливање у константном изразу"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "statement is not a constant expression"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unexpected expression %qE of kind %s"
 msgstr "очекиван је израз"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "‘B’ операнд није константа"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "contract predicate is false in constant expression"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "%<break%> must be in loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "%<break%> мора бити у оквиру петље или прекидача"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<continue%> must be in loop"
 msgid "%<continue%> outside of a loop"
 msgstr "%<continue%> мора бити у оквиру петље"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "%Jjump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "%Jскок у наредбени израз"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "неисправно претапање д-вредносног израза типа %qT у тип %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "виртуелне функције не могу бити пријатељи"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "division by zero is not a constant expression"
 msgstr "Недостаје или неисправан константан израз"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "%<delete[]%> is not a constant expression"
 msgstr "Лош тип у константном изразу"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "преливање у константном изразу"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "non-constant array initialization"
 msgstr "неконстантан индекс низа у успостављачу"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected end of file in '%s'"
 msgid "unexpected AST of kind %s"
@@ -63404,410 +63456,410 @@ msgstr "неисправан операнд у инструкцији"
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not nothrow copy assignable"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not nothrow default constructible"
 msgstr "тип %qs нема подразумевани конструктор за позивање"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr ""
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not trivially copy assignable"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not trivially default constructible"
 msgstr "тип %qs нема подразумевани конструктор за позивање"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qT is not trivially copy constructible"
 msgstr "%qs није исправна излазна датотека"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qT is not trivially destructible"
 msgstr "%qs није исправна излазна датотека"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr ""
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "base class %q#T has a non-virtual destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "основна класа %q#T има не-виртуелни деструктор"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an abstract class"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an aggregate"
 msgstr "%qT није скупински тип"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an array"
 msgstr "%qT није скупински тип"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT није основа за %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a bounded array"
 msgstr "%qT није именски простор"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a const type"
 msgstr "%qD није тип"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not default constructible, because"
 msgstr "тип %qs нема подразумевани конструктор за позивање"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D hides constructor for %q#T"
 msgid "%qT is not constructible from %qT, because"
 msgstr "%q#D скрива конструктор за %q#T"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not destructible, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an empty class"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT није шаблон"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a final class"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qT is not a function"
 msgstr "%q+D није функција,"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not invocable, because"
 msgstr "%q#T није класа"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qT није основа за %qT"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qE није променљива у одредби %qs"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a literal type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD није чланска шаблонска функција"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT није члан из %qT"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT није члан из %qT"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has no default constructor to call"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "тип %qs нема подразумевани конструктор за позивање"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qE није променљива у одредби %qs"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT није типа показивач-на-објекат"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a POD type"
 msgstr "%qD није тип"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not a pointer"
 msgstr "%qT није шаблон"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT није именски простор"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT није основа за %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "%qT није именски простор"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a trivial type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr ""
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not trivially copyable"
 msgstr "%qT није шаблон"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not trivially destructible, because"
 msgstr "%qT није приступна основа од %qT"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an unbounded array"
 msgstr "%qT није скупински тип"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qT is not a union"
 msgstr "%q+D није функција,"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT није основа за %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "argument %qd is not a constant"
-msgid "%qT is not consteval-only"
-msgstr "аргумент %qd није константа"
+#| msgid "%qT is not a template type"
+msgid "%qT is not a structural type"
+msgstr "%qT није шаблонски тип"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE не може бити употребљено као функција"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "%q+#D се не може декларисати"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not destructurable"
 msgstr "%qT није именски простор"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not declared in %qD"
 msgid "%qD is not deducible from %qT"
 msgstr "%qD није декларисано у %qD"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid constraints"
 msgstr "неисправна ограничења за операнд"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "адреса за %qD ће увек бити израчуната као %<true%>"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "constructors may not be cv-qualified"
 msgid "constraints not satisfied"
 msgstr "конструктори не могу бити кн-одређени"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -63842,52 +63894,52 @@ msgstr "asm декларација игнорисана услед сукоба
 msgid "previous declaration with fewer contracts here"
 msgstr "претходна декларација %q+D беше овде"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD declared void"
 msgid "parameter declared here"
 msgstr "параметар %qD декларисан празним"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "декларација %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "first declared here"
 msgstr "%q+D декларисано овде"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "constructor does not return a value to test"
 msgstr "Функција не враћа вредност"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "destructor does not return a value to test"
 msgstr "Функција не враћа вредност"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "function does not return a value to test"
@@ -63964,7 +64016,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%q+#D претходно декларисано овде"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "no member named %qE in %qT"
@@ -64048,90 +64100,90 @@ msgstr "одређени тип %qT не поклапа се са именом 
 msgid "awaitable type %qT is not a structure"
 msgstr "одређени тип %qT не поклапа се са именом деструктора ~%qT"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot be used with a constant"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs не може бити употребљено са константом"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "функција декларисана са %<noreturn%> има наредбу %<return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "трећи аргумент за %<__builtin_prefetch%> мора бити константа"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "трећи аргумент за %<__builtin_prefetch%> мора бити константа"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %q+D"
 msgid "no suspend point info for %qD"
 msgstr "нема претходног прототипа за %q+D"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "удвостручено %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "показивачи нису дозвољени као вредности случаја"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -64158,76 +64210,82 @@ msgstr "%qD није шаблонска функција"
 msgid "%qs used outside of constant expressions"
 msgstr "Лош тип у константном изразу"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "Duplicate %s declaration %qs"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "Удвостручена %s декларација %qs"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static member function %qD"
 msgid "taking address of an immediate function %qD"
 msgstr "неисправна употреба нестатичке чланске функције %qD"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "адреса за %qD ће увек бити израчуната као %<true%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qs attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "неисправан аргумент за атрибут %qs"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in template argument list"
 msgid "use fold expression in the attribute argument instead"
 msgstr "грешка у рашчлањивању листе шаблонских аргумената"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD није тип"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not a class type"
 msgstr "%qD није тип"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qE нема класни тип"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qD does not have integral type"
 msgstr "%qE нема класни тип"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -64280,7 +64338,7 @@ msgstr "неисправно успостављање неконстантног
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "претварање из %qT у %qT одбацује одредбе"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "претапање %qT у %qT не разрешава показивач"
@@ -64718,7 +64776,7 @@ msgstr "од претходне декларације %q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "Декларација %qs заклања претходну декларацију етикете"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D"
 msgid "previous declaration %qD"
@@ -64972,13 +65030,13 @@ msgstr "подразумевани аргумент дат за парамета
 msgid "previous specification in %q#D here"
 msgstr "после претходног навода у %q+#D"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "сукобљена декларација %q#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "previously declared here without exporting"
@@ -65206,7 +65264,7 @@ msgstr "  прескаче успостављање %q+#D"
 msgid "  enters %<template for%> statement"
 msgstr "очекивана је декларација или наредба"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -65256,601 +65314,601 @@ msgstr "%<typename %T::%D%> именује %q#T, што није тип"
 msgid "template parameters do not match template %qD"
 msgstr "параметри шаблона се не поклапају са шаблоном"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "захтевано равнање није степен двојке"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D invalid; an anonymous union can only have non-static data members"
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q+#D није исправно; анонимна унија може имати само нестатичке чланске податке"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "анонимна структура није унутар именованог типа"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "члан %q+#D са конструктором није дозвољен у анонимној скупини"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "члан %q+#D са деструктором није дозвољен у анонимној скупини"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "члан %q+#D са оператором копирања-доделе није дозвољен у анонимној скупини"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attribute ignored in declaration of %q#T"
 msgstr "атрибут игнорисан у декларацији %q+#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, fuzzy, gcc-internal-format
 #| msgid "attribute for %q+#T must follow the %qs keyword"
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "атрибут за %q+#T мора пратити кључну реч %qs"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "вишеструки типови у једној декларацији"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "поновљена декларација Ц++ уграђеног типа %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%qs може бити наведено само за функције"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "недостаје име типа у наредби typedef"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ИСО Ц++ забрањује анонимне структуре"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "%qs може бити наведено само за функције"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%qs може бити наведено само за функције"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> може бити наведено само унутар класе"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> може бити наведено само за конструкторе"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "складишна класа може бити наведена само за објекте и функције"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "одредбе могу бити наведене само за објекте и функције"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "одредбе могу бити наведене само за објекте и функције"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "одредбе могу бити наведене само за објекте и функције"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "a storage class can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "складишна класа може бити наведена само за објекте и функције"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 #| msgid "typedef declaration invalid in parameter declaration"
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "декларација typedef није исправна у декларацији параметра"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "Class %qs not found in type declaration"
 msgid "%qs cannot be used for type declarations"
 msgstr "Класа %qs не налази се у декларацији типа"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "атрибут се игнорише при извођењу шаблона"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
 msgid "attribute ignored"
 msgstr "атрибут %qE се игнорише"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %qD is initialized (use __typeof__ instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "дефиниција типа %qD је успостављена (употребите __typeof__)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "декларација %q#D има %<extern%> и ипак је успостављена"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "дефиниција %q+D означена као %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q#D је нестатички члански податак у %qT"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member-template declaration of %qD"
 msgstr "декларација шаблона %q#D"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member template declaration %qD"
 msgid "does not match member template declaration here"
 msgstr "неисправна декларација чланског шаблона %qD"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ИСО Ц++ не дозвољава да %<%T::%D%> буде дефинисано као %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "удвостручено успостављање %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "декларација %q#D изван класе није дефиниција"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "променљива %q#D има успостављач али је непотпуног типа"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "елементи низа %q#D имају непотпун тип"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "скупина %q#D има непотпун тип и не може се дефинисати"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD декларисано као упућивач али није успостављено"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, fuzzy, gcc-internal-format
 #| msgid "name %qD used in a GNU-style designated initializer for an array"
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "име %qD употребљено у успостављачу низа утврђеном као Гну-стил"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "име %qD употребљено у успостављачу низа утврђеном као Гну-стил"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "нетривијални утврђени успостављачи нису подржани"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "успостављач не одређује величину %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "недостаје величина низа у %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "низ %qD нулте величине"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of %q+D isn%'t known"
 msgid "storage size of %qD isn%'t known"
 msgstr "величина складишта за %q+D није позната"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of %q+D isn%'t constant"
 msgid "storage size of %qD isn%'t constant"
 msgstr "величина складишта за %q+D није константна"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "извините: семантика статичких података уткане функције %q+#D је погрешна (доћи ће до вишеструких копија)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "извините: семантика статичких података уткане функције %q+#D је погрешна (доћи ће до вишеструких копија)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 #| msgid "%J  you can work around this by removing the initializer"
 msgid "you can work around this by removing the initializer"
 msgstr "%J  можете ово заобићи уклањањем успостављача"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "неуспостављена константа %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "регистарска променљива %qD употребљена у угњежденој функцији"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 #| msgid "%Juninitialized member %qD with %<const%> type %qT"
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "%Jнеуспостављени члан %qD са %<const%> типом %qT"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has a user-defined constructor"
 msgid "%q#T has no user-provided default constructor"
 msgstr "тип %qs има кориснички дефинисан конструктор"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "неисправан тип %qT као успостављач за вектор типа %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "успостављач за %qT мора бити у витичастим заградама"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, fuzzy, gcc-internal-format
 #| msgid "name %qD used in a GNU-style designated initializer for an array"
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "име %qD употребљено у успостављачу низа утврђеном као Гну-стил"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "двосмислен захтев за чланом %qD"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT нема нестатички члански податак по имену %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD није члан у %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer for %q#D"
 msgstr "неисправан успостављач"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "превише успостављача за %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "витичасте заграде око скаларног успостављача за тип %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "витичасте заграде око скаларног успостављача за тип %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "недостају витичасте заграде око успостављача за %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %P has incomplete type %qT"
 msgid "structured binding has incomplete type %qT"
 msgstr "параметар %P непотпуног је типа %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 #| msgid "elements of array %q#D have incomplete type"
 msgid "elements of array %q#T have incomplete type"
 msgstr "елементи низа %q#D имају непотпун тип"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids compound literals"
 msgid "variable-sized compound literal"
 msgstr "ИСО Ц 90 забрањује сложене дословне ниске"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has incomplete type"
 msgid "%q#D has incomplete type"
 msgstr "%qD има непотпун тип"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "скаларни објекат %qD захтева један елемент у успостављачу"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be initialized by constructor, not by %<{...}%>"
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "%qD мора бити успостављен конструктором, не помоћу %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "низ %qD успостављен заграђеном константном ниском %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "успостављач неисправан за статички члан са конструктором"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "ИСО Ц++ забрањује успостављање унутар класе неконстантног статичког члана %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "ИСО Ц++ забрањује успостављање унутар класе неконстантног статичког члана %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(потребно је успостављање изван класе)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "затражена је адреса експлицитне регистарске променљиве %qD"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD is initialized"
 msgid "reference %qD is initialized with itself"
 msgstr "параметар %qD је успостављен"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "Стварни аргумент за ‘%s’ код %L мора бити показивач"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "Class %qs not found in type declaration"
 msgid "could not find variant declaration"
 msgstr "Класа %qs не налази се у декларацији типа"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "%s: recursive invocation of constructor %qs"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%s: рекурзивно позивање конструктора %qs"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "%<declare variant%> on destructor %qD"
 msgstr "поновљена декларација набрајача %q+D"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "декларација шаблона %q#D"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "%<declare variant%> on deleted %qD"
 msgstr "декларација шаблона %q#D"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%<declare variant%> on virtual %qD"
 msgstr "%qD декларисано као %<virtual%> %s"
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "додела (не успостављање) у декларацији"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ИСО Ц++ не дозвољава утврђене успостављаче"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %qs"
 msgid "%<register%> storage class specifier used"
 msgstr "складишна класа наведена за %qs"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D has %<extern%> and is initialized"
 msgid "declaration of %q#D has no initializer"
 msgstr "декларација %q#D има %<extern%> и ипак је успостављена"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -65858,131 +65916,131 @@ msgstr "повратни тип %q#T није потпун"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::main%> cannot be deleted"
 msgstr "%<::%D%> није декларисано"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "заклањање претходне декларације типа за %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr ""
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "функција %q#D успостављена као променљива"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decompose address"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "не могу да разложим адресу"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "lambda declared here"
 msgstr "%q+D декларисано овде"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at %q+D because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "  не може се користити застарело везивање код %q+D јер има деструктор"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an inaccessible base of %qT"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "%qT је неприступачна основа за %qT"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT није угњеждена класа у %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "structured binding refers to incomplete type %qT"
 msgstr "не може се %s показивач на непотпуни тип %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD includes %s to array of unknown bound %qT"
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "параметар %qD укључује %s у низ непознатих граница %qT"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare variable %q+D to be of abstract type %qT"
 msgid "cannot decompose variable length array %qT"
 msgstr "не може се декларисати променљива %q+D апстрактног типа %qT"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot decompose variable length vector %qT"
 msgstr "не може се декларисати показивач на %q#T"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "cannot decompose union type %qT"
 msgstr "не може се претворити из типа %qT у %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "стварање показивача на члан некласног типа %qT"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "не може се %s показивач на непотпуни тип %qT"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initializer provided for function"
 msgid "%u name provided for structured binding"
@@ -65992,7 +66050,7 @@ msgstr[1] "успостављач дат за функцију"
 msgstr[2] "успостављач дат за функцију"
 msgstr[3] "успостављач дат за функцију"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
@@ -66001,7 +66059,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
@@ -66010,1910 +66068,1921 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr ""
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 #| msgid "initialization string truncated to match variable at %L"
 msgid "in initialization of structured binding variable %qD"
 msgstr "успостављачка ниска подсечена да одговара променљивој код %L"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to static data member %qD"
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "не могу применити %<offsetof%> на статички члански податак %qD"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 #| msgid "initializer fails to determine size of %qD"
 msgid "initializer fails to determine size of %qT"
 msgstr "успостављач не одређује величину %qD"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 #| msgid "array size missing in %qD"
 msgid "array size missing in %qT"
 msgstr "недостаје величина низа у %qD"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 #| msgid "zero-size array %qD"
 msgid "zero-size array %qT"
 msgstr "низ %qD нулте величине"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "деструктор за туђинску класу %qT не може бити члан"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "конструктор за туђинску класу %qT не може бити члан"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD декларисано као %<virtual%> %s"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "наводиоци функције %<const%> и %<volatile%> за %qD нису исправни у декларацији %s"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD декларисано као %<virtual%> %s"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD декларисано као %<inline%> %s"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "наводиоци функције %<const%> и %<volatile%> за %qD нису исправни у декларацији %s"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD декларисано као %<virtual%> %s"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD декларисано као %<inline%> %s"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "наводиоци функције %<const%> и %<volatile%> за %qD нису исправни у декларацији %s"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD декларисано као %<virtual%> %s"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD декларисано као %<inline%> %s"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 #| msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in %s declaration"
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "наводиоци функције %<const%> и %<volatile%> за %qD нису исправни у декларацији %s"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D декларисано као пријатељ"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D декларисано са одредницом изузетака"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "дефиниција %qD није у именском простору који обухвата %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "статичка чланска функција %q#D декларисана са одредбама типа"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "именоване повратне вредности нису више подржане"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD није шаблонска функција"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "декларација пријатеља није у дефиницији класе"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "дефиниција експлицитне специјализације %qD у декларацији пријатеља"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "неисправна употреба ид. шаблона %qD у декларацији примарног шаблона"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "подразумевани аргументи нису дозвољени у декларацији пријатељске специјализације шаблона %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> није дозвољено у декларацији пријатељске специјализације шаблона %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "декларација %q#D изван класе није дефиниција"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "%<::main%> се не може декларисати као шаблон"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "%<::main%> се не може декларисати као уткано"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "%<::main%> се не може декларисати као статичко"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "%<::main%> се не може декларисати као статичко"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "%<::main%> се не може декларисати као шаблон"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "explicit object parameter declared here"
 msgstr "шаблонски параметарски тип %qT декларисан пријатељским"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "  declared here"
 msgstr "%q+D декларисано овде"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "декларација %qD као не-функције"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 #| msgid "template with C linkage"
 msgid "literal operator with C linkage"
 msgstr "шаблон са Ц повезивошћу"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option argument %qs"
 msgid "%qD has invalid argument list"
 msgstr "неисправан аргумент опције %qs"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-member function"
 msgstr "%qD мора бити нестатичка чланска функција"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> мора враћати %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "дефиниција имплицитно декларисаног %qD"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "definition of implicitly-declared %qD"
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "дефиниција имплицитно декларисаног %qD"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "%q#D explicitly defaulted here"
 msgstr "%q+#D претходно дефинисано овде"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "чланска функција %q#D није декларисана у класи %qT"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "%<::main%> се не може декларисати као шаблон"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 #| msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "аутоматска променљива %qE не може бити нитно-локална"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "strong using only meaningful at namespace scope"
 msgid "concept must be defined at namespace scope"
 msgstr "јако using има смисла само у досегу именског простора"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "именоване повратне вредности нису више подржане"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "неисправно успостављање унутар класе статичког чланског податка неинтегралног типа %qT"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "неисправно успостављање унутар класе статичког чланског податка неинтегралног типа %qT"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "неисправно успостављање унутар класе статичког чланског податка неинтегралног типа %qT"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "неисправно успостављање унутар класе статичког чланског податка неинтегралног типа %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ИСО Ц++ забрањује успостављање унутар класе неконстантног статичког члана %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ИСО Ц++ забрањује успостављање чланске константе %qD неинтегралног типа %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "величина низа %qD има неинтегрални тип %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "величина низа има неинтегрални тип %qT"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "величина низа %qD није интегралан констатан израз"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "величина низа није интегралан констатан израз"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ИСО Ц++ забрањује низ нулте величине %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ИСО Ц++ забрањује низ нулте величине"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids variable-size array %qD"
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ИСО Ц++ забрањује низ променљиве величине %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids variable-size array"
 msgid "ISO C++ forbids variable length array"
 msgstr "ИСО Ц++ забрањује низ променљиве величине"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "преливање у димензији низа"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not declare a template type"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD не декларише шаблонски тип"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "стварање показивача на члан упућивачког типа %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of voids"
 msgid "declaration of %qD as array of void"
 msgstr "декларација %qs као низа празних"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of void"
 msgstr "стварање низа типа %qT"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of functions"
 msgstr "декларација %qs као низа функција"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of functions"
 msgstr "стварање низа типа %qT"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of references"
 msgstr "декларација %qs као низа функција"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of references"
 msgstr "стварање низа типа %qT"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of function members"
 msgstr "декларација %qs као низа функција"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "creating array of function members"
 msgstr "декларација %qs као низа функција"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "декларација %qD као вишедимензионог низа мора имати границе за све димензије осим прве"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "вишедимензиони низ мора имати границе за све димензије осим прве"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "навод повратног типа за конструктор није исправан"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "одредбе нису дозвољене уз декларацију %<operator %T%>"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "навод повратног типа за деструктор није исправан"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "одредбе нису дозвољене уз декларацију %<operator %T%>"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "наведен повратни тип за %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "одредбе нису дозвољене уз декларацију %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "навод повратног типа за деструктор није исправан"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "одредбе нису дозвољене уз декларацију %<operator %T%>"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 #| msgid "too many template parameter lists in declaration of %qD"
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "превише листа шаблонских параметара у декларацији %qD"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "сукобљени наводиоци у декларацији %qs"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "неименована променљива или поље декларисано празним"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "променљива или поље декларисано празним"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "наводилац %<inline%> није исправан за функцију %qs декларисану изван глобалног досега"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "%qE није на почетку декларације"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "деструктори не могу бити кн-одређени"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together for %qs"
 msgid "%e and %e specified together"
 msgstr "%<signed%> и %<unsigned%> наведени заједно за %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "неисправна употреба одређеног имена %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "неисправна употреба одређеног имена %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "неисправна употреба одређеног имена %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT није ни класа ни именски простор"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "декларација %qD као не-функције"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "декларација %qD као не-члана"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "недостаје ид. декларатора; користи се резервисана реч %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "дефиниција функције не декларише параметре"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "декларација %qD као не-функције"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as %s"
 msgid "declaration of %qD as %<typedef%>"
 msgstr "декларација %qD као %s"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q+D shadows a parameter"
 msgid "declaration of %qD as parameter"
 msgstr "декларација %q+D заклања параметар"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, fuzzy, gcc-internal-format
 #| msgid "no classes specified"
 msgid "both %qs and %qs specified"
 msgstr "није наведена ниједна класа"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "Class %qs not found in type declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "Класа %qs не налази се у декларацији типа"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "два или више типова података у декларацији %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain %<complex%> meaning %<double complex%>"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ИСО Ц не подржава да обичан %<complex%> значи %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ИСО Ц++ забрањује декларацију %qs без типа"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_saveregs not supported by this target"
 msgid "%<__int%d%> is not supported by this target"
 msgstr "__builtin_saveregs није подржано овим циљем"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support %<long long%>"
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ИСО Ц++ не подржава %<long long%>"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "no class name specified with %qs"
 msgid "%qs specified with %qT"
 msgstr "нема имена класе наведеног помоћу %qs"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr ""
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 #| msgid "%qs not specified in enclosing parallel"
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs није наведено у обухватајућем паралелном"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qs specified with %<typeof%>"
 msgstr "%<__thread%> употребљено уз %<typedef%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "complex неисправно за %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "члан %qD не може бити декларисан и као виртуелни и као статички"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "члан %qD не може бити декларисан и као виртуелни и као статички"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "декларација typedef није исправна у декларацији параметра"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter %qs"
 msgid "storage class specified for template parameter %qs"
 msgstr "складишна класа наведена за параметар %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "складишна класа наведена за параметар %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "a parameter cannot be declared %qs"
 msgstr "шаблонски параметри не могу бити пријатељи"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "virtual outside class declaration"
 msgid "%<virtual%> outside class declaration"
 msgstr "virtual изван декларације класе"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "structured binding declaration cannot be %qs"
 msgstr "атрибут игнорисан у декларацији %q+#T"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "structured binding declaration cannot have type %qT"
 msgstr "атрибут игнорисан у декларацији %q+#T"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "вишеструке складишне класе у декларацији %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "складишна класа наведена за %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "угњеждена функција %qs декларисана као %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "декларација %qs на највишем нивоу наводи %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "%qs досега функције имплицитно аутоматска и декларасина као %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "наводиоци складишне класе нису исправни у декларацијама пријатељских функција"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "вишеструке складишне класе у декларацији %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "Очекивана је лева заграда"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to member function used in arithmetic"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "показивач на чланску функцију употребљен у аритметици"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "виртуелне функције не могу бити пријатељи"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "неисправна употреба %<restrict%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "неисправна употреба конструктора као шаблона"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "одредбе типова се игноришу на повратном типу функције"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs декларисано као функција која враћа функцију"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs декларисано као функција која враћа низ"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "%<noreturn%> function returns non-void value"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "функција са %<noreturn%> враћа непразну вредност"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "деструктор не може бити статичка чланска функција"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "конструктор не може бити статичка чланска функција"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "деструктори не могу бити кн-одређени"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "конструктори не могу бити кн-одређени"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "destructors may not be ref-qualified"
 msgstr "деструктори не могу бити кн-одређени"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "constructors may not be cv-qualified"
 msgid "constructors may not be ref-qualified"
 msgstr "конструктори не могу бити кн-одређени"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "конструктор не може бити виртуелан"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "виртуелне функције не могу бити пријатељи"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "декларација пријатеља није у дефиницији класе"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 #| msgid "can't define friend function %qs in a local class definition"
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "не може се дефинисати пријатељска функција %qs у дефиницији локалне класе"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "%sчланска функција %qD не може имати кн-одредбу"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "non-object member %qs cannot be declared %<mutable%>"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "не-објектни члан %qs не може бити декларисан %<mutable%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD мора бити нестатичка чланска функција"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "деструктори не могу имати параметре"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "не може се декларисати показивач на %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "не може се декларисати упућивач на %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "не може се декларисати показивач на члан %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "не може се декларисати упућивач на %q#T"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "не може се декларисати битско поље %qD са функцијским типом"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "ид. шаблона %qD употребљен као декларатор"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "чланске функције су имплицитно пријатељи својих класа"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "сувишна одредба %<%T::%> на члану %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot define member function %<%T::%s%> within %<%T%>"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "не може се дефинисати чланска функција %<%T::%s%> унутар %<%T%>"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function %<%T::%s%> within %<%T%>"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "не може се декларисати функција %<%T::%s%> унутар %<%T%>"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "не може се декларисати члан %<%T::%s%> унутар %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 #| msgid "data member %qD cannot be a member template"
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "члански податак %qD не може бити члански шаблон"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "члански податак не може имати променљиво измењив тип %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "параметар не може имати променљиво измењив тип %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 #| msgid "virtual outside class declaration"
 msgid "%<explicit%> outside class declaration"
 msgstr "virtual изван декларације класе"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%> у празној декларацији"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 #| msgid "only declarations of constructors can be %<explicit%>"
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "само декларације конструктора могу имати %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "не-члан %qs не може бити декларисан %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "не-објектни члан %qs не може бити декларисан %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "функција %qs не може бити декларисана %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "статичко %qs не може бити декларисано %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "константно %qs не може бити декларисано %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 #| msgid "function %qs cannot be declared %<mutable%>"
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "функција %qs не може бити декларисана %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "typedef may not be a function definition"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "typedef may not be a member function definition"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not allowed in other than a declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%> није дозвољено другде осим у декларацији"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %q+D declared %<inline%>"
 msgid "typedef declared %<auto%>"
 msgstr "дефиниција типа %q+D декларисана као %<inline%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, fuzzy, gcc-internal-format
 #| msgid "%Jtypedef name may not be a nested-name-specifier"
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "%Jиме за дефиницију типа не може бити угњеждени-именски-наводилац"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ИСО Ц++ забрањује угњеждени тип %qD истог имена као и обухватајућа класа"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> наведено уз декларацију пријатељске класе"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "шаблонски параметри не могу бити пријатељи"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "декларација пријатеља захтева реч class, тј. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "декларација пријатеља захтева реч class, тј. %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "покушај да се класа %qT учини пријатељем глобалног досега"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "неисправне одредбе уз тип не-чланске функције"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "апстрактни декларатор %qT употребљен као декларација"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of C++ built-in type %qT"
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "поновљена декларација Ц++ уграђеног типа %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "не може се користити %<::%> у декларацији параметра"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter %q+D to be of abstract type %qT"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "не може се декларисати параметар %q+D апстрактног типа %qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%<this%> се не може употребити у овом контексту"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %q+D declared %<inline%>"
 msgid "parameter declared %<auto%>"
 msgstr "параметар %q+D декларисан као %<inline%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "неисправна употреба шаблонског имена %qE без листе аргумената"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "non-static data member declared with placeholder %qT"
 msgstr "статички члан %qD декларисан као %<register%>"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array %qD"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ИСО Ц++ забрањује низ нулте величине %qD"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ИСО Ц 90 не подржава флексибилне чланске низове"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "неисправна употреба %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of C function %q#D conflicts with"
 msgid "declaration of function %qD in invalid context"
 msgstr "декларација Ц функције %q#D коси се са"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "функција %qD декларисана виртуелном унутар уније"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be declared virtual, since it is always static"
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD не може бити декларисана виртуелном, јер је увек статичка"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "очекивано одређено име у декларацији пријатеља за деструктор %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "декларација %qD као члана %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "Constructor can't be %s"
 msgid "a destructor cannot be %qs"
 msgstr "Конструктор не може бити %s"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 #| msgid "expected qualified name in friend declaration for destructor %qD"
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "очекивано одређено име у декларацији пријатеља за деструктор %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 #| msgid "Constructor can't be %s"
 msgid "a constructor cannot be %<concept%>"
 msgstr "Конструктор не може бити %s"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be a member function"
 msgstr "конструктор не може бити статичка чланска функција"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "не могу да отворим %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of implicitly-declared special member function"
 msgid "specialization of variable template %qD declared as function"
 msgstr "специјализација имплицитно декларисане посебне чланске функције"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "variable template declared here"
 msgstr "променљива или поље декларисано празним"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "field %qD has incomplete type %qT"
 msgstr "поље %qD има непотпун тип"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "име %qT има непотпун тип"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE није ни функција ни чланска функција; не може се декларисати пријатељем"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE није ни функција ни чланска функција; не може се декларисати пријатељем"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "дефиниција експлицитне специјализације %qD у декларацији пријатеља"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "static data member %qE declared %qs"
 msgstr "статички члан %qD декларисан као %<register%>"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "Сопствено ‘%s’ код %L не може имати успостављач"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "non-static data member %qE declared %qs"
 msgstr "статички члан %qD декларисан као %<register%>"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "складишна класа %<auto%> неисправна за функцију %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "складишна класа %<register%> неисправна за функцију %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "складишна класа %<__thread%> неисправна за функцију %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %<__thread%> invalid for function %qs"
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "складишна класа %<__thread%> неисправна за функцију %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "наводилац %<inline%> није исправан за функцију %qs декларисану изван глобалног досега"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "навод asm није дозвољен на дефиницији функције"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "%<static%> specified invalid for function %qs declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "%<static%> неисправно наведено за функцију %qs декларисану изван глобалног досега"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "наводилац %<inline%> није исправан за функцију %qs декларисану изван глобалног досега"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "виртуелна не-класна функција %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 #| msgid "No variable %qs defined in class %qs"
 msgid "%qs defined in a non-class scope"
 msgstr "Променљива %qs није дефинисана у класи %qs"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qs declared in a non-class scope"
 msgstr "%qD није декларисано у овом досегу"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "не може се декларисати статичка повезивост за чланску функцију %qD"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "не може се декларисати статичка функција унутар друге функције"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> не може бити употребљено при дефинисању (насупрот декларисања) статичког чланског податка"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "статички члан %qD декларисан као %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "не може се експлицитно декларисати спољашња повезивост за члан %q#D"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<extern%> variable %q+D in %<for%> loop initial declaration"
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "декларација спољашње променљиве %q+D у почетној декларацији %<for%> петље"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "статичко %qs не може бити декларисано %<mutable%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs успостављено и декларисано као %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs има и %<extern%> и успостављач"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 #| msgid "default argument %qE uses local variable %qD"
 msgid "default argument %qE uses %qD"
 msgstr "подразумевани аргумент %qE користи локалну променљиву %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "подразумевани аргумент %qE користи локалну променљиву %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "наводиоци складишне класе нису исправни у декларацијама параметара"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use %<::%> in parameter declaration"
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "не може се користити %<::%> у декларацији параметра"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "параметар %qD неисправно декларише тип метода"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD includes %s to array of unknown bound %qT"
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "параметар %qD укључује %s у низ непознатих граница %qT"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD includes %s to array of unknown bound %qT"
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "параметар %qD укључује %s у низ непознатих граница %qT"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "неисправан конструктор; вероватно сте мислили %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD не може бити декларисано унутар именског простора"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD не може бити декларисано статичко"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD мора бити нестатичка чланска функција"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a member function"
 msgstr "%qD мора бити нестатичка чланска функција"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD мора бити или нестатичка чланска функција или не-чланска функција"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD мора имати аргумент класног или набројивог типа"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ИСО Ц++ забрањује препуњавање оператора ?:"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD не може имати променљив број аргумената"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD мора узимати ниједан или један аргумент"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD мора узимати један или два аргумента"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "постфиксно %qD мора узимати %<int%> као аргумент"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "постфиксно %qD мора узимати %<int%> као други аргумент"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD мора узимати тачно два аргумента"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD мора узимати тачно један аргумент"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD мора узимати тачно два аргумента"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "претварање у %s%s никад неће користити оператор претварања типа"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "претварање у %s%s никад неће користити оператор претварања типа"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "претварање у %s%s никад неће користити оператор претварања типа"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "претварање у %s%s никад неће користити оператор претварања типа"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "претварање у %s%s никад неће користити оператор претварања типа"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "кориснички дефинисано %qD увек израчунава оба аргумента"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "префиксно %qD треба да враћа %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "постфиксно %qD треба да враћа %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD треба да враћа по вредност"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "употреба параметра шаблонског типа %qT после %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous template specialization %qD for %q+D"
 msgid "using alias template specialization %qT after %qs"
 msgstr "двосмислена специјализација шаблона %qD за %q+D"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "употреба typedef-имена %qD после %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D has a previous declaration here"
 msgid "%qD has a previous declaration here"
 msgstr "%q+D има претходну декларацију овде"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT се помиње као %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%qT has a previous declaration here"
 msgstr "%q+T има претходну декларацију овде"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT се помиње као набрајање"
@@ -67925,103 +67994,103 @@ msgstr "%qT се помиње као набрајање"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "потребан шаблонски аргумент за %<%s %T%>"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "двосмислено упућивање на %qD"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "class template %qD redeclared as non-template"
 msgstr "%qD употребљено као шаблон, а није"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD има исто име као и класа у којој је декларисано"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT није шаблон"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "употреба набрајања %q#D без претходне декларације"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "поновљена декларација %qT као не-шаблона"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "неисправна изведена унија %qT"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct or virtual base of %qT"
 msgid "%qT defined with direct virtual base"
 msgstr "тип %qT није непосредна или виртуелна основа од %qT"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "тип основе %qT није класа или структура"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "недефинисан рекурзивни тип %qT"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "неисправан удвостручен тип основе %qT"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "previous definition here"
 msgstr "%Jпретходна дефиниција је овде"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer at %C must be an integer."
 msgid "underlying type %qT of %qT must be an integral type"
@@ -68031,96 +68100,102 @@ msgstr "Крејов показивач код %C мора бити целобр
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "ниједан интегрални тип не може представљати све вредности набрајача за %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qD not integer constant"
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "вредност набрајача за %qD није целобројна константа"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qE is not an integer constant"
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "вредност набрајача за %qE није целобројна константа"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C restricts enumerator values to range of %<int%>"
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "ИСО Ц ограничава вредности набрајача на опсег %<int%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C restricts enumerator values to range of %<int%>"
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "ИСО Ц ограничава вредности набрајача на опсег %<int%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "преливање у вредностима набрајача код %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qE is not an integer constant"
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "вредност набрајача за %qE није целобројна константа"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "вишеструке дефиниције %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "повратни тип %q#T није потпун"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> треба да враћа упућивач на %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statements in function returning %qT"
 msgstr "нема повратне наредбе у функцији која враћа непразан тип"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 #| msgid "function return types not compatible due to %<volatile%>"
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "повратни типови функција нису сагласни услед %<volatile%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "нема повратне наредбе у функцији која враћа непразан тип"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD је већ дефинисано у класи %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "Processing %s\n"
 msgid "using %qs"
 msgstr "Обрађујем %s\n"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D употребљено пре декларисања"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -68592,366 +68667,366 @@ msgstr "ија не задовољава своја ограничења:"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "употреба %<typename%> изван шаблона"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    Included at %s:%d:"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    Укључено код %s:%d:"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    Included at %s:%d:"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    Укључено код %s:%d:"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "    inlined from %qD"
 msgstr "  у позиву %qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In static member function %qD"
 msgstr "У чланској функцији %qs:"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr ""
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "%d constructor(s) found\n"
 msgid "In constructor %qD"
 msgstr "нађених конструктора: %d\n"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "In destructor %qD"
 msgstr "нема подразумеваног аргумента за %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In lambda function"
 msgstr "У чланској функцији %qs:"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In explicit object member function %qD"
 msgstr "У чланској функцији %qs:"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In member function %qD"
 msgstr "У чланској функцији %qs:"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs:"
 msgid "In function %qD"
 msgstr "У функцији %qs:"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "but %qE is a type"
 msgstr "%qD није тип"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "  in thrown expression"
 msgid "but %qE is an expression"
 msgstr "  у баченом изразу"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol at %L is not a DUMMY variable"
 msgid "but %qE is a variable"
 msgstr "Симбол код %L није лажна променљива"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "but %qE is a parameter"
 msgstr "%qE није шаблон"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "but %qE is a function"
 msgstr "%q+D није функција,"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "but %qE is a data member"
 msgstr "%q#T има показивачке чланске податке"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD није шаблон функције"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "but %qE is a class template"
 msgstr "%qE није шаблон"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "but %qE is a variable template"
 msgstr "%qE није шаблон"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD је именски простор"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr ""
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "  у извођењу шаблона %qT"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr ""
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of %q#D"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "експлицитно извођење %q#D"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "required from %q#D\n"
 msgstr "дат за %q+D"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr ""
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "required from here\n"
 msgstr "позвано одавде"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr ""
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr ""
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "без аргумената"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "без аргумената"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "непотпун тип %qT употребљен у угњежденом наводиоцу имена"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "двосмислено упућивање на %<%T::%D%>"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD није члан у %qT"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD није члан у %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qD"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD није члан у %qD"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD није члан у %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> није декларисано"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> није декларисано"
@@ -69192,7 +69267,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "члан %qD је неуспостављен упућивач"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "успостављач низа мора бити нешто у витичастим заградама"
@@ -69320,7 +69395,7 @@ msgstr "тип %qT није непосредна или виртуелна ос
 msgid "type %qT is not a direct base of %qT"
 msgstr "тип %qT није непосредна основа од %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
@@ -69525,45 +69600,45 @@ msgstr "откривен могућ проблем у позиву операт
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "ни деструктор, ни класи посебан оператор delete неће бити позван, чак и ако су декларисани када се класа дефинише."
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "успостављач се прерано окончава"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "непозната величина низа за delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "повратни тип је непотпун тип"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "откривен могућ проблем у позиву оператора delete:"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined."
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "ни деструктор, ни класи посебан оператор delete неће бити позван, чак и ако су декларисани када се класа дефинише."
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "тип уз векторско delete није ни показивачки ни низовни"
@@ -69601,89 +69676,97 @@ msgstr "не може се %s показивач на непотпуни тип
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> није доступно за статичке чланске функције"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "запетљано име за %qD биће измењено у будућим верзијама ГЦЦа"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "запетљано име за %qD биће измењено у будућим верзијама ГЦЦа"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "неисправна #pragma %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable више није подржано"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "#pragma implementation за %qs појављује се пошто је датотека укључена"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD није дефинисано"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD није декларисано у овом досегу"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD није декларисано у овом досегу"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "%qD нема аргументе који зависе од шаблонског параметра, тако да декларација %qD мора бити доступна"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(ако употребите %<-fpermissive%>, Г++ ће прихватити овакав кôд, али дозвољавање недекларисаног имена је превазиђено)"
@@ -69693,64 +69776,57 @@ msgstr "(ако употребите %<-fpermissive%>, Г++ ће прихват
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "изостављени средњи операнд у %<?:%> не може бити запетљан"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -70170,7 +70246,7 @@ msgstr "поновљена декларација %q+D без повезивос
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "сукобљени наводиоци у декларацији %qs"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting type for imported declaration %#qD"
@@ -70188,461 +70264,461 @@ msgstr "сукобљени наводиоци у декларацији %qs"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "сукобљени типови за уграђену функцију %q+D"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "сукобљени наводиоци у декларацији %qs"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for %q+#D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "сукобљен повратни тип наведен за %q+#D"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "сукобљени наводиоци у декларацији %qs"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "сукобљена декларација %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "у декларацији %q+D"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "нема подразумеваног аргумента за %qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "existing default declared here"
 msgstr "%J%qD декларисано овде"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "подразумевани аргумент дат за параметар %d у %q#D"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of %q#D doesn't match"
 msgid "definition of %qD does not match"
 msgstr "спољашња декларација %q#D не слаже се"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "недостаје дефиниција"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "enumerator %qD does not match ..."
 msgstr "аргумент типа %qT не поклапа се са %qT"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "поновљена декларација набрајача %q+D"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE није типа %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "експлицитна специјализација не-шаблонског %qT"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%qD поново декларисано са другачијим приступом"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD не може бити декларисано унутар именског простора"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid " shadows template parm %q+#D"
 msgid "%qD has TU-local template argument %qD"
 msgstr " заклања шаблонски параметар %q+#D"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qD није шаблонска функција"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "%s is a reference, not call, to function %qE"
 msgid "%qD refers to TU-local function %qD"
 msgstr "%s је упућивач, а не позив, за функцију %qE"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 #| msgid "instantiation of %q+D as type %qT"
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "извођење %q+D је типа %qT"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "module %qs declared here"
 msgstr "%q+D декларисано овде"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "  from definition of %q+#D"
 msgid "macro definitions of %qE corrupted"
 msgstr "  из дефиниције %q+#D"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "inconsistent imported macro definition %qE"
 msgstr "неусаглашена одредница променљиве примерка"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 #| msgid "could not open dump file %qs: %s"
 msgid "compiled module file is %qs"
 msgstr "нисам могао да отворим датотеку пописа %qs: %s"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s"
 msgid "compiled module is %sversion %s"
 msgstr "collect2 верзија %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 верзија %s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs not found"
 msgid "module %qs found"
 msgstr "поље %qs није нађено"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "fixed tree mismatch"
 msgstr "неслагање типа успостављача поља"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "израз ограничења стека није подржан"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "declaration %qD conflicts with builtin"
 msgstr "декларација именског простора %qD коси се са"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "декларација именског простора %qD коси се са"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "сукобљена декларација %q#D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting declaration of %qD in global module"
 msgstr "сукобљена декларација %q#D"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of %qs"
 msgid "previously declared in module %qs"
 msgstr "претходна декларација %qs"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "previously declared in global module"
 msgstr "%q+#D претходно декларисано овде"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %q#D declares a non-template function"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "декларација пријатеља %q#D декларише нешаблонску функцију"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "поновљена декларација %q+D без повезивости"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "creating %s"
 msgid "reading CMI %qs"
 msgstr "прави %s"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "дефиниција метода није у контексту @implementation"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "module declared here"
@@ -70655,114 +70731,114 @@ msgstr "%q+D декларисано овде"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "module already declared"
 msgstr "Компонента ‘%s’ код %C већ је декларисана код %L"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr ""
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr ""
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown compiled module interface: %s"
 msgstr "непознат машински режим %qs"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing"
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Укључи традиционалну предобраду"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "invalid header name %qs"
 msgstr "неисправан параметар %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "%s: invalid file name: %s\n"
 msgid "invalid module name %qs"
 msgstr "%s: неисправно име датотеке: %s\n"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "грешка при писању %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "first error in %qD appeared here"
 msgstr "  %q+#D декларисано овде"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr ""
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown header kind %qs"
@@ -70779,7 +70855,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "функција %q+D поново декларисана са атрибутом неуткане"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
@@ -70831,167 +70907,178 @@ msgstr "декларација %q#D заклања параметар"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "декларација %qD као члана %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %q+D but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "декларација за параметар %q+D, али нема таквог"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 #| msgid "using declaration %q+D conflicts with a previous using declaration"
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "декларација коришћења %q+D коси се са претходном декларацијом коришћења"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s(%E) %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "%q#D declared here with no linkage"
 msgstr "%qD декларисано као упућивач али није успостављено"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%q#D declared here with internal linkage"
 msgstr "%qD поново декларисано са другачијим приступом"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%q#D declared here with module linkage"
 msgstr "%qD поново декларисано са другачијим приступом"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> именује деструктор"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "декларација употребе за не-члан у досегу класе"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT није ни класа ни именски простор"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "декларација употребе за не-члан у досегу класе"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "тип %qT није непосредна основа од %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared"
 msgid "%qD has not been declared in %qD"
 msgstr "%qD није декларисано"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD not in a namespace surrounding %qD"
 msgid "using-declaration may not name namespace %qD"
 msgstr "декларација %qD није у именском простору који окружује %qD"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> именује конструктор у %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "декларација %qD није у именском простору који окружује %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "експлицитна одредба у декларацији %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD треба да је декларисано унутар %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared"
 msgid "%qD has not been declared within %qD"
 msgstr "%qD није декларисано"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D декларисано као пријатељ"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires a single NTBS argument"
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "атрибут %qs захтева тачно један НТБС аргумент"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "атрибутска директива %qD игнорисана"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
@@ -71000,122 +71087,122 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D"
 msgid "  %qE"
 msgstr "  %q+#D"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<this%> није доступно за статичке чланске функције"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared"
 msgid "the macro %qs had not yet been defined"
 msgstr "%qD није декларисано"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "it was later defined here"
 msgstr "%J%qD декларисано овде"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "switch %qs is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "прекидач %qs више није подржан"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<this%> се не може употребити у овом контексту"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "cannot nest more than %d namespaces"
 msgstr "%qD не може бити декларисано унутар именског простора"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "Двосмислено име типа ‘%s’ код %C"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "алијас именског простора %qD није дозвољен овде, претпостављам %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "поновљена декларација %q+D без повезивости"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD не може бити декларисано унутар именског простора"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "Formal namespace"
 msgid "exporting unnamed namespace"
 msgstr "Формални именски простор"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "address area of %q+D conflicts with previous declaration"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "адресна област за %q+D коси се са претходном декларацијом"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "reachable %s definition here"
 msgstr "%Jпретходна дефиниција је овде"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX entering pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -71147,7 +71234,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -71197,7 +71284,7 @@ msgstr "%<::%D%> није декларисано"
 msgid "request for member %qE in non-class type %qT"
 msgstr "захтев за члан %qD у некласном типу %qT"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> has not been declared"
 msgid "%<%T::%E%> has not been declared"
@@ -71279,7 +71366,7 @@ msgstr "(можда недостаје тачка-зарез после дефи
 msgid "%qE is not a class template"
 msgstr "%qE није шаблон"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE није шаблон"
@@ -71622,1850 +71709,1861 @@ msgstr ""
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "ова медијска функција доступна је само на фр500"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type"
 msgstr "очекивана је декларација или наредба"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD није шаблон функције"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr ""
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe not supported"
 msgid "fixed-point types not supported in C++"
 msgstr "-pipe није подржано"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ИСО Ц++ забрањује витичасто заграђене групе унутар израза"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, fuzzy, gcc-internal-format
 #| msgid "statement-expressions are allowed only inside functions"
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "наредбени изрази дозвољени су само унутар функција"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected primary-expression"
 msgstr "очекиван је израз"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> се не може употребити у овом контексту"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 #| msgid "Objective-C declarations may only appear in global scope"
 msgid "a template declaration cannot appear at block scope"
 msgstr "декларације објективног Ц-а могу се јављати само у глобалном досегу"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "local variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "локална променљива %qD не може се појавити у овом контексту"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "локална променљива %qD не може се појавити у овом контексту"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "ова медијска функција доступна је само на фр500"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected id-expression"
 msgstr "очекиван је израз"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "досег %qT пре %<~%> није име класе"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "декларација %<~%T%> као члана у %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef-име %qD употребљено као декларатор деструктора"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, fuzzy, gcc-internal-format
 #| msgid "expected specifier-qualifier-list"
 msgid "expected unqualified-id"
 msgstr "очекивана је листа наводилаца-одредби"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD није шаблон"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%qT се разрешава до %qT, што није набројиви тип"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "непотпун тип %qT употребљен у угњежденом наводиоцу имена"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "непотпун тип %qT употребљен у угњежденом наводиоцу имена"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "непотпун тип %qT употребљен у угњежденом наводиоцу имена"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected nested-name-specifier"
 msgstr "очекивани су наводиоци декларације"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in casts"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %<__builtin_frame_address%>"
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "неподржан аргумент за %<__builtin_frame_address%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %<__builtin_return_address%>"
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "неподржан аргумент за %<__builtin_return_address%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %<__builtin_frame_address%>"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "неподржан аргумент за %<__builtin_frame_address%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %<__builtin_frame_address%>"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "неподржан аргумент за %<__builtin_frame_address%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 #| msgid "nested function %qs declared %<extern%>"
 msgid "selected function declared here"
 msgstr "угњеждена функција %qs декларисана као %<extern%>"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ИСО Ц++ забрањује сложене константе"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "неисправна употреба %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 #| msgid "%<%D::%D%> is not a member of %qT"
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> није члан у %qT"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "%Jtypedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%Jиме за дефиницију типа не може бити угњеждени-именски-наводилац"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new се не може применити на упућивачки тип"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "new се не може применити на функцијиски тип"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ИСО Ц++ не дозвољава утврђене успостављаче"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %qs expressions"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a new-expression"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "граница низа забрањена је после заграђеног ид. типа"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "покушајте да уклоните заграде око ид. типа"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected expression-list or type-id"
 msgstr "Очекиван је тип израза"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a new-type-id"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "атрибут се игнорише при извођењу шаблона"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "израз у декларатору new мора имати интегрални или набројиви тип"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "употреба старовремског претапања"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, fuzzy, gcc-internal-format
 #| msgid "suggest parentheses around && within ||"
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "предложи заграде око && унутар ||"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ИСО Ц не дозвољава додатно %<;%> изван функције"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected end of capture-list"
 msgstr "Неочекиван крај модула"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a reference type"
 msgid "%<this%> cannot be captured by reference"
 msgstr "new се не може применити на упућивачки тип"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 #| msgid "increment of read-only variable %qD"
 msgid "capture of non-variable %qE"
 msgstr "увећање само-за-читање променљиве %qD"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "default argument specified for lambda parameter"
 msgstr "подразумевани аргумент дат за параметар %d у %q#D"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here"
+msgid "%q#E declared here"
+msgstr "%q+D декларисано овде"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 #| msgid "attributes after parenthesized initializer ignored"
 msgid "attributes at the beginning of statement are ignored"
 msgstr "игноришу се атрибути после заграђеног успостављача"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected labeled-statement"
 msgstr "очекивана је наредба"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "етикета случаја %qE ван наредбе пребацивања"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%qE in namespace %qE does not name a type"
 msgid "%qE names the constructor, not the type"
 msgstr "%qE у именском простору %qE не именује тип"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr ""
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "lvalue required in asm statement"
 msgid "%<if consteval%> requires compound statement"
 msgstr "неопходна л-вредност у asm наредби"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected selection-statement"
 msgstr "очекивана је декларација или наредба"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "функција враћа низ"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs declared as a function"
 msgid "condition declares a function"
 msgstr "поље %qs декларисано као функција"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in conditions"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected initializer"
 msgstr "очекиван је идентификатор"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "non-local variable %q#D uses local type %qT"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "не-локална променљива %q#D користи локални тип %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "наредба израза има непотпун тип"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected iteration-statement"
 msgstr "очекивана је декларација или наредба"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in vector initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "сувишни елементи у успостављачу вектора"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "декларација пријатеља није у дефиницији класе"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ИСО Ц++ забрањује рачунско goto"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected jump-statement"
 msgstr "очекивана је наредба"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected module-partition"
 msgstr "очекиван је израз"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "Expected name"
 msgid "expected module-name"
 msgstr "Очекивано је име"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "декларација метода није у контексту @interface"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "декларација употребе за не-члан у досегу класе"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr ""
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr ""
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "декларација употребе за не-члан у досегу класе"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%qE may only occur once in an export declaration"
 msgstr "%<inline%> у празној декларацији"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ИСО Ц не дозвољава додатно %<;%> изван функције"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ИСО Ц не дозвољава додатно %<;%> изван функције"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 #| msgid "pure-specifier on function-definition"
 msgid "extra %<;%> after in-class function definition"
 msgstr "наводилац pure на дефиницији функције"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "attributes are not permitted in this position"
 msgstr "атрибут %qE није подржан на овој платформи"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr ""
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "експлицитна специјализација не-шаблонског %qT"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "експлицитно извођење не-шаблона %q#D"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "export-declarations are not permitted here"
 msgstr "показивачи нису дозвољени као вредности случаја"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "забрањено је мешање декларација и дефиниција функција"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a for-range-declaration"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 #| msgid "using %<typename%> outside of template"
 msgid "structured binding pack outside of template"
 msgstr "употреба %<typename%> изван шаблона"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "multiple types in one declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "вишеструки типови у једној декларацији"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "empty structured binding declaration"
 msgstr "празна декларација"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member function declaration"
 msgid "invalid initializer for structured binding declaration"
 msgstr "неисправна декларација чланске функције"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %qs"
 msgid "for-range-declaration cannot be %qs"
 msgstr "декларација шаблона %qs"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "наводиоци складишне класе нису исправни у декларацијама параметара"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> употребљено изван класе"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "  conflict with %q+D"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "  коси се са %q+D"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in condition"
 msgstr "%q+D неисправно у %q#T"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in lambda"
 msgstr "%q+D неисправно у %q#T"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "type-specifier invalid in lambda"
 msgstr "наводиоци складишне класе нису исправни у декларацијама параметара"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "дефиниција класе не може бити декларисана пријатељем"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "шаблони не могу бити виртуелни"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in explicit-specifier"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid linkage-specification"
 msgstr "неисправан навод основне класе"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a conversion-type-id"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<this%> in non-member function"
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "неисправна употреба %<this%> у нечланској функцији"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 #| msgid "only constructors take base initializers"
 msgid "only constructors take member initializers"
 msgstr "само конструктори узимају успостављаче основе"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "cannot expand initializer for member %qD"
 msgstr "недостаје успостављач за члан %qD"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 #| msgid "static declaration of %q+D follows non-static declaration"
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "статичка декларација %q+D прати нестатичку декларацију"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "анахронистични старовремски успостављач основне класе"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "кључна реч %<typename%> није дозвољена у овом контексту (успостављач одређеног члана имплицитно је тип)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected suffix identifier"
 msgstr "очекиван је идентификатор"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conditional operand"
 msgid "invalid encoding prefix in literal operator"
 msgstr "неисправан операнд услова"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected operator"
 msgstr "неочекиван операнд"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "кључна реч %<export%> није имплементирана, игнорише се"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "кључна реч %<export%> није имплементирана, игнорише се"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 #| msgid "%<-G%> is incompatible with %<-mabicalls%>"
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "%<-G%> није сагласно са %<-mabicalls%>"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid constrained type parameter"
 msgstr "неисправна ограничења за операнд"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "cv-qualified type parameter"
 msgstr "неисправан типски аргумент"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<this%> at top level"
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "неисправна употреба %<this%> на највишем нивоу"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "template parameter packs cannot have default arguments"
 msgstr "шаблонски параметри не могу бити пријатељи"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-id"
 msgstr "очекивана је наредба"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> не може започети листу шаблонских аргумената"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> је другачије написано %<[%>. Убаците размак између %<<%> и %<::%>"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 #| msgid "(if you use -fpermissive G++ will accept your code)"
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(Г++ ће прихватити ово ако задате -fpermissive)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid template-argument-list"
 msgstr "неисправан типски аргумент"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "%<<::%> cannot begin a template-argument list"
 msgid "expected %<(%> after template-argument-list"
 msgstr "%<<::%> не може започети листу шаблонских аргумената"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "грешка у рашчлањивању листе шаблонских аргумената"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-name"
 msgstr "очекивана је наредба"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "%qD употребљено као шаблон, а није"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "употребите %<%T::template %D%> да назначите да је шаблон"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers or %<...%>"
 msgid "expected parameter pack before %<...%>"
 msgstr "очекивани су наводиоци декларације или %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-argument"
 msgstr "очекивана је наредба"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid non-type template argument"
 msgstr "неисправан типски аргумент"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr ""
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "експлицитно извођење нешаблонског типа %qT"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "експлицитно извођење нешаблонског типа %qT"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "експлицитно извођење нешаблонског типа %qT"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "специјализација шаблона са Ц повезивошћу"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected type specifier"
 msgstr "очекивани су наводиоци декларације"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "use of %qs in template"
 msgid "use of %<auto%> in template argument"
 msgstr "употреба %qs у шаблону"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected template-id for type"
 msgstr "Очекиван је тип израза"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 #| msgid "Expected name"
 msgid "expected type-name"
 msgstr "Очекивано је име"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE не именује тип"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "Recognize GNU-defined keywords"
 msgid "concept defined here"
 msgstr "Препознаје кључне речи које дефинише Гну"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "неисправна употреба %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr ""
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "declaration %qD does not declare anything"
 msgstr "декларација ништа не декларише"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "атрибут се игнорише за класе без примерака"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "атрибут се игнорише при извођењу шаблона"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "атрибут се игнорише при предоченом-наводиоцу-типа који није унапредна декларација"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is an enumeration template"
 msgstr "%qD није шаблон функције"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD није члан у %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 #| msgid "Min/max instructions not allowed"
 msgid "unnamed scoped enum is not allowed"
 msgstr "Инструкције min/max нису дозвољене"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in enum-base"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<;%> or %<{%>"
 msgstr "очекивано је %<,%> или %<;%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 #| msgid "Enable automatic template instantiation"
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "Укључи аутоматско извођење шаблона"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "декларација пријатеља не именује ни класу ни функцију"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD in %qD which does not enclose %qD"
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "декларација %qD у %qD која не обухвата %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "декларација %qD у %qD која не обухвата %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, fuzzy, gcc-internal-format
 #| msgid "extra qualification ignored"
 msgid "extra qualification not allowed"
 msgstr "сувишне одредбе се игноришу"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ИСО Ц++ забрањује %s-вање набрајања"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a namespace-name"
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD није име именског простора"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD није име именског простора"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected namespace-name"
 msgstr "очекивано је име класе"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr ""
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "a nested namespace definition cannot be inline"
 msgstr "Упозори када се уткана функција не може уткати"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "namespace %qD entered"
 msgstr "употреба именског простора %qD као израза"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma%> is not allowed here"
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<#pragma%> није дозвољена овде"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "ид. шаблона не може да се јави у декларацији употребе"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "обликовање %s на тип упућивача %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "%Jcase value %qs not in enumerated type %qT"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%Jвредност случаја %qs није у набројивом типу %qT"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete typedef %qD"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "неисправна употреба непотпуног typedef %qD"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "opaque-enum-declaration here"
 msgstr "претходном декларацијом %q+#D овде"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in alias template declarations"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr ""
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "удвостручена кн-одредба"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%qD није дефинисано изван досега функције"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT није именски простор"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%qD није дефинисано изван досега функције"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "атрибут игнорисан у декларацији %q+#T"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "имена параметара (без типова) у декларацији функције"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "имена параметара (без типова) у декларацији функције"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "cast adds new qualifiers to function type"
 msgid "cannot handle qualified name for variant function"
 msgstr "претапање додаје нове одредбе функцијском типу"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "стандардна претварања нису дозвољена у овом контексту"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cleanup argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "чистачки аргумент није идентификатор"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "%s: declaration of function '%s' not converted\n"
 msgid "no declaration of base function %qs in this scope"
 msgstr "%s: декларација функције ‘%s’ није претворена\n"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "двосмислено упућивање на %qD"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 #| msgid "%s: function definition not converted\n"
 msgid "a function-definition is not allowed here"
 msgstr "%s: дефиниција функције није претворена\n"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "навод asm није дозвољен на дефиницији функције"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "атрибути нису дозвољени на дефиницији функције"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "успостављач дат за функцију"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "игноришу се атрибути после заграђеног успостављача"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared as inline"
 msgid "non-function %qD declared as implicit template"
 msgstr "функција %q+D поново декларисана као уткана"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "граница низа није целобројна константа"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "cannot define member of dependent typedef %qT"
 msgstr "стварање показивача на члан упућивачког типа %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a type"
 msgid "%<%T::%E%> is not a type"
@@ -73475,308 +73573,308 @@ msgstr "%<%T::%D%> није тип"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid declaration"
 msgid "invalid declarator"
 msgstr "Неисправна декларација"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "неисправна употреба конструктора као шаблона"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "употреба %<%T::%D%> уместо %<%T::%D%> за именовање конструктора у одређеном имену"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid declaration"
 msgid "qualified-id in declaration"
 msgstr "Неисправна декларација"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected declarator"
 msgstr "очекивани су наводиоци декларације"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD је именски простор"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "стварање показивача на члан некласног типа %qT"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected ptr-operator"
 msgstr "неочекиван операнд"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "удвостручена кн-одредба"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple ref-qualifiers"
 msgstr "удвостручена кн-одредба"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate virt-specifier"
 msgstr "удвостручена кн-одредба"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 #| msgid "missing makefile target after %qs"
 msgid "missing template arguments after %qE"
 msgstr "недостаје справљачки циљ после %qs"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in template argument list"
 msgid "%qT not permitted in template argument"
 msgstr "грешка у рашчлањивању листе шаблонских аргумената"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of %qT"
 msgstr "неисправна употреба %qD"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in template arguments"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<this%> in non-member function"
 msgid "invalid use of %<auto%> in template argument"
 msgstr "неисправна употреба %<this%> у нечланској функцији"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected type-specifier"
 msgstr "очекиван је идентификатор"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected %<,%> or %<...%>"
 msgstr "очекивано је %<:%> или %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in parameter types"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "наводиоци складишне класе нису исправни у декларацијама параметара"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr ""
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "подразумевани аргументи су дозвољени само за параметре функција"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "template parameter pack cannot have a default argument"
 msgstr "шаблонски параметри не могу бити пријатељи"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "parameter pack cannot have a default argument"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ИСО Ц++ не дозвољава утврђене успостављаче"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ИСО Ц++ не дозвољава утврђене успостављаче"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ИСО Ц++ не дозвољава утврђене успостављаче"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected class-name"
 msgstr "очекивано је име класе"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "expected %<;%> after class definition"
 msgstr "%q+D декларисано уткано после своје дефиниције"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "expected %<;%> after struct definition"
 msgstr "%q+D декларисано уткано после своје дефиниције"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "expected %<;%> after union definition"
 msgstr "Неочекивано смеће после декларације функције код %C"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qD specifier"
 msgstr "удвостручено %qs"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<{%> or %<:%>"
 msgstr "очекивано је %<,%> или %<;%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "qualified name does not name a class"
 msgstr "декларација пријатеља не именује ни класу ни функцију"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "кључна реч %<typename%> није дозвољена изван шаблона"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "неисправно име класе у декларацији %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "дефиниција експлицитне специјализације %qD у декларацији пријатеља"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "експлицитној специјализацији мора претходити %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "function template %qD redeclared as a class template"
 msgstr "%qD употребљено као шаблон, а није"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+#T"
 msgid "previous definition of %q#T"
@@ -73785,293 +73883,293 @@ msgstr "претходна дефиниција %q+#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected class-key"
 msgstr "очекивано је име класе"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<class%> or %<typename%>"
 msgstr "очекивано је %<,%> или %<;%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, fuzzy, gcc-internal-format
 #| msgid "a class-key must be used when declaring a friend"
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "при декларацији пријатеља мора бити употребљена кључна реч class"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "декларација пријатеља не именује ни класу ни функцију"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr ""
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "битско поље %qD неинтегралног типа"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "наводилац pure на дефиницији функције"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use %<::%> in parameter declaration"
 msgid "stray %<,%> at end of member declaration"
 msgstr "не може се користити %<::%> у декларацији параметра"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %<;%> at end of member declaration"
 msgstr "очекивано је %<(%> или крај линије"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "attributes in parameter array declarator ignored"
 msgid "attributes on base specifiers are ignored"
 msgstr "атрибути у параметарском декларатору низа игнорисани"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "кључна реч %<typename%> није дозвољена у овом контексту (основна класа је имплицитно тип)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in an exception-specification"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "ИСО Ц++ не дозвољава утврђене успостављаче"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD in linkage specification"
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "неисправна употреба %qD у одредници повезивости"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in exception-declarations"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> у празној декларацији"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD не може имати подразумеване аргументе"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr ""
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "Атрибут %s коси се са атрибутом %s код %L"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected an identifier for the attribute name"
 msgstr "очекиван је идентификатор или %<(%>"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected attribute before %<...%>"
 msgstr "очекивано је %<:%> или %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "ненулти атрибут без аргумената код непрототипа"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected conditional-expression"
 msgstr "очекиван је израз"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qs is only available with %qs"
 msgstr "%qE није променљива у одредби %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "атрибут %qE се игнорише за %qE"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "атрибут се игнорише за класе без примерака"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "expression must be enclosed in parentheses"
 msgstr "наредба израза има непотпун тип"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "захтевани положај није целобројна константа"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "захтевано равнање није константа"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 #| msgid "invalid redeclaration of %q+D"
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "неисправна поновљена декларација %q+D"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "премало листа параметара шаблона"
@@ -74080,487 +74178,487 @@ msgstr "премало листа параметара шаблона"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "превише листа шаблонских параметера"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "именоване повратне вредности нису више подржане"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "неисправна декларација чланског шаблона у локалној класи"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "шаблон са Ц повезивошћу"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid explicit specialization"
 msgstr "неисправан навод основне класе"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %qs"
 msgid "template declaration of %<typedef%>"
 msgstr "декларација шаблона %qs"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "декларација ништа не декларише"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization in non-namespace scope %qD"
 msgid "explicit template specialization cannot have a storage class"
 msgstr "експлицитна специјализација у не-именскопросторном досегу %qD"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<>>%> should be %<> >%> within a nested template argument list"
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%H%<>>%> треба да је %<> >%> унутар угњеждене листе шаблонских аргумената"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "сувишно %<>>%>, користите %<>%> за затварање листе шаблонских аргумената"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "сувишно %<>>%>, користите %<>%> за затварање листе шаблонских аргумената"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "неисправна употреба %qD у одредници повезивости"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "  conflict with %q+D"
 msgid "%qD specifier conflicts with %qs"
 msgstr "  коси се са %q+D"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> пре %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support %<long long%>"
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ИСО Ц++ не подржава %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 #| msgid "both %<short%> and %<char%> in declaration specifiers"
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "и %<short%> и %<char%> у наводиоцима декларације"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate %qD"
 msgstr "удвостручено %qE"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "удвостручено %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<new%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<delete%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<return%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<extern%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected %<static_assert%>"
 msgstr "очекивана је наредба"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<decltype%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<operator%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<class%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<template%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<namespace%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<using%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<asm%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<try%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<catch%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<throw%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<auto%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<__label__%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@try%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@synchronized%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@throw%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<__transaction_relaxed%>"
 msgstr "очекивано је %<none%> или %<shared%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<co_yield%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<::%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<...%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<*%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<~%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected %<:%> or %<::%>"
 msgstr "очекивано је %<:%> или %<...%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<:]%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "ознака %qs употребљена при именовању %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "%q#T was previously declared here"
 msgstr "%q+#D претходно декларисано овде"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "не може се декларисати упућивач на %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared with greater visibility than its base %qT"
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT декларисано са већом видљивошћу од своје основе %qT"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 #| msgid "template class without a name"
 msgid "replace the class-key with %qs"
 msgstr "шаблонска класа без имена"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "%qT referred to as %qs"
 msgid "%qT defined as %qs here"
 msgstr "%qT се помиње као %qs"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qD was declared here"
 msgid "%qT first declared as %qs here"
 msgstr "%J%qD декларисано овде"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD поново декларисано са другачијим приступом"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, fuzzy, gcc-internal-format
 #| msgid "%<template%> (as a disambiguator) is only allowed within templates"
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "%<template%> (као разјашњење двосмислености) дозвољено је само унутар шаблона"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "датотека се завршава подразумеваним аргументом"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "конструкција %<@%D%> објективног Ц++а на погрешном месту"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> мора навести тип као аргумент"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "неисправно име селектора објективног Ц++а"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 #| msgid "Class or interface declaration expected"
 msgid "objective-c++ method declaration is expected"
 msgstr "Очекивана је декларација класе или сучеља"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "method attributes must be specified at the end"
 msgstr "%Jатрибут одељка се не може навести за локалне променљиве"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid type for iteration variable %qE"
 msgid "invalid type for instance variable"
 msgstr "%Hнеисправан тип променљиве итерације %qE"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "очекиван је идентификатор после %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "атрибут %qE се игнорише за %qE"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid type for property"
 msgstr "неисправан типски аргумент"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr ""
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected integer expression list"
 msgstr "очекиван је целобројни израз"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<wait%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "очекивано је %<,%>, %<;%> или %<}%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid reduction-identifier"
 msgstr "неисправан успостављач"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in iterator type"
@@ -74570,192 +74668,192 @@ msgstr "не могу се дефинисати нови типови у пов
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable више није подржано"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 #| msgid "iteration variable %qs should not be reduction"
 msgid "iteration variable %qD should not be reduction"
 msgstr "не би требало да променљива итерације %qs буде свођена"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp section%> може бити употребљено само у конструкцији %<#pragma omp sections%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not a C pointer"
 msgstr "%qD није тип"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<target%>"
 msgstr "очекивано је %<{%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "неисправан успостављач"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected id-expression (arguments)"
 msgstr "очекиван је израз"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in declare reduction type list"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "очекивано је %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD није чланска шаблонска функција"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "OpenMP directives at %C may not appear in PURE or ELEMENTAL procedures"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "ОпенМП директиве код %C не могу се јављати у чистим или елементалним процедурама"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "junk at end of %<#pragma GCC pch_preprocess%>"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "смеће на крају %<#pragma GCC pch_preprocess%>"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%> може бити употребљено само у сложеним наредбама"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp flush%> може бити употребљено само у сложеним наредбама"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC diagnostic not allowed inside functions"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "#pragma GCC diagnostic није дозвољено унутар функција"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "унутармодулске оптимизације нису имплеметиране за Ц++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "стандардна претварања нису дозвољена у овом контексту"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, fuzzy, gcc-internal-format
 #| msgid "templates may not be %<virtual%>"
 msgid "implicit templates may not be %<virtual%>"
 msgstr "шаблони не могу бити виртуелни"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -75276,17 +75374,23 @@ msgstr "обухватајући шаблони класа не бивају е
 msgid "redeclaration of %qD with different constraints"
 msgstr "декларација %qF баца различите изузетке"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "too many template-parameter-lists"
+msgid "local class in lambda in template parameter list"
+msgstr "превише листа шаблонских параметера"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "наводиоци шаблона нису задати у декларацији %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "redeclared with %d template parameter"
@@ -75296,7 +75400,7 @@ msgstr[1] "%qD употребљено без параметара шаблона
 msgstr[2] "%qD употребљено без параметара шаблона"
 msgstr[3] "%qD употребљено без параметара шаблона"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "previous declaration %qD used %d template parameter"
@@ -75306,143 +75410,143 @@ msgstr[1] "претходном декларацијом %q+#D овде"
 msgstr[2] "претходном декларацијом %q+#D овде"
 msgstr[3] "претходном декларацијом %q+#D овде"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "шаблонски параметар %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "поново декларисано овде као %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here as %q#D"
 msgid "redeclared here"
 msgstr "поново декларисано овде као %q#D"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qF throws different exceptions"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "декларација %qF баца различите изузетке"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 #| msgid "%J  original definition appeared here"
 msgid "original declaration appeared here"
 msgstr "%J  првобитна дефиниција налази се овде"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qF throws different exceptions"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "декларација %qF баца различите изузетке"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер је показивач"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер објекат %qD нема спољашњу повезивост"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE није исправан шаблонски аргумент типа %qT јер %qD нема спољашњу повезивост"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "(показивач на члан може бити формиран само помоћу %<&%E%>)"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qT није члан из %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "got %d template parameters for %q#D"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "добих %d шаблонских параметара за %q#D"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %q#T and %q#T"
 msgid "  mismatched types %qT and %qT"
 msgstr "поређење између типова %q#T и %q#T"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "шаблонски аргумент %qE уплиће шаблонске параметре"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "  %qE is not equivalent to %qE"
 msgstr "%qs није исправно за %qs"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, fuzzy, gcc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "Неусаглашени рангови за оператор код %L и %L"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "делимична специјализација %qT не специјализује ниједан шаблонски аргумент"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "  member function type %qT is not a valid template argument"
 msgstr "Наредбена функција ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
@@ -75451,7 +75555,7 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
@@ -75460,373 +75564,373 @@ msgstr[1] ""
 msgstr[2] ""
 msgstr[3] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "не може се претворити из типа %qT у %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an ambiguous base of %qT"
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "%qT је двосмислена основа за %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "  %qT is not derived from %qT"
 msgstr "тип %qT није изведен из типа %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "не може се %s показивач на непотпуни тип %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "  template argument %qE does not match %qE"
 msgstr "аргумент типа %qT не поклапа се са %qT"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE није исправан шаблонски аргумент типа %qT јер %qE није променљива"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE није исправан шаблонски аргумент типа %qT јер %qD нема спољашњу повезивост"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE није исправан шаблонски аргумент типа %qT јер %qE није променљива"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "the address of %qD is not a valid template argument"
 msgstr "адреса за %qD ће увек бити израчуната као %<true%>"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qE није исправан шаблонски аргумент типа %qT јер %qD нема спољашњу повезивост"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD није исправан шаблонски аргумент јер је %qD променљива, а не адреса неке променљиве"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qD није исправан шаблонски аргумент јер је %qD променљива, а не адреса неке променљиве"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер се константне ниске не могу користити у овом контексту"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 #| msgid "template argument for %qD uses local type %qT"
 msgid "in template argument for type %qT"
 msgstr "шаблонски аргумент за %qD користи локални тип %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер се коси са кн-одредбом"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер није л-вредност"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a non-constant expression"
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер није константан израз"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер је показивач"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "покушајте са %qE уместо тога"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE није исправан шаблонски аргумент за тип %qT јер је типа %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 #| msgid "applying attributes to template parameters is not implemented"
 msgid "ignoring attributes on template argument %qT"
 msgstr "примењивање атрибута на шаблонске параметре није имплементирано"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Ignoring statement label in empty statement at %C"
 msgid "ignoring attributes in template argument %qE"
 msgstr "Игноришем етикету наредбе у празној наредби код %C"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, fuzzy, gcc-internal-format
 #| msgid "name of class shadows template template parameter %qD"
 msgid "injected-class-name %qD used as template template argument"
 msgstr "име класе заклања шаблонски шаблонски параметар %qD"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of destructor %qD as a type"
 msgid "invalid use of destructor %qE as a type"
 msgstr "неисправна употреба деструктора %qD као типа"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "да упутите на тип шаблонског параметра, употребите %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "неслагање типа/вредности код аргумента %d у листи шаблонских параметара за %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  очекивах константу типа %qT, добих %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  очекивах шаблон класе, добих %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  очекивах тип, добих %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr " очекивах тип, добих %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  очекивах шаблон класе, добих %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a template of type %qD, got %qD"
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  очекивах шаблон типа %qD, добих %qD"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "неслагање типа/вредности код аргумента %d у листи шаблонских параметара за %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "  expected %qD but got %qD"
 msgstr "  очекивах тип, добих %qE"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument %qE to %qT"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "нисам могао да претворим шаблонски аргумент %qE у %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "неисправан шаблонски аргумент %d"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "погрешан број шаблонских аргумената ((%d, а треба %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "погрешан број шаблонских аргумената ((%d, а треба %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "дат за %q+D"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "подразумевани аргумент дат за параметар %d у %q#D"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%q#D is not a function template"
 msgstr "%qD није шаблон функције"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "нешаблонски тип %qT употребљен као шаблон"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "за декларацију шаблона %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "template constraint failure for %qD"
 msgstr "декларација шаблона %q#D"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "use of %qs in template"
 msgid "use of invalid variable template %qE"
 msgstr "употреба %qs у шаблону"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "дубина извођења шаблона премашује максимум од %d (употребите -ftemplate-depth-NN да повећате дубину) извођења %qD"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr ""
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "argument to \"%s\" should be a non-negative integer"
 msgid "score argument must be non-negative"
 msgstr "аргумент за „%s“ треба да је ненегативан цео број"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr ""
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be constant integer expression"
 msgstr "очекиван је целобројни израз"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "instantiating erroneous template"
 msgstr "  у извођењу шаблона %qT"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
 msgstr ""
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 #| msgid "%Jflexible array member in union"
 msgid "flexible array member %qD in union"
 msgstr "%Jфлексибилан члански низ у унији"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE није на почетку декларације"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find 'nm'"
 msgid "cannot index an empty pack"
 msgstr "не могу да нађем ‘nm’"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for %q#D"
 msgid "  when instantiating default argument for call to %qD"
 msgstr "поновљена дефиниција подразумеваног аргумента за %q#D"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "стварање показивача на чланску функцију некласног типа %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr ""
@@ -75844,132 +75948,132 @@ msgstr ""
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "променљива %qD има функцијски тип"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "неисправан тип параметра %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "у декларацији %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "функција враћа низ"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "функција враћа функцију"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice type"
 msgstr "%qE није променљива у одредби %qs"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE није променљива у одредби %qs"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "обликовање упућивача на празно"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forming pointer to reference type %qT"
 msgstr "обликовање %s на тип упућивача %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forming reference to reference type %qT"
 msgstr "обликовање %s на тип упућивача %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring %qV qualifiers added to function type %qT"
 msgid "forming pointer to qualified function type %qT"
 msgstr "игнорисање %qV одредбе додате функцијском типу %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring %qV qualifiers added to function type %qT"
 msgid "forming reference to qualified function type %qT"
 msgstr "игнорисање %qV одредбе додате функцијском типу %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "стварање показивача на члан некласног типа %qT"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "стварање показивача на члан упућивачког типа %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "стварање показивача на члан празног типа"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "стварање низа типа %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "претпоставља се да низ %q+D има један елемент"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT није тип класе, структуре, нити уније"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT се разрешава до %qT, што није набројиви тип"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT се разрешава до %qT, што није класни тип"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT се разрешава до %qT, што није набројиви тип"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type template"
 msgstr "очекивана је декларација или наредба"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "употреба %qs у шаблону"
@@ -75977,224 +76081,224 @@ msgstr "употреба %qs у шаблону"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<~%T%> as member of %qT"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "декларација %<~%T%> као члана у %qT"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 #| msgid "qualified type %qT does not match destructor name ~%qT"
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "одређени тип %qT не поклапа се са именом деструктора ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "зависно име %qE рашчлањује се као не-тип, али извођење производи тип"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "ставите %<typename %E%> ако мислите на тип"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr ""
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of void expression"
 msgid "invalid use of pack expansion expression"
 msgstr "неисправна употреба израза празног типа"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, fuzzy, gcc-internal-format
 #| msgid "%<...%> as arguments.)"
 msgid "use %<...%> to expand argument pack"
 msgstr "%<...%> за аргументе.)"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a type"
 msgid "use %<%T::%D%> instead"
 msgstr "%<%T::%D%> није тип"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE undeclared here (not in a function)"
 msgid "%qD declared here, later in the translation unit"
 msgstr "%H%qE недекларисано овде (не у функцији)"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %<__builtin_return_address%>"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "неподржан аргумент за %<__builtin_return_address%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "погрешан број аргумената наведне за атрибут %qs"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT није ни класа ни именски простор"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD није ни класа ни именски простор"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "употреба неисправног поља %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is/uses anonymous type"
 msgid "%qT is/uses unnamed type"
 msgstr "%qT јесте/користи анонимни тип"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "шаблонски аргумент за %qD користи локални тип %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT је променљиво измењив тип"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "интегрални израз %qE није константа"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  покушај извођења %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#T"
 msgstr "двосмислено извођење шаблона класе за %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#D"
 msgstr "двосмислено извођење шаблона класе за %q#T"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %+#D"
 msgid "%s %#qS"
 msgstr "%s %+#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "експлицитно извођење не-шаблона %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%qD is not a static data member of a class template"
 msgstr "%q#D је нестатички члански податак у %qT"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "поклапајући шаблон за %qD није нађен"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "експлицитно извођење нешаблонског типа %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "експлицитно извођење %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "удвостручено експлицитно извођење %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids the use of %<extern%> on explicit instantiations"
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ИСО Ц++ забрањује употребу %<extern%> на експлицитним извођењима"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "складишна класа %qD примењена на извођење шаблона"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiation of non-class template %qD"
 msgstr "експлицитно извођење не-шаблона %q#D"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "експлицитно извођење нешаблонског типа %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "експлицитно извођење %q#T пре дефиниције шаблона"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ИСО Ц++ забрањује употребу %qE на експлицитним извођењима"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "удвостручено експлицитно извођење %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "експлицитна специјализација %qD после прве употребе"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -76207,174 +76311,174 @@ msgstr "навод asm није дозвољен на дефиницији фу
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "експлицитно извођење %qD али дефиниција није доступна"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth-NN to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "дубина извођења шаблона премашује максимум од %d извођења %q+D, могуће услед стварања виртуелних табела (употребите -ftemplate-depth-NN да повећате максимум)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template constant parameter"
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T није исправан тип за шаблонски константан параметар"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "invalid template non-type parameter"
 msgstr "употреба параметра шаблонског типа %qT после %qs"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template constant parameter"
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T није исправан тип за шаблонски константан параметар"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "кључна реч %<typename%> није дозвољена изван шаблона"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "opaque vector types cannot be initialized"
 msgid "a concept cannot be constrained"
 msgstr "непрозирни векторски типови не могу бити успостављени"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT није именски простор"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "дефиниција %q#T унутар листе шаблонских параметара"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "%qD употребљено без параметара шаблона"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "use #include instead"
 msgid "use %qD directly instead"
 msgstr "користите #include уместо тога"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "class template argument deduction failed:"
 msgstr "неисправан шаблонски аргумент %d"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "функција се не разматра за уткивање"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 #| msgid "explicit qualification in declaration of %qD"
 msgid "explicit deduction guide declared here"
 msgstr "експлицитна одредба у декларацији %qD"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid method declaration, return type required"
 msgid "unable to deduce lambda return type from %qE"
 msgstr "Неисправна декларација метода, неопходан је повратни тип"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, fuzzy, gcc-internal-format
 #| msgid "unable to emulate %qs"
 msgid "unable to deduce %qT from %qE"
 msgstr "не могу да емулирам %qs"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "ија не задовољава своја ограничења:"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "ија не задовољава своја ограничења:"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -76382,379 +76486,442 @@ msgstr "ија не задовољава своја ограничења:"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new се не може применити на упућивачки тип"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new се не може применити на функцијиски тип"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 #| msgid "name of class shadows template template parameter %qD"
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "име класе заклања шаблонски шаблонски параметар %qD"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "new се не може применити на функцијиски тип"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new се не може применити на функцијиски тип"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new се не може применити на функцијиски тип"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of %qE"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "несагласни тип за аргумент %d у %qE"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qT није именски простор"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "не могу да извршим ‘%s’: %s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "неочекиван операнд"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "не могу да извршим ‘%s’: %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  очекивах тип, добих %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT није типа показивач-на-објекат"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT must be a function type"
 msgstr "%qD није шаблон функције"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr ""
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "не може се декларисати битско поље %qD са функцијским типом"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr ""
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %<access_context%> argument"
 msgstr "неисправан типски аргумент"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr ""
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected %s statement at %C"
 msgid "unexpected argument to %qs"
 msgstr "Неочекивана наредба %s код %C"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of %qE"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "несагласни тип за аргумент %d у %qE"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "сукобљен повратни тип наведен за %q+#D"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "сукобљен повратни тип наведен за %q+#D"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function '%s'"
 msgid "unknown metafunction %qD"
 msgstr "непозната функција навода ‘%s’"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "splice argument must be an expression of type %qs"
 msgstr "Ознака %s код %L мора бити типа %s"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "%qE cannot be used as a function"
+msgid "cannot splice a null reflection"
+msgstr "%qE не може бити употребљено као функција"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "не може се користити %<::%> у декларацији параметра"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "add %<constexpr%>"
 msgstr "удвостручено %<const%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "стандардна претварања нису дозвољена у овом контексту"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr ""
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected a reflection of an expression"
 msgstr "очекиван је целобројни израз"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "кључна реч %<typename%> није дозвољена изван шаблона"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "употреба именског простора %qD као израза"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "не може се експлицитно декларисати спољашња повезивост за члан %q#D"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "Enforce class member access control semantics"
+msgid "invalid class member access of type template %qE"
+msgstr "Спроведи семантику контроле приступа члановима класе"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can't use '%s' as a %s register"
+msgid "cannot use %qE to access a class member"
+msgstr "„%s“ се не може користити као %s регистар"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD није шаблон функције"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -77115,648 +77282,648 @@ msgstr "неисправна дефиниција одређеног типа %q
 msgid "invalid base-class specification"
 msgstr "неисправан навод основне класе"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 #| msgid "protected member %q+#D in anonymous union"
 msgid "cannot capture member %qD of anonymous union"
 msgstr "заштићени члан %q+#D у анонимној унији"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not captured"
 msgstr "%qD није тип"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of local variable with automatic storage from containing function"
 msgstr "употреба %<auto%> променљиве из обухватајуће функције"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "употреба параметра из обухватајуће вункције"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "use of parameter from containing function"
 msgid "use of parameter outside function body"
 msgstr "употреба параметра из обухватајуће вункције"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in template argument list"
 msgid "missing template arguments"
 msgstr "грешка у рашчлањивању листе шаблонских аргумената"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "шаблонски параметар %qD типа %qT није дозвољен у интегралном константном изразу јер није интегралног или набројивог типа"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "употреба шаблона класе %qT као израза"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "захтев за члан %qD двосмислен је у вишеструком снопу наслеђивања"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD се не може јавити у константном изразу"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "тип за %qE није познат"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an enumeration type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "величина низа има неинтегрални тип %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "pack index is not an integral constant"
 msgstr "граница низа није целобројна константа"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qs is negative"
 msgid "pack index %qE is negative"
 msgstr "величина низа %qs је негативна"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "наводиоци складишне класе нису исправни у декларацијама параметара"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "не може се применити %<offsetof%> на деструктор %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "не може се применити %<offsetof%> на чланску функцију %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "не може се применити %<offsetof%> на чланску функцију %qD"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "не може се применити %<offsetof%> на чланску функцију %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr ""
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "user defined reduction lookup is ambiguous"
 msgstr "двосмислено упућивање на %qD"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %+#D"
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has invalid type for %<reduction%>"
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE има неисправан тип за %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "Expected initialization expression at %C"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "Очекиван је успостављачки израз код %C"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "linear step expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD није променљива у одредби %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %<firstprivate%>"
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qE није променљива у одредби %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %<lastprivate%>"
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qE није променљива у одредби %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<gang%> static expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<gang%> static value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<gang%> num expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<vector%> length expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<worker%> num expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<gang%> num value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<vector%> length value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 #| msgid "%<num_threads%> value must be positive"
 msgid "%<worker%> num value must be positive"
 msgstr "вредност %<num_threads%> мора бити позитивна"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "израз за величину одломка при распоређивању мора бити интегрални"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%qs length expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<async%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<thread_limit%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 #| msgid "%<continue%> must be in loop"
 msgid "%<device%> id must be integral"
 msgstr "%<continue%> мора бити у оквиру петље"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "израз за величину одломка при распоређивању мора бити интегрални"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, fuzzy, gcc-internal-format
 #| msgid "schedule chunk size expression must be integral"
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "израз за величину одломка при распоређивању мора бити интегрални"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not allowed in other than a declaration"
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%<[*]%> није дозвољено другде осим у декларацији"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in clause %qs"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD није променљива у одредби %qs"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD се појављује више од једном у одредбама података"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "Име ‘%s’ се не може употребити као дефинисани оператор код %C"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr ""
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr ""
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 #| msgid "reimplementation of class %qs"
 msgid "template %qE in clause %qs"
 msgstr "поновљена имплементација класе %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<grainsize%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<priority%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<hint%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "num_threads expression must be integral"
 msgid "%<filter%> expression must be integral"
 msgstr "израз за num_threads мора бити интегрални"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "индексирана вредност није ни низ ни показивач"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "%<tree%> is not defined as a pointer type"
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tree%> није дефинисано као показивачки тип"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, fuzzy, gcc-internal-format
 #| msgid "%<threadprivate%> %qE is not file, namespace or block scope variable"
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qE није датотека, именски простор нити променљива блоковског досега"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, fuzzy, gcc-internal-format
 #| msgid "%<threadprivate%> %qE has incomplete type"
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "нитно-локално %qE има непотпун тип"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, fuzzy, gcc-internal-format
 #| msgid "%Hinvalid type for iteration variable %qE"
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%Hнеисправан тип променљиве итерације %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr ""
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr ""
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "CRIS-port assertion failed: "
 msgid "static assertion failed: %.*s"
 msgstr "Тврдња КРИС-порта није прошла: "
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, fuzzy, gcc-internal-format
 #| msgid "non-static declaration of %q+D follows static declaration"
 msgid "non-constant condition for static assertion"
 msgstr "нестатичка декларација %q+D прати статичку декларацију"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_expect%> must be a constant"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "други аргумент за %<__builtin_expect%> мора бити константа"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%s не може да разреши адресу препуњене функције"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT is not a non-union class type"
 msgstr "%qD није шаблон функције"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_next_arg%> позвано без аргумената"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_next_arg%> позвано без аргумената"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr ""
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a class or namespace"
 msgid "%qD is not a class or alias template"
 msgstr "%qD није ни класа ни именски простор"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "леви операнд зарез-израза нема ефекта"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "шаблонски аргумент %qE уплиће шаблонске параметре"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<__builtin_choose_expr%> not a constant"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -77765,383 +77932,383 @@ msgstr "први аргумент за %<__builtin_choose_expr%> није кон
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot be used with a constant"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "%qs не може бити употребљено са константом"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV одредбе не могу се применити на %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid " declared here"
 msgstr "%q+D декларисано овде"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "Use 32-bit floating-point registers"
 msgid "%qT is a floating-point type"
 msgstr "Користи 32-битне регистре покретног зареза"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "%qT није шаблонски тип"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT није основа за %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T има показивачке чланске податке"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "padding occurs between %qD and %qD"
 msgstr "поређење између %q#T и %q#T"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs није датотека података гкова"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class %qT has cv qualifiers"
 msgid "base class %qT is not public"
 msgstr "основна класа %qT има кн-одредбе"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is not public"
 msgstr "%qD није тип"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD is mutable"
 msgstr "%qD није тип"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has an incomplete type"
 msgid "%qD has a non-structural type"
 msgstr "%qD има непотпун тип"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute takes no arguments"
 msgstr "%Jатрибут %qE примењује се само на функције"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr ""
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "неисправна декларација чланске функције"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%Jcase value %qs not in enumerated type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%Jвредност случаја %qs није у набројивом типу"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> примењено на битско поље"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %q+D but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "декларација за параметар %q+D, али нема таквог"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "захтевано init_priority није целобројна константа"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "атрибут %qE може се користити само уз дефиниције објеката класног типа у датотечном досегу"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "захтевано init_priority је ван опсега"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "захтевано init_priority резервисано је за унутрашњу употребу"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as %s"
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "декларација %qD као %s"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires a single NTBS argument"
 msgid "the %qE attribute requires arguments"
 msgstr "атрибут %qs захтева тачно један НТБС аргумент"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%T::%D%> није исправан декларатор"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%T::%D%> није исправан декларатор"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "атрибут %qE се игнорише на не-класним типовима"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "атрибут %qE може се применити само на дефиниције класа"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "атрибут се игнорише при извођењу шаблона"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "атрибут се игнорише при извођењу шаблона"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%Jатрибут %qE примењује се само на функције"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "%Jатрибут %qE примењује се само на функције"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr ""
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "атрибут %qs примењује се само на променљиве"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "annotation on void parameter"
 msgstr "неисправан параметар %qs"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "функција не враћа податак типа ниске"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -78368,893 +78535,899 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT нема члан по имену %qE"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> није члан у %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD није члан у %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD није чланска шаблонска функција"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT није типа показивач-на-објекат"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of array indexing on pointer to member"
 msgstr "неисправна употреба %qs на показивачу-на-члан"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "неисправна употреба %qs на показивачу-на-члан"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "неисправна употреба %qs на показивачу-на-члан"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "недостаје индекс у упућивачу низа"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "индексирање низа декларисаног као %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "индексирана вредност није ни низ ни показивач"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "недостаје објекат у употреби %qE"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "Generate default single-precision SH4 code"
 msgid "no default version in scope"
 msgstr "Створи подразумевани кôд једноструке тачности за СХ4"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ИСО Ц++ забрањује звање %<::main%> унутар програма"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, fuzzy, gcc-internal-format
 #| msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>"
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "мора се употребити или %<.*%> или %<->*%> за позив показивача на чланску функцију у %<%E (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE не може бити употребљено као функција"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE не може бити употребљено као функција"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qD cannot be used as a function"
 msgstr "%qE не може бити употребљено као функција"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "expression cannot be used as a function"
 msgstr "%qE не може бити употребљено као функција"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "too many arguments to constructor %q#D"
 msgstr "превише аргумената за %s %q+#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "too few arguments to constructor %q#D"
 msgstr "премало аргумената за %s %q+#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qs"
 msgid "too many arguments to member function %q#D"
 msgstr "превише аргумената за функцију %qs"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qs"
 msgid "too few arguments to member function %q#D"
 msgstr "премало аргумената за функцију %qs"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qs"
 msgid "too many arguments to function %q#D"
 msgstr "превише аргумената за функцију %qs"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qs"
 msgid "too few arguments to function %q#D"
 msgstr "премало аргумената за функцију %qs"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "too many arguments to method %q#D"
 msgstr "превише аргумената за %s %q+#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "too few arguments to method %q#D"
 msgstr "премало аргумената за %s %q+#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "превише аргумената за функцију"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "превише аргумената за функцију"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "параметар %P за %qD непотпуног је типа %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "параметар %P непотпуног је типа %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "адреса за %qD никако не може бити NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "адреса за %qD никако не може бити NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "адреса за %qD никако не може бити NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "адреса за %qD никако не може бити NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "операнди у ?: различитих су типова %qT и %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types %qT and %qT lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "недостаје претапање за %s између различитих типова показивача %qT и %qT"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "операнди у ?: различитих су типова %qT и %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "недостаје претапање за %s између различитих типова показивача %qT и %qT"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "претапање из функцијског позива типа %qT у непоклапајући тип %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "претапање из функцијског позива типа %qT у непоклапајући тип %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "аритметика са показивачем на непотпун тип"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "претпоставља се претапање у тип %qT из препуњене функције"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL употребљено аритметички"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ИСО Ц++ забрањује поређење показивача и целобројног"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "operand types are %qT and %qT"
 msgstr "нема типа по имену %q#T у %q#T"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "поређење уређености показивача са целобројном нулом"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "неуређено поређење са не-реалним аргументом"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "захтев за имплицтно претварање из %qT у %qT није дозвољен у Ц++у"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "неисправни операнди типова %qT и %qT за бинарно %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ИСО Ц++ забрањује употребу показивача типа %<void *%> у одузимању"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ИСО Ц++ забрањује употребу показивача на функцију у одузимању"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ИСО Ц++ забрањује употребу показивача на метод у одузимању"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "неисправна употреба показивача на непотпун тип у аритметици са показивачима"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of constructor %qD"
 msgstr "узимање адресе привременог"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of destructor %qD"
 msgstr "узимање адресе привременог"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "неисправна употреба %qE за добијање показивача-на-чланску-функцију"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  неопходан је одређен ид."
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "заграде око %qE не могу бити коришћене за добијање показивача-на-чланску-функцију"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ИСО Ц++ забрањује узимање адресе неодређене или заграћене нестатичке чланске функције, за добијање показивача на чланску функцију. Употребите %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 #| msgid "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%>"
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ИСО Ц++ забрањује узимање адресе неодређене или заграћене нестатичке чланске функције, за добијање показивача на чланску функцију. Употребите %<&%T::%D%>"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ИСО Ц++ забрањује узимање адресе везане чланске функције за добијање показивача на чланску функцију. Употребите %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ИСО Ц++ забрањује узимање адресе везане чланске функције за добијање показивача на чланску функцију. Употребите %<&%T::%D%>"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(показивач на члан може бити формиран само помоћу %<&%E%>)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "узимање адресе привременог"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ИСО Ц++ забрањује узимање адресе функције %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "не може се створити показивач на упућивачки члан %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field %qD"
 msgid "attempt to take address of bit-field"
 msgstr "не може се узети адреса битског поља %qD"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr ""
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ИСО Ц++ забрањује %s-вање набрајања"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ИСО Ц++ забрањује %s-вање набрајања"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "не може се %s показивач на непотпуни тип %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "не може се %s показивач на непотпуни тип %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing a pointer of type %qT"
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ИСО Ц++ забрањује %s-вање показивача типа %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing a pointer of type %qT"
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ИСО Ц++ забрањује %s-вање показивача типа %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "не може се узети адреса од %<this%>, јер је д-вредносни израз"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "затражена је адреса од %qD, а декларисано је као %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 #| msgid "initializer for %qT must be brace-enclosed"
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "успостављач за %qT мора бити у витичастим заградама"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in initializer"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in functional cast"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "листа израза %s узима се као сложени израз"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "претварање из %qT у %qT одбацује одредбе"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "неисправно статичко претапање из типа %qT у тип %qT"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "неисправно статичко претапање из типа %qT у тип %qT"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "useless cast to type %q#T"
 msgstr "неисправно претапање у функцијски тип %qT"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "одредбе типова се игноришу на повратном типу функције"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "неисправно статичко претапање из типа %qT у тип %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "class type %qT is incomplete"
 msgstr "повратни тип %q#T није потпун"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "претварање из %qT у %qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "неисправно претапање д-вредносног израза типа %qT у тип %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "претапање из %qT у %qT губи на тачности"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 #| msgid "%s between distinct pointer-to-member types %qT and %qT lacks a cast"
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "недостаје претапање за %s између различитих типова показивача-на-члан %qT и %qT"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "претапање из %qT у %qT повећава неопходно равнање циљног типа"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ИСО Ц++ забрањује претапање између показивача на функцију и показивача на објекат"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "неисправно претапање из типа %qT у тип %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "неисправна употреба константног претапања са типом %qT, који није показивач, нити показивач на члански податак"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "неисправна употреба константног претапања са типом %qT, који је показивач или упућивач на функцијски тип"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "неисправно константно претапање д-вредности типа %qT у тип %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "неисправно константно претапање из типа %qT у тип %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ИСО Ц++ забрањује претапање у низовни тип %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "неисправно претапање у функцијски тип %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "не може се претворити %qE из типа %qT у тип %qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  у израчунавању %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "assigning to an array from an initializer list"
 msgstr "неконстантан индекс низа у успостављачу"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "несагласни типови у додели %qT у %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "низ употребљен као успостављач"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "неисправна додела низа"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   у претварању показивача на чланску функцију"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "претварање показивача на члан преко виртуелне основе %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   у претварању показивача на члан"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "неисправно претварање у тип %qT из типа %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 #| msgid "cannot convert %qT to %qT for argument %qP to %qD"
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "не може се претворити %qT у %qT као аргумент %qP за %qD"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "не може се претворити %qT у %qT у %s"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "не може се претворити %qT у %qT у %s"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in return"
 msgstr "не може се претворити %qT у %qT у %s"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "не може се претворити %qT у %qT у %s"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE might be a candidate for a format attribute"
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "аргумент %d од %qE може бити кандидат за форматски атрибут"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 #| msgid "return type might be a candidate for a format attribute"
 msgid "parameter might be a candidate for a format attribute"
 msgstr "повратни тип може бити кандидат за форматски атрибут"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 #| msgid "argument of function call might be a candidate for a format attribute"
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "аргумент позива функције може бити кандидат за форматски атрибут"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 #| msgid "argument of function call might be a candidate for a format attribute"
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "аргумент позива функције може бити кандидат за форматски атрибут"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 #| msgid "assignment left-hand side might be a candidate for a format attribute"
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "лева страна доделе може бити кандидат за форматски атрибут"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of %q+D"
 msgid "in passing argument %P of %qD"
 msgstr "у прослеђивању аргумента %P за %q+D"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "враћање упућивача на привремени"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "враћање упућивача на привремени"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable %q+D returned"
 msgid "reference to local variable %qD returned"
 msgstr "враћање упућивача на локалну променљиву %q+D"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of label %qD returned"
 msgstr "враћање адресе локалне променљиве %q+D"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of local variable %qD returned"
 msgstr "враћање адресе локалне променљиве %q+D"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "Missing return statement"
 msgid "redundant move in return statement"
 msgstr "Недостаје наредба повратка"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in initialization"
 msgid "redundant move in initialization"
 msgstr "несагласни типови у успостављању"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "враћање вредности из деструктора"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "не може се враћати из руковаоца у блоку покушаја у конструктору"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "враћање вредности из конструктора"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "наредба враћања без вредности, у функцији која враћа %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "returning initializer list"
 msgstr "недостаје успостављач"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "не могу се дефинисати нови типови у повратном типу"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "Неусаглашени рангови за оператор код %L и %L"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with no value, in function returning %qT"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "наредба враћања без вредности, у функцији која враћа %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> не сме вратити NULL, осим ако је декларисан уз %<throw()%> (или је задато -fcheck-new)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr ""
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s value"
 msgid "using rvalue as lvalue"
@@ -79704,19 +79877,19 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown attribute %qs"
 msgstr "непознат машински режим %qs"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after being called"
 msgid "%q+D declared weak after being used"
 msgstr "%q+D декларисано уткано пошто је већ позвано"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -79745,47 +79918,47 @@ msgstr "недостаје успостављач за члан %qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "адреса за %qD никако не може бити NULL"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "не може се декларисати показивач на %q#T"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "Складишти имена функција у објектном коду"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "Nested %s %s is %s; cannot be accessed from here"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "Угњеждено %s %s у %s; не може му се приступити отуда"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qs used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "регистарска променљива %qs употребљена у угњежденој функцији"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has reference type for %qs"
 msgid "forward reference to frame of %qs"
@@ -79872,36 +80045,36 @@ msgstr ""
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "превише аргумената за функцију %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can't open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "не могу да отворим %s за писање: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "отварам улазну датотеку %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can't open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "не могу да отворим %s за писање: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "отварам датотеку зависности %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -80007,7 +80180,7 @@ msgstr ""
 msgid "%qs is not an associative array"
 msgstr "%qT није скупински тип"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -80024,25 +80197,25 @@ msgstr "%q+D је обично нестатичка функција"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs није исправно за %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "recursive reference %qs"
 msgstr "не може се декларисати упућивач на %q#T"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "Constant expression required"
 msgid "non-constant expression %qs"
 msgstr "Неопходан константан израз"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "  in thrown expression"
 msgid "%qs is not an expression"
 msgstr "  у баченом изразу"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "type %qs is not an expression"
@@ -80143,18 +80316,18 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "Уткане функције Ц-а 99 нису подржане; користим Гну 89"
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "не може се користити ид. типова уз -fno-rtti"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -80500,8 +80673,8 @@ msgstr "Упућивач низа код %C не може имати више о
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -80799,7 +80972,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "аргумент атрибута %qs није константна ниска"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad kind for logical constant at %C"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -80889,7 +81062,7 @@ msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L м
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити целобројан или процедура"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -81054,7 +81227,7 @@ msgstr "Наредба ENTRY код %C не може бити унутар са
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "Аргументи ‘%s’ и ‘%s’ сопственог ‘%s’ код %L морају бити истог типа"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different type kinds at %L"
@@ -81072,7 +81245,7 @@ msgstr "Нулти показивач код %L није дозвољен као
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити показивач"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
@@ -81230,8 +81403,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -81335,9 +81508,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "Наредба ENTRY код %C не може бити унутар садржаног потпрограма"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs intrinsic with KIND argument at %L"
@@ -81355,13 +81528,13 @@ msgstr "Аргумент ‘dim’ за сопствено ‘%s’ код %L н
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити скалар"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити бројеван или логички"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
@@ -81469,681 +81642,681 @@ msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L м
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Сопствено ‘%s’ код %L мора имати бар два аргумента"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Недостају аргументи за сопствено %s код %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Недостају аргументи за сопствено %s код %L"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Недостају аргументи за сопствено %s код %L"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different character kinds at %L"
 msgstr "Проширење: Различите врсте типова код %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "Аргумент ‘a%d’ сопственог ‘%s’ код %L мора бити %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "Аргумент ‘a1’ сопственог ‘%s’ код %L мора бити целобројан или реалан"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "Аргумент ‘a1’ сопственог ‘%s’ код %L мора бити целобројан или реалан"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 #| msgid "different shape on dimension 1 for arguments '%s' and '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "различити облици по димензији 1 аргумената ‘%s’ и ‘%s’ код %L за сопствено ’matmul’"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 #| msgid "different shape on dimension 2 for argument '%s' and dimension 1 for argument '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "различити облици по димензији 2 аргумента ‘%s’ и димензији 1 аргумента ‘%s’ код %L за сопствено ’matmul’"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2"
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити ранга 1 или 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити истог типа и врсте као ‘%s’"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити целобројан или реалан"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити показивач"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Други аргумент у NEAREST код %L не може бити нула"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Други аргумент у NEAREST код %L не може бити нула"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "Аргументи ‘%s’ и ‘%s’ сопственог ‘%s’ код %L морају бити истог ранга %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "Аргументи ‘%s’ и ‘%s’ сопственог ‘%s’ код %L морају бити истог ранга %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "Други аргумент у NEAREST код %L не може бити нула"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити резервљив"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr ""
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'"
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити истог типа и врсте као ‘%s’"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити од лажне променљиве"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити од опционе лажне променљиве"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must not be a sub-object of '%s'"
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L не сме бити подобјекат од ‘%s’"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a variable"
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити променљива"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr ""
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a logical array"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити логички низ"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "Аргумент ‘shape’ сопственог ‘reshape’ код %L мора бити низ константне величине"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити %s"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "Аргумент ‘shape’ сопственог ‘reshape’ код %L има више од %d елемената"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "Аргумент ‘a%d’ сопственог ‘%s’ код %L мора бити %s(%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити ранга %d"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "Аргумент ‘dim’ за сопствено ‘%s’ код %L није исправан димензиони индекс"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "Аргумент ‘dim’ за сопствено ‘%s’ код %L није исправан димензиони индекс"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Без уметања нема довољно елемената да подрже облик у сопственом RESHAPE код %L"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a numeric type"
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити бројевног типа"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "Атрибут %s коси се са атрибутом %s код %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "Аргумент ‘source’ сопственог ‘shape’ код %L не сме бити низ претпостављене величине"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити скалар"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)"
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L не може бити намере-у"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "Аргумент ‘source’ сопственог ‘shape’ код %L не сме бити низ претпостављене величине"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити неизведени тип"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr ""
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment to non-POINTER at %L"
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Додела показивача непоказивачу код %L"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора бити функција"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "Други аргумент у NEAREST код %L не може бити нула"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "Компонента код %C мора имати атрибут показивача"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "Недостају аргументи за сопствено %s код %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити мање ранга од %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "Аргумент ‘dim’ за сопствено ‘%s’ код %L није исправан димензиони индекс"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити мање ранга од %d"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "Стварни аргумент за ‘%s’ код %L мора бити показивач"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Превише аргумената за %s код %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Превише аргумената за %s код %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same kind as '%s'"
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити исте врсте као ‘%s’"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "Аргументи ‘%s’ и ‘%s’ сопственог ‘%s’ код %L морају бити истог типа"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Аргумент у ATANH код %L мора бити у опсегу -1 до 1"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити %s"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Превише аргумената за %s код %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "погрешан број шаблонских аргумената ((%d, а треба %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити врсте %d"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити скалар"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "Аргумент ‘%s’ сопственог ‘%s’ код %L мора бити целобројан или логички"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -82216,12 +82389,12 @@ msgstr "успостављачка ниска подсечена да одгов
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "успостављачка ниска подсечена да одговара променљивој код %L"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Индекс почетка подниске код %L је мањи од један"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "Индекс краја подниске код %L премашује дужину ниске"
@@ -82276,2262 +82449,2262 @@ msgstr "Променљива ‘%s’ код %C са успостављачем
 msgid "Simplification error"
 msgstr "гимплификација није успела"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 #| msgid "Host associated variable '%s' may not be in the DATA statement at %C."
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Домаћином придружена променљива ‘%s’ не може бити у наредби DATA код %C."
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 #| msgid "Extension: initialization of common block variable '%s' in DATA statement at %C"
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Проширење: успостављање заједничког блока ‘%s’ у наредби DATA код %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C"
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Симбол ‘%s’ мора бити параметар у наредби DATA код %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid init statement"
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Неисправна успостављачка наредба"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%s не може да се јави у константном изразу"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "Успостављање код %C није дозвољено у чистој процедури"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "Наредба ENTRY код %C не може бити унутар INTERFACE"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Неконстантан одељак низа код %L у наредби DATA"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "Наредба DATA код %C није дозвољена у чистој процедури"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Empty old style initializer list at %C"
 msgstr "Проширење: Старовремско успостављање код %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array component of structure at %C must have an explicit shape"
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Низовна компонента структуре код %C мора имати експлицитан облик"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "сувишни елементи у скаларном инцијализатору"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C must be an integer."
 msgid "Repeat spec must be an integer at %C"
 msgstr "Крејов показивач код %C мора бити целобројни."
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Очекивана је етикета алтернативног повратка код %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "End of scalar initializer expected at %C"
 msgstr "Очекиван је скаларни успостављачки израз код %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "сувишни елементи у успостављачу низа"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "сувишни елементи у успостављачу низа"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in OpenMP variable list at %C"
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Синтаксна грешка у ОпенМП листи аргумената код %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Лоша одредница намере код %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "deferred type parameter at %C"
 msgstr "употреба параметра шаблонског типа %qT после %qs"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal character in BOZ constant at %C"
 msgid "Old-style character length at %C"
 msgstr "Недозвољени знак у БОЗ константи код %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Синтаксна грешка у одредници знаковне дужине код %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Процедура ‘%s’ код %C већ је дефинисана код %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Процедура ‘%s’ код %C већ је дефинисана код %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Глобално име ‘%s’ код %L се већ користи као %s код %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Процедура ‘%s’ код %C има експлицитно сучеље и не може имати атрибуте декларисане код %L"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Променљива изведеног типа ‘%s’ код %L мора имати атрибут SEQUENCE да би била објекат еквиваленције"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Резервљиви низ ‘%s’ код %L мора имати одложени облик"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Низ претпостављеног облика код %L мора бити лажни аргумент"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L cannot have a type"
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Симбол ‘%s’ код %L не може имати тип"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr ""
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CHARACTER expression at %L is being truncated (%d/%d)"
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "Знаковни израз код %L бива подсечен (%d/%d)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The CHARACTER elements of the array constructor at %L must have the same length (%d/%d)"
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Знаковни елементи конструктора низа код %L морају имати исту дужину (%d/%d)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 #| msgid "Initializer not allowed for PARAMETER '%s' at %C"
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Успостављач није дозвољен за параметар ‘%s’ код %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "Недостаје успостављач за параметар код %L"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C with an initializer already appears in a DATA statement"
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Променљива ‘%s’ код %C са успостављачем већ се појављује у наредби DATA"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Неслагање рангова у упућивачу низа код %L (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize multi-dimensional array with initializer"
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "у успостављачу се не могу успостављати вишедимензиони низови"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "bad array initializer"
 msgid "Bad shape of initializer at %L"
 msgstr "лош успостављач низа"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "не може се декларисати показивач на %q#T"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Синтаксна грешка у декларацији података код %C"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "Функција ‘%s’ код %L је сопствена али није сагласна са сопственом"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Компонента код %C мора имати атрибут показивача"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr ""
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Низовна компонента структуре код %C мора имати експлицитан или одложени облик"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "Component %qs at %C already declared at %L"
 msgstr "Компонента ‘%s’ код %C већ је декларисана код %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Показивачка низовна компонента структуре код %C мора имати одложен облик"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Резервљива компонента структуре код %C мора имати одложен облик"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Низовна компонента структуре код %C мора имати експлицитан облик"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "листа параметара са тротачком не може поклопити декларацију празне листе имена параметара"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "Двосмислено успостављање NULL() код %C"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NULL() initialization at %C is ambiguous"
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "Двосмислено успостављање NULL() код %C"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Успостављање показивача код %C није дозвољена у чистој процедури"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Error in pointer initialization at %C"
 msgstr "Проширење: Старовремско успостављање код %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "non-NULL pointer initialization at %C"
 msgstr "Проширење: Старовремско успостављање код %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "Атрибут %s коси се са атрибутом %s код %L"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected character in variable list at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Неочекиван знак у листи променљивих код %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може имати показивачку вредност"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be of INTEGER type"
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Индекс низа код %L мора бити целобројни"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Лажно ‘%s’ код %L не може имати успостављач"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C."
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Удвостручена одредница низа за Крејов показиваног код %C."
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set pointee array spec."
 msgstr "не могу да претворим у показивачки тип"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Old-style initialization at %C"
 msgstr "Проширење: Старовремско успостављање код %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid initialization of reference of type %qT from expression of type %qT"
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "неисправно успостављање упућивача типа %qT изразом типа %qT"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Проширење: Старовремско успостављање код %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Успостављање код %C није за показивачку променљиву"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Успостављање показивача код %C захтева ‘=>’, не ‘=’"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Очекиван је успостављачки израз код %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Успостављање променљиве код %C није дозвољена у чистој процедури"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Успостављање резервљиве компоненте код %C није дозвољено"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of allocatable component at %C is not allowed"
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "Успостављање резервљиве компоненте код %C није дозвољено"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The pointer component '%s' of '%s' at %L is a type that has not been declared"
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Показивачка компонента ‘%s’ у ‘%s’ код %L припада типу који није декларисан"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Спољашње ‘%s’ код %L не може имати успостављач"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Старовремска декларација типа %s*%d није подржана код %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Нестандардна декларација типа %s*%d код %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing right paren at %C"
 msgid "Missing right parenthesis at %C"
 msgstr "Недостаје лева заграда код %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Очекиван је успостављачки израз код %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Очекиван је скаларни успостављачки израз код %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Врста %d није подржана за тип %s код %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Различите врсте типова параметара у додели показивача код %L"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing right paren at %C"
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Недостаје лева заграда код %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Kind %d not supported for type %s at %C"
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Врста %d није подржана за тип %s код %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Синтаксна грешка у декларацији CHARACTER код %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Израз код %L мора бити целобројног типа"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "Израз код %L мора бити целобројног типа"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "Параметар врсте за %s код %L мора бити инцијализовани израз"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "двосмислено упућивање на %qD"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: BYTE type at %C"
 msgid "BYTE type at %C"
 msgstr "Проширење: тип BYTE код %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "Тип BYTE употребљен код %C није доступан на циљној машини"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument list function at %L is not allowed in this context"
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Функција листе аргумената код %L није дозвољена у овом контексту"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "malformed spec function name"
 msgid "Malformed type-spec at %C"
 msgstr "лоше формирано име функције навода"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C is ambiguous"
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Двосмислено име типа ‘%s’ код %C"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected CASE statement at %C"
 msgid "CLASS statement at %C"
 msgstr "Неочекивана наредба CASE код %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Удвостручена наредба IMPLICIT NONE код %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate IMPLICIT NONE statement at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "Удвостручена наредба IMPLICIT NONE код %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Недостаје знаковни опсег за имплицитно код %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Слова морају бити у алфабетском поретку у наредби IMPLICIT код %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE statement at %C follows blanket SAVE statement"
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "Наредба SAVE код %C прати покривачку наредбу SAVE"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Празна наредба IMPLICIT код %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "Наредба ENTRY код %C не може бити унутар INTERFACE"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "IMPORT statement at %C"
 msgstr "Празна наредба IMPLICIT код %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in %s statement at %C"
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Синтаксна грешка у наредби %s код %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting list of named entities at %C"
 msgstr "Очекивана је наредба %s код %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing dimension specification at %C"
 msgid "Missing codimension specification at %C"
 msgstr "Недостаје одредница димензија код %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Недостаје одредница димензија код %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Удвостручени атрибут %s код %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s attribute at %L is not allowed outside of a MODULE"
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "Атрибут %s код %L није дозвољен изван модула"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "Атрибут код %L није дозвољен у дефиницији типа"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s attribute at %L"
 msgid "PROTECTED attribute at %C"
 msgstr "Удвостручени атрибут %s код %L"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Line truncated at %C"
 msgid "VALUE attribute at %C"
 msgstr "Линија одсечена код %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L не може имати атрибут показивача"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може имати низовну вредност"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr ""
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing generic specification in USE statement at %C"
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Недостаје генеричка одредница у наредби USE код %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "Missing name"
 msgid "Missing symbol"
 msgstr "недостаје име"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "BIND(C) statement at %C"
 msgstr "Празна наредба IMPLICIT код %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "Компонента код %C мора имати атрибут показивача"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition."
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Изведени тип код %C није претходно дефинисан и зато се не може појавити у дефиницији изведеног типа."
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Синтаксна грешка у декларацији података код %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Синтаксна грешка у декларацији података код %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr ""
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "MODULE PROCEDURE код %C мора бити у генеричком сучељу модула"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "procedure name = %s"
 msgid "IMPURE procedure at %C"
 msgstr "име процедуре = %s"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer expression required at %C"
 msgid "A type parameter list is required at %C"
 msgstr "Неопходан целобројни израз код %C"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Alternate-return argument at %C"
 msgstr "Очекивана је етикета алтернативног повратка код %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unused parameter %s declared at %L"
 msgid "A parameter name is required at %C"
 msgstr "Неупотребљен параметар %s декларисан код %L"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Име ‘%s’ код %C је име процедуре"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Очекивана је друга димензија у декларацији низа код %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Неочекивано смеће у формалној листи аргумената код %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Удвостручени симбол ‘%s’ у формалној листи аргумената код %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Удвостручени симбол ‘%s’ у формалној листи аргумената код %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "Променљива RESULT код %C мора бити различита од имена функције"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Неочекивано смеће после декларације функције код %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Атрибут SAVE код %L не може бити наведен у чистој процедури"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy procedure '%s' at %C cannot have a generic interface"
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Лажна процедура ‘%s’ код %C не може имати генеричко сучеље"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Име изведеног типа ‘%s’ код %C већ има основни тип %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Очекивано је завршно име код %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected structure component name at %C"
 msgid "Procedure pointer component at %C"
 msgstr "Очекивано је име компоненте структуре код %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in structure constructor at %C"
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Синтаксна грешка у конструктору структуре код %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "MODULE PROCEDURE код %C мора бити у генеричком сучељу модула"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "PROCEDURE statement at %C"
 msgstr "Застарело: наредба PAUSE код %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Очекивана је формална листа аргумената у дефиницији функције код %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "ENTRY statement at %C"
 msgstr "Празна наредба IMPLICIT код %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "Наредба ENTRY код %C не може бити унутар PROGRAM"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "Наредба ENTRY код %C не може бити унутар MODULE"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "Наредба ENTRY код %C не може бити унутар MODULE"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "Наредба ENTRY код %C не може бити унутар BLOCK DATA"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "Наредба ENTRY код %C не може бити унутар INTERFACE"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока SELECT"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока DERIVED TYPE"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока IF-THEN"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока DO"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока SELECT"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока FORALL"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока WHERE"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "Наредба ENTRY код %C не може бити унутар садржаног потпрограма"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Неочекивана наредба END код %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "Наредба ENTRY код %C не може бити у садржаној процедури"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "Наредба ENTRY код %C не може бити у садржаној процедури"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Alternate return cannot appear in operator interface at %L"
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "Алтернативно враћање не може да се јави у сучељу оператора код %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Period required in format specifier at %C"
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Потребна тачка у наводиоцу формата код %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Синтаксна грешка у одредници CASE код %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing or invalid constant expression"
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "Недостаје или неисправан константан израз"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing format label at %C"
 msgid "Missing closing paren for binding label at %C"
 msgstr "Недостаје етикета формата код %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function name '%s' not allowed at %C"
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Име функције ‘%s’ није дозвољено код %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Неочекивана наредба END код %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s statement at %C cannot follow %s statement at %L"
 msgid "END statement instead of %s statement at %L"
 msgstr "Наредба %s код %C не може пратити наредбу %s код %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "Очекивана је наредба %s код %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting %s statement at %L"
 msgstr "Очекивана је наредба %s код %C"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Очекивано је име блока за ‘%s’ у наредби %s код %C"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Очекивано је завршно име код %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 #| msgid "Expected label '%s' for %s statement at %C"
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Очекивана је етикета ‘%s’ за наредбу %s код %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Недостаје одредница низа код %L у наредби DIMENSION"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing array specification at %L in DIMENSION statement"
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Недостаје одредница низа код %L у наредби DIMENSION"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Одредница низа мора бити одложена код %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Неочекиван знак у листи променљивих код %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<(%> at %C"
 msgstr "Очекивано је ‘(’ код %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Очекивано је име променљиве код %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C must be an integer."
 msgid "Cray pointer at %C must be an integer"
 msgstr "Крејов показивач код %C мора бити целобројни."
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes."
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Крејов показивач код %C има %d бајтова тачности; меморијска адреса захтева %d бајтова."
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Очекивано је ‘,’ код %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
 msgstr "не могу да претворим у показивачки тип"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C."
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Удвостручена одредница низа за Крејов показиваног код %C."
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Очекивано је ‘)’ код %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" or end of statement at %C"
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "Очекивано је ‘,’ или крај наредбе код %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer declaration at %C requires -fcray-pointer flag."
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Декларација Крејовог показивача код %C захтева заставицу -fcray-pointer."
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "CONTIGUOUS statement at %C"
 msgstr "Застарело: наредба PAUSE код %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "Одредница приступа оператора %s код %C је већ наведена"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "Одредница приступа оператора .%s. код %C је већ наведена"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "PROTECTED statement at %C"
 msgstr "Празна наредба IMPLICIT код %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "Наредба DATA код %C није дозвољена у чистој процедури"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "Наредба DATA код %C није дозвољена у чистој процедури"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Очекивано је име променљиве код %C у наредби PARAMETER"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Очекиван је знак = у наредби PARAMETER код %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Очекиван је израз код %C у наредби PARAMETER"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initializer not allowed for COMMON variable '%s' at %C"
 msgid "Initializing already initialized variable at %C"
 msgstr "Успостављач није дозвољен за заједничку променљиву ‘%s’ код %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Неочекивани знакови у наредби PARAMETER код %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Очекивана је променљива у наредби READ код %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Очекивана је променљива у наредби READ код %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Покривачка наредба SAVE код %C прати претходну наредбу SAVE"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "Наредба SAVE код %C прати покривачку наредбу SAVE"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "VALUE statement at %C"
 msgstr "Застарело: наредба PAUSE код %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate PRIVATE statement at %C"
 msgid "VOLATILE statement at %C"
 msgstr "Удвостручена наредба PRIVATE код %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Застарело: наредба PAUSE код %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE код %C мора бити у генеричком сучељу модула"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected :: in TYPE definition at %C"
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Очекивано је :: у дефиницији TYPE код %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Симбол ‘%s’ код %C је већ придружен домаћину"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be thread-local because it has non-POD type %qT"
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qD не може бити нитно-локално зато што је не-ПОД типа %qT"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type at %C can only be PRIVATE within a MODULE"
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Изведени тип код %C може бити само приватан унутар модула"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type at %C can only be PUBLIC within a MODULE"
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Изведени тип код %C може бити само јаван унутар модула"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate construct label '%s' at %C"
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Удвостручена етикета конструкције ‘%s’ код %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Дефиниција изведеног типа ‘%s’ код %C је већ учињена"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Junk after MAP statement at %C"
 msgstr "Неочекивано смеће после наредбе ELSE код %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Junk after UNION statement at %C"
 msgstr "Неочекивано смеће после наредбе ELSE код %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Неочекивано смеће после декларације функције код %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected CASE statement at %C"
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Неочекивана наредба CASE код %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Име типа ‘%s’ код %C не може бити исто као сопственог типа"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Очекивано је :: у дефиницији TYPE код %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type definition at %C has no components"
 msgid "Mangled derived type definition at %C"
 msgstr "Дефиниција изведеног типа код %C нема компонената"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Име типа ‘%s’ код %C не може бити исто као сопственог типа"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Име изведеног типа ‘%s’ код %C већ има основни тип %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Име изведеног типа ‘%s’ код %C већ има основни тип %s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити опцион"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "Дефиниција изведеног типа ‘%s’ код %C је већ учињена"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Синтаксна грешка у декларацији CHARACTER код %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Крејов показивани код %C не може бити низ претпостављеног облика"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "New in Fortran 2003: ENUM and ENUMERATOR at %C"
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "Ново у фортрану 2003: ENUM и ENUMERATOR код %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Набрајач премашује Ц-ов целобројни тип код %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "Набрајач %L није успостављен целобројним изразом"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "Очекивана је наредба дефиниције ENUM пре %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Синтаксна грешка у дефиницији ENUMERATOR код %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s specification at %C"
 msgid "Duplicate access-specifier at %C"
 msgstr "Удвостручена одредница %s код %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s attribute at %L"
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Удвостручени атрибут %s код %L"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected VARIABLE at %C"
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Очекивано је VARIABLE код %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate SEQUENCE statement at %C"
 msgid "Duplicate DEFERRED at %C"
 msgstr "Удвостручена наредба SEQUENCE код %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a nameless interface at %C"
 msgid "Expected access-specifier at %C"
 msgstr "Очекивано је безимено сучеље код %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected binding attribute at %C"
 msgstr "Очекивано је завршно име код %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 #| msgid "identifier expected after %<@protocol%>"
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "очекиван је идентификатор после %<@protocol%>"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "%<)%> expected at %C"
 msgstr "Очекивано је ‘(’ код %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected binding name at %C"
 msgstr "Очекивано је завршно име код %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Очекивано је завршно име код %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<::%> at %C"
 msgstr "Очекивано је ‘(’ код %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected array subscript at %C"
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Очекиван је индекс низа код %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Malformed GENERIC statement at %C"
 msgstr "Неисправан облик наредбе PROGRAM код %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<=>%> at %C"
 msgstr "Очекивано је ‘(’ код %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Shape specification at %L cannot be negative"
 msgid "The access specification at %L not in a module"
 msgstr "Одредница облика код %L не може бити негативна"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "Одредница приступа оператора %s код %C је већ наведена"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "Одредница приступа оператора %s код %C је већ наведена"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Expected specific procedure name at %C"
 msgstr "Очекивана је процедура за аргумент ‘%s’ код %L"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to find a specific INTRINSIC procedure for the reference '%s' at %L"
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "Не могу да нађем одређену сопствену процедуру за упућивач ‘%s’ код %L"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Неочекивано смеће после наредбе ELSE код %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected specific binding name at %C"
 msgstr "Очекивано је завршно име код %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific function for the generic '%s' at %L"
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "Нема одређене функције за генеричко ‘%s’ код %L"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected VARIABLE at %C"
 msgid "Empty FINAL at %C"
 msgstr "Очекивано је VARIABLE код %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Expected module procedure name at %C"
 msgstr "Очекивана је процедура за аргумент ‘%s’ код %L"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" at %C"
 msgid "Expected %<,%> at %C"
 msgstr "Очекивано је ‘,’ код %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 #| msgid "procedure name = %s"
 msgid "Unknown procedure name %qs at %C"
 msgstr "име процедуре = %s"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 #| msgid "%s procedure at %L is already declared as %s procedure"
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "Процедура %s код %L је већ декларисана као процедура %s"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected characters in PARAMETER statement at %C"
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Неочекивани знакови у наредби PARAMETER код %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Синтаксна грешка у итератору FORALL код %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Синтаксна грешка у декларацији CHARACTER код %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Синтаксна грешка у декларацији CHARACTER код %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in ENUMERATOR definition at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -84682,457 +84855,457 @@ msgstr ""
 msgid "IM part_ref at %C"
 msgstr ""
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Неопходни бројевни или знаковни операнди у изразу код %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Оператор надовезивања у изразу код %L мора имати два знаковна операнда"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Оператор надовезивања код %L мора надовезивати ниске исте врсте"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "Оператор .NOT. у изразу код %L мора имати логички операнд"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "Неопходни су логички операнди у изразу код %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Могу се користити само сопствени оператори у изразу код %L"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Неопходни су бројевни операнди у изразу код %L"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 #| msgid "Too few components in structure constructor at %C"
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Премало компонената у конструктору структуре код %C"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 #| msgid "assumed character length variable '%s' in constant expression at %L"
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Знаковна променљива претпостављене дужине ‘%s’ у константном изразу код %L."
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Evaluation of nonstandard initialization expression at %L"
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Проширење: Израчунавање нестандардног успостављачког израза код %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' in initialization expression at %L must be an intrinsic function"
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "Функција ‘%s’ у успостављачком изразу код %L мора бити сопствена"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Параметар ‘%s’ код %L није декларисан или је променљива, што се не своди на константан израз"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 #| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "трансформационо сопствено ‘%s’ код %L није дозвољено у успостављачком изразу"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Параметар ‘%s’ код %L није декларисан или је променљива, што се не своди на константан израз"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_init_expr(): Unknown expression type"
 msgstr "Очекиван је тип израза"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Одредничка функција ‘%s’ код %L не може бити наредбена функција"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be an internal function"
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Одредничка функција ‘%s’ код %L не може бити унутрашња функција"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Одредничка функција ‘%s’ код %L мора бити чиста"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be RECURSIVE"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Одредничка функција ‘%s’ код %L не може бити рекурзивна"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Променљива ‘%s’ се не може јавити у изразу код %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити опцион"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити намере-из"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Променљива ‘%s’ се не може јавити у изразу код %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_restricted(): Unknown expression type"
 msgstr "Очекиван је тип израза"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Израз код %L мора бити целобројног типа"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Function %qs at %L must be PURE"
 msgstr "Одредничка функција ‘%s’ код %L мора бити чиста"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Израз код %L мора бити скалар"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s at %L"
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Несагласни рангови у %s код %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "different shape for %s at %L on dimension %d (%d/%d)"
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "%s код %L има различит облик за димензију %d (%d/%d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "употреба параметра шаблонског типа %qT после %qs"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a VALUE"
 msgid "%qs at %L is not a VALUE"
 msgstr "‘%s’ код %L није вредност"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Недозвољен нулти корак код %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Несагласни рангови %d и %d у додели код %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Тип променљиве је UNKNOWN у додели код %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "Појављује се NULL на десној страни у додели код %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "POINTER valued function appears on right-hand side of assignment at %L"
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Функција са показивачком вредношћу појављује се на десној страни доделе код %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible types in assignment at %L, %s to %s"
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Несагласни типови у додели код %L, %s у %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Циљ доделе показивача није показивач код %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "‘%s’ у додели показивача код %L не може бити л-вредност јер је процедура"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate %s specification at %C"
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Удвостручена одредница %s код %C"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Различити типови у додели показивача код %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "stack size must not be greater than 64k"
 msgid "Stride must not be present at %L"
 msgstr "величина стека не сме бити већа од 64k"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Спољашњи објекат ‘%s’ код %L не може имати успостављач"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Различити типови у додели показивача код %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Различите врсте типова параметара у додели показивача код %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Различите врсте типова параметара у додели показивача код %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' requires argument list at %C"
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Наредбена функција ‘%s’ захтева листу аргумената код %C"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Унутрашња процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not allowed as an actual argument"
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Сопствено ‘%s’ код %L није дозвољено као стварни аргумент"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr ""
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Очекивана је процедура за аргумент ‘%s’ код %L"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate interface declaration for class %qs"
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "удвостручена декларација сучеља за класу %qs"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Различите знаковне дужине у додели показивача код %L"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Циљ доделе показивача није показивач код %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Различити типови у додели показивача код %L"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Различите врсте типова параметара у додели показивача код %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Различити рангови у додели показивача код %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Циљ доделе показивача није показивач код %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -85140,208 +85313,208 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data target at %L shall not have a coindex"
 msgstr "Елемент преноса података код %L не може имати показивачке компоненте"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "Изборни израз у рачунском GOTO код %L мора бити скаларни целобројан израз"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "Циљ доделе показивача није ни циљ ни показивач код %L"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Аргумент наредбе SELECT код %L мора бити скаларни израз"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Циљ доделе показивача није ни циљ ни показивач код %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Лош циљ у додели показивача у чистој процедури код %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Додела показивача са векторским индексом на десној страни код %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Циљ доделе показивача није показивач код %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "Успостављање показивача код %C захтева ‘=>’, не ‘=’"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "Компонента код %C мора имати атрибут показивача"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Објекат ‘%s’ код %L мора имати атрибут %s за SAVE"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Унутрашња процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr ""
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%qE није исправан шаблонски аргумент типа %qT јер %qE није променљива"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Променљива ‘%s’ се не може јавити у изразу код %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr ""
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -85364,7 +85537,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "creating array of %qT"
@@ -85431,47 +85604,47 @@ msgstr "Променљива ‘%s’ код %C не може се редефи
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "Променљива ‘%s’ код %C не може се редефинисати унутар петље која почиње код %L"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "Променљива ‘%s’ код %C не може се редефинисати унутар петље која почиње код %L"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "Променљива ‘%s’ код %C не може се редефинисати унутар петље која почиње код %L"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s at %L"
 msgid "Interchanging loops at %L"
 msgstr "Несагласни рангови у %s код %L"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "%s between %L and %L"
@@ -85606,12 +85779,12 @@ msgstr "Први аргумент дефинисане доделе код %L м
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Други аргумент дефинисане доделе код %L мора бити намере-у"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Први аргумент сучеља оператора код %L мора бити намере-у"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Други аргумент сучеља оператора код %L мора бити намере-у"
@@ -86070,334 +86243,339 @@ msgstr "Стварни аргумент за ‘%s’ код %L мора бит
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Недостаје одредница алтернативног враћања у позиву потпрограма код %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 #| msgid "Missing actual argument for argument '%s' at %L"
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Недостаје стварни аргумент за аргумент ‘%s’ код %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, fuzzy, gcc-internal-format
 #| msgid "Same actual argument associated with INTENT(%s) argument '%s' and INTENT(%s) argument '%s' at %L"
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Исти стварни аргумент придружен намере-%s аргументу ‘%s’ и намере-%s аргументу ‘%s’ код %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Аргумент процедуре код %L је локалан у чистој процедури и има атрибут показивача"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Аргумент процедуре код %L је локалан у чистој процедури и прослеђује се аргументу намере-%s"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Аргумент процедуре код %L је локалан у чистој процедури и прослеђује се аргументу намере-%s"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Процедура ‘%s’ позвана са имплицитним сучељем код %L"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Процедура ‘%s’ позвана са имплицитним сучељем код %L"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Процедура ‘%s’ позвана са имплицитним сучељем код %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic character length function '%s' at %L must have an explicit interface"
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Аутоматска функција знаковне дужине ‘%s’ код %L мора имати експлицитно сучеље"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Очекивана је процедура за аргумент ‘%s’ код %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Кључна реч ‘%s’ код %L није у процедури"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Симбол ‘%s’ код %L већ има експлицитно сучеље"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "MOLD argument to NULL required at %L"
 msgstr "Недостају аргументи за сопствено %s код %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Процедура ‘%s’ позвана са имплицитним сучељем код %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Процедура ‘%s’ позвана са имплицитним сучељем код %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D aliased to undefined symbol %qs"
 msgid "Unable to find symbol %qs"
 msgstr "%q+D удволичено са недефинисаним симболом %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 #| msgid "Entity '%s' at %C is already present in the interface"
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Ентитет ‘%s’ код %C је већ присутан у сучељу"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "Не могу да претворим %s у %s код %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "Садржана процедура ‘%s’ код %L у чистој процедури мора такође бити чиста"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "Садржана процедура ‘%s’ код %L у чистој процедури мора такође бити чиста"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "Ознака %s код %L мора бити типа %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "Аргумент димензије код %L мора целобројни"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Унутрашња функција знаковне вредности ‘%s’ код %L не може бити претпостављене дужине"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити намере-из"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "Наредба DATA код %C није дозвољена у чистој процедури"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "Процедура ‘%s’ у %s код %L није ни функција ни потпрограм"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Превише аргумената у позиву ‘%s’ код %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -86606,7 +86784,7 @@ msgstr "Претварање из %s у %s код %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -87224,7 +87402,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, fuzzy, gcc-internal-format
 #| msgid "NAMELIST object '%s' at %L cannot have ALLOCATABLE components"
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
@@ -87412,12 +87590,12 @@ msgstr "Целобројно преливање"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -87979,7 +88157,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "Крејов показивач код %C мора бити целобројни."
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -88537,103 +88715,103 @@ msgstr "Очекивано је име блока за ‘%s’ у наредб
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "Наредба ENTRY код %C не може бити унутар блока DO"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "SELECT RANK statement at %C"
 msgstr "Празна наредба IMPLICIT код %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr "Статусни израз код %C мора бити променљива"
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Синтаксна грешка у наредби SAVE код %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Неочекивана наредба CASE код %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in CASE specification at %C"
 msgstr "Синтаксна грешка у одредници CASE код %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Неочекивана наредба END код %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Синтаксна грешка у одредници CASE код %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Синтаксна грешка у одредници CASE код %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "Неочекивана наредба END код %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "Статусни израз код %C мора бити променљива"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "Синтаксна грешка у одредници CASE код %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "Наредба ELSEWHERE код %C није обухваћена блоком WHERE"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 #| msgid "Label '%s' at %C doesn't match WHERE label '%s'"
 msgid "Label %qs at %C doesn't match WHERE label %qs"
@@ -89703,7 +89881,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
@@ -89741,12 +89919,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Неочекивано смеће после наредбе ELSE код %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -90263,7 +90441,7 @@ msgstr "Неочекивано смеће после наредбе ELSE код
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "Одредба NUM_THREADS код %L захтева скаларни целобројни израз"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be of type %s"
 msgid "INTEGER expression of %s clause at %L must be positive"
@@ -90286,7 +90464,7 @@ msgstr "Крејов показивач ‘%s’ у одредби %s код %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Крејов показивани ‘%s’ у одредби %s код %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
@@ -90322,19 +90500,19 @@ msgstr "Низ претпостављене величине ‘%s’ у одр
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "Показивачки објекат ‘%s’ у одредби %s код %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Крејов показивач ‘%s’ у одредби %s код %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointee '%s' in %s clause at %L"
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Крејов показивани ‘%s’ у одредби %s код %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 #| msgid "POINTER object '%s' in %s clause at %L"
 msgid "ALLOCATABLE object %qs in %s clause at %L"
@@ -90457,8 +90635,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "Одредба IF код %L захтева скаларни логички израз"
@@ -90543,7 +90721,7 @@ msgstr ""
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "Object %qs is not a variable at %L"
@@ -90567,7 +90745,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' present on multiple clauses at %L"
 msgid "Symbol %qs present on multiple clauses at %L"
@@ -90610,7 +90788,7 @@ msgstr "Симбол ‘%s’ присутан у више одредби код
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE се појављује више од једном у одредбама података"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -90951,631 +91129,641 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 #| msgid "%s REDUCTION variable '%s' must be INTEGER at %L"
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "Променљива %s-свођења ‘%s’ мора бити целобројна код %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 #| msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "Одредба IF код %L захтева скаларни логички израз"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr ""
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "Величина одломка у одредби SCHEDULE код %L захтева скаларни целобројни израз"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s at %L"
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Несагласни рангови у %s код %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "SIZES requires constant expression at %L"
 msgstr "Лош тип у константном изразу"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Очекиван је скаларни успостављачки израз код %C"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "Наредба !$OMP ATOMIC мора поставити скаларну променљиву сопственог типа код %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "Наредба !$OMP ATOMIC мора поставити скаларну променљиву сопственог типа код %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "Наредба !$OMP ATOMIC мора поставити скаларну променљиву сопственог типа код %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "„израз“ у додели у !$OMP ATOMIC типа „пром = пром оп израз“ мора бити скаларан и не може садржати „пром“ код %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "Наредба !$OMP ATOMIC мора поставити скаларну променљиву сопственог типа код %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "Наредба !$OMP ATOMIC мора поставити скаларну променљиву сопственог типа код %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "„израз“ у додели у !$OMP ATOMIC типа „пром = пром оп израз“ мора бити скаларан и не може садржати „пром“ код %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC assignment operator must be +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "Оператор доделе у !$OMP ATOMIC мора бити једно од +, *, -, /, .AND., .OR., .EQV., .NEQV. код %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "Додела у !$OMP ATOMIC мора бити „пром = пром оп израз“, или „пром = израз оп пром“ код %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "„пром = пром оп израз“ у !$OMP ATOMIC није математички истоветан са „пром = пром оп (израз)“ код %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "„израз“ у додели у !$OMP ATOMIC типа „пром = пром оп израз“ мора бити скаларан и не може садржати „пром“ код %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC assignment intrinsic IAND, IORor IEOR must have two arguments at %L"
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "У додели у !$OMP ATOMIC сопствени IAND, IOR, IEORl морају имати два аргумента код %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "Сопствени доделе у !$OMP ATOMIC мора бити MIN, MAX, IAND, IOR или IEOR код %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, fuzzy, gcc-internal-format
 #| msgid "!$OMP ATOMIC intrinsic arguments except one must not reference '%s' at %L"
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "Аргументи сопственог уз !$OMP ATOMIC, сви осим једног, не могу садржати ‘%s’ код %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "Аргументи сопственог уз !$OMP ATOMIC морају бити скаларни код %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, fuzzy, gcc-internal-format
 #| msgid "First or last !$OMP ATOMIC intrinsic argument must be '%s' at %L"
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Први или последњи аргумент сопственог уз !$OMP ATOMIC мора бити ‘%s’ код %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "Додела у !$OMP ATOMIC мора имати оператор или сопствени на десној страни код %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected exponent in expression at %C"
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "Очекиван је изложилац у изразу код %C"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP DO не може бити DO WHILE или DO без контроле петље код %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "Променљива итерације у !$OMP DO мора бити целобројног типа код %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must not be THREADPRIVATE at %L"
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "Променљива итерације у !$OMP DO не може бити нитно-локална код %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "Променљива итерације у !$OMP DO присутна у одредби која није ни PRIVATE ни LASTPRIVATE код %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "Променљива итерације у !$OMP DO присутна у одредби која није ни PRIVATE ни LASTPRIVATE код %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "Променљива итерације у !$OMP DO мора бити целобројног типа код %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Hiteration variable %qE is unsigned"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "%Hнеозначена променљива итерације %qE"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "Стварни аргумент за ‘%s’ код %L мора бити показивач"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Numeric operands are required in expression at %L"
 msgid "property must be a logical expression at %L"
 msgstr "Неопходни су бројевни операнди у изразу код %L"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be an integer expression at %L"
 msgstr "очекиван је целобројни израз"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected an initialization expression at %C"
 msgid "property must be a constant logical expression at %L"
 msgstr "Очекиван је успостављачки израз код %C"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected exponent in expression at %C"
 msgid "property must be a constant integer expression at %L"
 msgstr "Очекиван је изложилац у изразу код %C"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP DO не може бити DO WHILE или DO без контроле петље код %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP DO iteration variable must be of type integer at %L"
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "Променљива итерације у !$OMP DO мора бити целобројног типа код %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOGICAL operands are required in expression at %L"
 msgid "TILE requires constant expression at %L"
 msgstr "Неопходни су логички операнди у изразу код %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected an initialization expression at %C"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Очекиван је успостављачки израз код %C"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -92291,68 +92479,68 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %C is already ambiguous"
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Садржана процедура ‘%s’ код %C је већ двосмислена"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Неочекивана наредба %s у одељку CONTAINS код %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s statement at %C cannot follow %s statement at %L"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "Наредба %s код %C не може пратити наредбу %s код %L"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "Наредба CONTAINS код %C је већ у садржаној програмској јединици"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Глобално име ‘%s’ код %L се већ користи као %s код %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Глобално име ‘%s’ код %L се већ користи као %s код %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Глобално име ‘%s’ код %L се већ користи као %s код %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Глобално име ‘%s’ код %L се већ користи као %s код %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "Празно BLOCK DATA код %C коси се са претходним BLOCK DATA код %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Неочекивана наредба %s у BLOCK DATA код %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Неочекивана наредба %s у модулу код %C"
@@ -92360,7 +92548,7 @@ msgstr "Неочекивана наредба %s у модулу код %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Два главна програма, код %L и %C"
@@ -92859,136 +93047,136 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr "Симбол код %L није лажна променљива"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "Ознака %s код %L мора бити типа %s"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Interface %qs at %L may not be generic"
 msgstr "Корак итератора код %L не може бити нула"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Одредничка функција ‘%s’ код %L не може бити наредбена функција"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Унутрашња процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "MODULE PROCEDURE код %C мора бити у генеричком сучељу модула"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in elemental subroutine '%s' at %L is not allowed"
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Наводилац алтернативног повратка није дозвољен у елементалном потпрограму ‘%s’ код %L"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in function '%s' at %L is not allowed"
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Наводилац алтернативног повратка није дозвољен у функцији ‘%s’ код %L"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L is not allowed in this context"
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Аргумент-по-вредности код %L није дозвољен у овом контексту"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Лажна процедура ‘%s’ чисте процедуре код %L мора такође бити чиста"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Аргумент ‘%s’ чисте функције ‘%s’ код %L мора бити намере-у"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "Аргумент ‘%s’ чисте функције ‘%s’ код %L мора бити намере-у"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified"
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Аргумент ‘%s’ чистог потпрограма ‘%s’ код %L мора имати наведену намеру"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified"
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Аргумент ‘%s’ чистог потпрограма ‘%s’ код %L мора имати наведену намеру"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L мора бити скалар"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Кључна реч ‘%s’ код %L није у процедури"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L мора бити скалар"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L не може имати атрибут показивача"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L не може имати атрибут показивача"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "Лажна процедура код %L није дозвољена у елементалној процедури"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
@@ -92996,1085 +93184,1085 @@ msgstr "Аргумент ‘%s’ елементалне процедуре ко
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Аргумент ‘%s’ наредбене функције код %L мора бити скалар"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued argument '%s' of statement function at %L must have constant length"
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Аргумент знаковне вредности ‘%s’ наредбене функције код %L мора имати константну дужину"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Процедура сучеља ‘%s’ код %L има исто име као и обухватајућа процедура"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 #| msgid "Contained function '%s' at %L has no IMPLICIT type"
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Садржана функција ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 #| msgid "Contained function '%s' at %L has no IMPLICIT type"
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Садржана функција ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Унутрашња функција знаковне вредности ‘%s’ код %L не може бити претпостављене дужине"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Унутрашња функција знаковне вредности ‘%s’ код %L не може бити претпостављене дужине"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure %s at %L has entries with mismatched array specifications"
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Процедура %s код %L има уносе са неусаглашеним одредницама низа"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure %s at %L has entries with mismatched array specifications"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "Процедура %s код %L има уносе са неусаглашеним одредницама низа"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Резултат функције %s не може бити низ у функцији %s код %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Улазни резултат %s не може бити низ у функцији %s код %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Резултат функције %s не може бити показивач у функцији %s код %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Улазни резултат %s не може бити показивач у функцији %s код %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Резултат функције %s не може бити показивач у функцији %s код %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Улазни резултат %s не може бити показивач у функцији %s код %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Резултат функције %s не може бити типа %s у функцији %s код %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Улазни резултат %s не може бити типа %s у функцији %s код %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a DO block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Наредба ENTRY код %C не може бити унутар блока DO"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a DO block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Наредба ENTRY код %C не може бити унутар блока DO"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COMMON block /%s/ not found at %C"
 msgid "COMMON block at %L"
 msgstr "Заједнички блок /%s/ није нађен код %C"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Аутоматски низ ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "Променљива изведеног типа у заједничком код %C нема атрибут SEQUENCE"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "Променљива изведеног типа у заједничком код %C нема атрибут SEQUENCE"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "Променљива изведеног типа у заједничком код %C нема атрибут SEQUENCE"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block /%s/ not found at %C"
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "Заједнички блок /%s/ није нађен код %C"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "Објекат ‘%s’ код %L мора имати атрибут %s за SAVE"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The rank of the element in the derived type constructor at %L does not match that of the component (%d/%d)"
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Ранг елемента у конструктору изведеног типа код %L не одговара оном компоненте (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Елемент у конструктору изведеног типа код %L, за показивачку компоненте ‘%s’, јесте %s а треба да буде %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s' should be a POINTER or a TARGET"
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "Елемент у конструктору изведеног типа код %L, за показивачку компоненту ‘%s’, треба да је показивач или циљ"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %C"
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Превише компонената у конструктору структуре код %C"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %C"
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Превише компонената у конструктору структуре код %C"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 #| msgid "The rank of the element in the derived type constructor at %L does not match that of the component (%d/%d)"
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Ранг елемента у конструктору изведеног типа код %L не одговара оном компоненте (%d/%d)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s' should be a POINTER or a TARGET"
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Елемент у конструктору изведеног типа код %L, за показивачку компоненту ‘%s’, треба да је показивач или циљ"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Додела показивача са векторским индексом на десној страни код %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Елемент у конструктору изведеног типа код %L, за показивачку компоненте ‘%s’, јесте %s а треба да буде %s"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, fuzzy, gcc-internal-format
 #| msgid "The upper bound in the last dimension must appear in the reference to the assumed size array '%s' at %L."
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Горња граница у последњој димензији мора се појавити у упућивачу на низ претпостављене величине ‘%s’ код %L."
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "%qs at %L is ambiguous"
 msgstr "Двосмислен симбол ‘%s’ код %L"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 #| msgid "GENERIC non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Генеричка несопствена процедура ‘%s’ није дозвољена као стварни аргумент код %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in function '%s' at %L is not allowed"
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Наводилац алтернативног повратка није дозвољен у функцији ‘%s’ код %L"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Сопствено ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic at %L does not exist"
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "Сопствено код %L не постоји"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Етикета %d поменута код %L није дефинисана"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Унутрашња процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Наредбена функција ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not allowed as an actual argument"
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Сопствено ‘%s’ код %L није дозвољено као стварни аргумент"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Унутрашња процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Елементална несопствена процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to find a specific INTRINSIC procedure for the reference '%s' at %L"
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Не могу да нађем одређену сопствену процедуру за упућивач ‘%s’ код %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Двосмислен симбол ‘%s’ код %L"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Аргумент-по-вредности код %L није бројевног типа"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "Аргумент-по-вредности код %L не може бити низ или одељак низа"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Аргумент-по-вредности код %L није дозвољен у овом контексту"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Није дозвољено прослеђивање унутрашње процедуре по локацији код %L"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "Елементална несопствена процедура ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optionalargument with the same rank (12.4.1.5)"
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "‘%s’ код %L је низ и опцион; ако недостаје, не може бити стварни аргумент елементалне процедуре, осим ако постоји не-опциони аргумент истог ранга (12.4.1.5)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 #| msgid "coverage mismatch for function %qs while reading counter %qs"
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "неслагање покривача за функцију %qs у току читања бројача %qs"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 #| msgid "Type/rank mismatch in argument '%s' at %L"
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Неслагање типа/ранга у аргументу ‘%s’ код %L"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific function for the generic '%s' at %L"
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "Нема одређене функције за генеричко ‘%s’ код %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 #| msgid "Generic function '%s' at %L is not consistent with a specific intrinsic interface"
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Генеричка функција ‘%s’ код %L није у складу са одређеним сопственим сучељем"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Функција ‘%s’ код %L је сопствена али није сагласна са сопственом"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Не могу да разрешим одређену функцију ‘%s’ код %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Функција ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Функција ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "упућивач на не-чисту функцију ‘%s’ код %L унутар FORALL %s"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 #| msgid "reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "упућивач на не-чисту функцију ‘%s’ код %L унутар FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, fuzzy, gcc-internal-format
 #| msgid "reference to non-PURE function '%s' at %L inside a FORALL %s"
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "упућивач на не-чисту функцију ‘%s’ код %L унутар FORALL %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot write to internal file unit '%s' at %C inside a PURE procedure"
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Не могу да пишем у унутрашњу датотеку ‘%s’ код %C унутар чисте процедуре"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Unexpected junk after %qs at %L"
 msgstr "Неочекивано смеће после наредбе ELSE код %C"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "%qs at %L is not a function"
 msgstr "‘%s’ код %L није функција"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "Функција ‘%s’ декларисана је као CHARACTER(*) и не може бити употребљена код %L пошто није лажни аргумент"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Недостаје листа аргумената у функцији ‘%s’ код %C"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, fuzzy, gcc-internal-format
 #| msgid "User defined non-ELEMENTAL function '%s' at %L not allowed in WORKSHARE construct"
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "Кориснички дефинисана неелементална функција ‘%s’ код %L није дозвољена у конструкцији WORKSHARE"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 #| msgid "SUBROUTINE '%s' at %L cannot call itself, as it is not RECURSIVE"
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "Потпрограм ‘%s’ код %L не може позивати самог себе, пошто није рекурзиван"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L cannot call itself, as it is not RECURSIVE"
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Функција ‘%s’ код %L не може позивати саму себе, пошто није рекурзивна"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function at %L is recursive"
 msgid "Using function %qs at %L is deprecated"
 msgstr "Наредбена функција код %L је рекурзивна"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "Лажна процедура код %L није дозвољена у елементалној процедури"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Позив потпрограма за ‘%s’ у блоку FORALL код %L није чист"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Позив потпрограма за ‘%s’ у блоку FORALL код %L није чист"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Позив потпрограма за ‘%s’ у блоку FORALL код %L није чист"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' at %L is not PURE"
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Позив потпрограма за ‘%s’ код %L није чист"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 #| msgid "There is no specific subroutine for the generic '%s' at %L"
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Нема одређеног потпрограма за генеричко ‘%s’ код %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "Generic subroutine '%s' at %L is not consistent with an intrinsic subroutine interface"
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Генерички потпрограм ‘%s’ код %L није у складу са сучељем сопственог потпрограма"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Потпрограм ‘%s’ код %L је сопствени али није сагласан са сопственим"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific subroutine '%s' at %L"
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Не могу да разрешим одређени потпрограм ‘%s’ код %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "„%s“ код %L има тип који није у складу са позивом код %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 #| msgid "Call to ENTRY '%s' at %L is recursive, but subroutine '%s' is not declared as RECURSIVE"
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "Позив за унос ‘%s’ код %L јесте рекурзиван, али потпрограм ‘%s’ није декларисан као такав"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 #| msgid "SUBROUTINE '%s' at %L cannot call itself, as it is not RECURSIVE"
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Потпрограм ‘%s’ код %L не може позивати самог себе, пошто није рекурзиван"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr ""
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Облици операнада код %L и %L нису усагласиви"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може имати показивачку вредност"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Shape specification at %L cannot be negative"
 msgid "Impure function at %L might not be evaluated"
 msgstr "Одредница облика код %L не може бити негативна"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "Аргумент-по-вредности код %L не може бити низ или одељак низа"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "поређење неозначеног израза >= 0 је увек тачно"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Неисправна врста за %s код %L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator '%s' at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Операнд унарног бројевног оператора ‘%s’ код %%L је %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Операнди бинарног бројевног оператора ‘%s’ код %%L су %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Неусаглашени рангови за оператор код %L и %L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Операнди оператора надовезивања ниски код %%L су %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator '%s' at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Операнди логичког оператора ‘%s’ код %%L су %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .NOT. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Операнд оператора .NOT. код %%L је %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "Комплексне величине се не могу поредити код %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Неусаглашени рангови за оператор код %L и %L"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "Неисправна врста за %s код %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "Неисправна врста за %s код %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Логичке код %%L морају бити поређене са %s уместо %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Операнди оператора поређења ‘%s’ код %%L су %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr ""
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "unknown operator '%s' in %%:version-compare"
 msgid "Unknown operator %qs at %L"
 msgstr "непознате оператор ‘%s’ у %%:version-compare"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator '%s' at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Операнд корисничког оператора ‘%s’ код %%L је %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator '%s' at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Операнди корисничког оператора ‘%s’ код %%L су %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Недозвољен нулти корак код %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Упућивач низа код %L је изван граница"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "недостаје индекс у упућивачу низа"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Није наведена десна горња граница низа претпостављене величине код %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Неслагање рангова у упућивачу низа код %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Неслагање рангова у упућивачу низа код %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "index in dimension %d is out of bounds at %L"
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Индекс у димензији %d је ван граница код %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Индекс низа код %L мора бити скалар"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be of INTEGER type"
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Индекс низа код %L мора бити целобројни"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: REAL array index at %L"
 msgid "REAL array index at %L"
 msgstr "Проширење: реални индекс низа код %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Аргумент димензије код %L мора целобројни"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid array initializer for non-array type %qs"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Неисправан успостављач низа за ненизовни тип %qs"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Индекс низа код %L је низ ранга %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Аргумент димензије код %L мора целобројни"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Аргумент димензије код %L мора целобројни"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "STAT's expression at %L must be a variable"
 msgstr "Статусни израз код %C мора бити променљива"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Индекс почетка подниске код %L мора бити целобројни"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Индекс почетка подниске код %L мора бити скалар"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "Индекс краја подниске код %L мора бити целобројни"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "Индекс краја подниске код %L мора бити скалар"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L must be scalar"
 msgid "Substring end index at %L is too large"
 msgstr "Индекс краја подниске код %L мора бити скалар"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "resolve_ref(): Bad array reference"
 msgstr "Лош упућивач низа код %L"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Компонента десно од делимичног упућивача са ненултим рангом не сме имати атрибут показивача код %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Компонента десно од делимичног упућивача са ненултим рангом не сме имати атрибут резервљивости код %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Два или више делимична упућивача са ненултим рангом не смеју бити наведени код %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr ""
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
@@ -94084,12 +94272,12 @@ msgstr "Низ претпостављеног облика код %L мора б
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
@@ -94099,440 +94287,440 @@ msgstr "Низ претпостављеног облика код %L мора б
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "Лош упућивач низа код %L"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s',used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "Променљива ‘%s’, употребљена у одредничком изразу, користи се код %L пре наредбе ENTRY у којој је параметар"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' is used at %L before the ENTRY statement in which it is a parameter"
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "Променљива ‘%s’ употребљена је код %L пре наредбе ENTRY у којој је параметар"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared %s"
 msgid "Using variable %qs at %L is deprecated"
 msgstr "променљива примерка %qs декларисана је %s"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "Лош упућивач низа код %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, fuzzy, gcc-internal-format
 #| msgid "The type %s cannot be host associated at %L because it is blocked by an incompatible object of the same name at %L"
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr "Тип %s не може бити придружен домаћину код %L зато што га блокира несагласан објекат истог имена код %L"
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be scalar"
 msgid "Passed-object at %L must be scalar"
 msgstr "Ознака %s код %L мора бити скалар"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L мора бити скалар"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be INTEGER"
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%s код %L мора бити целобројно"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "Очекиван је тип израза"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s код %L мора бити скалар"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "%s at %L must be integer"
 msgstr "%s код %L мора бити скалар"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s код %L мора бити целобројно"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "Израз за корак у петљи DO код %L не може бити нула"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Очекивано је име променљиве код %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Променљивој ‘%s’ код %L није додељена етикета формата"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "Атрибут SAVE код %L не може бити наведен у чистој процедури"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in %s clause at %L"
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Низ претпостављене величине ‘%s’ у одредби ‘%s’ код %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer '%s' in %s clause at %L"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Крејов показивач ‘%s’ у одредби %s код %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr ""
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "Индекс-име у FORALL код %L мора бити скларни целобројан"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "Израз за почетак у FORALL код %L мора бити скаларни целобројан"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "Израз за крај у FORALL код %L мора бити скаларни целобројан"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "Израз за корак у FORALL код %L мора бити скаларни %s"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "Израз за корак у FORALL код %L не може бити нула"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "Променљива ‘%s’ се не може јавити у изразу код %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in ALLOCATE statement at %L must be ALLOCATABLE or a POINTER"
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Израз у наредби ALLOCATE код %L мора бити резервљив или показивач"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Могу се користити само сопствени оператори у изразу код %L"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Потребна је одредница низа у наредби ALLOCATE код %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Потребна је одредница низа у наредби ALLOCATE код %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Потребна је одредница низа у наредби ALLOCATE код %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array specification in ALLOCATE statement at %L"
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Лоша одредница низа у наредби ALLOCATE код %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Лоша одредница низа у наредби ALLOCATE код %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' must not appear an the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "‘%s’ не може да се јави у одредници низа код %L у истој наредби резервисања где се и само резервише"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array specification in ALLOCATE statement at %L"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "Лоша одредница низа у наредби ALLOCATE код %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "ASSIGN код %L захтева скаларну подразумевану целобројну променљиву"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Етикета код %L није у истом блоку као наредба GOTO код %L"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "ASSIGN код %L захтева скаларну подразумевану целобројну променљиву"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -94541,326 +94729,326 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "Етикета CASE код %L преклапа етикету CASE код %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "Израз у наредби CASE код %L мора бити типа %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be kind %d"
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Израз у наредби CASE код %L мора бити врста %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Израз у наредби CASE код %L мора бити скалар"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Изборни израз у рачунском GOTO код %L мора бити скаларни целобројан израз"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Аргумент наредбе SELECT код %L не може бити %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Аргумент наредбе SELECT код %L мора бити скаларни израз"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be of type %s"
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Израз у наредби CASE код %L мора бити типа %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "DEFAULT CASE код %L не може бити праћен другим DEFAULT CASE код %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Логички опсег у наредби CASE код %L није дозвољен"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "constant logical value in CASE statement is repeated at %L"
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "константна логичка вредност у наредби CASE поновљена је код %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Одредница опсега код %L не може никако бити поклопљена"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Блок логичког SELECT CASE код %L има више од два случаја"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "Не могу да разрешим одређену функцију ‘%s’ код %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Име ‘%s’ се не може употребити као дефинисани оператор код %C"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Selector at %L cannot be NULL()"
 msgstr "Корак итератора код %L не може бити нула"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Selector at %L has no type"
 msgstr "Функција ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Синтаксна грешка у наредби EQUIVALENCE код %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CASE label at %L overlaps with CASE label at %L"
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "Етикета CASE код %L преклапа етикету CASE код %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %C is being used before it is defined"
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Изведени тип ‘%s’ код %C користи се пре него што је дефинисан"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Име изведеног типа ‘%s’ код %C већ има основни тип %s"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected %s statement at %C"
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Неочекивана наредба %s код %C"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Неисправна врста за %s код %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L мора бити скалар"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "Елемент преноса података код %L не може имати показивачке компоненте"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "Елемент преноса података код %L не може имати показивачке компоненте"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have ALLOCATABLE components"
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "Елемент преноса података код %L не може имати резервљиве компоненте"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "Елемент преноса података код %L не може имати приватне компоненте"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have PRIVATE components"
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "Елемент преноса података код %L не може имати приватне компоненте"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Елемент преноса података код %L не може бити пун упућивач на низ претпостављене величине"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "Индекс-име у FORALL код %L мора бити скларни целобројан"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "Аргумент-по-вредности код %L не може бити низ или одељак низа"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "Аргумент-по-вредности код %L не може бити низ или одељак низа"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "ASSIGN код %L захтева скаларну подразумевану целобројну променљиву"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "ASSIGN код %L захтева скаларну подразумевану целобројну променљиву"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "Одредба NUM_THREADS код %L захтева скаларни целобројни израз"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "Наредба !$OMP ATOMIC мора поставити скаларну променљиву сопственог типа код %L"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити врсте %d"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Аргумент наредбе SELECT код %L мора бити скаларни израз"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ACOS at %L must be between -1 and 1"
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Аргумент у ACOS код %L мора бити између -1 и 1"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Наредба код %L није исправна наредба циља гранања за наредбу гранања код %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Branch at %L causes an infinite loop"
 msgid "Branch at %L may result in an infinite loop"
@@ -94868,17 +95056,17 @@ msgstr "Гранање код %L води у бесконачну петљу"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -94886,229 +95074,229 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Етикета код %L није у истом блоку као наредба GOTO код %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "Маска у WHERE код %L има неусаглашен облик"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "Циљ доделе у WHERE код %L има неусаглашен облик"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Неподржана наредба унутар WHERE код %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Додела у индексну променљиву за FORALL код %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, fuzzy, gcc-internal-format
 #| msgid "The FORALL with index '%s' cause more than one assignment to this object at %L"
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "FORALL са индексом ‘%s’ изазива више од једне доделе овом објекту код %L"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "Индекс-име у FORALL код %L мора бити скларни целобројан"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Спољашња конструкција FORALL већ има индекс са овим именом %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Очекивано је име променљиве код %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "Одредба WHERE/ELSEWHERE код %L захтева логички низ"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "Не могу да претворим %s у %s код %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER expression at %L is being truncated (%d/%d)"
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "Знаковни израз код %L бива подсечен (%d/%d)"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Right side of assignment at %L is a derived type containing a POINTER in a PURE procedure"
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Десна страна доделе код %L је изведени тип који садржи показивач у чистој процедури"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Додела у индексну променљиву за FORALL код %L"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Додела у индексну променљиву за FORALL код %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Pointer procedure assignment at %L"
 msgstr "Различити типови у додели показивача код %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "Наредба ASSIGNED GOTO код %L захтева целобројну променљиву"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' has not been assigned a target label at %L"
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Променљивој ‘%s’ није додељена циљна етикета код %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Алтернативна наредба повратка код %L захтева скаларни целобројни наводилац повратка"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Очекиван је успостављачки израз у CASE код %C"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "ASSIGN код %L захтева скаларну подразумевану целобројну променљиву"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "Неисправна врста за %s код %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Arithmetic IF statement at %L requires a numeric expression"
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Аритметичко IF код %L захтева бројевни израз"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Излазни услов из петље DO WHILE код %L мора бити скаларни логички израз"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL mask clause at %L requires a LOGICAL expression"
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "Одредба маске у FORALL код %L захтева логички израз"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_trans_code(): лош кôд наредбе"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter %s declared at %L"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Неупотребљен параметар %s декларисан код %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -95116,68 +95304,68 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array %qs is too large"
 msgid "String length at %L is too large"
 msgstr "величина низа %qs је превелика"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Резервљиви низ ‘%s’ код %L мора имати одложени облик"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 #| msgid "Scalar object '%s' at %L may not be ALLOCATABLE"
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Скаларни објекат ‘%s’ код %L не може бити резервљив"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Низовни показивач ‘%s’ код %L мора имати одложен облик"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L cannot have a deferred shape"
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Низ ‘%s’ код %L не може имати одложен облик"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, fuzzy, gcc-internal-format
 #| msgid "The type %s cannot be host associated at %L because it is blocked by an incompatible object of the same name at %L"
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Тип %s не може бити придружен домаћину код %L зато што га блокира несагласан објекат истог имена код %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -95185,1003 +95373,1003 @@ msgstr "Објекат ‘%s’ код %L мора имати атрибут %s
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "The module or main program array '%s' at %L must have constant shape"
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Низ модула или главног програма ‘%s’ код %L мора имати константан облик"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "Ентитет са претпостављеном знаковном дужином код %L мора бити лажни аргумент или параметар"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "%qs at %L must have constant character length in this context"
 msgstr "‘%s’ код %L мора имати константну знаковну дужину у овом контексту"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "‘%s’ код %L мора имати константну знаковну дужину у овом контексту"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Резервљиво ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Спољашње ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Лажно ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Сопствено ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Резултат функцији ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Аутоматски низ ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "in %s, at %s:%d"
 msgid "%s at %L"
 msgstr "у %s, код %s:%d"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued statement function '%s' at %L must have constant length"
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Наредбена функција знаковне вредности ‘%s’ код %L мора имати константну дужину"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is of a PRIVATE type and cannot be a dummy argument of '%s', which is PUBLIC at %L"
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "‘%s’ је приватног типа и не може бити лажни аргумент у ‘%s’, који је јаван код %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Резултат функцији ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Спољашњи објекат ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL function '%s' at %L must have a scalar result"
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "Елементална функција ‘%s’ код %L мора имати скаларни резултат"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "Наредбена функција ‘%s’ код %L није дозвољена као стварни аргумент"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може имати низовну вредност"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може имати показивачку вредност"
 
 # no-c-format
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може бити чиста"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be recursive"
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може бити рекурзивна"
 
 # no-c-format
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "Функција типа CHARACTER(*) ‘%s’ код %L не може бити чиста"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' at %C cannot have a generic interface"
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Лажна процедура ‘%s’ код %C не може имати генеричко сучеље"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "Атрибут процедуре коси се са атрибутом листе имена у ‘%s’ код %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "Атрибут процедуре коси се са атрибутом листе имена у ‘%s’ код %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "Атрибут процедуре коси се са атрибутом листе имена у ‘%s’ код %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute in '%s' at %L"
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "Атрибут %s коси се са атрибутом %s у ‘%s’ код %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Аргумент за %s код %L мора бити дужине један"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора имати бар један аргумент"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Аргумент у ICHAR код %L мора бити дужине један"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити показивач"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити резервљив"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must not be OPTIONAL"
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L не сме бити опциони"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "Први аргумент сучеља оператора код %L мора бити намере-у"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора имати бар један аргумент"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "Процедура сучеља ‘%s’ код %L има исто име као и обухватајућа процедура"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Корак итератора код %L не може бити нула"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "Процедура ‘%s’ позвана са имплицитним сучељем код %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора имати бар један аргумент"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити неизведени тип"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити неизведени тип"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити скалар"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити резервљив"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити показивач"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Процедура сучеља ‘%s’ код %L има исто име као и обухватајућа процедура"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Процедура сучеља ‘%s’ код %L има исто име као и обухватајућа процедура"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Низовни показивач ‘%s’ код %L мора имати одложен облик"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Аргумент у ICHAR код %L мора бити дужине један"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора имати бар један аргумент"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити неизведени тип"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Аргумент димензије код %L мора бити скалар"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L не може имати атрибут показивача"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити резервљив"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 #| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Процедура сучеља ‘%s’ код %L има исто име као и обухватајућа процедура"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, fuzzy, gcc-internal-format
 #| msgid "Character length of component '%s' needs to be a constant specification expression at %L."
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Знаковна дужина компоненте ‘%s’ мора бити константан одреднички израз код %L."
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Израз код %L мора бити целобројног типа"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 #| msgid "The component '%s' is a PRIVATE type and cannot be a component of '%s', which is PUBLIC at %L"
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Компонента ‘%s’ је приватни тип и не може бити компонента у ‘%s’, која је јавна код %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Компонента %s типа SEQUENCE декларисаног код %L нема атрибут SEQUENCE"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared"
 msgid "Derived type %qs at %L has not been declared"
 msgstr "%qD није декларисано"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s'at %C is not allowed."
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Низ претпостављене величине ‘%s’ у листи имена ‘%s’ код %C није дозвољен."
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 #| msgid "PRIVATE symbol '%s' cannot be member of PUBLIC namelist at %L"
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "Приватни симбол ‘%s’ не може бити члан јавне листе имена код %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 #| msgid "PRIVATE symbol '%s' cannot be member of PUBLIC namelist at %L"
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "Приватни симбол ‘%s’ не може бити члан јавне листе имена код %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "Атрибут процедуре коси се са атрибутом листе имена у ‘%s’ код %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter array '%s' at %L cannot be automatic or assumed shape"
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Параметарски низ ‘%s’ код %L не може бити аутоматског или претпостављеног облика"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, fuzzy, gcc-internal-format
 #| msgid "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type"
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Имплицитно типски параметар ‘%s’ код %L не одговара каснијем имплицитном типу"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Несагласан изведени тип у параметру код %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "Објекат ‘%s’ код %L мора имати атрибут %s за SAVE"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Expecting constant expression near %L"
 msgstr "Лош тип у константном изразу"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "Атрибут процедуре коси се са атрибутом листе имена у ‘%s’ код %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "Атрибут процедуре коси се са атрибутом листе имена у ‘%s’ код %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad specification for assumed size array at %C"
 msgid "Bad specification for assumed size array at %L"
 msgstr "Лоша одредница за низ претпостављене величине код %C"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Низ претпостављене величине код %L мора бити лажни аргумент"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Низ претпостављеног облика код %L мора бити лажни аргумент"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Низ претпостављеног облика код %L мора бити лажни аргумент"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Симбол код %L није лажна променљива"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued statement function '%s' at %L must have constant length"
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Наредбена функција знаковне вредности ‘%s’ код %L мора имати константну дужину"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, fuzzy, gcc-internal-format
 #| msgid "The derived type '%s' at %L is of type '%s', which has not been defined."
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Изведени тип ‘%s’ код %L је типа ‘%s’, који није дефинисан."
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "Променљива изведеног типа у заједничком код %C нема атрибут SEQUENCE"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "Аргумент за %s код %L мора бити дужине један"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 #| msgid "PUBLIC function '%s' at %L cannot be of PRIVATE type '%s'"
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "Јавна функција ‘%s’ код %L не може бити приватног типа ‘%s’"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, fuzzy, gcc-internal-format
 #| msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "Лажни аргумент намере-из ‘%s’ код %L је претпостављене величине и зато не може имати подразумевани успостављач"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити намере-из"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити намере-из"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Аргумент-по-вредности код %L не може бити низ или одељак низа"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Резервљиви низ ‘%s’ код %L мора имати одложени облик"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Лажна процедура код %L није дозвољена у елементалној процедури"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist %s cannot be renamed by USE association to %s."
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Листа имена %s не може се преименовати у %s придружењем USE."
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Нитно-приватно код %L не снима се"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "Објекат ‘%s’ код %L мора имати атрибут %s за SAVE"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Резервљиво ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting definable entity near %L"
 msgstr "Очекивана је наредба %s код %C"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 #| msgid "BLOCK DATA element '%s' at %L must be in COMMON"
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "BLOCK DATA елемент ‘%s’ код %L мора бити у заједничком"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "Лажно ‘%s’ код %L не може имати успостављач"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L не може имати атрибут показивача"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Неконстантан одељак низа код %L у наредби DATA"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "Наредба DATA код %L има више променљивих него вредности"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Неконстантан одељак низа код %L у наредби DATA"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "Израз за корак у петљи DO код %L не може бити нула"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "Наредба DATA код %L има више вредности него променљивих"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Ознака %d код %L дефинисана али неупотребљена"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Ознака %d код %L дефинисана али не може бити употребљена"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Променљива изведеног типа ‘%s’ код %L мора имати атрибут SEQUENCE да би била објекат еквиваленције"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Променљива изведеног типа ‘%s’ код %L не може имати резервљиве компоненте како би била објекат еквиваленције"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with default initializer cannot be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Променљива изведеног типа ‘%s’ код %L са подразумеваним успостављачем не може бити објекат еквиваленције"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Променљива изведеног типа ‘%s’ код %L са показивачким компонентама не може бити објекат еквиваленције"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Синтаксна грешка у наредби EQUIVALENCE код %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 #| msgid "Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure procedure '%s'"
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "Члан заједничког блока ‘%s’ код %L не може бити објекат еквиваленције у чистој процедури ‘%s’"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, fuzzy, gcc-internal-format
 #| msgid "Named constant '%s' at %L cannot be an EQUIVALENCE object"
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
@@ -96189,96 +96377,96 @@ msgstr "Именована константа ‘%s’ код %L не може 
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Синтаксна грешка у наредби EQUIVALENCE код %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Низ ‘%s’ код %L са неконстантним границама не може бити објекат еквиваленције"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, fuzzy, gcc-internal-format
 #| msgid "Structure component '%s' at %L cannot be an EQUIVALENCE object"
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Компонената структуре ‘%s’ код %L не може бити објекат еквиваленције"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Подниска код %L има нулту дужину"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Различите знаковне дужине у додели показивача код %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 #| msgid "PUBLIC function '%s' at %L cannot be of PRIVATE type '%s'"
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "Јавна функција ‘%s’ код %L не може бити приватног типа ‘%s’"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L has no IMPLICIT type"
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "Унос ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора бити функција"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L cannot be assumed character length"
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Процедура корисничког оператора ‘%s’ код %L не може бити претпостављене знаковне дужине"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Процедура корисничког оператора ‘%s’ код %L мора имати бар један аргумент"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Први аргумент сучеља оператора код %L не може бити опциони"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Други аргумент сучеља оператора код %L не може бити опциони"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Сучеље оператора код %L мора имати, највише, два аргумента"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
@@ -96302,108 +96490,108 @@ msgstr "игноришем непостојећи директоријум „%s
 msgid "%qs is not a directory"
 msgstr "%qD није тип"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Line truncated at %C"
 msgid "Line truncated at %L"
 msgstr "Линија одсечена код %C"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Премашено ограничење од %d настављања у наредби код %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 #| msgid "Missing '&' in continued character constant at %C"
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Недостаје ‘&’ у настављеној знаковној константи код %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Табулатор противан стандарду код %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid KIND parameter of %s at %L"
 msgid "Invalid character 0x%s at %C"
 msgstr "Неисправан параметар врсте за %s код %L"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, fuzzy, gcc-internal-format
 #| msgid "'&' not allowed by itself in line %d"
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "‘&’ не може бити само у линији %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconforming tab character in column 1 of line %d"
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Табулатор противан стандарду у колони 1 линије %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: file %s left but not entered"
 msgid "file %qs left but not entered"
 msgstr "%s:%d: датотека %s је напуштена, али у њу није уђено"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Illegal preprocessor directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s:%d: Недозвољена предобрађивачка директива"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, fuzzy, gcc-internal-format
 #| msgid "File '%s' is being included recursively"
 msgid "File %qs is being included recursively"
 msgstr "Датотека ‘%s’ се укључује рекурзивно"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file '%s'"
 msgid "Cannot open file %qs"
 msgstr "Не могу да отворим датотеку ‘%s’"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open included file %qs"
 msgstr "Не могу да отворим укључену датотеку ‘%s’"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "Не могу да отворим укључену датотеку ‘%s’"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "Included file %qs is not a regular file"
@@ -96582,231 +96770,231 @@ msgstr "Ако је први аргумент у ATAN2 код %L нула, др
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Аргумент у IACHAR код %L мора бити дужине један"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Аргумент функције IACHAR код %L ван опсега [0,127]"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "Збир другог и трећег аргумента у IBITS премашује битску величину код %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Аргумент у ICHAR код %L мора бити дужине један"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of IBCLR exceeds bit size at %L"
 msgid "Second argument of %s is negative at %L"
 msgstr "Други аргумент у IBCLR премашује битску величину код %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFT exceeds bit size at %L"
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "Магнитуда другог аргумента у ISHFT премашује битску величину код %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %L"
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "Магнитуда другог аргумента у ISHFTC премашује BIT_SIZE првог аргумента код %L"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "Аргумент димензије код %L је ван граница"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "Аргумент у LOG код %L не може бити мањи или једнак нули"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "Комплексни аргумент у LOG код %L не може бити нула"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "Аргумент у LOG10 код %L не може бити мањи или једнак нули"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "Други аргумент у NEAREST код %L не може бити нула"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_trans_code(): лош кôд наредбе"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L shall not be zero"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Други аргумент у NEAREST код %L не може бити нула"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Result of %s is NaN at %L"
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Резултат %s јесте NaN код %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument NCOPIES of REPEAT intrinsic is negative"
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "Аргумент NCOPIES уз сопствено REPEAT негативан је"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument NCOPIES of REPEAT intrinsic is negative"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "Аргумент NCOPIES уз сопствено REPEAT негативан је"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer too large at %C"
 msgid "Reshaped array too large at %C"
 msgstr "Цео број превелик код %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Резултат SCALE прелива своју врсту код %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "Аргумент ‘%s’ за сопствено ‘%s’ код %L мора бити ранга %d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Лош тип у константном изразу"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Аргумент у SQRT код %L има негативну вредност"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid second argument of IBSET at %L"
 msgid "invalid argument of SQRT at %L"
 msgstr "Неисправан други аргумент у IBSET код %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -97178,80 +97366,80 @@ msgstr "Очекивано је завршно име код %C"
 msgid "Labeled DO statement at %L"
 msgstr "Неочекивана наредба END код %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'"
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Име ‘%s’ код %C је двосмислен упућивач на ‘%s’ из модула ‘%s’"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from current program unit"
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Име ‘%s’ код %C је двосмислен упућивач на ‘%s’ из текуће програмске јединице"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Симбол ‘%s’ код %C је већ придружен домаћину"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Променљива изведеног типа ‘%s’ код %L мора имати атрибут SEQUENCE да би била објекат еквиваленције"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition at %C has no components"
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Дефиниција изведеног типа код %C нема компонената"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Променљива изведеног типа ‘%s’ код %L мора имати атрибут SEQUENCE да би била објекат еквиваленције"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -97284,29 +97472,35 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "array initialized from non-constant array expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "низ успостављен не-константним низовним изразом"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "лош тип израза током хода (%d)"
@@ -97420,127 +97614,127 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr "Очекиван је успостављачки израз код %C"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY '%s' at %L has no IMPLICIT type"
 msgid "%s at %L has no default type"
 msgstr "Унос ‘%s’ код %L нема имплицитан тип"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "сопствена променљива која није процедура"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return value of function %qs at %L not set"
 msgstr "Враћај вредности функција у регистрима ФПУа"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Deferred type parameter not yet supported"
 msgstr "Различите врсте типова параметара у додели показивача код %L"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, fuzzy, gcc-internal-format
 #| msgid "backend decl for module variable %s already exists"
 msgid "backend decl for module variable %qs already exists"
 msgstr "декларација зачеља за модулску променљиву %s већ постоји"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable %s declared at %L"
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Неупотребљена променљива %s декларисана код %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Лажни аргумент ‘%s’ код %L не може бити намере-из"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 #| msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "Лажни аргумент намере-из ‘%s’ код %L је претпостављене величине и зато не може имати подразумевани успостављач"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "Unused dummy argument %qs at %L"
 msgstr "Превише аргумената за %s код %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable %s declared at %L"
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Неупотребљена променљива %s декларисана код %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 #| msgid "Unused variable %s declared at %L"
 msgid "Unused variable %qs declared at %L"
 msgstr "Неупотребљена променљива %s декларисана код %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter %s declared at %L"
 msgid "Unused parameter %qs declared at %L"
 msgstr "Неупотребљен параметар %s декларисан код %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter %s declared at %L"
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Неупотребљен параметар %s декларисан код %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Враћај вредности функција у регистрима ФПУа"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "DW_LOC_OP %s not implemented"
 msgid "Unsigned not yet implemented"
 msgstr "DW_LOC_OP %s није имплементирано"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -97571,12 +97765,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "Непознат сопствени оператор"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Непозната функције листе аргумената код %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -97594,12 +97788,12 @@ msgstr "Сопствена функција %s(%d) није препозната
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "Аргумент ‘dim’ за сопствено ‘%s’ код %L није исправан димензиони индекс"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "iteration variable %qs should not be reduction"
 msgid "The event variable at %L shall not be coindexed"
@@ -97627,197 +97821,197 @@ msgstr "-fprefetch-loop-arrays није подржано за овај циљ"
 msgid "implicit mapping of assumed size array %qD"
 msgstr "Лоша одредница за низ претпостављене величине код %C"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "optional class parameter"
 msgstr "неисправан параметар %qs"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "Очекиван је тип израза"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid type expression"
 msgid "unhandled expression"
 msgstr "Неисправан типски израз"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_code(): лош кôд наредбе"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Име ‘%s’ код %C је име процедуре"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Automatic character length function '%s' at %L must have an explicit interface"
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "Аутоматска функција знаковне дужине ‘%s’ код %L мора имати експлицитно сучеље"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find class %qs"
 msgid "Cannot find symbol %qs at %L"
 msgstr "не могу да нађем класу %qs"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "Процедура ‘%s’ у %s код %L није ни функција ни потпрограм"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a function"
 msgid "variant %qs at %L is the same as base function"
 msgstr "‘%s’ код %L није функција"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a procedure for argument '%s' at %L"
 msgid "Expected positive argument index at %L"
 msgstr "Очекивана је процедура за аргумент ‘%s’ код %L"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L exceeds the string length"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Индекс краја подниске код %L премашује дужину ниске"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Алтернативан повратак код %L без лажног аргумента *"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Аргумент ‘%s’ наредбене функције код %L мора бити скалар"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Аргумент ‘%s’ елементалне процедуре код %L не може имати атрибут показивача"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%qs at %L is specified more than once"
 msgstr "%qs може бити наведено само за функције"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr ""
@@ -98194,7 +98388,7 @@ msgstr "fclose %s"
 msgid "two or more sections for %s"
 msgstr "два или више типова података у декларацији %qs"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -98557,32 +98751,32 @@ msgstr "низ употребљен као успостављач"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "захтевано равнање није константа"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "захтевано равнање није степен двојке"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "захтевано равнање је превелико"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -104107,10 +104301,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "нестатички метод %q+D потискује статички метод"
 
-#, gcc-internal-format
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D употребљено пре декларисања"
-
 #, gcc-internal-format
 #~ msgid "declaration of %qs shadows a parameter"
 #~ msgstr "декларација %qs заклања параметар"
@@ -104465,10 +104655,6 @@ msgstr ""
 #~ msgid "Class %qs not found in %<throws%>"
 #~ msgstr "Класа %qs не налази се у %<throws%>"
 
-#, gcc-internal-format
-#~ msgid "Duplicate %s declaration %qs"
-#~ msgstr "Удвостручена %s декларација %qs"
-
 #, gcc-internal-format
 #~ msgid "Class %qs doesn't define the abstract method %<%s %s%> from %s %<%s%>. This method must be defined or %s %qs must be declared abstract"
 #~ msgstr "Класа %qs не дефинише апстрактни метод %<%s %s%> из %s %<%s%>. Овај метод мора бити дефинисан или %s %qs мора бити декларисано апстрактно"
--- a/src/gcc/po/sv.po
+++ b/src/gcc/po/sv.po
@@ -30,10 +30,10 @@
 # thunk			snutt
 msgid ""
 msgstr ""
-"Project-Id-Version: gcc 16.1-b20260329\n"
+"Project-Id-Version: gcc 16.1.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
-"PO-Revision-Date: 2026-04-24 22:05+0200\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
+"PO-Revision-Date: 2026-05-18 11:39+0200\n"
 "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
 "Language: sv\n"
@@ -1276,12 +1276,12 @@ msgstr "Alias:"
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Kända PTX ISA-versioner (att användas med flaggan -mptx=):"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "Ange PTX-ISA-versionen att använda."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr "Initiera ptx-register."
@@ -1430,7 +1430,7 @@ msgstr "Generera kod för PA2.0 (kräver binutils 2.10 eller senare)."
 #: config/pa/pa.opt:42
 #, no-c-format
 msgid "Generate libcalls for atomic loads and stores when sync libcalls are disabled."
-msgstr "Generera bibliteksanrop för atomiska läsningar och lagringar när synkrona biblioteksanrop är avaktiverade."
+msgstr "Generera biblioteksanrop för atomära läsningar och lagringar när synkrona biblioteksanrop är avaktiverade."
 
 #: config/pa/pa.opt:50
 #, no-c-format
@@ -2100,13 +2100,13 @@ msgstr "Aktivera standardkonvertering mellan __float128 & long double."
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "Använd angiven stackskyddsvakt."
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2554,7 +2554,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Antag att mål-CPU:n är konfigurerad för rak byteordning."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Antag att mål-CPU:n är konfigurerad med omvänd byteordning."
@@ -2629,7 +2629,7 @@ msgstr "Använd mindre men långsammare prolog- och epilogkod."
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr "Konvertera BASE + LARGE_OFFSET-adresser till NEW_BASE + SMALL_OFFSET för att tillåta att minnesåtkomster genereras som komprimerade instruktioner. Siktar för närvarande på 32-bitars laddning/lagring av heltal."
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2663,10 +2663,10 @@ msgstr "Dra nytta av länkarlättnader för att reducera antalet instruktioner s
 #: config/riscv/riscv.opt:163
 #, no-c-format
 msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR. The ISA-dependent CSR are only valid when the specific ISA is set.  The read-only CSR can not be written by the CSR instructions."
-msgstr "Aktivera CSR-kontroll för den ISA-beroende CSR:en och endast läsnings-CSR:er. De ISA-beroande CSR:erna är endast giltiga för det specifika ISA-uppsättningen. Endast läsnings-CSR:er kan inte skrivas av CSR-instruktionerna."
+msgstr "Aktivera CSR-kontroll för den ISA-beroende CSR:en och endast läsnings-CSR:er. De ISA-beroande CSR:erna är endast giltiga för den specifika ISA-uppsättningen. Endast läsnings-CSR:er kan inte skrivas av CSR-instruktionerna."
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Utelämna rampekaren i lövfunktioner."
@@ -2776,7 +2776,7 @@ msgstr "-param=vsetvl-strategy=<sträng>\tSätt optimeringsnivån för VSETVL-in
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr "-param=riscv-two-source-permutes Aktivera permuteringar med två källvektorer."
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr "Åsidosätt den skalära kostnadsmodellen så att vektorisering alltid är lönsam."
@@ -2822,7 +2822,7 @@ msgstr "-mrvv-vector-bits=<sträng>\tAnge typen av bitar i ett RVV-vektorregiste
 msgid "The possible TLS dialects:"
 msgstr "De möjliga TLS-dialekterna:"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -3325,7 +3325,7 @@ msgstr "Denna flagga används internt för multilib-generering och -val. Enheten
 #: config/avr/avr.opt:137
 #, no-c-format
 msgid "Optimization. Split register additions from load/store instructions. Most useful on Reduced Tiny."
-msgstr "Optimering. Dela registeradditioner fån ladda-/lagrainstruktioner. Mest användbart på Reduced Tiny."
+msgstr "Optimering. Dela registeradditioner från ladda-/lagrainstruktioner. Mest användbart på Reduced Tiny."
 
 #: config/avr/avr.opt:141
 #, no-c-format
@@ -5085,7 +5085,7 @@ msgstr "Stöd inbyggda RAOINT-funktioner och -kodgenerering."
 msgid "Enable conservative small loop unrolling."
 msgstr "Aktivera konservativ utrullning av små slingor."
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr "Begränsa hur mycket autovektoriseraren får rulla ut en slinga."
@@ -5440,7 +5440,7 @@ msgstr "Vid länkning för mål med rak byteordning, generera gammaldags avbild
 msgid "Cost to assume for a branch insn."
 msgstr "Kostnad att anta för en greninstruktion."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr "Använd grenskyddsfunktioner."
@@ -5745,212 +5745,217 @@ msgstr "Sätt att gå runt ARM Cortex-A53:s errata nummer 835796."
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr "Sätt att gå runt ARM Cortex-A53:s errata nummer 843419."
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr "Aktivera avsmalning av 64-bitars skrivningar till generella register till 32-bitars när de övre 32 bitarna av registret är oanvända."
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "Registret använt för att nå trådpekaren:"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Ange trådpekarregistret."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "Anta inte att ojusterade åtkomster hanteras av systemet."
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Ange bitstorlek på omedelbara TLS-avstånd.  Giltiga värden är 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "Använd funktioner i arkitekturen ARK."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "Använd funktioner i och optimera för angiven CPU."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr "Optimera för CPU."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Generera kod som följer det angivna ABI:et."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr "-fdump-tuning-model=<filnamn> Dumpa aktuell trimningsmodell till en JSON-fil."
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr "-muser-provided-CPU=<json-tuning-fil> Användarspecifika CPU-trimningar."
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr "-moverride=<sträng>\tEndast avancerade användare!  Åsidosätt CPU-optimeringsparametrar."
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "Kända AArch64-ABI:er (att användas med flaggan -mabi=):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr "PC-relativa litterala laddningar."
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr "Välj räckvidd för signering av returadress."
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Räckvidder som stödjs för signering av AArch64-returadresser (att användas med flaggan -msign-return-address=):"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Aktivera approximationen av invers kvadratrot.  Att aktivera detta reducerar precisionen på resultatet av invers kvadratrot till ungefär 16 bitar för enkel precision och till 32 bitar för dubbel precision."
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr "Aktivera approximationen av kvadratrot.  Att aktivera detta reducerar precisionen på resultatet av kvadratrot till ungefär 16 bitar för enkel precision och till 32 bitar för dubbel precision.  Om aktiverat implicerar det -mlow-precision-recip-sqrt."
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Aktivera approximationen av division.  Att aktivera detta reducerar precisionen på resultatet av division till ungefär 16 bitar för enkel precision och till 32 bitar för dubbel precision."
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr "Ange när ett tidigt registerallokeringspass skall aktiveras. Möjligheterna är: alla funktioner, funktioner som har tillgång till stegvisa multiregisterinstruktioner och inga funktioner."
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "De möjliga SVE-vektorlängderna:"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "-msve-vector-bits=<antal>\tAnge antalet bitar i ett SVE-vektorregister."
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
-msgstr "-autovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Framtvinga en ISA-valsstrategi för autovektorisering. För bästa prestanda rekommenderas det starkt att använda -mcpu eller -mtune istället. Denna parameter bör bara användas för kodutforskning."
+msgstr "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Framtvinga en ISA-valsstrategi för autovektorisering. För bästa prestanda rekommenderas det starkt att använda -mcpu eller -mtune istället. Denna parameter bör bara användas för kodutforskning."
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr "Aktiverar utförlig dump av kostnadsmodellen i dumpfilerna för felsökning."
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr "Generera kod för att spåra när CPU:n kan spekulera felaktigt."
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
-msgstr "Aktivera kopieringen av sammanslagningspasset av load/store-par för AArch64 som köre före registerallokering."
+msgstr "Aktivera kopieringen av sammanslagningspasset av load/store-par för AArch64 som körs före registerallokering."
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
-msgstr "Aktivera kopieringen av sammanslagningspasset av load/store-par för AArch64 som köre efter registerallokering."
+msgstr "Aktivera kopieringen av sammanslagningspasset av load/store-par för AArch64 som körs efter registerallokering."
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Använd systemregistret som anges på kommandoraden som registret för stackskyddsvakt.  Denna flagga skall användas med fstack-protector-strong och är inte till för kod i användarmarken."
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Använd en omedelbar för att få avstånd från stackskyddsvaktregistret, sp_el0.  Denna flagga skall användas med fstack-protector-strong och är inte till för kod i användarmarken."
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Generera lokala anrop till atomära operationer utanför linjen."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr "Överväg vid vektorisering att använda flera olika tillvägagångssätt och använd kostnadsmodellen för att välja den billigaste."
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr "Antalet Newtoniterationer för att beräkna inversen för typen float.  Precisionen i divisionen är proportionell mot denna parameter när divisionsapproximering är aktiverat.  Standardvärdet är 1."
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr "Antalet Newtoniterationer för att beräkna inversen för typen double. Precisionen i divisionen är proportionell mot denna parameter när divisionsapproximering är aktiverat. Standardvärdet är 2."
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr "Ett gammalt alias för -mautovec-preference. Om både -mautovec-preference och --param=aarch64-autovec-preference skickas kommer värdet --param att användas."
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr "Konstant memcpy-storlek i byte över vilken MOPS-sekvenser skall användas."
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr "Konstant memmove-storlek i byte över vilken MOPS-sekvenser skall användas."
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr "Konstant memset-storlek i byte över vilken MOPS-sekvenser skall användas."
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
-msgstr "--param=aarch64-ldp-policy=[default|always|never|aligned] Finkorning policy för laddningspar."
+msgstr "--param=aarch64-ldp-policy=[default|always|never|aligned] Finkornig policy för laddningspar."
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
-msgstr "--param=aarch64-stp-policy=[default|always|never|aligned] Finkorning policy för lagringspar."
+msgstr "--param=aarch64-stp-policy=[default|always|never|aligned] Finkornig policy för lagringspar."
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr "Gräns på antal aliaskontroller som utförs vid försök att forma en ldp/stp."
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr "Parameter för att styra vilka återskrivningsmöjligheter vi försöker hantera i sammanslagningspasset av load/store-par. Värdet noll avaktiverar återskrivningshantering. Ett betyder att vi försöker forma par som inbegriper en eller flera återskrivningsåtkomster när möjligt. Ett värde på två betyder att vi även försöker att opportunistiskt forma återskrivningsmöjligheter genom vikning i avslutande destruktiva uppdateringar av basregistret som används av ett par."
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr "Param för att styra tröskelvärdet i antal granuler bortom vilken en explicit slinga för att tagga ett minnesblock matas ut."
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, no-c-format
 msgid "This option is deprecated."
 msgstr "Denna flagga bör undvikas."
@@ -6643,7 +6648,7 @@ msgstr "Generera approximativ inversdivision och kvadratrot i programvara för b
 #: config/loongarch/loongarch.opt:302
 #, no-c-format
 msgid "Avoid using the GOT to access external symbols."
-msgstr "Undvika att använda GOT för att komma åt externa symboler."
+msgstr "Undvik att använda GOT för att komma åt externa symboler."
 
 #: config/loongarch/loongarch.opt:311
 #, no-c-format
@@ -6948,7 +6953,7 @@ msgstr "Använd för att generera kod för några äldre kärnversioner."
 #: config/darwin.opt:179
 #, no-c-format
 msgid "Ignore the normal two-level namespace; resolve symbols in command line order and do not record which library provided the resolved symbol."
-msgstr "Ignorera den normala tvånivånamnrymden; slå upp symboler i kommandoradsordning och notera inte vilket bibliotek som tillhandahöll den upplösta symbolen."
+msgstr "Ignorera den normala tvånivånamnrymden; slå upp symboler i kommandoradsordning och notera inte vilket bibliotek som tillhandahöll den uppslagna symbolen."
 
 #: config/darwin.opt:183
 #, no-c-format
@@ -6958,7 +6963,7 @@ msgstr "För assemblern (och länkaren) tillåt alla arkitekturundervarianter at
 #: config/darwin.opt:187
 #, no-c-format
 msgid "Set the output object such that, on loading, dyld will ignore any two-level namespace information and resolve symbols in the discovery order for loaded libs."
-msgstr "Sätt utdataobjektet så att, vid laddning, dyld kommer ignorera tvånivås namnrymdsinformation och lösa upp symboler i upptäcktsordning från de laddade biblioteken."
+msgstr "Sätt utdataobjektet så att, vid laddning, dyld kommer ignorera tvånivås namnrymdsinformation och slå upp symboler i upptäcktsordning från de laddade biblioteken."
 
 #: config/darwin.opt:191
 #, no-c-format
@@ -7928,7 +7933,7 @@ msgstr "Mata ut sammanslagna multiplicera-addera-instruktioner för långa dubbl
 #: config/s390/s390.opt:352
 #, no-c-format
 msgid "Store all argument registers on the stack."
-msgstr "Slagra alla argumentregister på stacken."
+msgstr "Lagra alla argumentregister på stacken."
 
 #: config/s390/s390.opt:356
 #, no-c-format
@@ -8783,7 +8788,7 @@ msgstr "Preprocessa modulen med cpp."
 #: m2/lang.opt:79 m2/lang.opt:83
 #, no-c-format
 msgid "Passed to the preprocessor if -fcpp is used (internal switch)."
-msgstr "Skickas till proprocessorn om -fcpp används (intern flagga)."
+msgstr "Skickas till preprocessorn om -fcpp används (intern flagga)."
 
 #: m2/lang.opt:87
 #, no-c-format
@@ -8803,7 +8808,7 @@ msgstr "Spåra procedurers radnummer (intern flagga)."
 #: m2/lang.opt:99
 #, no-c-format
 msgid "Recognize the specified suffix as a definition module filename."
-msgstr "Känn igen det angivna suffixet som ett definitionsmudulsfilnamn."
+msgstr "Känn igen det angivna suffixet som ett definitionsmodulsfilnamn."
 
 #: m2/lang.opt:103
 #, no-c-format
@@ -8850,6 +8855,7 @@ msgstr "Sätt alla platsvärden till ett specifikt värde (intern flagga)."
 msgid "Internal debug tracing for quad,token,line,all (internal switch)."
 msgstr "Intern felsökningsspårning för quad,token,line,all (intern flagga)."
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125348
 #: m2/lang.opt:139
 #, no-c-format
 msgid "Dump Modula-2 internal intemediate representation specified by: all,quad,decl,gimple."
@@ -8978,7 +8984,7 @@ msgstr "Intern information för kompilatorfelsökning, dumpa listan av kvadruple
 #: m2/lang.opt:251
 #, no-c-format
 msgid "Runtime range checking for numerical values."
-msgstr "Körtidkontrol av intervall för numeriska värden."
+msgstr "Körtidkontroll av intervall för numeriska värden."
 
 #: m2/lang.opt:255
 #, no-c-format
@@ -9003,7 +9009,7 @@ msgstr "Generera en C-kodsställning för den aktuella modulen som kompileras."
 #: m2/lang.opt:271
 #, no-c-format
 msgid "Generate a C++ source scaffold for the current module being compiled."
-msgstr "Generera en C++-kodställingsinitiering och -avslutning för varje modul inuti main."
+msgstr "Generera en C++-kodsställning för den aktuella modulen som kompileras."
 
 #: m2/lang.opt:275
 #, no-c-format
@@ -9013,7 +9019,7 @@ msgstr "Generera huvudfunktionen."
 #: m2/lang.opt:279
 #, no-c-format
 msgid "Generate static scaffold initialization and finalization for every module inside main."
-msgstr "Generera statisk ställningsinitiering och avslutning för varje modul inuti main."
+msgstr "Generera statisk ställningsinitiering och -avslutning för varje modul inuti main."
 
 #: m2/lang.opt:283
 #, no-c-format
@@ -9038,7 +9044,7 @@ msgstr "Skapa en swig-gränssnittsfil för modulen."
 #: m2/lang.opt:303
 #, no-c-format
 msgid "Optimize non var unbounded parameters by passing it by reference, providing it is not written to within the callee procedure."
-msgstr "Optimera icke-var obegränsade parametrar genom att skicka dem via referens, förutsatt att den inte skrivs till i den anropade proceduren.."
+msgstr "Optimera icke-var obegränsade parametrar genom att skicka dem via referens, förutsatt att den inte skrivs till i den anropade proceduren."
 
 #: m2/lang.opt:307
 #, no-c-format
@@ -9423,7 +9429,7 @@ msgstr "Ange att ett externt BLAS-bibliotek skall användas för matmul-anrop p
 #: fortran/lang.opt:575
 #, no-c-format
 msgid "Use an external BLAS library with 64-bit indexing for matmul on large-size arrays."
-msgstr "Använd ett externt BLAS-bibliotek med 64-bitars inderxering för matmul-anrop på stora vektorer."
+msgstr "Använd ett externt BLAS-bibliotek med 64-bitars indexering för matmul-anrop på stora vektorer."
 
 #: fortran/lang.opt:579
 #, no-c-format
@@ -9863,7 +9869,7 @@ msgstr "Använd återanrop istället för inline:ad kod om antalet åtkomster i
 #: params.opt:55
 #, no-c-format
 msgid "Prefix calls to memcpy, memset and memmove with __asan_ or __hwasan_ for -fsanitize=kernel-address or -fsanitize=kernel-hwaddress."
-msgstr "Prefixa anrop av memcpy, memset och memmove med __asan_ ller __hwasan_ för -fsanitize=kernel-address eller -fsanitize=kernel-hwaddress."
+msgstr "Prefixa anrop av memcpy, memset och memmove med __asan_ eller __hwasan_ för -fsanitize=kernel-address eller -fsanitize=kernel-hwaddress."
 
 #: params.opt:59
 #, no-c-format
@@ -9958,7 +9964,7 @@ msgstr "Den maximala längden på en konstant sträng för att ett inbyggt strä
 #: params.opt:131
 #, no-c-format
 msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches.  If 0, use the default for the machine."
-msgstr "Det minsta antalet olika värden för vilka det är bäst att använda hopptabeller istället för ett träd med villkorliga grenar- Om 0, använd standardvärdet för maskinen."
+msgstr "Det minsta antalet olika värden för vilka det är bäst att använda hopptabeller istället för ett träd med villkorliga grenar. Om 0, använd standardvärdet för maskinen."
 
 #: params.opt:135
 #, no-c-format
@@ -9998,7 +10004,7 @@ msgstr "Max antal rader att indexera till filcachen. När satt till 0 sätts sto
 #: params.opt:163
 #, no-c-format
 msgid "Scale factor to apply to the number of statements in a threading path crossing a loop back edge when comparing to max-jump-thread-duplication-stmts."
-msgstr "Skalfaktor att använda på antalet satser i en trådningsväg som korsar en slingas bakåtbpge vid jämförelse med max-jump-thread-duplication-stmts."
+msgstr "Skalfaktor att använda på antalet satser i en trådningsväg som korsar en slingas bakåtbåge vid jämförelse med max-jump-thread-duplication-stmts."
 
 #: params.opt:167
 #, no-c-format
@@ -10289,7 +10295,7 @@ msgstr "Storleken på L2-cachen."
 #: params.opt:406
 #, no-c-format
 msgid "Maximal growth due to inlining of large function (as a percentage)."
-msgstr "Maximal på grund av inline:ing av stora funktioner (som en procentsats)."
+msgstr "Maximal ökning på grund av inline:ing av stora funktioner (som en procentsats)."
 
 #: params.opt:410
 #, no-c-format
@@ -10429,7 +10435,7 @@ msgstr "Det maximala antalet instruktionskombinationsförsök att kombinera."
 #: params.opt:543
 #, no-c-format
 msgid "The maximum number of instructions that combine searches in order to find the next use of a particular register."
-msgstr "Det maximala antalet instruktioner som kombinerar sökningar för att att hitta nästa användning av ett visst register."
+msgstr "Det maximala antalet instruktioner som kombinerar sökningar för att hitta nästa användning av ett visst register."
 
 #: params.opt:547
 #, no-c-format
@@ -10915,7 +10921,7 @@ msgstr "--param=ranger-debug=[none|trace|gori|cache|tracegori|all] Anger utmatni
 #: params.opt:1000
 #, no-c-format
 msgid "Maximum depth of logical expression evaluation ranger looks through when evaluating outgoing edge ranges."
-msgstr "Maximalt djup på beräkningsintervallare av logiska uttryck tittar igenom vid beräkning av utgående bågintervall."
+msgstr "Maximalt djup på logiska uttryck som beräkningsintervallare tittar igenom vid beräkning av utgående bågintervall."
 
 #: params.opt:1005
 #, no-c-format
@@ -11185,7 +11191,7 @@ msgstr "Maximalt antal predikat med ”or” i den normaliserade predikatkedjan.
 #: params.opt:1228
 #, no-c-format
 msgid "Maximum amount of work done to prune paths where the variable is always initialized."
-msgstr "Maximal mäng arbete som görs för att ansa vägar där variabeln alltid är initierad."
+msgstr "Maximal mängd arbete som görs för att ansa vägar där variabeln alltid är initierad."
 
 #: params.opt:1232
 #, no-c-format
@@ -11274,8 +11280,8 @@ msgstr "Aktivera slingvektorisering av flyttalsinduktioner."
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
-msgstr "Skalningsfaktorn i procent som ska tillämpas på alla skalära slingkostnader när vektoriseringslönsamhetsanalys utförs. Standardvärdet är 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
+msgstr "Aktivera vektorisering av slingor som kanske inte är lönsamma enligt kostnadsmodellen men utför ändå kostnad mellan vektorlägen."
 
 #: params.opt:1304
 #, no-c-format
@@ -11350,17 +11356,17 @@ msgstr "Antalet byte vid vilket stränglitteraler i textkonstdiagram från analy
 #: analyzer/analyzer.opt:63
 #, no-c-format
 msgid "The number of literal bytes to show at the head of a string literal in text art when ellipsizing it."
-msgstr "Antalet literala byte att visa vid huvudet av en strängliteral i textkonst när den har ellips."
+msgstr "Antalet litterala byte att visa vid huvudet av en stränglitteral i textkonst när den har ellips."
 
 #: analyzer/analyzer.opt:67
 #, no-c-format
 msgid "The number of literal bytes to show at the tail of a string literal in text art when ellipsizing it."
-msgstr "Antalet literala byt att visa vid slutet av en strängliteral i textkonst när den har ellips."
+msgstr "Antalet litterala byt att visa vid slutet av en stränglitteral i textkonst när den har ellips."
 
 #: analyzer/analyzer.opt:71
 #, no-c-format
 msgid "The ideal width in characters of text art diagrams generated by the analyzer."
-msgstr "Den ideala bredden i tecken för textkonstdiagram som genereras ava analysatorn."
+msgstr "Den ideala bredden i tecken för textkonstdiagram som genereras av analysatorn."
 
 #: analyzer/analyzer.opt:75
 #, no-c-format
@@ -11410,7 +11416,7 @@ msgstr "Varna för kodvägar i vilka en filbeskrivare inte stängs."
 #: analyzer/analyzer.opt:111
 #, no-c-format
 msgid "Warn about code paths in which an operation is attempted in the wrong phase of a file descriptor's lifetime."
-msgstr "Varna för kodvägar i vilka en ågärd försöker göras i fel fas av en filbeskrivares livstid."
+msgstr "Varna för kodvägar i vilka en åtgärd försöker göras i fel fas av en filbeskrivares livstid."
 
 #: analyzer/analyzer.opt:115
 #, no-c-format
@@ -11635,7 +11641,7 @@ msgstr "Begränsa analyseraren till att köra just den namngivna kontrollen."
 #: analyzer/analyzer.opt:291
 #, no-c-format
 msgid "Add extra annotations to diagrams."
-msgstr "Lägg till extra annotationer till diagram."
+msgstr "Lägg till extra annoteringar till diagram."
 
 #: analyzer/analyzer.opt:299
 #, no-c-format
@@ -11665,7 +11671,7 @@ msgstr "Slå samman tillräckligt lika tillstånd under analysen."
 #: analyzer/analyzer.opt:319
 #, no-c-format
 msgid "Stop exploring an execution path after certain diagnostics."
-msgstr "Sluta att utforska en exekveringsväg efter visas felmeddelanden."
+msgstr "Sluta att utforska en exekveringsväg efter vissa felmeddelanden."
 
 #: analyzer/analyzer.opt:323
 #, no-c-format
@@ -11952,7 +11958,7 @@ msgstr "Varna vid försök att frigöra ett icke-heap-objekt."
 #: common.opt:654
 #, no-c-format
 msgid "Warn when -fhardened did not enable an option from its set."
-msgstr "Varna när -fardened inte aktiverade någon flagga från sin uppsättning."
+msgstr "Varna när -fhardened inte aktiverade någon flagga från sin uppsättning."
 
 #: common.opt:665
 #, no-c-format
@@ -12342,7 +12348,7 @@ msgstr "Denna flagga bör undvikas, använd -fsanitize-recover= istället."
 #: common.opt:1184
 #, no-c-format
 msgid "Use traps instead of diagnostics of undefined behavior sanitizers."
-msgstr "Använd trap istället för diagnostik av saniterare av odefinierat beteende."
+msgstr "Använd trap istället för diagnostik av sanerare av odefinierat beteende."
 
 #: common.opt:1194
 #, no-c-format
@@ -12432,7 +12438,7 @@ msgstr "Utför interna konsistenskontroller."
 #: common.opt:1287
 #, no-c-format
 msgid "For -f*-prefix-map= options compare canonicalized pathnames rather than just strings."
-msgstr "För flaggor av typ -f*-prefix-map= jämför kononiserade sökvägsnamn istället för bara strängar."
+msgstr "För flaggor av typ -f*-prefix-map= jämför kanoniserade sökvägsnamn istället för bara strängar."
 
 #: common.opt:1291
 #, no-c-format
@@ -13007,7 +13013,7 @@ msgstr "Härda villkorsgrenar genom att kontrollera omvända villkor."
 #: common.opt:1974
 #, no-c-format
 msgid "Harden control flow by recording and checking execution paths."
-msgstr "Härda styrflödet genom att spela in och kontroller körvägar."
+msgstr "Härda styrflödet genom att spela in och kontrollera körvägar."
 
 #: common.opt:1978
 #, no-c-format
@@ -13447,7 +13453,7 @@ msgstr "Låt bli att generera stackramar när det är möjligt."
 #: common.opt:2507
 #, no-c-format
 msgid "Generate SIMD clones for functions with the OpenMP declare target directive."
-msgstr "Generera SIMD-kloner för funktioner med direketivet OpenMP declare target."
+msgstr "Generera SIMD-kloner för funktioner med direktivet OpenMP declare target."
 
 #: common.opt:2526
 #, no-c-format
@@ -13467,7 +13473,7 @@ msgstr "Skriv en KÄLLFIL.opt-record.json-fil med detaljer om vilka optimeringar
 #: common.opt:2538
 #, no-c-format
 msgid "Detect loops calculating CRC and replace with faster implementation. If the target supports CRC instruction and the CRC loop uses the same polynomial as the one used in the CRC instruction, directly replace with the corresponding CRC instruction. Otherwise, if the target supports carry-less-multiplication instruction, generate CRC using it. If neither case applies, generate table-based CRC."
-msgstr "Upptäck slingor som beräknar CRC och ersätt dem med en snabbare implementation. Om målet stödjer en CRC-instruktion och CRC-slingan använder samma polynom smo det som används i CRC-instruktionen, ersätt då direkt med motsvarande CRC-instruktion. Annars, om målet stödjer en instruktion för minnesfri multiplikation, generera en CRC som använder det. Om inget av fallen är tillämpligt, generera tabellbaserad CRC."
+msgstr "Upptäck slingor som beräknar CRC och ersätt dem med en snabbare implementation. Om målet stödjer en CRC-instruktion och CRC-slingan använder samma polynom som det som används i CRC-instruktionen, ersätt då direkt med motsvarande CRC-instruktion. Annars, om målet stödjer en instruktion för minnesfri multiplikation, generera en CRC som använder det. Om inget av fallen är tillämpligt, generera tabellbaserad CRC."
 
 #: common.opt:2552
 #, no-c-format
@@ -14767,7 +14773,7 @@ msgstr "Varna för dolda deklarationer i inre räckvidder."
 #: algol68/lang.opt:69
 #, no-c-format
 msgid "-Whidden-declarations=[none|prelude|all] Warn about declarations hidden in inner scopes."
-msgstr "-Whidden-declarations=[inget|prelude|all] Varna för deklarationer som döljs i inre räckvidder."
+msgstr "-Whidden-declarations=[none|prelude|all] Varna för deklarationer som döljs i inre räckvidder."
 
 #: algol68/lang.opt:73
 #, no-c-format
@@ -14827,7 +14833,7 @@ msgstr "-fmodules-map=<mapstring>                 Association mellan modulindika
 #: algol68/lang.opt:141 algol68/lang.opt:145
 #, no-c-format
 msgid "-fmodules-map-file=<filename>              File containing modules map."
-msgstr "-fmodules-map-file=<filnamn>               Fil som innehåller modulermappning."
+msgstr "-fmodules-map-file=<filnamn>               Fil som innehåller modulmappning."
 
 #: rust/lang.opt:47 rust/lang.opt:51 c-family/c.opt:1609 c-family/c.opt:1613
 #, no-c-format
@@ -14922,7 +14928,7 @@ msgstr "Använd WIP-lånekontrolleraren."
 #: rust/lang.opt:221
 #, no-c-format
 msgid "-frust-edition=[unwind|abort]             Panic strategy to compile crate with."
-msgstr "-frust-edition=[unwind|abort]             Panikstrategi att kompilera lådan med."
+msgstr "-frust-edition=[unwind|abort]             Panikstrategi att kompilera låren med."
 
 #: rust/lang.opt:234
 #, no-c-format
@@ -15509,7 +15515,7 @@ msgstr "Varna för aritmetiska konverteringar som bör undvikas på operander d
 #: c-family/c.opt:684
 #, no-c-format
 msgid "Warn about deprecated space between \"\" and suffix in a user-defined literal operator."
-msgstr "Varna för föråldrade mellanrum mellan \"\" och suffix i en användardefinierad literal operator."
+msgstr "Varna för föråldrade mellanrum mellan \"\" och suffix i en användardefinierad litteral operator."
 
 #: c-family/c.opt:688
 #, no-c-format
@@ -16194,7 +16200,7 @@ msgstr "Varna när ett argument skickas till restrict-kvalificerade parameterali
 #: c-family/c.opt:1338
 #, no-c-format
 msgid "Warn whenever void-returning functions return a non-void expressions, or a return expression is missing in a function not returning void."
-msgstr "Varna närhelst void-returnerande funktioner returnerar ett yttryck som inte äv void, eller ett returuttryck saknas i en funktion som inte returnerar void."
+msgstr "Varna närhelst void-returnerande funktioner returnerar ett uttryck som inte är void, eller ett returuttryck saknas i en funktion som inte returnerar void."
 
 #: c-family/c.opt:1342
 #, no-c-format
@@ -16459,7 +16465,7 @@ msgstr "Varna för flyttalskonstanter utan suffix."
 #: c-family/c.opt:1601
 #, no-c-format
 msgid "Warn about character arrays initialized as unterminated character sequences with a string literal."
-msgstr "Varna för teckenvektorer som initieras som oavslutade teckensekvenser med en strängliteral."
+msgstr "Varna för teckenvektorer som initieras som oavslutade teckensekvenser med en stränglitteral."
 
 #: c-family/c.opt:1617
 #, no-c-format
@@ -16544,7 +16550,7 @@ msgstr "Varna för xor-operatorer där det verkar som att användaren avsåg exp
 #: c-family/c.opt:1699
 #, no-c-format
 msgid "Warn when a literal '0' is used as null pointer."
-msgstr "Varna när en ordagrann '0' används som en nollpekare."
+msgstr "Varna när en ordagrann ”0” används som en nollpekare."
 
 #: c-family/c.opt:1703
 #, no-c-format
@@ -16700,7 +16706,7 @@ msgstr "-fcontracts-client-check=[none|pre|all] Välj vilka kontrakt som skall k
 #: c-family/c.opt:1968
 #, no-c-format
 msgid "-fcontracts-definition-check=[on|off]\tEnable or disable contract checks on the definition side for all functions (default on)."
-msgstr "-fcontracts-definition-check=[on|off]\tAktivera eller avaktivera kontraktskontroller av definitionssidad för alla funktioner (standard på)."
+msgstr "-fcontracts-definition-check=[on|off]\tAktivera eller avaktivera kontraktskontroller av definitionssidan för alla funktioner (standard på)."
 
 #: c-family/c.opt:1972
 #, no-c-format
@@ -17105,7 +17111,7 @@ msgstr "Slå på stöd för C++14 storleksbestämd deallokering."
 #: c-family/c.opt:2408
 #, no-c-format
 msgid "-fstrict-flex-arrays=<level>    Control when to treat the trailing array of a structure as a flexible array member for the purposes of accessing the elements of such an array. The default is treating all trailing arrays of structures as flexible array members."
-msgstr "-fstrict-flex-arrays=<nivå>     Styr när den avslutande vektorn i en post skall behandlas som en flexibel vektormedlem vid åtkomst av elementen i en sådan vektor. Standard är att betrakta alla avslutende vektorer i poster som flexibla vektormedlemmar."
+msgstr "-fstrict-flex-arrays=<nivå>     Styr när den avslutande vektorn i en post skall behandlas som en flexibel vektormedlem vid åtkomst av elementen i en sådan vektor. Standard är att betrakta alla avslutande vektorer i poster som flexibla vektormedlemmar."
 
 #: c-family/c.opt:2415
 #, no-c-format
@@ -17626,7 +17632,7 @@ msgstr "Varna om en numerisk sträng är felaktig."
 #: cobol/lang.opt:169
 #, no-c-format
 msgid "Warn if referenced CDF PARAMETER is not defined."
-msgstr "Varna om en refererarad CDF PARAMETER inte är definierad."
+msgstr "Varna om en refererad CDF PARAMETER inte är definierad."
 
 #: cobol/lang.opt:174
 #, no-c-format
@@ -18081,7 +18087,7 @@ msgstr "Aktivera r-värdesargument till ref-parametrar."
 #: d/lang.opt:420
 #, no-c-format
 msgid "Disable access to variables marked `@system' from @safe code."
-msgstr "Avaktivera åtkomst till varialer markerade ”@system” från @safe kod."
+msgstr "Avaktivera åtkomst till variabler markerade ”@system” från @safe kod."
 
 #: d/lang.opt:424
 #, no-c-format
@@ -18188,79 +18194,79 @@ msgstr "Följ D-språksutgåvan 2024."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Följ den senaste D-språksutgåvan 202Y (experimentellt)."
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr "ett anropad-kopierat argument lagras i den aktuella funktionens ram"
 
-#: calls.cc:1537
+#: calls.cc:1533
 msgid "argument must be passed by copying"
 msgstr "argument måste skickas med kopiering"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr "maskinbeskrivningen har inte något sibcall_epilogue-instruktionsmönster"
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr "den anropade returnerar en post"
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr "målet kan inte optimera anropet till ett syskonanrop"
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr "den anropade returnerar två gånger"
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr "den anropade returnerar inte"
 
-#: calls.cc:2595
+#: calls.cc:2596
 msgid "volatile function type"
 msgstr "volatile funktionstyp"
 
-#: calls.cc:2614
+#: calls.cc:2615
 msgid "nested function"
 msgstr "nästad förväntades"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr "den anropade behöver fler fack på stacken än anroparen"
 
-#: calls.cc:2639
+#: calls.cc:2640
 msgid "inconsistent number of popped arguments"
 msgstr "inkonsistent antal poppade argument"
 
-#: calls.cc:2646
+#: calls.cc:2647
 msgid "frontend does not support sibling call"
 msgstr "framänden stödjer inte syskonanrop"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr "andra orsaker"
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr "inuti ett annat anrop"
 
-#: calls.cc:3085
+#: calls.cc:3086
 msgid "variable size arguments"
 msgstr "argument med variabel storlek"
 
-#: calls.cc:3109
+#: calls.cc:3110
 msgid "hidden string length argument passed on stack"
 msgstr "argument med dold stränglängd skickat på stacken"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr "anroparen och den anropade är inte överens om befordran av funktionens returvärde"
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 msgid "tail call production failed"
-msgstr "svansanropsprduktionen misslyckades"
+msgstr "svansanropsproduktionen misslyckades"
 
 #: cfgrtl.cc:2830
 msgid "flow control insn inside a basic block"
@@ -18302,7 +18308,7 @@ msgstr[1] "%d destruerare hittade\n"
 #, c-format
 msgid "%d frame table found\n"
 msgid_plural "%d frame tables found\n"
-msgstr[0] "%d ramtabeller hittad\n"
+msgstr[0] "%d ramtabell hittad\n"
 msgstr[1] "%d ramtabeller hittade\n"
 
 #: collect2.cc:1834
@@ -18378,12 +18384,12 @@ msgstr "'%%l'-operand är inte en etikett"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "flyttalskonstant felanvänd"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -18861,7 +18867,7 @@ msgid ""
 "                                        and coverage file contents\n"
 msgstr ""
 "  merge-stream [flaggor] [<fil>]        Slå samman täckningsströmsfil (eller\n"
-"                                        standard in) täckningsfilsinnehåll\n"
+"                                        standard in) och täckningsfilsinnehåll\n"
 
 #: gcov-tool.cc:258
 #, c-format
@@ -19032,7 +19038,7 @@ msgstr ""
 #: gcov.cc:1104
 #, c-format
 msgid "  -e, --prime-paths               Show prime path coverage summary\n"
-msgstr "  -e, --prime-paths               Visa sammanfattning av primevägstäckning\n"
+msgstr "  -e, --prime-paths               Visa sammanfattning av primärvägstäckning\n"
 
 #: gcov.cc:1105
 #, c-format
@@ -19296,7 +19302,7 @@ msgstr "%s:redan sedda block för ”%s”\n"
 #: gcov.cc:2391
 #, c-format
 msgid "%s:already seen conditions for '%s'\n"
-msgstr "%s:redan seda villkor för ”%s”\n"
+msgstr "%s:redan sedda villkor för ”%s”\n"
 
 #: gcov.cc:2449 gcov.cc:2589
 #, c-format
@@ -19688,11 +19694,11 @@ msgstr "JSON-litteral"
 msgid "this is the insn:"
 msgstr "detta är instruktionen:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 msgid "unable to reload address in "
 msgstr "kan inte ladda om adressen i "
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "kan inte generera omläsningar för:"
 
@@ -19912,7 +19918,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC heuristik: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonym>"
@@ -19963,7 +19969,7 @@ msgstr "anropet kan kasta ett undantag som fångas lokalt eller utför uppstädn
 
 #: tree-tailcall.cc:977
 msgid "return value used after call"
-msgstr "returvärdets använt efter anropet"
+msgstr "returvärdet använt efter anropet"
 
 #: tree-tailcall.cc:1074 tree-tailcall.cc:1102
 msgid "call invocation refers to locals"
@@ -20290,20 +20296,20 @@ msgstr "ej stödd operand för kod ”%c”"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "ogiltig operand för ”%%%c”"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "ogiltig vektorkonstant"
@@ -20348,71 +20354,71 @@ msgstr "ogiltig operandprefix ”%%%c”"
 msgid "invalid address mode"
 msgstr "ogiltigt adressläge"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 msgid "invalid conversion from type %<mfloat8_t%>"
-msgstr "ogiltig konvertering från typen %<bfloat8_t%>"
+msgstr "ogiltig konvertering från typen %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 msgid "invalid conversion to type %<mfloat8_t%>"
-msgstr "ogiltig konvertering till typen %<bfloat8_t%>"
+msgstr "ogiltig konvertering till typen %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "åtgärden preincrement är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "åtgärden predecrement är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "åtgärden postincrement är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "åtgärden postdecrement är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr "åtgärden negering är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr "åtgärden plus är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr "åtgärden minus är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr "åtgärden multiplicera är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr "åtgärden dividera är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr "åtgärden skifta är inte tillåten på svbool_t"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr "endast operationerna == och != tillåts på svbool_t"
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 msgid "subscript operation not supported on svbool_t"
 msgstr "åtgärden indexering stödjs inte på svbool_t"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
-msgstr "operationen är inte tillåten på typen %<bfloat8_t%>"
+msgstr "operationen är inte tillåten på typen %<mfloat8_t%>"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "det går inte att kombinera GNU- och SVE-vektorer i en binär operation"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20429,13 +20435,13 @@ msgid "invalid %%r value"
 msgstr "ogiltigt %%r-värde"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "ogiltigt %%R-värde"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "ogiltigt %%N-värde"
@@ -20450,7 +20456,7 @@ msgstr "ogiltigt %%P-värde"
 msgid "invalid %%h value"
 msgstr "ogiltigt %%h-värde"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "ogiltigt %%L-värde"
@@ -20465,7 +20471,7 @@ msgstr "ogiltigt %%m-värde"
 msgid "invalid %%M value"
 msgstr "ogiltigt %%M-värde"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "ogiltigt %%U-värde"
@@ -20797,7 +20803,7 @@ msgstr "ej stödd operand"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21042,126 +21048,126 @@ msgstr "ogiltig fp-konstant"
 msgid "Expected register or constant integer."
 msgstr "Register eller konstant heltal förväntades."
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "ogiltig UNSPEC som operand"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "ogiltig användning av register ”%s”"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "felaktig användning av asm-flaggutdata"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "ogiltig operandstorlek för operandkod ”O”"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "ogiltig operandstorlek för operandkod ”z”"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "ogiltig operandtyp använd med operandkod ”%c”"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "ogiltig operandstorlek för operandkod ”%c”"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "operanden är inte en villkorskod, ogiltig operandkod ”Y”"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "operand är inte en villkorskod, ogiltig operandkod ”D”"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "operand är inte en villkorskod, ogiltig operandkod ”%c”"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "operand är inte en justerbar minnesreferens, ogiltig operandkod ”H”"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "operanden är inte ett heltal, ogiltig operandkod ”K”"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "operanden är inte ett specifikt heltal, ogiltig operandkod ”r”"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "operanden är inte ett heltal, ogiltig operandkod ”R”"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "operanden är inte ett specifikt heltal, ogiltig operandkod ”R”"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "operand är inte en minnesreferens, ogiltig operandkod ”v”"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "ogiltig operandkod ”%c”"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "ogiltig begränsning för operand"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr "ogiltig vektoromedelbar"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "okänt instruktionsläge"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "ogiltig konvertering från typen %<__bf16%> utan flaggan %<-msse2%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "ogiltig konvertering från typen %<_Float16%> utan flaggan %<-msse2%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "ogiltig konvertering till typen %<__bf16%> utan flaggan %<-msse2%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "ogiltig konvertering till typen %<_Float16%> utan flaggan %<-msse2%>"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr "operationen är inte tillåten på typen %<bf16%> utan flaggan %<-msse2%>"
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr "operationen är inte tillåten på typen %<_Float16%> utan flaggan %<-msse2%>"
 
@@ -21240,9 +21246,9 @@ msgstr "%%%c är inte ett giltigt operandprefix"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "felaktig användning av ”%%%c”"
@@ -21307,7 +21313,7 @@ msgid "insn contains an invalid address !"
 msgstr "instruktionen innehåller en ogiltig adress!"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "ogiltig adress"
 
@@ -21382,7 +21388,7 @@ msgstr "ogiltig omlokalisering"
 msgid "invalid %%H value"
 msgstr "ogiltigt %%H-värde"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "ogiltigt %%d-värde"
@@ -21432,32 +21438,32 @@ msgstr "ej stödd konstant adress:"
 msgid "unsupported memory expression:"
 msgstr "ej stött minnesuttryck:"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, c-format
 msgid "invalid vector operand"
 msgstr "ogiltig vektoroperand"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr "modifieraren ”N” behöver en registeroperand"
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, c-format
 msgid "invalid register number for 'N' modifier"
-msgstr "ogiltig registernummer för modifieraren ”N”"
+msgstr "ogiltigt registernummer för modifieraren ”N”"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr "modifieraren ”H” behöver en registeroperand"
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr "modifieraren ”H” är endast för heltalsregister"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr "modifieraren ”H” kan inte tillämpas på R31"
@@ -21514,7 +21520,7 @@ msgstr "Felaktig 128-bitsförflyttning"
 msgid "invalid %%A value"
 msgstr "ogiltigt %%A-värde"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "ogiltigt %%D-värde"
@@ -21554,7 +21560,7 @@ msgstr "ogiltig %%J-kod"
 msgid "invalid %%k value"
 msgstr "ogiltigt %%k-värde"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "ogiltigt %%K-värde"
@@ -21584,17 +21590,17 @@ msgstr "ogiltigt %%T-värde"
 msgid "invalid %%u value"
 msgstr "ogiltigt %%u-värde"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "ogiltig %%v-kod"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "ogiltigt %%V-värde"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "ogiltigt %%x-värde"
@@ -21803,27 +21809,27 @@ msgstr "ogiltig %%s-operand"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "flyttalskonstant inte en giltig omedelbar operand"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "”B”-operand är ej konstant"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "”B”-operand har flera bitar satta"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "”o”-operand är ej konstant"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, c-format
 msgid "'h' operand is not SImode register"
 msgstr "”h”-operand är ej ett SImode-register"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: okänd kod"
@@ -21879,24 +21885,24 @@ msgstr "ogiltig operandadress (4)"
 msgid "Unable to load DLL."
 msgstr "Kan inte ladda en DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "felaktig test"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "ogiltigt mask"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "ogiltigt %%t/%%b-värde"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "inget register i adress"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "adressavstånd inte en konstant"
 
@@ -21928,7 +21934,7 @@ msgstr "{felaktig}"
 msgid "aka"
 msgstr "även"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anonym})"
 
@@ -21953,8 +21959,8 @@ msgstr "({anonym})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "%<;%> förväntades"
@@ -21982,7 +21988,7 @@ msgstr "%<:%> eller %<)%> förväntades"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "%<)%> förväntades"
@@ -21990,7 +21996,7 @@ msgstr "%<)%> förväntades"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "%<]%> förväntades"
@@ -22010,13 +22016,13 @@ msgstr "%<;%>, %<,%> eller %<)%> förväntades"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "%<(%> förväntades"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "%<[%> förväntades"
@@ -22025,7 +22031,7 @@ msgstr "%<[%> förväntades"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22042,13 +22048,13 @@ msgstr "%<{%> förväntades"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "%<:%> förväntades"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "%<while%> förväntades"
@@ -22058,7 +22064,7 @@ msgstr "%<while%> förväntades"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "%<,%> förväntades"
@@ -22068,18 +22074,18 @@ msgid "expected %<.%>"
 msgstr "%<.%> förväntades"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "%<@end%> förväntades"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "%<>%> förväntades"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "%<,%> eller %<)%> förväntades"
@@ -22089,45 +22095,45 @@ msgstr "%<,%> eller %<)%> förväntades"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "%<=%> förväntades"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "%<)%> eller %<,%> förväntades"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "%<}%> förväntades"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "%<else%> förväntades"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "%<#pragma omp section%> eller %<}%> förväntades"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr "<meddelandet okänt vid kompileringstillfället>"
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(anonym)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "%<<%> förväntades"
@@ -22152,7 +22158,7 @@ msgstr "kandidat %i:"
 msgid "  after user-defined conversion:"
 msgstr "  efter användardefinierad konvertering:"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "kandidat är:"
@@ -22176,7 +22182,7 @@ msgstr "<klamrar runt initierarlista>"
 
 #: cp/error.cc:699
 msgid "<unresolved overloaded function type>"
-msgstr "<ej upplöst överlagrad funktionstyp>"
+msgstr "<ej uppslagen överlagrad funktionstyp>"
 
 #: cp/error.cc:894
 msgid "<type error>"
@@ -22252,7 +22258,7 @@ msgstr "<mallparameterfel>"
 msgid "<statement>"
 msgstr "<sats>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<okänd>"
@@ -22279,252 +22285,288 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<uttrycksfel>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<okänd operator>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "I global räckvidd:"
 
-#: cp/reflect.cc:565
-msgid "array element not a constant integer"
-msgstr "vektorelementet är inte ett konstant heltal"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr "reflect_constant_array misslyckades"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr "reflect_constant misslyckades"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+msgid "array element not a constant integer"
+msgstr "vektorelementet är inte ett konstant heltal"
+
+#: cp/reflect.cc:1117
 msgid "reflection does not represent a type"
 msgstr "reflektionen representerar inte en typ"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 msgid "reflection does not have template arguments"
 msgstr "reflektionen har inte mallargument"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 msgid "reflection does not represent a function or function type"
 msgstr "reflektionen representerar inte en funktion eller funktionstyp"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr "reflektionen representerar inte en operatorfunktion eller operatorfunktionsmall"
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 msgid "operators argument is not a valid operator"
-msgstr "operatorsargument är inte en giltigt operator"
+msgstr "operatorsargument är inte en giltig operator"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 msgid "reflection does not have a type"
 msgstr "reflektionen har inte en typ"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr "reflektionen representerar inte ett objekt med statisk lagringstid, eller en referens till ett sådant objekt"
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr "reflektionen representerar inte en annotering eller ett giltigt argument till ett splitsningsuttryck"
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr "reflektionen representerar inte en entitet med förälder"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr "reflektionen representerar inte en parameter till den aktuella funktionen"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "reflektionen representerar inte en funktion eller funktionstyp med en returtyp"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr "reflektion av en virtuell direkt basrelation med abstrakt härledd klass"
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr "reflektionen passar inte offset_of"
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr "icke-konstant avstånd för offset_of"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr "reflektionen passar inte size_of"
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr "reflektion med ofullständig typ i size_of"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 msgid "reflection not suitable for alignment_of"
 msgstr "reflektion inte möjlig för alignment_of"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 msgid "alignment_of on function type"
-msgstr "alignement_of på en funktionstyp"
+msgstr "alignment_of på en funktionstyp"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr "reflektion med en ofullständig typ i alignment_of"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr "reflektion passar inte bit_size_of"
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "reflektion med ofullständig typ i bit_size_of"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr "reflektion med has_identifier falskt"
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr "identifier_of kan inte representeras i vanlig bokstavlig kodning"
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr "u8identifier_of kan inte representeras i UTF-8"
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
-msgstr "reflektionen representerar inte en typ, typalias, en variabel, funktion, namnutrymme, uppräknare, direkt basklassrelation eller icke-statisk datamedlem"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr "display_string_of kan inte representeras i vanlig bokstavlig kodning"
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr "u8display_string_of kan inte representeras i UTF-8"
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr "reflektionen representerar inte en typ, typalias, en variabel, funktion, funktionsparameter, namnutrymme, uppräknare, direkt basklassrelation eller icke-statisk datamedlem"
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr "reflektionen representerar inte en fullständig typ eller typalias"
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr "reflect_object misslyckades"
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr "reflect_function misslyckades"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr "värdemedlem saknas"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr "oväntat värde på värdemedlem"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr "typmedlem saknas"
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr "reflektionen representerar inte en fullständig uppräkningstyp"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "reflektionen representerar inte en uppräkningsbar uppräkningstyp"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
-msgstr "reflektionen representerar en icke-heltals eller booleansk typ"
+msgstr "reflektionen representerar en icke-heltals eller boolesk typ"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 msgid "reflection does not represent a template"
 msgstr "reflektionen representerar inte en mall"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 msgid "invalid argument to can_substitute"
 msgstr "ogiltigt argument till can_substitute"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr "can_substitute returnerade falskt"
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 msgid "type is not object or reference type"
 msgstr "typen är inte en objekt- eller referenstyp"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr "konvertering från vanlig bokstavlig kodning till källteckenuppsättning misslyckades"
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "konvertering från kodningen UTF-8 till källteckenuppsättningen misslyckades"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 msgid "name is not a valid identifier"
 msgstr "namnet är inte en giltig identifierare"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr "namnet är ett nyckelord"
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr "namnet är en inbyggd egenskap"
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr "varken namnet eller bit_width angivet"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr "inget namn och icke-tom annotering angiven"
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "bit_width specificerad med en typ som inte är ett heltal eller en uppräkningstyp"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 msgid "both alignment and bit_width specified"
 msgstr "både justering och bit_width angivet"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr "bit_width specificerad med no_unique_address sant"
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
-msgstr "fältbreddsspecificerare<"
+msgstr "bit_width 0 med angivet namn"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr "bit_width är negativt"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr "namnet är ospecificerat och typen är const"
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr "namnet är ospecificerat och typen är volatile"
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr "minnesjusteringen är inte en potens av två"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr "justeringen är negativ"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr "justering är mindre än alignment_of"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+msgid "reflection does not have non-array object type"
+msgstr "reflektionen har inte en objekttyp som inte är en vektor"
+
+#: cp/reflect.cc:6506
+msgid "current scope does not represent a function"
+msgstr "aktuell räckvidd representerar inte en funktion"
+
+#: cp/reflect.cc:6526
+msgid "current scope does not represent a class nor a member function"
+msgstr "aktuell räckvidd representerar inte en klass eller en medemsfunktion"
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr "ofullständig föräldraklass"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr "varken en fullständig klass eller namnrymd"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 msgid "not a complete class type"
 msgstr "inte en fullständig klasstyp"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr "höljestyp (closure)"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 msgid "value cannot be extracted"
 msgstr "värdet kan inte extraheras"
 
@@ -22568,52 +22610,52 @@ msgstr "konvertering konverterar bort konstantskap"
 msgid "source type is not polymorphic"
 msgstr "källtypen är inte polymorfisk"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "kandidater är:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "fel typ på argument till unärt minus"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "fel typ på argument till unärt plus"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "fel typ på argument till bitkomplement"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "fel typ på argument till abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "fel typ på argument till konjunktion"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "i argument till unärt !"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "ingen pre-ökningsoperator för typen"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "ingen post-ökningsoperator för typen"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "ingen pre-minskningsoperator för typen"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "ingen post-minskningsoperator för typen"
 
@@ -22629,59 +22671,59 @@ msgstr " [se %<-fallow-invalid-boz%>]"
 msgid "BOZ constant truncated at %L"
 msgstr "BOZ-konstanten avhuggen vid %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "argument ”a%d” och ”a%d” för inbyggd ”%s”"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "argumenten ”%s” och ”%s” för inbyggd %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "argument ”%s” och ”%s” för inbyggd ”%s”"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 msgid "NULL() is not interoperable"
 msgstr "NULL() är inte en interoperabel"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 msgid "BOZ literal constant"
-msgstr "BOZ-literalkonstant"
+msgstr "BOZ-litteralkonstant"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 msgid "Expression is polymorphic"
 msgstr "Uttrycket är polymorft"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr "Uttrycket är en ej interoperabel härledd typ"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 msgid "Procedure unexpected as argument"
 msgstr "En procedur oväntad som argument"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr "Utvidgning för att använda en icke-C_Bool-sort LOGICAL"
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr "Utvidgning för att använda en icke-C_CHAR-sort CHARACTER"
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr "Typen skall ha en teckenlängd på 1"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr "Co-vektorer är inte interoperabla"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr "Vektorer med antagen storlek är inte interoperabla"
 
@@ -22763,7 +22805,7 @@ msgstr "Borttagen funktion:"
 msgid "Unsigned:"
 msgstr "Teckenlös:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "vektortilldelning"
 
@@ -22772,17 +22814,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr "Indexvariabeln %qs omdefinierad vid %L i proceduren %qs anropad inifrån DO-slinga vid %L"
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr "Felaktig utsträckning i argument B i inbyggd MATMUL i dimension 1: är %ld, skulle vara %ld"
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "Vektorbindning stämmer inte för dimension 1 av vektorn (%ld/%ld)"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "Vektorbindning stämmer inte för dimension 2 av vektorn (%ld/%ld)"
@@ -22958,11 +23000,11 @@ msgstr "block-IF"
 msgid "implied END DO"
 msgstr "implicerat END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "tilldelning"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "pekartilldelning"
 
@@ -22970,125 +23012,125 @@ msgstr "pekartilldelning"
 msgid "simple IF"
 msgstr "enkelt IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "elementär procedur"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "allokerbart argument"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "asynkront argument"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "valfritt argument"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "pekarargument"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "målargument"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "värdeargument"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "volatilt argument"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "argument med antagen form"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "argument med antagen ordning"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "co-vektorargument"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "parametriserat härlett typargument"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "polymorft argument"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "attributet NO_ARG_CHECK"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "argument med antagen typ"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "vektorresultat"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "pekare eller allokerbart resultat"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr "resultat med teckenlängd som inte är konstant"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "bind(c)-procedur"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Slingvariabel"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "iteratorvariabel"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Startuttryck i DO-slinga"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "Slututtryck i DO-slinga"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Steguttryck i DO-slinga"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "DEALLOCATE-objekt"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "ALLOCATE-objekt"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "STAT-variabel"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "ERRMSG-variabel"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "objekt i READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "ACQUIRED_LOCK-variabel"
 
@@ -23097,31 +23139,31 @@ msgstr "ACQUIRED_LOCK-variabel"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Olika CHARACTER-längder (%ld/%ld) i vektorkonstruerare"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "Heltalsspill vid beräkning av mängden minne att allokera"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr "Värdet på PDT LEN-parametern ”%s” stämmer inte överens med det i attrappdeklarationen"
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Aktuell stränglängd matchar inte den deklarerade för attrappargument ”%s” (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Aktuell stränglängd är kortare än den deklarerade för attrappargument ”%s” (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "Målet för återavbildning av ordning är för litet (%ld < %ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Tilldelning av skalär till en oallokerad vektor"
 
@@ -23184,27 +23226,27 @@ msgstr "Argument NCOPIES till inbyggd REPEAT är negativt (dess värde är %ld)"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Argumentet NCOPIES till inbyggd REPEAT är för stort"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "FROMPOS-argumentet (%ld) är utanför intervallet 0:%d i inbyggd MVBITS"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "LEN-argumentet (%ld) är utanför intervallet 0:%d i inbyggd MVBITS"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "TOPOS-argumentet (%ld) är utanför intervallet 0:%d i inbyggd MVBITS"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) i inbyggd MVBITS"
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) i inbyggd MVBITS"
@@ -23301,7 +23343,7 @@ msgid "expected boolean type"
 msgstr "boolesk typ förväntades"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "heltal förväntades"
@@ -23364,7 +23406,7 @@ msgstr "för få argument"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "för många argument"
@@ -23495,7 +23537,7 @@ msgstr "gränssnitt eller pekare till gränssnitt förväntades"
 
 #: go/gofrontend/expressions.cc:18218
 msgid "may only omit types within composite literals of slice, array, or map type"
-msgstr "kan endast utelämna typer med sammanstatta litteraler av typen skiva, vektor eller avbildning"
+msgstr "kan endast utelämna typer med sammansatta litteraler av typen skiva, vektor eller avbildning"
 
 #: go/gofrontend/expressions.cc:18312 go/gofrontend/expressions.cc:18624
 msgid "map composite literal must have keys"
@@ -23503,7 +23545,7 @@ msgstr "avbildning av sammansatta litteraler måste ha nycklar"
 
 #: go/gofrontend/expressions.cc:18657
 msgid "expected struct, slice, array, or map type for composite literal"
-msgstr "en av typerna post, skiva, vektor eller avbildning förväntades för en sammanstatt litteral"
+msgstr "en av typerna post, skiva, vektor eller avbildning förväntades för en sammansatt litteral"
 
 #: go/gofrontend/expressions.cc:19272 go/gofrontend/statements.cc:2121
 msgid "type assertion only valid for interface types"
@@ -23533,7 +23575,7 @@ msgstr "kan inte falla igenom sista fallet i en switch"
 
 #: go/gofrontend/statements.cc:1288
 msgid "cannot use %<_%> as value"
-msgstr "det går inte att %<_%> som ett värde"
+msgstr "kan inte använda %<_%> som ett värde"
 
 #: go/gofrontend/statements.cc:1300 go/gofrontend/statements.cc:2528
 msgid "invalid left hand side of assignment"
@@ -23759,7 +23801,7 @@ msgstr "profileringsstöd för VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "mål-OS:et stödjer inte ojusterade åtkomster"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "profilering är inte implementerat ännu för denna arkitektur"
@@ -24002,13 +24044,13 @@ msgstr "undantaget %qs"
 msgid "Global declarative %s for %s"
 msgstr "Global deklarativ %s för %s"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr "%s:%d: felaktig %<symbol_type_t%> %d"
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr "SET identifierare-11 TO LOKALE"
@@ -24169,12 +24211,12 @@ msgstr "%qs bör undvikas, använd -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs bör undvikas, använd -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "okänd autovektoriserarpreferens %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "okänd LDP/STP-policy %qs"
@@ -24208,6 +24250,7 @@ msgstr "Okänd flagga till byteordervärde: %qs"
 msgid "Unrecognized option to floating-point init value: %qs"
 msgstr "Okänt argument till -floating-point initieringsvärde: %qs"
 
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125348
 #: fortran/lang.opt:702
 #, gcc-internal-format
 msgid "%qs is not an inline-controlable intrinsic"
@@ -24599,8 +24642,8 @@ msgstr "ignorerar attributet %qE eftersom det står i konflikt med attributet %q
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "tidigare deklaration här"
@@ -24617,7 +24660,7 @@ msgstr "attributdirektivet %qE ignorerat"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "attributdirektivet %<%E::%E%> med räckvidd ignorerat"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "fel antal argument angivet för attributet %qE"
@@ -24627,7 +24670,7 @@ msgstr "fel antal argument angivet för attributet %qE"
 msgid "expected %i or more, found %i"
 msgstr "%i eller fler förväntades, hittade %i"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "%i förväntades, %i hittades"
@@ -24710,12 +24753,12 @@ msgstr "typattribut ignoreras efter att typen redan är definierad"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -24831,133 +24874,133 @@ msgstr "autoprofilen innehåller ett ogiltigt symbolnamnsindex %d"
 msgid "auto-profile contains invalid filename index %d"
 msgstr "autoprofilen innehåller ett ogiltigt filnamnsindex %d"
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr "autoprofilen för %q+F innehåller en inline:ad funktion med symbolnamnet %s istället för symbolnamnet %s"
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr "motsvarande anrop"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr "duplicerad antalsinformation i autoprofilen för %q+F med relativ plats %i diskriminator %i"
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr "motsvarande källplats"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr "duplicerad anropsplats i autoprofilen för %q+F med relativ plats %i, diskriminator %i"
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr "information om både anropsmål och inline:ad anropsplats finns i autoprofilen för funktionen %q+F med relativ plats %i, diskriminator %i"
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr "autoprofilen för %q+F verkar innehålla förlorad diskriminator %i för anrop av %s på relativ plats %i"
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr "autoprofilen för %q+F innehåller flera mål för ett direkt anrop med relativ plats %i, diskriminator %i"
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr "funktionen innehåller två anrop med samma relativa plats +%i, diskriminator %i, som leder till förlorad autoprofil"
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr "platsen för det första anropet"
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr "platsen för den det andra anropet"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
-msgstr "autoprofilen för %q+F innehåller indirekta anropmål som inte är associerade med en indirekt anropssats"
+msgstr "autoprofilen för %q+F innehåller indirekta anropsmål som inte är associerade med en indirekt anropssats"
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr "räknare %<PRIu64> med relativ plats +%i, diskriminator %i"
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr "autoprofilen för %q+F innehåller extra satser"
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, gcc-internal-format
 msgid "location is after end of function"
 msgstr "platsen är efter slutet på funktion"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr "auto-profilen för %q+F innehåller extra anropsplatser"
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr "anrop av %s med totalt antal %<PRId64>, relativ plats +%i, diskriminator %i"
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "Ej förväntades TAGG."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr "auto-profilen innehåller en duplicerad funktionsinstans %s"
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "kan inte öppna profileringsfilen %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr "AutoFDO-profilens magiska tal stämmer inte"
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "AutoFDO-profilens version %u stämmer inte med %u"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "det går inte att läsa sammanfattningsinformationen från %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "det går inte att läsa strängtabellen från %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "det går inte att läsa profilen från %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "det går inte att läsa modulprofilen från %s"
@@ -24967,7 +25010,7 @@ msgstr "det går inte att läsa modulprofilen från %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "index %qwi till en konstant sträng pekar utanför dess gränser"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qE är deklarerad här"
@@ -25070,7 +25113,7 @@ msgstr "icke-konstant argument 0 till %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "otillåtet argument 0 till %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, gcc-internal-format
 msgid "third argument to %<crc%> builtins must be a constant"
 msgstr "tredje argumentet till inbyggd %<crc%> måste vara en konstant"
@@ -25144,12 +25187,12 @@ msgstr "sista argumentet till %qD är inte en heltalskonstant mellan 0 och 3"
 msgid "cannot tail-call: %s"
 msgstr "kan inte göra svansanrop: %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "funktionsanrop har sammansatt värde"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "skickar för många argument på stacken"
@@ -25792,342 +25835,342 @@ msgstr "grundblock inte utlagda i ordning"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "antal gb-noter i instruktionskedjan (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "antal anropande bågar är felaktigt"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr "saknat indirekt anrop i en spekulativ anropssekvens"
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr "indirekt anrop i en spekulativ anropssekvens har ingen spekulativ flagga"
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr "spekulativa bågar är inte närliggande"
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr "direkt anrop av %s i en spekulativ anropssekvens har ingen spekulativ flagga"
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr "direkt anrop av %s i en spekulativ anropssekvens har speculative_id %i utanför intervallet"
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr "dubblerat direkt anrop av %s i en spekulativ anropssekvens med speculative_id %i"
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr "call stmt-hashen pekar inte på den första direkta bågen av en spekulativ anropssekvens"
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr "dubblerad referens %s i en spekulativ anropssekvens med speculative_id %i"
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "saknade direkta anrop för spekulation %i"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "referens saknas för spekulation %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr "antalet spekulativa mål %i stämmer inte med num_speculative_call_targets %i"
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "aux-fält satt för båge %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr "cgraph-antalet är felaktigt"
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "inline-klon i samma comdat-grupplista"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "inline-klonantal är inte kompatibelt"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "tp_first_run måste vara icke-negativt"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "lokala symboler måste vara definierade"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "externt synlig inline-klon"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "inline-klon som man tar adressen till"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "inline-klon tvingas till utdata"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr "inline-klon refereras av assemblern"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr "calls_comdat_local är satt utanför någon comdat-grupp"
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr "felaktig flagga till calls_comdat_local"
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "attributet malloc skall användas på en funktion som returnerar en pekare"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr "semantisk interposition stämmer inte"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "aux-fält satt för indirekt båge från %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "bågräknaren är inte kompatibel med funktionsräknaren"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "bågräknaren är inte kompatibel med inline:ad funktionsräknare"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "En indirektbåge från %s är inte markerad som indirekt eller har associerad indirect_info, motsvarande sats är: "
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr "bågen har både call_stmt och lto_stmt_uid satta"
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr "comdat-lokal funktion anropad av %s utanför dess comdat"
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "inlined_to-pekare är fel"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "flera inline-anropare"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "inlined_to-pekare angiven för noninline-anropare"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "anropsbågantal stämmer inte med GB-antal"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "indirekta anropsantal stämmer inte med GB-antal"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr "referensen har både stmt och lto_stmt_uid satta"
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "inlined_to-pekare är angivet men inga företrädare finns"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "inlined_to-pekare refererar till sig själv"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "cgraph_node har fel clone_of"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "cgraph_node har fel klonlista"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "cgraph_node är i klonlistan men den är inte en klon"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "cgraph_node har fel prev_clone-pekare"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "dubbellänkad lista av kloner trasig"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "Alias har anropsbågar"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "Alias har icke-alias-referens"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "Alias har mer än en aliasreferens"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "Analyserat alias har ingen referens"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "Ingen båge ut från snuttnod"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "Mer än en båge ut från en snuttnod"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "Snuttar får inte ha en kropp"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "delat anropssats:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "bågpekare till fel deklaration:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "ett indirekt båge med okänd anropsmål motsvarande ett call_stmt med en känd deklaration:"
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "anropsgrafsbåge saknas för anropssats:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "referens till död sats"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr "en båge som inte är ett återanrop har callback_id satt"
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr "bågen har både callback och has_callback satta"
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
-msgstr "återanopsbågen %s→%s har ingen återanropsbärare"
+msgstr "återanropsbågen %s→%s har ingen återanropsbärare"
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr "återanropsbågen %s→%s har räknare för återanropsbåge som inte stämmer, förväntade högst %d, hittade %d"
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr "återanropsbärande bågen pekar mot __builtin_unreachable, men dess återanropsbåge %s → %s gör inte det"
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "båge %s->%s har ingen motsvarande anropssats"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "en indirekt båge från %s har inget motsvarande call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr "ursprung saktas för en nod i en nästad lista"
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "ursprunget pekar på en annan förälder"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node misslyckades"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "%s: sektion %s.%d saknas"
@@ -26225,17 +26268,17 @@ msgstr "%qD är definierad men inte använd"
 #: cgraphunit.cc:1508
 #, gcc-internal-format
 msgid "%<ifunc%> resolver for %qD must return %qT"
-msgstr "%<ifunc%>-upplösning för %qD måste returnera %qT"
+msgstr "%<ifunc%>-uppslagning för %qD måste returnera %qT"
 
 #: cgraphunit.cc:1511 cgraphunit.cc:1534
 #, gcc-internal-format
 msgid "resolver indirect function declared here"
-msgstr "upplösning av indirekt funktion deklarerad här"
+msgstr "uppslagning av indirekt funktion deklarerad här"
 
 #: cgraphunit.cc:1531
 #, gcc-internal-format
 msgid "%<ifunc%> resolver for %qD should return %qT"
-msgstr "%<ifunc%>-upplösning för %qD skall returnera %qT"
+msgstr "f%<ifunc%>-uppslagning för %qD skall returnera %qT"
 
 #: cgraphunit.cc:1541
 #, gcc-internal-format
@@ -26891,17 +26934,17 @@ msgstr "total storlek på lokala objekt överskrider maximum %wu"
 msgid "impossible constraint in %<asm%>"
 msgstr "omöjlig begränsning i %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "variabeln %q+D kan skrivas över av %<longjmp%> eller %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "argumentet %q+D kan skrivas över av %<longjmp%> eller %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "funktionen returnerar ett aggregat"
@@ -27570,7 +27613,7 @@ msgstr "%qD angiven gräns %E är lika med källängden"
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "flexibel vektormedlem %qD har inte väldefinierade utfyllnadsbitar för %qs"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr "PDP11-bitfältshantering stödjs inte i %qs"
@@ -27610,7 +27653,7 @@ msgstr "%qD har fler än %u block, det begärda maximumet för %<-fharden-contro
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr "en referens till etiketten %qD definierad inuti attribututtrycket %<assume%> från utsidan av attributet"
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr "%qD definierades här"
@@ -27630,24 +27673,24 @@ msgstr "nollpekardereferens"
 msgid "function may return address of local variable"
 msgstr "funktionen kan returnera adressen till en lokal variabel"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "funktionen returnerar adress till en lokal variabel"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -28537,7 +28580,7 @@ msgstr "förväntar sig mellan %E och %E byte i en region av storlek %E"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr "%qD anropad på pekaren %qE med nollskilt avstånd%s"
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr "returnerad från %qD"
@@ -28607,204 +28650,204 @@ msgstr "i ett anrop av allokeringsfunktionen %qD deklarerad här"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "okänd arkitekturspecificerare i minnesmodell %wi för %qD"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "ogiltig minnesmodell %qs för %qD"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "ogiltig minnesmodell %wi för %qD"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 msgid "valid models are %e"
 msgstr "giltiga modeller är %e"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "ogiltig felminnesmodell %qs för %qD"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "giltiga felmodeller är: %qs, %qs, %qs, %qs"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "felminnesmodell %qs kan inte vara starkare än lyckad minnesmodell %qs för %qD"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "felminnesmodell %wi kan inte vara starkare än lyckad minnesmodell %wi för %qD"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "värdet %2$s på det bundna argumentet %1$i är negativt för ett vektorargument %3$i av typ %4$s med variabel längd"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "argument %i:s värde %s är negativt"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr "argument %i är null men värdet på det motsvarande storleksargumentet %i är %s"
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "refererar argument %u av typ %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "i ett anrop till funktionen %qD deklarerad med attributet %qs"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "i ett anrop med typen %qT och attributet %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "i ett anrop till funktionen %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "i ett anrop med typen %qT"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr "%qD anropat på ett oallokerat objekt %qD"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr "%qD anropat på en pekare till ett oallokerat objekt %qE"
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr "tilldelad här"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD anropad på en pekare returnerad från en allokeringsfunktion som inte stämmer"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr "%qD anropad på en pekare till ett oallokerat objekt"
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "pekaren %qE kan användas efter %qD"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "pekaren %qE används efter %qD"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr "pekaren kan användas efter %qD"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "pekaren använd efter %qD"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, gcc-internal-format
 msgid "call to %qD here"
 msgstr "anrop av %qD här"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr "hängande pekare %qE till %qD kan användas"
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr "använder den hängande pekaren %qE till %qD"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "hängande pekare till %qD kan användas"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr "använder en hängande pekare till %qD"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD är deklarerad här"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr "hängande pekare %qE till namnlös temporär kan användas"
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr "använder en hängande pekare %qE till en namnlös temporär"
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr "hängande pekare till en namnlös temporär kan användas"
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "använder en hängande pekare till en namnlös temporär"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "den namnlösa temporären är definierad här"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "%qD anropad på pekaren %qE som skickas till en allokeringsfunktion som inte stämmer %qD"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "%qD anropad på en pekare skickad till en omallokeringsfunktion som inte stämmer %qD"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr "anrop till %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "lagrar adressen till den lokala variabeln %qD i %qE"
@@ -29121,7 +29164,7 @@ msgstr "attributet %<fallthrough%> föregår inte en case-etikett eller standard
 #: gimplify.cc:4024
 #, gcc-internal-format
 msgid "the %<device%> clause must be present if the %<interop%> clause has more than one list item"
-msgstr "%<device%>-klausulen måste finnas om %<interop%>-klausulen hare mer än ett listelement"
+msgstr "%<device%>-klausulen måste finnas om %<interop%>-klausulen har mer än ett listelement"
 
 #: gimplify.cc:4030
 #, gcc-internal-format
@@ -29323,7 +29366,7 @@ msgstr "baspekarcykel detekterad"
 #: gimplify.cc:12053
 #, gcc-internal-format
 msgid "data movement for component %qE is not compatible with movement for struct %qE"
-msgstr "dataförflyttning för komponent %qE är inte kompatiblel med förflyttning för posten %qE"
+msgstr "dataförflyttning för komponent %qE är inte kompatibel med förflyttning för posten %qE"
 
 #: gimplify.cc:12369
 #, gcc-internal-format
@@ -29607,346 +29650,346 @@ msgstr "symbol %u har %<y-location == %llu%>"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "ogiltig användning av attributet %<fallthrough%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "den virtuella tabellen för typen %qD bryter mot endefinitionsregeln"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "en variabel med samma assemblernamn som den virtuella tabellen är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "den virtuella tabellen för typen %qD innehåller RTTI-information"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr "men övertrumfas av en utan från en annan översättningsenhet"
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "RTTI kommer inte att fungera för denna typ"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "typen som står i konflikt och är definierad i en annan översättningsenhet har en virtuell tabell med annan storlek"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "typen som står i konflikt och är definierad i en annan översättningsenhet med annan RTTI-information"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "typen som står i konflikt är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "innehåller den ytterligare virtuella metoden %qD"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "typen som står i konflikt är definierad i en annan översättningsenhet och har en virtuell tabell med fler poster"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "virtuell metod %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr "borde matcha den virtuella metoden %qD men gör det inte"
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "typen som står i konflikt är definierad i en annan översättningsenhet och har en virtuell tabell med annat innehåll"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "typen %qT (typedef av %qT) bryter mot C++ endefinitionsregel"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "typen %qT bryter mot C++ endefinitionsregel"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "en annan typ är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr "den första skillnaden mellan motsvarande definitioner är fältet %qD"
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr "den första skillnaden mellan motsvarande definitioner är metoden %qD"
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "typen %qT definierad i en anonym namnrymd kan inte matcha typen %qT över gränsen för översättningsenheten"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "typen %qT definierad i en anonym namnrymd kan inte matcha över gränsen för översättningsenheten"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "den inkompatibla typen definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "typnamnet %qs skall matcha typnamnet %qs"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "den inkompatibla typen är definierad här"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "vektortyper har olika gränser"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "returvärdets typ stämmer inte"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "typen på implicit this-pekare stämmer inte"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "typer stämmer inte i parameter %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "typer har olika parameterantal"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "typen %qT själv bryter mot C++ endefinitionsregel"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "typen %qT borde matcha typen %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "en typ med annan precision är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "en vektortyp med ett annat antal element är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "en typ med annan teckenhet är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "den är definierad som en pekare i en annan adressrymd i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "den är definierad som en pekare till en annan typ i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "en vektor med annan storlek är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "har ett annat returvärde i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "har andra parametrar i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "en typ definierad i en annan översättningsenhet är inte polymorf"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "en typ definierad i en annan översättningsenhet är polymorf"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "en typ med en annan virtuell tabellpekare är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "en typ med andra baser är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "ett fält med ett annat namn är definierat i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "ett fält med samma namn men annan typ är definierat i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "fält har en annan layout i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr "ett fält är ett bitfält medan det andra inte är det"
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "en typ med ett annat antal fält är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "en typ med en annan storlek är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr "en typ behöver konstrueras medan den andra inte behöver det"
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "minneslayouten stämmer inte"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "den andra basen är definierad här"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] "Deklaration av typen %qD final skulle möjliggöra avvirtualisering av %i anrop"
 msgstr[1] "Deklaration av typen %qD final skulle möjliggöra avvirtualisering av %i anrop"
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
-msgstr[0] "Deklaration av typen %qD final skulle möjliggöra avvirtualisering av %i anrop utförda %lli gånger"
+msgstr[0] "Deklaration av typen %qD final skulle möjliggöra avvirtualisering av %i anrop utfört %lli gånger"
 msgstr[1] "Deklaration av typen %qD final skulle möjliggöra avvirtualisering av %i anrop utförda %lli gånger"
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] "Deklaration av den virtuella destrueraren %qD final skulle möjliggöra avvirtualisering av %i anrop"
 msgstr[1] "Deklaration av den virtuella destrueraren %qD final skulle möjliggöra avvirtualisering av %i anrop"
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] "Deklaration av metoden %qD final skulle möjliggöra avvirtualisering av %i anrop"
 msgstr[1] "Deklaration av metoden %qD final skulle möjliggöra avvirtualisering av %i anrop"
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Deklaration av den virtuella destrueraren %qD final skulle möjliggöra avvirtualisering av %i anrop utfört %lli gånger"
 msgstr[1] "Deklaration av den virtuella destrueraren %qD final skulle möjliggöra avvirtualisering av %i anrop utförda %lli gånger"
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] "Deklaration av metoden %qD final skulle möjliggöra avvirtualisering av %i anrop utfört %lli gånger"
 msgstr[1] "Deklaration av metoden %qD final skulle möjliggöra avvirtualisering av %i anrop utförda %lli gånger"
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "typen %qs bryter mot C++ endefinitionsregel"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "en uppräkningstyp med ett annat antal värden är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "en uppräkningstyp med andra värdenamn definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "en uppräkningstyp med andra värden är definierad i en annan översättningsenhet"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "namnet %qs skiljer från namnet %qs som är definierat i en annan översättningsenhet"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "namnet %qs är definierat som %u-bitars medan en annan översättningsenhet definierar det som %u-bitars"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "namnet %qs är definierat till %wd medan en annan översättningsenhet definierar det som %wd"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "namnet %qs är definierat till ett annat värde i en annan översättningsenhet"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr "definitionen stämmer inte överens"
@@ -29966,7 +30009,7 @@ msgstr "ipa-inline-sammanfattning saknas i indatafil"
 msgid "IPA modref summary is missing in input file"
 msgstr "IPA modref-sammanfattning saknas i indatafilen"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "ogiltig hoppfunktion i LTO-ström"
@@ -30044,7 +30087,7 @@ msgstr "%qD är inte berättigat till %<strub%> på grund av att %<-fsplit-stack
 #: ipa-strub.cc:702
 #, gcc-internal-format
 msgid "%qD is not eligible for %<strub%> because of attribute %<noipa%>"
-msgstr "%qD är inte berättigat till %<strub%> på grund av attriutet %<noipa%>"
+msgstr "%qD är inte berättigat till %<strub%> på grund av attributet %<noipa%>"
 
 #: ipa-strub.cc:717
 #, gcc-internal-format
@@ -30069,7 +30112,7 @@ msgstr "%qD är inte berättigat till internt %<strub%> på grund av att det inn
 #: ipa-strub.cc:902
 #, gcc-internal-format
 msgid "%qD is not eligible for internal %<strub%> because the address of a local label escapes"
-msgstr "%qD är inte berättigat till internt %<strub%> på grund av att det är adressen till en lokal etikett smiter"
+msgstr "%qD är inte berättigat till internt %<strub%> på grund av att adressen till en lokal etikett smiter"
 
 #: ipa-strub.cc:941
 #, gcc-internal-format
@@ -30144,7 +30187,7 @@ msgstr "ramstorlek för stor för pålitlig stackkontroll"
 #: json-parsing.cc:1085
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum nesting depth exceeded: %i"
-msgstr "maximalt nästningsdjup överskridet %i"
+msgstr "maximalt nästningsdjup överskridet: %i"
 
 #: json-parsing.cc:1145
 #, gcc-internal-format, gfc-internal-format
@@ -30196,12 +30239,12 @@ msgstr "maximalt antal LRA-tilldelningspass uppnått (%d)"
 msgid "unable to find a register to spill"
 msgstr "kan inte hitta ett register att spilla"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "inkonsistenta operandbegränsningar i en %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "maximalt antal genererade omladdningsinstruktioner per instruktion uppnått (%d)"
@@ -30568,7 +30611,7 @@ msgstr "%qs-klausul med %<sink%>-modifierare väntar på en lexikalt senare iter
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "%qs-klausul med %<sink%>-modifierare refererar till en iteration som aldrig är i iterationsrymden"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr "felaktig OpenMP ickerektangulärt slingsteg; %<(%E - %E) * %E%> är inte en multipel av slinga %d steg %qE"
@@ -30786,7 +30829,7 @@ msgstr "endast %<distribute%>- %<parallel%>-, eller %<loop%>-regioner tillåts v
 #: omp-low.cc:3352
 #, gcc-internal-format
 msgid "OpenMP constructs other than %<parallel%>, %<loop%> or %<simd%> may not be nested inside a %<loop%> region"
-msgstr "OpenMP-konstruktioner andra än %<parallel%>, %<loop%> eller %<simd%> får inte inneslutna i en %<loop%>-region"
+msgstr "OpenMP-konstruktioner andra än %<parallel%>, %<loop%> eller %<simd%> får inte vara inneslutna i en %<loop%>-region"
 
 #: omp-low.cc:3372
 #, gcc-internal-format
@@ -30866,7 +30909,7 @@ msgstr "ogiltig beroendesort i omp %<ordered%> %<depend%>"
 #: omp-low.cc:3727
 #, gcc-internal-format
 msgid "%<ordered%> construct with %<depend%> clause must be closely nested inside an %<ordered%> loop"
-msgstr "en %<ordered%> konstruktion med %<depend%>-klausul måste vara nära innesluten inuti en %<ordered%>-slinga"
+msgstr "en %<ordered%>-konstruktion med %<depend%>-klausul måste vara nära innesluten inuti en %<ordered%>-slinga"
 
 #: omp-low.cc:3743
 #, gcc-internal-format
@@ -30881,17 +30924,17 @@ msgstr "en %<ordered%> region får inte vara nära innesluten inuti en %<critica
 #: omp-low.cc:3769 omp-low.cc:3814
 #, gcc-internal-format
 msgid "%<ordered%> region must be closely nested inside a loop region with an %<ordered%> clause"
-msgstr "en %<ordered%> region måste vara nära innesluten inuti en slingaregion med en %<ordered%>-klausul"
+msgstr "en %<ordered%> region måste vara nära innesluten inuti en slingregion med en %<ordered%>-klausul"
 
 #: omp-low.cc:3778
 #, gcc-internal-format
 msgid "%<ordered%> construct without %<doacross%> or %<depend%> clauses must not have the same binding region as %<ordered%> construct with those clauses"
-msgstr "en %<ordered%>-konstruktion utan %<doacross%>- eller %<depend%>-klausuler får inte ha samma bindningsregion som en en %<ordered%>-konstruktion med dessa klausuler"
+msgstr "en %<ordered%>-konstruktion utan %<doacross%>- eller %<depend%>-klausuler får inte ha samma bindningsregion som en %<ordered%>-konstruktion med dessa klausuler"
 
 #: omp-low.cc:3797
 #, gcc-internal-format
 msgid "%<ordered%> construct without %<doacross%> or %<depend%> clauses binds to loop where %<collapse%> argument %wd is different from %<ordered%> argument %wd"
-msgstr "en %<ordered%> konstruktion utan %<doacross%>- eller %<depend%>-klausuler binder till en sligna där %<collapse%>-argument %wd skiljer från %<ordered%>-argument %wd"
+msgstr "en %<ordered%> konstruktion utan %<doacross%>- eller %<depend%>-klausuler binder till en slinga där %<collapse%>-argument %wd skiljer från %<ordered%>-argument %wd"
 
 #: omp-low.cc:3831
 #, gcc-internal-format
@@ -31955,22 +31998,22 @@ msgstr "explicit använda register måste vara grupperade i toppen på stacken"
 msgid "output operand %d must use %<&%> constraint"
 msgstr "utdataoperand %d måste använda %<&%>-begränsning"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "%qs: [%u] felaktigt %<next_regno%> för tom kedja (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "%qs: slinga i %<next_regno%>-kedja (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "%qs: [%u] felaktigt %<oldest_regno%> (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr "%qs: [%u] ej tomt register i kedja (%s %u %i)"
@@ -32245,7 +32288,7 @@ msgstr "flera indata till hårdregistret: %s"
 #: stmt.cc:680
 #, gcc-internal-format
 msgid "hard register constraint for input %i conflicts with %<asm%> clobber list"
-msgstr "hård registerbegränsning för indata %i står i konflikt med %<asm%> överskrivningslista"
+msgstr "hård registerbegränsning för indata %i står i konflikt med %<asm%>-överskrivningslista"
 
 #: stmt.cc:699
 #, gcc-internal-format
@@ -32755,7 +32798,7 @@ msgstr "%<-fstack-clash-protection%> stödjs inte på mål där stacken växer f
 #: toplev.cc:1667
 #, gcc-internal-format
 msgid "%<-fstack-clash-protection%> is not enabled by %<-fhardened%> because %<-fstack-check%> was specified on the command line"
-msgstr "%<-fstack-clash-protection%> aktiveras inte av %<-fhardened%> eftersom %<-fstack-check%> specificerades på"
+msgstr "%<-fstack-clash-protection%> aktiveras inte av %<-fhardened%> eftersom %<-fstack-check%> specificerades på kommandoraden"
 
 #: toplev.cc:1677
 #, gcc-internal-format
@@ -32907,167 +32950,167 @@ msgstr "yttre transaktion i %<transaction_safe%>-funktion"
 msgid "ignoring loop annotation"
 msgstr "ignorerar slingannotering"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "konstant inte omräknad när %<ADDR_EXPR%> ändrades"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "sidoeffekter inte omräknade när %<ADDR_EXPR%> ändrades"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "adress tagen, men %<TREE_ADDRESSABLE%>-biten är inte satt"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "icke skalär %qs"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "ogiltig position eller storleksoperand till %qs"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr "precisionen på typen på heltalsresultatet stämmer inte med fältstorleken på %qs"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "lägesstorleken på resultat av icke-heltalstyp stämmer inte med fältstorleken på %qs"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "%qs av icke-läges-precisionsoperand"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "position plus storlek överskrider storleken på det refererade objektet i %qs"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "typfel i %qs-referens"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "konvertering av %qs på vänster sida av %qs"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "konvertering av register till en annan storlek i %qs"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr "icke-toppnivås %qs"
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "ogiltig operand till %qs"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "typer stämmer inte i %qs"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "ogiltig %qs-avståndsoperator"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "ogiltig adressoperand i %qs"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "ogiltig avståndsoperand i %qs"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "felaktig klick i %qs"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr "%qs i gimple IL"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr "%qs använt som bas där ett icke-register krävs"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "ogiltigt uttryck som min-l-värde"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "gimple-anrop har två mål"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "gimple-anrop har inget mål"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "ogiltig funktion i gimple-anrop"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "icke-funktion i gimple-anrop"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "ogiltigt pure-const-tillstånd för funktion"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "ogiltig vänstersida i gimple-anrop"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr "LHS i %<noreturn%>-anrop"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "ogiltig konvertering i gimple-anrop"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "ogiltig statisk kedja i gimple-anrop"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "statisk kedja med funktion som inte använder en"
@@ -33078,597 +33121,597 @@ msgstr "statisk kedja med funktion som inte använder en"
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_unreachable%> eller %<__builtin_trap%> anropad med argument"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr "%<DEFERRED_INIT%>-anrop skall ha samma konstanta storlek på det första argumentet och LHS"
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "ogiltigt argument till gimple-anrop"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "ogiltiga operander i gimple-jämförelse"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "typen på operander i jämförelse stämmer inte överens"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "ej stödd operation eller typ för vektorjämförelse som returnerar en boolean"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "icke-vektoroperander i vektorjämförelse"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "ogiltig resultattyp i vektorjämförelse"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "felaktig resultattyp i jämförelse"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "icke-register som vänstersida av unär operation"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "ogiltig operand i unär operation"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "ogiltiga vektortyper i nop-konvertering"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "ogiltiga typer i nop-konvertering"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "ogiltiga typer adressrymdskonvertering"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "ogiltiga typer i fixdecimalskonvertering"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "ogiltiga typer i konvertering till flyttal"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "ogiltiga typer i konvertering till heltal"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "typer stämmer inte i %qs-uttryck"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "ogiltiga typer för %qs"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr "%qs skall vara från en skalär till en liknande vektor"
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "ogiltig typ för %qs"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "icketrivial konvertering i unär operation"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "ej register som vänstersida av binär operation"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "ogiltiga operander binär operation"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "ogiltiga operander som inte är vektor till %qs"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "ogiltiga (pekar)operander %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "vektortyper förväntades i %qs"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "typfel i binärt uttryck"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "icke-register som vänstersida av treställig operation"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "ogiltiga operander treställig operation"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr "första argumentet till en %qs måste vara av boolesk vektortyp med samma antal element som resultatet"
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "vektortyper förväntades i %qs"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "vektorer med olika elementantal funna i %qs"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "ogiltig masktyp i %qs"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "otillåten typkombination i %qs"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "ogiltig position eller storlek i %qs"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "%qs in i icke-läges-precisionsoperand"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "insättning utanför intervallet i %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%qs inte på elementgräns"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "icketrivial konvertering i %qs"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "felaktig vänstersida (%qs) för tilldelningen:  %qs"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "%qs vänstersida i clobber-sats"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "%qs vänstersida i tilldelningssats"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "ogiltig operand till %qs"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "ogiltigt storleksargument till %qs i laddning"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "ogiltig högersida för gimple-minneslagring: %qs"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr "icke-register som vänstersida med vektorkonstruerare"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "felaktig typ av vektor-%qs-element"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "felaktigt antal vektor-%qs-element"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "felaktig typ av vektor-CONSTRUCTOR-element"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr "vektor-%qs med elementindex som inte är NULL"
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "vektor-%qs-element är inte ett GIMPLE-värde"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "%qs för annat än en vektor med element"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "icke-temporal lagringsvänstersida kan inte vare ett gimple-register"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "ogiltig operand i retursats"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "ogiltig konvertering i retursats"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "goto-destination är varken en etikett eller en pekare"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "ogiltig operand till switch-sats"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "annat än heltalstyp i en switch-sats"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "ogiltig standardfallsetikett i en switch-sats"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "ogiltig %<CASE_CHAIN%>"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "ogiltig case-etikett i en switch-sats"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "ogiltigt case-intervall i en switch-sats"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "typprecision stämmer inte i en switch-sats"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "typer stämmer inte för case-etikett i en switch-sats"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "case-etiketter är inte sorterade i en switch-sats"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "etikettens kontext är inte den aktuella funktionsdeklarationen"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "felaktig post i %<label_to_block_map%>"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "felaktig inställning av nummer på landningsplatta"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "ogiltig jämförelsekod i gimple-villkor"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "ogiltig etikett i gimple-villkor"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr "gimple cond-villkor kan inte kasta"
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "ogiltigt %<PHI%>-resultat"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "%<PHI%>-definition saknas"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "ogiltigt %<PHI%>-argument"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "inkompatibla typer i %<PHI%>-argument %u"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "%<verify_gimple%> misslyckades"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "död sats i EH-tabell"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr "platsreferensblock som inte är i blockträd"
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "lokal deklaration från en annan funktion"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) är satt till ett felaktigt grundblock"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr "PHI-nod med plats"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "felaktig delning av trädnoder"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "virtuell PHI med argumentplatser"
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (sats) är satt till ett felaktigt grundblock"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "sats markerad för att kasta, men gör inte det"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "sats markerad för att kasta i mitten av block"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple misslyckades"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK har IL associerat med sig"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK har IL associerat med sig"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "fall igenom till utgång från gb %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr "ingångsblockantal inte initierat"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr "utgångsblockantal inte initierat"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr "sannolikheten för bågen från ingångsblocket är inte initierad"
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "utgångsblocksräknaren är inte kompatibel med  ingångsblocksräknaren"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr "antal gb %d inte initierat"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr "sannolikheten för bågen %d→%d inte initierad"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "antalet gb %d är inte kompatibelt med ingångsblocksräknaren"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr "den ej lokala etiketten %qD är inte den första i en sekvens av etiketter för gb %d"
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr "EH-landningsplatteetiketten %qD är inte den första i en sekvens av etiketter för gb %d"
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "etiketten %qD till block stämmer inte i gb %d"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "etiketten %qD har ofullständig kontext i gb %d"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "flödesstyrning mitt i grundblock %d"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr "etiketten %qD mitt i grundblock %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr "anropet av returns_twice är inte sist i grundblock %d"
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr "anropet av returns_twice är inte först i grundblock %d"
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "fall igenom-båge efter styrsats i gb %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "sant/falskt-båge efter en icke-GIMPLE_COND i gb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "felaktiga utgående bågflaggor vid slutet av gb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "uttrycklig goto vid slutet av gb %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "returbåge pekar inte på utgång i gb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "hittade standardfall som inte var vid början av case-vektor"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "case-etiketter är inte sorterade: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "extra utgående båge %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "båge saknas %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%>-funktion returnerar"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "flödet når slutet på en icke-void-funktion"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "ignorerar returvärdet av %qD, deklarerad med attributet %<warn_unused_result%>"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "ignorerar returvärdet av funktion deklarerad med attributet %<warn_unused_result%>"
@@ -33848,12 +33891,12 @@ msgstr "målet stödjer inte helt atomär profiluppdatering, enkelläge valt med
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "målet stödjer inte atomär profiluppdatering, enkelläge valt"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "ogiltigt fn-specifikationsattribut ”%s”"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "ogiltigt fn-specifikationsattribut ”%s” arg %i"
@@ -34362,7 +34405,7 @@ msgstr "vektorvillkor kommer expanderas bitvis"
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "vektorblandningsoperationen kommer expanderas bitvis"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr "vektorisering hände inte för en simd-slinga"
@@ -34660,7 +34703,7 @@ msgstr "%<TYPE_MODE%> av %<TYPE_CANONICAL%> är inte kompatibla"
 #: tree.cc:14495
 #, gcc-internal-format
 msgid "main variant of %<TYPE_CANONICAL%> of main variant is not its own %<TYPE_CANONICAL%>"
-msgstr "huvudvarianten av %<TYPE_CANONICAL%> av huvudvarianten är inte en sin egen %<TYPE_CANONICAL%>"
+msgstr "huvudvarianten av %<TYPE_CANONICAL%> av huvudvarianten är inte sin egen %<TYPE_CANONICAL%>"
 
 #: tree.cc:14513
 #, gcc-internal-format
@@ -34782,28 +34825,28 @@ msgstr "%<TYPE_CACHED_VALUES_P%> är satt när det inte skulle vara det"
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "%<TYPE_METHOD_BASETYPE%> är inte en huvudvariant"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "saknat attribut %<target%> för flerversioners %qD"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "tidigare deklaration av %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%qD står i konflikt med överlappande %<target_clone%>-deklaration"
 
-#: tree.cc:15804
+#: tree.cc:15824
 msgid "%qD conflicts for version %qB"
 msgstr "%qD står i konflikt med versionen %qB"
 
-#: tree.cc:15817
+#: tree.cc:15837
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "%qD står i konflikt med tidigare deklaration för version %qB"
 
@@ -34877,7 +34920,7 @@ msgstr "endast nollinitierare är tillåtna i sektionen %qs"
 msgid "no initializers are allowed in section %qs"
 msgstr "inga initierare är tillåtna i sektionen %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "inget registernamn angivet för %q+D"
@@ -35022,7 +35065,7 @@ msgstr "%qs-symbolen %q+D är ytterst sitt eget mål"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "%qs-symbolen %q+D måste ha statisk länkklass"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "aliasdefinitioner stödjs inte i denna konfiguration"
@@ -35067,53 +35110,53 @@ msgstr "packad layout"
 msgid "cannot tail-call: return value must be a call"
 msgstr "kan inte svansanropa: returvärdet måste vara ett anrop"
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "argumentet till attributet %qE är ogiltigt"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "argument %2$i till attributet %1$qE är ogiltigt"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "argumentet till attributet %qE har typen %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "argument %2$i till attributet %1$qE har typen %3$qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "värdet %2$qE på attributet %1$qE är inte en heltalskonstant"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "värdet %3$qE på argument %2$i till attributet %1$qE är inte en heltalskonstant"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "värdet %2$qE till attributet %1$qE refererar inte till en funktionsparameter"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "värdet %3$qE på argument %2$i till attributet %1$qE refererar inte till en funktionsparameter"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "värdet %2$qE på argumentet till attributet %1$qE överskrider antalet funktionsparametrar %3$u"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "värdet %3$qE på argument %2$i till attributet %1$qE överskrider antalet funktionsparametrar %4$u"
@@ -35128,12 +35171,12 @@ msgstr "värdet %2$qE på argumentet till attributet %1$qE refererar inte till e
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "värdet %3$qE på argument %2$i till attributet %1$qE refererar inte till en variabelargumentlista"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "värdet %2$qE på argumentet till attributet %1$qE refererar till parametertypen %3$qT"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "värdet %3$qE på argumentet %2$i till attributet %1$qE refererar till parametertypen %4$qT"
@@ -35340,12 +35383,12 @@ msgstr "kan inte använda läge %qs för uppräkningstyper"
 msgid "mode %qs applied to inappropriate type"
 msgstr "läge %qs applicerat på olämplig typ"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "attributet ”section” stödjs inte för denna målarkitektur"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "attributet ”section” är inte tillåten för %q+D"
@@ -35355,18 +35398,18 @@ msgstr "attributet ”section” är inte tillåten för %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "argument till sektionsattributet är inte en strängkonstant"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "attributet ”section” kan inte anges för lokala variabler"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "sektion %q+D står i konflikt med tidigare deklaration"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "sektion i %q+D kan inte åsidosättas"
@@ -35394,7 +35437,7 @@ msgstr "attributet %qE kan inte anges för %q+D"
 #: c-family/c-attribs.cc:2906
 #, gcc-internal-format
 msgid "%qE attribute may not be specified for a non-array field"
-msgstr "attributet %qE får inte anges för annat fält en vektor"
+msgstr "attributet %qE får inte anges för annat fält än en vektor"
 
 #: c-family/c-attribs.cc:2913
 #, gcc-internal-format
@@ -35424,7 +35467,7 @@ msgstr "attributet %qE är inte tillåtet för annat fält än en vektor eller p
 #: c-family/c-attribs.cc:2969
 #, gcc-internal-format
 msgid "%qE attribute is not allowed for a non-flexible array member field"
-msgstr "attributet %qE är inte tillåtet för ett annat fält än en ickeflexibel vektor"
+msgstr "attributet %qE är inte tillåtet för ett annat fält än en ickeflexibel vektormedlem"
 
 #: c-family/c-attribs.cc:2981
 #, gcc-internal-format
@@ -35451,7 +35494,7 @@ msgstr "argumentet till %<counted_by%> är inte en identifierare"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "argumentet %qE till  %<counted_by%> står i konflikt med tidigare deklaration %qE"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "inline-funktionen %q+D deklarerad svag"
@@ -35497,12 +35540,12 @@ msgstr "ignorerar attributet %qE satt på en oinitierad variabel"
 msgid "%qE attribute is only applicable on functions"
 msgstr "attributet %qE är bara tillämpligt på funktioner"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "attributet %<symver%> fungerar bara på funktioner och variabler"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "attributet %<symver%> är bara tillämpligt på symboler"
@@ -35512,12 +35555,12 @@ msgstr "attributet %<symver%> är bara tillämpligt på symboler"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "argumentet till attributet %<symver%> är inte en strängkonstant"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr "symver-attributargument måste ha formatet %<namn@nodnamn%>"
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr "argumentet %qs till attributet %<symver%> måste innehålla en eller två %<@%>"
@@ -35608,23 +35651,23 @@ msgstr "attributet %qE ignorerat eftersom %qT redan är definierat"
 msgid "visibility argument not a string"
 msgstr "synlighetsargumentet är inte en sträng"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "attributet %qE ignorerat för typer"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "argumentet till attributet %qE måste vara en av %qs, %qs, %qs eller %qs"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD omdeklarerad med annan synlighet"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD deklarerades %qs vilket medför standardsynlighet"
@@ -35641,7 +35684,7 @@ msgstr "argumentet %qE måste vara en av %qs, %qs, %qs eller %qs"
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "attributet %qE är bara tillämpligt på funktioner"
@@ -35712,7 +35755,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "argument 1 till attribut %qE måste ta en pekartyp som sitt första argument; har %qT"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "attributet %qE ignoreras på en funktion som returnerar %qT"
@@ -35750,7 +35793,7 @@ msgstr "kan inte sätta attributet %qE efter definitionen"
 #: c-family/c-attribs.cc:4419
 #, gcc-internal-format
 msgid "%qE attribute on function type without pointer arguments returning %<void%>"
-msgstr "attributet %qE på en funktiontyp utan pekarargument som returnerar %<void%>"
+msgstr "attributet %qE på en funktionstyp utan pekarargument som returnerar %<void%>"
 
 #: c-family/c-attribs.cc:4482
 #, gcc-internal-format
@@ -35787,7 +35830,7 @@ msgstr "%qD är inte kompatibel med %qD"
 msgid "%qE argument is not a function"
 msgstr "argumentet %qE är inte en funktion"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "deprecated-meddelande är inte en sträng"
@@ -35853,7 +35896,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "attributet %qE ignorerat för icke-enum"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "attributet %qE behöver ett strängargument"
@@ -36014,15 +36057,15 @@ msgid "requested position is less than zero"
 msgstr "begärd position är mindre än noll"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "tom sträng i attributet %<target%>"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "argument till attribut %qE är inte en strängkonstant"
@@ -36288,7 +36331,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "föreslår parenteser runt tilldelning som används som sanningsvärde"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "ogiltig användning av %<restrict%>"
@@ -36459,8 +36502,8 @@ msgstr "för få variabla argument för att få plats med en vaktpost"
 msgid "missing sentinel in function call"
 msgstr "vaktpost saknas i funktionsanrop"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "felaktig flagga %qs till attributet %<optimize%>"
@@ -37469,7 +37512,7 @@ msgstr "ej stödd konkatenering av stränglitteraler som inte följer standard"
 msgid "traditional C rejects string constant concatenation"
 msgstr "traditionell C stödjer inte strängkonstantsammanslagning"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr "%<#pragma omp critical%> med %<hint%>-klausul kräver ett namn, utom när %<omp_sync_hint_none%> används"
@@ -37524,7 +37567,7 @@ msgstr "%<depobj%>-beroendetyp angiven i %<depend%>-klausul på en %<depobj%>-ko
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "en %<iterator%>-modifierare får inte anges på en %<depobj%>-konstruktion"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "ogiltig typ för iterationsvariabeln %qE"
@@ -37539,17 +37582,17 @@ msgstr "%<_Atomic%>-iterationsvariabel %qE"
 msgid "%qE is not initialized"
 msgstr "%qE är inte initierad"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "styrpredikat saknas"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "ogiltigt styrpredikat"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "utelämnat ökningsuttryck"
@@ -37559,7 +37602,7 @@ msgstr "utelämnat ökningsuttryck"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr "ökningen är inte en konstant 1 eller -1 för villkoret %<!=%>"
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "ogiltigt ökningsuttryck"
@@ -37654,18 +37697,18 @@ msgstr "felaktig reduktionsmodifierare %<task%> på en konstruktion inte kombine
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr "%<inscan%> %<reduction%>-klausul på en annan konstruktion än %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr "%qD angivet i en %<allocate%>-klausul men inte i en explicit privatiseringsklausul"
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD är inte ett funktionsargument"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "bitfältet %qE i %qs-klausul"
@@ -37675,8 +37718,8 @@ msgstr "bitfältet %qE i %qs-klausul"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE har inte en avbildbar typ i %qs-klausul"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%> %qE i %qs-klausul"
@@ -38169,7 +38212,7 @@ msgstr "felformaterat %<#pragma message%>, ignoreras"
 #: c-family/c-pragma.cc:1358 cp/parser.cc:4897 cp/parser.cc:4993
 #, gcc-internal-format
 msgid "string literal with user-defined suffix is invalid in this context"
-msgstr "en strängliteral med ett användardefinierat suffix tillåtet i denna kontext"
+msgstr "en stränglitteral med ett användardefinierat suffix tillåtet i denna kontext"
 
 #: c-family/c-pragma.cc:1366
 #, gcc-internal-format
@@ -38191,7 +38234,7 @@ msgstr "ogiltig plats för %<pragma %s%>, ignoreras"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "felformaterat %<#pragma %s%>, ignoreras"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "skräp vid slutet av %<#pragma %s%>"
@@ -38263,8 +38306,8 @@ msgstr "dumpflaggor hanteras inte här"
 msgid "wrong type argument to %s"
 msgstr "fel typ på argument till %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -38750,17 +38793,17 @@ msgstr "minskning av funktion %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "funktionen %qD använd som %<asm%>-utdata"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "tilldelning till endast läsbar plats %qE"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "ökning av endast läsbar plats %qE"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "minskning av endast läsbar plats %qE"
@@ -39026,7 +39069,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "att skicka argument %i till en %qs-kvalificerad parameter blir alias med argument %Z"
 msgstr[1] "att skicka argument %i till en %qs-kvalificerad parameter blir alias med argumenten %Z"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr "detta villkor har identiska grenar"
@@ -39494,7 +39537,7 @@ msgstr "%<-march=%s%>: utökningen %qs börjar med ”z” men är en standardut
 #: common/config/riscv/riscv-common.cc:572
 #, gcc-internal-format
 msgid "%<-march=%s%>: extension %qs starts with 's' but is unsupported standard supervisor extension"
-msgstr "%<-march=%s%>: utvidgningen %qs börjar med ”s” men är en standardövervakarutvidgning som inte stöjds"
+msgstr "%<-march=%s%>: utvidgningen %qs börjar med ”s” men är en standardövervakarutvidgning som inte stödjs"
 
 #: common/config/riscv/riscv-common.cc:581
 #, gcc-internal-format
@@ -39524,7 +39567,7 @@ msgstr "%<-march=%s%>: ISA-strängen måste börja med rv32, rv64, en RVA-profil
 #: common/config/riscv/riscv-common.cc:985
 #, gcc-internal-format
 msgid "%<-march=%s%>: rv%de is not a valid base ISA"
-msgstr "%<-march%s%>: rv%de är inte en giltig bas-ISA"
+msgstr "%<-march=%s%>: rv%de är inte en giltig bas-ISA"
 
 #: common/config/riscv/riscv-common.cc:998
 #, gcc-internal-format
@@ -39594,17 +39637,17 @@ msgstr "%<-march=%s%>: utökningen h kräver utökningen i"
 #: common/config/riscv/riscv-common.cc:1197
 #, gcc-internal-format
 msgid "%<-march=%s%>: zcd conflicts with zcmt"
-msgstr "%<-mcpu=%s%> zcd står i konflikt med zcmt"
+msgstr "%<-march=%s%>: zcd står i konflikt med zcmt"
 
 #: common/config/riscv/riscv-common.cc:1199
 #, gcc-internal-format
 msgid "%<-march=%s%>: zcd conflicts with zcmp"
-msgstr "%<-mcpu=%s%> zcd står i konflikt med zcmp"
+msgstr "%<-march=%s%>: zcd står i konflikt med zcmp"
 
 #: common/config/riscv/riscv-common.cc:1208
 #, gcc-internal-format
 msgid "%<-march=%s%>: xtheadvector conflicts with vector extension or its sub-extensions"
-msgstr "%<-march=%s%>: xtheadvector står i konflikt med en vektorutökning eller des underutökning"
+msgstr "%<-march=%s%>: xtheadvector står i konflikt med en vektorutökning eller dess underutökning"
 
 #: common/config/riscv/riscv-common.cc:1306
 #, gcc-internal-format
@@ -39629,7 +39672,7 @@ msgstr "%<-mcpu=%s%>: okänd CPU"
 #: common/config/riscv/riscv-common.cc:1808
 #, gcc-internal-format
 msgid "Cannot find suitable multilib set for %<-march=%s%>/%<-mabi=%s%>"
-msgstr "Kan inte hitta en lämpligt multilib-mängd för %<-march=%s%>/%<-mabi=%s%>"
+msgstr "Kan inte hitta en lämplig multilib-mängd för %<-march=%s%>/%<-mabi=%s%>"
 
 #: common/config/rs6000/rs6000-common.cc:175 config/sparc/sparc.cc:1823
 #, gcc-internal-format
@@ -39958,7 +40001,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "ACLE-funktionen %qD behöver ISA-utökningen %qs"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "man kan aktivera %qs genom att använda kommandoradsflaggan %<-march%>, eller genom att använda attributet eller pragmat %<target%>"
@@ -40017,7 +40060,7 @@ msgstr "128-bitars systemregisterstöd kräver utvidgningen %<d128%>"
 #: config/aarch64/aarch64-builtins.cc:3572
 #, gcc-internal-format
 msgid "invalid system register name provided"
-msgstr "felaktig namn på systemregister angivet"
+msgstr "felaktigt namn på systemregister angivet"
 
 #: config/aarch64/aarch64-builtins.cc:3586
 #, gcc-internal-format
@@ -40140,7 +40183,7 @@ msgstr "%s inte igenkänd, använder standardvärdet %qs"
 #: config/aarch64/aarch64-json-tunings-parser.cc:313
 #, gcc-internal-format
 msgid "key %qs is not a tuning parameter, skipping"
-msgstr "nyckeln %qs är inte ett trimningsparameter, hoppar över"
+msgstr "nyckeln %qs är inte en trimningsparameter, hoppar över"
 
 #: config/aarch64/aarch64-json-tunings-parser.cc:329
 #, gcc-internal-format
@@ -40347,7 +40390,7 @@ msgstr "skickar %qT som argument %d till %qE, vilken förväntar sig en pekare t
 #: config/aarch64/aarch64-sve-builtins.cc:2069
 #, gcc-internal-format
 msgid "passing %qT to argument %d of %qE, which expects the data to be 16 bits or wider"
-msgstr "skickar %qT som argument %d till %qE, vilken förväntar sig att datan skall vara 16 bitar bredare"
+msgstr "skickar %qT som argument %d till %qE, vilken förväntar sig att datan skall vara 16 bitar eller bredare"
 
 #: config/aarch64/aarch64-sve-builtins.cc:2072
 #, gcc-internal-format
@@ -40587,7 +40630,7 @@ msgstr "skickar %qT som argument %d till %qE, men dess %qT-form tar inte enkla v
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "dubblerad definition av %qs"
@@ -40633,7 +40676,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "SVE-typen %qT har inte en definierad justering"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "variabler av typen %qT kan inte ha trådlokal lagringsvaraktighet"
@@ -40684,7 +40727,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "SVE-typen %qT är inte tillåten i en klausul %<map%>"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr "det går inte att referera %qT-objekttyper i en region %<target%>"
@@ -40727,7 +40770,7 @@ msgstr "kan inte skapa en ny räckvidd %qs eftersom %qs delas med sin anropare"
 #: config/aarch64/aarch64.cc:830
 #, gcc-internal-format
 msgid "%qE attribute applies only to function definitions"
-msgstr "attributet %qE är bara tillämpligt på funktionesdefinitioner"
+msgstr "attributet %qE är bara tillämpligt på funktionsdefinitioner"
 
 #: config/aarch64/aarch64.cc:876
 #, gcc-internal-format
@@ -40777,19 +40820,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "SVE-typen %qT kan inte skickas till en funktion utan prototyp"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr "parameterskickandet för argument av typen %qT ändrades i GCC 13.1"
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr "parameterskickandet för argument av typen %qT ändrades i GCC 14.1"
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -40835,208 +40878,208 @@ msgstr "anrop av en funktion som delar andra tillstånd än %qs från en funktio
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr "använd %<__arm_preserves(\"za\")%> om den anropade bevarar ZA"
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr "okänd flagga skickad i %<-moverride=%s%> (%s)"
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr "%qs-sträng är felformad"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "felaktigt format på %<sve_width%>"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "ogiltigt %<sve_width%>-värde: %d"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "trimningssträngen saknas i flaggan (%s)"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "okänd trimningsflagga (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr "inkompatibla flaggor %<-mstack-protector-guard=global%> och %<-mstack-protector-guard-offset=%s%>"
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr "både %<-mstack-protector-guard-offset%> och %<-mstack-protector-guard-reg%> måste användas med %<-mstack-protector-guard=sysreg%>"
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr "ange ett systemregister med en liten stränglängd"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs är inte ett giltigt avstånd i %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr "%<-fsanitize=shadow-call-stack%> kräver %<-ffixed-x18%>"
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "%<-fsanitize=shadow-call-stack%> står i konflikt med användningen av register x18 av måloperativsystemet"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "%<-fsanitize=memtag-stack%> kräver ISA-utökningen %qs"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "strömningsfunktioner behöver ISA-utökningen %qs"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "funktioner med SME-tillstånd behöver ISA-utökningen %qs"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr "endast värdena 12 (4 kB) och 16 (64 kB) stödjs som vaktstorlek.  Det givna värdet %d (%llu kB) är utanför intervallet"
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr "stackkrockvaktsstorlek %<%d%> måste vara lika med testintervallet %<%d%>"
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "ogiltigt argument givet till %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr "%qs måste vara ensamt till %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "ogiltigt argument %qs till %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "flaggan %<-mcpu=%s%> står i konflikt med flaggan %<-march=%s%> och resulterade i att flaggan %qs lades till"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "assemblern stödjer inte %<-mabi=ilp32%>"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%<-mabi=ilp32%> bör undvikas"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr "signering av returadress stödjs endast för %<-mabi=lp64%>"
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr "kodmodell %qs med %<-f%s%>"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "kodmodellen %qs stödjs inte i ilp32-läge"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "funktioner med %qs-tillstånd behöver ISA-utökningen %qs"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "namn saknas i pragmat eller attributet %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "felaktig funktionsmodifierare %s på värdet %qs i pragmat eller attributet %<target()%>"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "namn saknas i pragmat eller attributet %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "felaktig funktionsmodifierare %qs på värdet %qs i pragmat eller attributet %<target()%>"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "felaktigt namn %qs i pragmat eller attributet %<target(\"tune=\")%>"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "värde saknas i pragmat eller attributet %<target()%>"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "felformaterat pragma eller attribut %<target()%>"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "pragmat eller attributet %<target(\"%s\")%> tar inte något argument"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "pragmat eller attributet %<target(\"%s\")%> tillåter inte en negerad form"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "pragmat eller attributet %<target(\"%s=%s\")%> är inte giltigt"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41044,194 +41087,194 @@ msgstr "pragmat eller attributet %<target(\"%s=%s\")%> är inte giltigt"
 msgid "attribute %<target%> argument not a string"
 msgstr "argument till attribut %<target%> är inte en sträng"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr "arkitekturutvidgningen %qs skall prefixas av %<+%>"
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "pragmat eller attributet %<target(\"%s\")%> är inte giltigt"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "felformaterat pragma eller attribut %<target(\"%s\")%>"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "attributet %<target_version%> har flera värden"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "argument till attributet %<target_version%> är inte en sträng"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "värde saknas i attributet %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "felaktig funktionsmodifierare %qs på värdet %qs i attributet %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "dubblerade funktionsmodifierare %qs på värdet %qs i attributet %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "multiversionering av virtuell funktion stödjs inte"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "multiversionering behöver %<ifunc%> som inte stödjs på detta mål"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr "%q+D har ett inkonsekvent prioritetsvärde för en funktion med flera versioner"
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+D deklarerades tidigare här med prioritetsvärdet %d"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr "parameterskickandet för argument av typen %qT med %<[[no_unique_address]]%>-medlemmar ändrades %{i GCC 10.1%}"
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr "parameterskickandet för argument av typen %qT när C++17 är aktiverat ändrades till att matcha C++14 %{i GCC 10.1%}"
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr "parameterskickandet för argument av typen %qT ändrades %{i GCC 12.1%}"
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "bana %wd utanför intervallet %wd - %wd"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "ej stödd simdlen %wd"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "GCC stödjer för närvarande inte returtypen %qT för simd"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "returtyp %qT stödjs ej för simd"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "GCC stödjer för närvarande inte argumenttypen %qT för simd"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "argumenttyp %qT som inte stödjs till simd"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "GCC stödjer för närvarande inte simdlen %wd för typen %qT"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "GCC stödjer för närvarande inte en simdclone med simdlen:ar %wd och %wd för dessa typer."
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "kan inte använda attributet %qs på %q+D efter att funktionen redan har definierats"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "%q+D definierades här"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr "icke-lokala goto i en funktion med SME-tillstånd"
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr "fångar ett icke-lokalt undantag i funktioner med SME-tillstånd"
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "argument %d till %qE måste vara ett konstant heltalsuttryck"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "skickar %wd som argument %d till %qE, vilken förväntar sig värdet %wd"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "skickar %wd som argument %d till %qE, vilken förväntar sig ett värde i intervallet [%wd, %wd]"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "skickar %wd som argument %d till %qE, vilken förväntar sig %wd eller %wd"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "skickar %wd som argument %d till %qE, vilken förväntar sig %wd, %wd, %wd eller %wd"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "skickar %wd som argument %d till %qE, vilken förväntar sig ett giltigt %qT-värde"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "en tom sträng är inte giltig för en version %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "felaktig funktionsmodifierare %qs i versionen %qB till attributet %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "dubblerade funktionsmodifierare %qs i versionen %qB till attributet %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "felaktig funktion %qs i versionen %qB till attributet %<target_clones%>"
 
@@ -41419,12 +41462,12 @@ msgstr "argumentet till attributet %qE är inte ”ilink” eller ”firq”"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -41557,22 +41600,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "argumentet till attributet %qE ignoreras"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "attributet %qE är bara tillämpligt på variabler"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "alternativ är inte tillåtna i %<asm%>-flaggutdata"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "okänd %<asm%>-flaggutdata %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "ogiltig typ för %<asm%>-flaggutdata"
@@ -41590,7 +41633,7 @@ msgstr "ogiltigt argument %qs till %qs"
 #: config/arm/aarch-common.cc:726
 #, gcc-internal-format
 msgid "argument %qs can only appear alone in %qs"
-msgstr "argumentet %qs ken endast förekomma ensamt i %qs"
+msgstr "argumentet %qs kan endast förekomma ensamt i %qs"
 
 #: config/arm/arm-builtins.cc:2229
 #, gcc-internal-format, gfc-internal-format
@@ -41655,7 +41698,7 @@ msgstr "%<#pragma GCC arm%> kräver en strängparameter"
 #: config/arm/arm-c.cc:156
 #, gcc-internal-format
 msgid "%<#pragma GCC arm \"arm_mve.h\"%> requires a boolean parameter"
-msgstr "%<#pragma GCC arm \"arm_mve.h\"%> kräver en strängparameter"
+msgstr "%<#pragma GCC arm \"arm_mve.h\"%> kräver en boolesk parameter"
 
 #: config/arm/arm-c.cc:160
 #, gcc-internal-format
@@ -41710,7 +41753,7 @@ msgstr "skickar %qT som argument %d till %qE, men föregående argument hade typ
 #: config/arm/arm-mve-builtins.cc:1696
 #, gcc-internal-format
 msgid "passing %qT to argument %d of %qE, which expects a pointer to %qT"
-msgstr "skickar %qT som argument %d till %qE, vilken förväntar sig en pkare på %qT"
+msgstr "skickar %qT som argument %d till %qE, vilken förväntar sig en pekare på %qT"
 
 #: config/arm/arm-mve-builtins.cc:2338
 #, gcc-internal-format
@@ -42105,12 +42148,12 @@ msgstr "%<-fpie%> stödjs inte"
 msgid "%<-fPIE%> is not supported"
 msgstr "%<-fPIE%> stödjs inte"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "funktionsattributen %qs och %qs är ömsesidigt uteslutande"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "funktionen %qs kan inte ha argument"
@@ -42120,7 +42163,7 @@ msgstr "funktionen %qs kan inte ha argument"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr "metoden %qs har ett implicit argument %<this%>"
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "funktionen %qs kan inte returnera ett värde"
@@ -42298,7 +42341,7 @@ msgstr "%s förväntar sig ett heltal konstant vid kompileringstillfället"
 #: config/avr/avr.cc:16362
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expects a compile time integer constant of 0x01, 0x7f, 0x80 or 0xfe as first argument"
-msgstr "%s förväntar sig en kompilatorstillfälles heltalskonstant på 0x01, 0x7f, 0x80 eller 0xfe som första argument"
+msgstr "%s förväntar sig en heltalskonstant vid kompileringstillfället på 0x01, 0x7f, 0x80 eller 0xfe som första argument"
 
 #: config/avr/avr.cc:16377
 #, gcc-internal-format, gfc-internal-format
@@ -42447,7 +42490,7 @@ msgstr "indirekt anrop i en funktion, vilket inte stödjs av eBPF"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "ogiltigt argument inbyggd funktion"
@@ -42475,7 +42518,7 @@ msgstr "kunde inte inline:a anropet av %<__builtin_memset%>: storleken måste va
 #: config/bpf/bpf.cc:1492 config/bpf/bpf.cc:1495
 #, gcc-internal-format
 msgid "could not inline call to %<__builtin_memset%>: too many bytes, use %<-minline-memops-threshold%>"
-msgstr "kunde int inline:a anropet av %<__builtin_memset%>: för många byte, använd %<-minline-memops-threshold%>"
+msgstr "kunde inte inline:a anropet av %<__builtin_memset%>: för många byte, använd %<-minline-memops-threshold%>"
 
 #: config/bpf/core-builtins.cc:1796
 #, gcc-internal-format
@@ -42763,7 +42806,7 @@ msgstr "använder %<vector_length (64)%>, ignorerar %d"
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr "använder %<vector_length (64)%>, ignorerar körtidsinställningen"
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr "använder %<num_workers (%d)%>, ignorerar %d"
@@ -42929,168 +42972,169 @@ msgstr "parameter till inbyggd måste vara en strängkonstant eller -litteral"
 msgid "parameter to builtin not valid: %s"
 msgstr "parameter till inbyggd är inte giltig: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "avbrottshanteringsrutiner kan inte anropas direkt"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "det sista argumentet måste vara en 2-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "det femte argumentet måste vara en 8-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "det tredje argumentet måste vara en 8-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "det sista argumentet måste vara en 1-bits omedelbar"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "det sista argumentet måste vara en 3-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "det sista argumentet måste vara en 4-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "det sista argumentet måste vara en 1-bits omedelbar"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr "”%s” behöver isa-flaggan %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "det sista argumentet måste vara en 5-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "det näst sista argumentet måste vara en 8-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "det sista argumentet måste vara en 8-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "det tredje argumentet måste vara en jämförelsekonstant"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "felaktigt jämförelsesätt"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "felaktig avrundningsoperand"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "det omedelbara argumentet måste vara en 4-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "det omedelbara argumentet måste vara en 5-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "det omedelbara argumentet måste vara en 8-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "det fjärde argumentet måste vara en av uppräkningsvärdena %qs"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "väljaren måste vara en heltalskonstant i intervallet [0..%wi]"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE behöver en okänd isa-flagga"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE behöver isa-flaggan %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "andra, tredje och fjärde argumentet måste vara en konstant"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, gcc-internal-format
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ogiltigt andra argument till %<__builtin_ia32_prefetch%>; använder noll"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, gcc-internal-format
 msgid "invalid third argument"
 msgstr "ogiltigt tredje argument"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr "instruktionsförhandshämtning är aktuellt när man är i 64-bitsläge med RIP-relativ adressering och flaggat %<-mprefetchi%>; de förblir NOP:ar annars"
 
-#: config/i386/i386-expand.cc:15240
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125348
+#: config/i386/i386-expand.cc:15246
 #, gcc-internal-format
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ogiltigt fjärde argument till %<__builtin_ia32_prefetch%>; använder noll"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "ogiltigt tredje argument till %<__builtin_ia32_prefetch%>; använder noll"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "andra argumentet måste vara en konstant"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "det sista argumentet måste vara en 32-bitars omedelbar"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "sista argumentet måste vara en omedelbar"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "det sista argumentet ha skala 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "argumentet till den inbyggda %<xabort%> måste vara en 8-bitars omedelbar"
@@ -43457,7 +43501,7 @@ msgstr "%<-mno-fentry%> är inte kompatibelt med SEH"
 #: config/i386/i386-options.cc:2879
 #, gcc-internal-format
 msgid "%<-pg%> without %<-mfentry%> may be unreliable with shrink wrapping"
-msgstr "%<-pg%> utan %<-mfentry%> kan vara opålitligt med krympinkappsling"
+msgstr "%<-pg%> utan %<-mfentry%> kan vara opålitligt med krympinkapsling"
 
 #: config/i386/i386-options.cc:2884
 #, gcc-internal-format
@@ -43489,8 +43533,8 @@ msgstr "%qs är inte ett giltigt basregister i %<-mstack-protector-guard-reg=%>"
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr "%<-fcf-protection=full%> är inte aktiverat av %<-fhardened%> eftersom det angavs på kommandoraden"
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%<-fcf-protection%> är inte kompatibelt med denna målarkitektur"
@@ -43733,7 +43777,7 @@ msgstr "ABI:et för att skicka en post med %<complex float%> medlem har ändrats
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "ABI:et för att skicka C-poster med bitfält med nollbredd har ändrats i GCC %{12.1%}"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr "SSE-registerretur med SSE2 avaktiverat"
@@ -43758,12 +43802,12 @@ msgstr "SSE-registerargument med SSE avaktiverat"
 msgid "x87 register return with x87 disabled"
 msgstr "x87-registerretur med x87 avaktiverat"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "anrop av %qD med SSE-anropskonvention utan SSE/SSE2 aktiverat"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr "detta är ett fel i GCC som kan gås runt genom att lägga till attributet used till den anropade funktionen"
@@ -43773,128 +43817,128 @@ msgstr "detta är ett fel i GCC som kan gås runt genom att lägga till attribut
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "ABI:et för att skicka parametrar med %d-bytejustering har ändrats i GCC 4.6"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "%<-mcall-ms2sysv-xlogues%> är inte kompatibel med %s"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "attributet %<ms_hook_prologue%> är inte kompatibelt med %<-mfentry%> i 32-bitsläge"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr "Dynamic Realign Argument Pointer (DRAP) stödjs inte i avbrottshanteringsrutiner.  Detta kan gås runt genom att undvika funktioner med sammansatta returvärden."
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "Stackomjustering stödjs inte med %<__builtin_eh_return%>"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "regparm-nästade funktioner stödjs inte med %<__builtin_eh_return%>"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%<-fsplit-stack%> stödjer inte fastcall med nästade funktioner"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "%<-fsplit-stack%> stödjer inte 2 registerparametrar för en nästad funktion"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "%<-fsplit-stack%> stödjer inte 3 registerparametrar"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "%<-mtls-dialect=gnu2%> måste användas med en funktion med attributet %<no_caller_saved_registers%>"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "%<-mtls-dialect=gnu2%> måste användas med en undantagshanteringsrutin"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "%<-mtls-dialect=gnu2%> måste användas med en avbrottshanteringsrutin"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr "modifieraren %<V%> på ett register som inte är heltal"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "ej stödd storlek för heltalsregister"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "utökade register har inga höga halvor"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "ej stödd operandstorlek för utökat register"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "operand som inte är heltal använt med operandkod %<z%>"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "den tomma klassen %qT parameterskickande ABI ändras i %<-fabi-version=12%> (GCC 8)"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "justeringen av %<_Atomic %T%>-fält ändrades i %{GCC 11.1%}"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "inga register tillgängliga för profilering %<-mcmodel=large%s%>"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "profileringen %<-mcmodel=large%> med PIC stödjs inte"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr "%<__bfloat16%> är omdefinierat från typedef %<short%> till reell %<__bf16%> sedan GCC 13.1, var vaksam på implicita konverteringar mellan %<__bf16%> och %<short%>; en explicit bittypkonvertering kan behövas här"
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "okänd arkitekturspecifik minnesmodell"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr "%<HLE_ACQUIRE%> används inte med %<ACQUIRE%> eller starkare minnesmodell"
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr "%<HLE_RELEASE%> används inte med %<RELEASE%> eller starkare minnesmodell"
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "%<-fexcess-precision=16%> är inte kompatibel med %<-mfpmath=387%>"
@@ -43945,7 +43989,7 @@ msgstr "%<gp_offset%> (%ld) eller %<end_offset%> (%ld) är mindre än noll"
 msgid "argument %qd is not a constant"
 msgstr "argumentet %qd är inte en konstant"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr "%<PRINT_OPERAND_ADDRESS%>, null-pekare"
@@ -43955,7 +43999,7 @@ msgstr "%<PRINT_OPERAND_ADDRESS%>, null-pekare"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "%<PRINT_OPERAND%>: Okänd interpunktion %<%c%>"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr "%<PRINT_OPERAND%> null-pekare"
@@ -43993,7 +44037,7 @@ msgstr "okänd nativ FPU-typ %<0x%x%>, %qs misslyckades"
 #: config/loongarch/loongarch-cpu.cc:180
 #, gcc-internal-format
 msgid "floating-point unit %qs differs from PRID preset %qs"
-msgstr "flyttalsenheten %qs skiler från PRID-förinställningen %qs"
+msgstr "flyttalsenheten %qs skiljer från PRID-förinställningen %qs"
 
 #: config/loongarch/loongarch-cpu.cc:204
 #, gcc-internal-format
@@ -44108,48 +44152,48 @@ msgstr "värdet på pragmat eller attributet %<target(\"%s\")%> får inte vara t
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "argument %qs till attribut %<target%> är okänt"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "”default” kan inte ställas in tillsammans med andra funktioner i %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "tecknet före %<;%> i attributet %qs får inte vara tomt"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr "i attributet %qs får prioritet inte vara tomt"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr "i attributet %qs får antalet funktioner inte överstiga två"
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr "Att sätta prioritetsvärdet till %qs är otillåtet i attributet %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr "i attributet %qs skall den andra funktionen vara ”priority=%<tal%>” istället för %qs"
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr "i attributet %qs måste man ange ett tillåtet värde på ”arch”"
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "attributet %qs stödjs inte i %<target_version%> eller %<target_clones%>"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "%qs stödjs inte i attributet target"
@@ -44253,7 +44297,7 @@ msgstr "%<-falign-loops=%d%> stödjs ej"
 #: config/m68k/m68k.cc:693
 #, gcc-internal-format
 msgid "%<-fstack-limit-%> options are not supported on this cpu"
-msgstr "%<-fstack-limit-flaggor%> stödjs inte på denna målarkitektur"
+msgstr "%<-fstack-limit-%>-flaggor stödjs inte på denna målarkitektur"
 
 #: config/m68k/m68k.cc:811
 #, gcc-internal-format
@@ -44814,7 +44858,7 @@ msgstr "%<-mdata-region=upper%> förutsätter den stora minnesmodellen (%<-mlarg
 #: config/msp430/msp430.cc:291
 #, gcc-internal-format
 msgid "%<-fuse-cxa-atexit%> is not supported for msp430-elf"
-msgstr "%<-fcall-saved-REG%> stödjs inte för msp430-elf"
+msgstr "%<-fuse-cxa-atexit%> stödjs inte för msp430-elf"
 
 #: config/msp430/msp430.cc:296
 #, gcc-internal-format
@@ -44902,7 +44946,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr "MSP430 inbyggda funktioner fungerar endast inuti avbrottshanterare"
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "felaktig inbyggd kod"
@@ -45125,82 +45169,82 @@ msgstr "kan inte öppna intermediär ptx-fil"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "flaggan %s stödjs inte tillsammans med %<-fopenacc%>"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr "PTX-version (%<-mptx%>) behöver vara åtminstone %s för att stödja vald %<-misa%> (sm_%s)"
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "%<-march=%> måste anges"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "genererar inte en patcharea, nop:ar stödjs inte"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr "statisk initiering av variabeln %q+D i %<.shared%>-minne stödjs inte"
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr "kan inte skicka ut ojusterade pekare i ptx-assembler"
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr "PTX stödjer inte svaga deklarationer (endast svaga definitioner)"
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "attributet %qE kräver returtypen void"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "attributet %qE är inte tillåtet med lagringsklassen auto"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "barriärvärdet måste vara inom [0,15]"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, gcc-internal-format
 msgid "complement argument must be constant"
-msgstr "komplmentargumentet måste vara konstant"
+msgstr "komplementargumentet måste vara konstant"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr "använder %<vector_length (%d)%> på grund av anrop av vektorpartitionerbar rutin, ignorerar %d"
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr "använder %<vector_length (%d)%>, ignorerar körtidsinställningen"
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr "använder %<vector_length (%d)%>, ignorerar %d"
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr "variabeln %qD justerad för OpenACC privatiseringsnivå: %qs"
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "svaga aliasdefinitioner stödjs inte i denna konfiguration"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "aliasdefinitioner för annat än funktioner stödjs inte i denna konfiguration"
@@ -45353,7 +45397,7 @@ msgstr "oväntad arkitektur till attributet %<target()%>: måste börja med + el
 #: config/riscv/riscv-target-attr.cc:162
 #, gcc-internal-format
 msgid "unexpected arch for %<target()%> attribute: bad string found %qs"
-msgstr "oväntat arkitektur till attributet %<target()%>: felaktig sträng funnen %qs"
+msgstr "oväntad arkitektur till attributet %<target()%>: felaktig sträng funnen %qs"
 
 #: config/riscv/riscv-target-attr.cc:189
 #, gcc-internal-format
@@ -45427,323 +45471,323 @@ msgstr "läget %s förväntades för operand %d till instruktionen %s men fick l
 #: config/riscv/riscv-v.cc:379
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
-msgstr "felaktig antal operander till instruktionen %s, %d förväntades men fick %d.\n"
+msgstr "felaktigt antal operander till instruktionen %s, %d förväntades men fick %d.\n"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr "skickar %wd som argument %d till %qE, vilken förväntar sig ett värde i intervallet [%wd, %wd] eller %wd"
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "RVV-typen %qT har inte en fast storlek"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "RVV-typen %qT har inte en definierad justering"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "aritmetik på pekare till RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr "medlemsvariabler kan inte ha RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "fält kan inte ha RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "vektorelement kan inte ha RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "det går inte att allokera objekt med RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "kan inte radera objekt med RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "kan inte kasta eller fånga RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "fångst av kopia av RVV-typen %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "RVV-typen %qT är inte tillåten i en klausul %<map%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "RVV-typen %qT är inte tillåten i en klausul %<target%> %<private%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "RVV-typen %qT är inte tillåten i en klausul %<target%> %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "RVV-typen %qT är inte tillåten i en enhetsklausul %<target%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "den inbyggda funktionen %qE behöver ISA-utökningen zvfbfmin eller zvfbfwma"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "den inbyggda funktionen %qE behöver ISA-utökningen zvfhmin eller zvfh"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "den inbyggda funktionen %qE behöver ISA-utökningen zve32f, zve64f, zve64d eller v"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "den inbyggda funktionen %qE behöver ISA-utökningen zve64d eller v"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "den inbyggda funktionen %qE behöver ISA-utökningen zve64x, zve64f, zve64d eller v"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "okänd inbyggd RVV"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "den inbyggda funktionen %qE kräver ISA-utökningen %qs"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "ingen funktion som stämmer för anrop av %qE med tomma argument"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "okänt cpu %qs till %<-mtune%>"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "denna åtgärd kräver ISA-utökningen RVV"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "man kan aktivera RVV genom att använda kommandoradsflaggan %<-march%>, eller genom att använda attributet eller pragmat %<target%>"
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "ABI:et för en tillplattad post med nollängds bitfält ändrades i GCC 10"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "ABI:et för en tillplattad tom union med nollängds vektor ändrades i GCC 16"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "RVV-typen %qT kan inte skickas till en funktion utan prototyp"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "%s %qT kräver ISA-utökningen V"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT kräver ISA-utökningen zve64x, zve64f, zve64d eller v"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "%s %qT kräver ISA-utökningen zvfhmin eller zvfh"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT kräver ISA-utökningen zve32f, zve64f, zve64d eller v"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "%s %qT kräver ISA-utökningen zve64d eller v"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr "%s %qT kräver den minimala vektorlängden %qd men %qd ges"
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "funktionsattributet %qs kräver ISA-utökningen V"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr "värdet %d på %<ABI_VLEN%> stödjs inte för attributet %qs; %<ABI_VLEN%>  måste vara i intervallet [32, 16384] och måste vara en potens av 2"
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "funktionsattributet %qs kräver ISA-utökningen vektor"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "attributet ”rnmi” kräver ISA-utökningen Smrnmi"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "argumentet till attributet %qE är inte %<\"supervisor\"%>, %<\"machine\"%> eller %<\"rnmi\"%>"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr "%qs stödjs endast när %<-mrvv-vector-bits=zvl%> anges"
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qs använt på %qT som inte är en RVV-typ"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "%qs kräver en heltalskonstant"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr "felaktig RVV-vektorstorlek %qd, förväntad storlek är %qd baserat på LMUL av typen och %qs"
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr "%<-mdiv%> kräver %<-march%> för att innefatta utökningen %<M%>"
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "För närvarande kräver implementationen %<V%> utökningen %<M%>"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr "Aktuell RISC-V GCC stödjer inte VLEN större än 4096 bitar till utökningen ”V”"
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "Nuvarande RISC-V GCC stödjer inte RVV i läget rak byteordning"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "kodmodell %qs med %qs"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr "begärt ABI kräver %<-march%> för att innefatta utökningen %qc"
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr "rv32e kräver ABI:et ilp32e"
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr "rv64e kräver ABI:et lp64e"
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, gcc-internal-format
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ILP32E ABI stödjer inte utökningen %qc"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr "LP64E ABI är markerat för att undvikas i GCC"
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr "om du behöver LP64E meddela gärna GCC-projektet via %{PR116152%}"
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr "z*inx kräver ABI:et ilp32, ilp32e, lp64 eller lp64"
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "ABI:et kräver %<-march=rv%d%>"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "%<-mpreferred-stack-boundary=%d%> måste vara mellan %d och %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr "%<-mriscv-attribute%> RISC-V ELF-attribut behöver GNU as 2.32 [%<-mriscv-attribute%>]"
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs är inte ett giltigt basregister i %qs"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs är inte ett giltigt tal i %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "funktionen %qs kan inte ha olika avbrottstyp"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr "kan inte allokera vl-register för %qs på detta mål"
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "felaktig version %qB till attributet %<target_clones%>"
 
@@ -45905,7 +45949,7 @@ msgstr "inbyggd %qs är endast giltigt i 64-bitsläge"
 #: config/rs6000/rs6000-builtin.cc:3187
 #, gcc-internal-format
 msgid "unresolved overload for builtin %qF"
-msgstr "ej upplöst överlagrad inbyggd %qF"
+msgstr "ej uppslagen överlagrad inbyggd %qF"
 
 #: config/rs6000/rs6000-builtin.cc:3290
 #, gcc-internal-format
@@ -46121,7 +46165,7 @@ msgstr "%<-mvsx%> och %<-msoft-float%> är inkompatibla"
 #: config/rs6000/rs6000.cc:3845
 #, gcc-internal-format
 msgid "%<-mvsx%> and %<-mavoid-indexed-addresses%> are incompatible"
-msgstr "%<-mvsx%> och %<-mvoid-indexed-addresses%> är inkompatibla"
+msgstr "%<-mvsx%> och %<-mavoid-indexed-addresses%> är inkompatibla"
 
 #: config/rs6000/rs6000.cc:3856
 #, gcc-internal-format
@@ -46220,7 +46264,7 @@ msgstr "%<-mrop-protect%> behöver %<-mcpu=power8%> eller senare"
 #: config/rs6000/rs6000.cc:4856
 #, gcc-internal-format
 msgid "%<-mrop-protect%> requires the ELFv2 ABI"
-msgstr "%<-mprop-protect%> behöver ELFv2 ABI:et"
+msgstr "%<-mrop-protect%> behöver ELFv2 ABI:et"
 
 #: config/rs6000/rs6000.cc:4874
 #, gcc-internal-format
@@ -46490,7 +46534,7 @@ msgstr "Inbyggd %qF kräver z17 eller högre"
 #: config/s390/s390.cc:939
 #, gcc-internal-format
 msgid "unresolved overloaded builtin"
-msgstr "ej upplöst överlagrad inbyggd"
+msgstr "ej uppslagen överlagrad inbyggd"
 
 #: config/s390/s390.cc:946
 #, gcc-internal-format
@@ -46739,22 +46783,22 @@ msgstr "behovet av minne för lokala variabler överskrider kapaciteten"
 msgid "%<function_profiler%> support"
 msgstr "stöd för %<function_profiler%>"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "det går inte använda %<va_start%> i en avbrottsfunktion"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "switch-sats med storleken %lu ingångar är för stor"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "attributet %<__BELOW100__%> är bara tillämpbart på variabler"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "attributet %<__BELOW100__%> är inte tillåtet med lagringsklassen auto"
@@ -46977,32 +47021,32 @@ msgstr "%qs är laddad men symbolen %qs finns inte: %s"
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%qs är definierad men stöd för insticksmoduler är avaktiverat"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "booleska register krävs för flyttalsalternativet"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "%<-f%s%> stödjs inte med CONST16-instruktioner"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC krävs men stödjs inte med CONST16-instruktioner"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "endast oinitierade variabler kan placeras i en %<.bss%>-sektion"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr "constantsynth: metoden %qs felaktig instruktionssekvens, %wd (%wx) förväntades"
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr "constantsynth: metoden %qs värde stämmer inte, %wd (%wx) syntetiserad %wd (%wx) förväntades"
@@ -47089,7 +47133,7 @@ msgstr "attributet %qs kräver prototyper med namngivna argument"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "attributet %qs fungerar bara på funktioner med variabelt antal argument"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47170,8 +47214,8 @@ msgstr "den angivna filen %s är en katalog"
 msgid "could not get size of source file"
 msgstr "kunde inte få storleken på källfilen"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "värdet av typen void ignoreras inte vilket bör göras"
@@ -47650,7 +47694,7 @@ msgstr "switch hoppar in i satsuttryck"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE definierad som fel sorts tagg"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "attributet %qE tillämpat på %qD med returtypen void"
@@ -47799,7 +47843,7 @@ msgstr "ISO C90 stödjer inte %<static%> eller typkvalificerare i parametervekto
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 stödjer inte %<[*]%>-vektordeklarerare"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "%<omp::%s%> är inte tillåtet att anges i detta sammanhang"
@@ -47809,7 +47853,7 @@ msgstr "%<omp::%s%> är inte tillåtet att anges i detta sammanhang"
 msgid "%q+D is usually a function"
 msgstr "%q+D är vanligtvis en funktion"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "ingen tidigare deklaration av %qD"
@@ -47885,7 +47929,7 @@ msgstr "kan inte lägga objekt med volatile-fält i register"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "oinitierad %<const %D%> är ogiltig i C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%q+D i deklarationsmålsdirektiv har inte en avbildbar typ"
@@ -48038,7 +48082,7 @@ msgstr "dubblerad %<_Atomic%>"
 #: c/c-decl.cc:7086
 #, gcc-internal-format, gfc-internal-format
 msgid "conflicting named address spaces (%s vs %s)"
-msgstr "motstridande namngivna adressrymder (%s respektive %s)"
+msgstr "motstridiga namngivna adressrymder (%s respektive %s)"
 
 #: c/c-decl.cc:7109 c/c-parser.cc:3982
 #, gcc-internal-format
@@ -48085,7 +48129,7 @@ msgstr "lagringsklass angiven för parameter %qE"
 msgid "storage class specified for unnamed parameter"
 msgstr "lagringsklass angiven för namnlös parameter"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "lagringsklass angiven för typnamn"
@@ -48258,7 +48302,7 @@ msgstr "typnamn är deklarerat som en funktion som returnerar en vektor"
 msgid "function definition has qualified void return type"
 msgstr "funktionsdefinition som har kvalificerad void-returtyp"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "typkvalificerare ignoreras för funktions returtyp"
@@ -48385,7 +48429,7 @@ msgstr "ISO C förbjuder const- eller volatile-funktionstyper"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "en medlem av an post eller union får inte ha variabel typ"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "variabel eller fält %qE deklarerad void"
@@ -48597,7 +48641,7 @@ msgstr "att definiera en typ i %qs-uttryck är ogiltigt i C++"
 msgid "%qT defined in underspecified object initializer"
 msgstr "%qT är definierat i underspecificerad objektinitierare"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "deklaration som inte deklarerar något"
@@ -48662,10 +48706,10 @@ msgstr "posten har inga namngivna medlemmar"
 msgid "struct has no members"
 msgstr "posten har inga medlemmar"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
-msgstr "flexibel vektormedlem i union är en GCC-utökning"
+msgstr "flexibel vektormedlem i union är en GCC-utvidgning"
 
 #: c/c-decl.cc:9748
 #, gcc-internal-format
@@ -48675,7 +48719,7 @@ msgstr "flexibel vektormedlem inte vid slutet av post"
 #: c/c-decl.cc:9753
 #, gcc-internal-format
 msgid "flexible array member in a struct with no named members is a GCC extension"
-msgstr "flexibel vektormedlem i struct utan namngivna medlemmar är en GCC-utökning"
+msgstr "flexibel vektormedlem i struct utan namngivna medlemmar är en GCC-utvidgning"
 
 #: c/c-decl.cc:9800
 #, gcc-internal-format
@@ -48727,7 +48771,7 @@ msgstr "omdeklaration av %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr "%<enum%> deklarerad med men definierad utan en fast underliggande typ"
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr "angiven sort för liten för uppräkningsvärden"
@@ -48782,7 +48826,7 @@ msgstr "uppräkningsvärdet är utanför intervallet för %qs"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C begränsar uppräkningsvärden till intervallet hos %<int%> före C23"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "inline-funktionen %qD har fått attributet %qs"
@@ -48932,12 +48976,12 @@ msgstr "argument %qD stämmer inte med inbyggd prototyp"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "argument %qD stämmer inte med prototypen"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "ingen retursats i funktion som returnerar icke-void"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "parametern %qD sätts men används inte"
@@ -49019,7 +49063,7 @@ msgstr "%<auto%> använt med %<constexpr%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "två eller fler datatyper i deklaration av specificerare"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> är för långt för GCC"
@@ -49123,7 +49167,7 @@ msgstr "ISO C90 stödjer inte booleska typer"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C stödjer inte typen %<_Float%d%s%> före C23"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<_Float%d%s%> stödjs inte för denna målarkitektur"
@@ -49280,12 +49324,12 @@ msgstr "argumentet till %<signed _BitInt%> måste vara åtminstone 2"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C stödjer inte %<%s_BitInt(%d)%> före C23"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr "%<#pragma omp declare reduction%>-kombinerare refererar variabeln %qD som inte är varken %<omp_out%> eller %<omp_in%>"
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr "%<#pragma omp declare reduction%>-initierare refererar till variabeln %qD som inte är varken %<omp_priv%> eller %<omp_orig%>"
@@ -49345,37 +49389,37 @@ msgstr "satsen %<break%> operand %qE refererar till en %<switch%> utanför sin k
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs är ett nyckelord med %qs framöver"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "vänsterskift med negativt värde"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "vänstershiftoperanden är negativ"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "högershiftoperanden är negativ"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "vänstershiftoperanden ≥ storleken på typen"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "högershiftoperanden ≥ storleken på typen"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "vänstershiftoperanden ≥ storleken på vektorelementet"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "högershiftoperanden ≥ storleken på vektorelementet"
@@ -49395,7 +49439,7 @@ msgstr "markör för versionshanteringskonflikt i filen"
 msgid "to match this %qs"
 msgstr "för att matcha denna %qs"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "oväntat radslut"
@@ -49405,7 +49449,7 @@ msgstr "oväntat radslut"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C förbjuder tomma översättningsenheter"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -49414,7 +49458,7 @@ msgstr "%qs utan motsvarande %qs"
 #: c/c-parser.cc:2126 cp/semantics.cc:4068
 #, gcc-internal-format
 msgid "%<omp begin declare variant%> without corresponding %<omp end declare variant%>"
-msgstr "%<omp start declare variant%> utan motsvarande %<omp end declare variant%>"
+msgstr "%<omp begin declare variant%> utan motsvarande %<omp end declare variant%>"
 
 #: c/c-parser.cc:2230 c/c-parser.cc:14910
 #, gcc-internal-format
@@ -49452,8 +49496,8 @@ msgid "unknown type name %qE"
 msgstr "okänt typnamn %qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "deklarationsspecificerare förväntades"
@@ -49488,7 +49532,7 @@ msgstr "attributet %<musttail%> blandat med andra attribut på satsen %<return%>
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "%<;%>, identifierare eller %<(%> förväntades"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "prefixattribut ignoreras för metoder"
@@ -49503,12 +49547,12 @@ msgstr "prefixattribut ignoreras för implementeringar"
 msgid "unexpected attribute"
 msgstr "oväntat attribut"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "attributet %<fallthrough%> följs inte av %<;%>"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "attributet %<assume%> följs inte av %<;%>"
@@ -49551,7 +49595,7 @@ msgstr "%qs behöver en initierad datadeklaration"
 msgid "%qs may only be used with a single declarator"
 msgstr "%qs kan endast användas med en ensam deklarerare"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "%<,%> eller %<;%> förväntades"
@@ -49582,10 +49626,10 @@ msgstr "en %<__RTL%>-funktion kan inte vara en nästad funktion"
 #: c/c-parser.cc:3372
 #, gcc-internal-format
 msgid "%<__GIMPLE%> function cannot be a nested function"
-msgstr "en %<__RTL%>-funktion kan inte vara en nästad funktion"
+msgstr "en %<__GIMPLE%>-funktion kan inte vara en nästad funktion"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "strängkonstant förväntades"
@@ -49615,7 +49659,7 @@ msgstr "uttryck i statisk försäkran är inte konstant"
 msgid "static assertion failed: %E"
 msgstr "statisk försäkran misslyckades: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "statisk försäkran misslyckades"
@@ -49669,8 +49713,8 @@ msgstr "kan inte använda nyckelordet %qs som en uppräkningskonstant"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "identifierare förväntades"
@@ -49700,12 +49744,12 @@ msgstr "felaktig underliggande typ för %<enum%>"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "underliggande typ för %<enum%> står i konflikt med tidigare deklaration"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "komma i slutet av uppräkningslista"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -49786,22 +49830,22 @@ msgstr "deklarationsspecificerare eller %<...%> förväntades"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "parenteser måste utelämnas om attributargumentlistan är tom"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "ett OpenMP-direktiv förväntades"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "%<directive%> eller %<sequence%> förväntades"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "attributet %<omp::%E%> behöver argument"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "attributet %qE tar inga argument"
@@ -49811,7 +49855,7 @@ msgstr "attributet %qE tar inga argument"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C stödjer inte %<[[]]%>-attribut före C23"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr "objekt med variabel storlek kan inte initieras utom med en tom initierare"
@@ -49841,17 +49885,17 @@ msgstr "ISO C90 förbjuder specificering av underobjekt som skall initieras"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "föråldrad användning av designerade initierare utan %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "inre slingor måste vara perfekt nästade i %<#pragma acc loop%>"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "inre slingor måste vara perfekt nästade med en %<ordered%>-klausul"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr "inre slingor måste vara perfekt nästade med en %<reduction%> %<inscan%>-klausul"
@@ -49861,44 +49905,44 @@ msgstr "inre slingor måste vara perfekt nästade med en %<reduction%> %<inscan%
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr "inre slingor måste vara perfekt nästade i %<pragma omp tile%>"
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr "OpenMP-direktiv blandas med attribut- och pragma-syntax på samma sats"
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr "OpenMP %<omp::decl%>-attribut på en sats"
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "okänt OpenMP-direktivnamn i klausulargumentet %qs"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr "OpenMP-konstruktion bland %<omp::directive%>-attribut kräver att alla %<omp::directive%>-attribut på samma sats är i samma %<omp::sequence%>"
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr "flera fristående OpenMP-direktiv bland %<omp::directive%>-attribut måste alla vara inom samma %<omp::sequence%>"
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr "fristående OpenMP-direktiv i attributet %<omp::directive%> får bara förekomma på en tom sats"
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr "OpenMP-direktiv blandas med attribut- och pragma-syntax på samma deklaration"
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "attributet %qs tar inga argument"
@@ -49929,7 +49973,7 @@ msgstr "ISO C90 förbjuder blandade deklarationer och kod"
 msgid "expected %<}%> before %<else%>"
 msgstr "%<}%> förväntades före %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> utan ett föregående %<if%>"
@@ -49944,7 +49988,7 @@ msgstr "etikett vid slutet av sammansatt sats"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "sats förväntades"
@@ -49979,27 +50023,27 @@ msgstr "ISO C stödjer inte if-deklarationer före C2Y"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "en deklaration i styruttrycket måste ha en initierare"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "en deklaration förväntades"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "föreslår klamrar runt tom kropp i en %<if%>-sats"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "föreslår klamrar runt tom kropp i en %<else%>-sats"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "föreslår uttryckliga klamrar för att undvika tvetydighet i %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr "en slinga är inte tillåten i mellanliggande kod i OpenMP:s slingkropp"
@@ -50019,12 +50063,12 @@ msgstr "flera iterationsvariabler i snabb uppräkning"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "ogiltigt iterationsvariabel i snabb uppräkning"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr "slingvillkor saknas i slinga med %<GCC ivdep%>-pragma"
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr "slingvillkor saknas i slinga med %<GCC unroll%>-pragma"
@@ -50039,8 +50083,8 @@ msgstr "saknad samling i snabb uppräkning"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "upprepade %<asm%>-kvalificerare %qE"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr "först sedd här"
@@ -50062,12 +50106,12 @@ msgstr "ISO C förbjuder utelämnande av den mittersta termen i ett %<?:%>-uttry
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr "divisionen %<sizeof (%T) / sizeof (%T)%> beräknar inte antalet vektorelement"
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "första %<sizeof%>-operanden deklarerades här"
@@ -50239,7 +50283,7 @@ msgstr "ISO C90 stödjer inte den fördefinierade identifieraren %<__func__%>"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "uttryck förväntades"
@@ -50254,12 +50298,12 @@ msgstr "klammergrupp inuti uttryck endast tillåtet inuti en funktion"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C förbjuder klammergrupper inuti uttryck"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, gcc-internal-format
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "den frivilliga andra parametern till %<va_start%> är inte det sista namngivna argumentet"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr "makrot %<va_start%> använt med ytterligare argument andra än identifierare av det sista namngivna argumentet"
@@ -50404,7 +50448,7 @@ msgstr "argumentet till %<__builtin_counted_by_ref%> måste vara en vektor eller
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "argumentet till %<__builtin_counted_by_ref%> måste vara ett fält i en post"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "fel antal argument till %<__builtin_shuffle%>"
@@ -50444,7 +50488,7 @@ msgstr "argument 1 i anrop av funktionen %qs har typen %<char%>"
 msgid "rotate count is negative"
 msgstr "rotationsantalet är negativt"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr "%<omp_all_memory%> kan bara användas i en OpenMP %<depend%>-klausul"
@@ -50554,7 +50598,7 @@ msgstr "använder absolutvärdesfunktionen %qD för decimala flyttal när argume
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr "absolutvärdesfunktionen %qD ges ett argument av typen %qT men har en parameter av typen %qT som kan orsaka avhuggning av värdet"
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr "anrop av OpenMP:s körtids-API är inte tillåtet i mellanliggande kod"
@@ -50594,12 +50638,12 @@ msgstr "objective-c-metoddeklaration förväntas"
 msgid "no type or storage class may be specified here,"
 msgstr "ingen typ eller lagringsklass kan anges här,"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "tom egenskapsattributslista"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, gcc-internal-format
 msgid "missing property attribute"
 msgstr "saknat egenskapsattribut"
@@ -50609,57 +50653,57 @@ msgstr "saknat egenskapsattribut"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "okänt egenskapsattribut %<%s%s%>"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "okänt egenskapsattribut"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "%<=%> förväntades efter Objective-C %qE"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "%qE-väljarnamn förväntades"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "setter-metodnamn måste avslutas med %<:%>"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr "%<#pragma GCC unroll%> kräver ett tilldelningsuttryck som beräknas till en icke-negativ heltalskonstant mindre än %u"
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr "mellanliggande kod får inte innehålla körbara OpemMP-direktiv"
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma %s%> får bara användas i sammansatta satser"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> måste ha filräckvidd"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp scan%> får bara användas i en slingkonstruktion med %<inscan%> %<reduction%>-klausul"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> får bara användas i %<#pragma omp sections%>-konstruktion"
@@ -50669,12 +50713,12 @@ msgstr "%<#pragma omp section%> får bara användas i %<#pragma omp sections%>-k
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma %s%> får bara användas med filräckvidd"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "for-, while- eller do-sats förväntades"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> måste komma först"
@@ -50684,11 +50728,11 @@ msgstr "%<#pragma GCC pch_preprocess%> måste komma först"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "för många %qs-klausuler"
@@ -50703,58 +50747,58 @@ msgstr "uttrycket måste vara ett heltal"
 msgid "%qD is not a variable"
 msgstr "%qD är inte en variabel"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD är inte en pekarvariabel"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "collapse-argument behöver ett positivt konstant heltalsuttryck"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "%<none%> eller %<present%> förväntades"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "%<none%>, %<shared%>, %<private%> eller %<firstprivate%> förväntades"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "ett konstant logiskt uttryck förväntades"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "%<data%>, %<update%>, %<enter%> eller %<exit%> förväntades"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "%<data%> förväntades"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "för många %<if%>-klausuler med %qs-modifierare"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "för många %<if%>-klausuler"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "för många %<if%>-klausuler utan modifierare"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr "om någon %<if%>-klausul har en modifierare måste alla %<if%>-klausuler använda modifierare"
@@ -50777,22 +50821,22 @@ msgstr "%<num_threads%>-värdet måste vara positivt"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_tasks%>-värdet måste vara positivt"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%<grainsize%>-värdet måste vara positivt"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "%<priority%>-värdet måste vara positivt"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "konstant heltalsuttryck med giltigt sync-hint-värde förväntades"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "%<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> eller %<default%> förväntades"
@@ -50802,99 +50846,99 @@ msgstr "%<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> elle
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "%<scalar%>, %<aggregate%>, %<pointer%> eller %<all%> förväntades"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "för många %<defaultmap%>-klausuler med %qs-modifierare"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "för många %<defaultmap%>-klausuler med ospecificerad kategori"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "%qs-uttrycket måste vara ett heltal"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%qs-värdet måste vara positivt"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "för många %<static%>-argument"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "oväntat argument"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "argumentet till %<tile%> behöver en positiv heltalskonstant"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "för många %<self%>-klausuler"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "%<reproducible%> eller %<unconstrained%> förväntades"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "%<concurrent%> förväntades"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "%<teams%>, %<parallel%> eller %<thread%> förväntades"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "ordered-argument behöver ett positivt konstant heltalsuttryck"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr "%<-%>-operatorn för reduktioner fasas ut i OpenMP 5.2"
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "%<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> eller identifierare förväntades"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "både %<monotonic%>- och %<nonmonotonic%>-modifierare angivna"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "%<runtime%>-schemaläggning tar ingen %<chunk_size%>-parameter"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "%<auto%>-schemaläggning tar ingen %<chunk_size%>-parameter"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "värdet på styckesstorleken måste vara positivt"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "ogiltig schedule-sort"
@@ -50904,41 +50948,41 @@ msgstr "ogiltig schedule-sort"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_teams%>-värdet måste vara positivt"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr "%<num_teams%> undre gräns %qE är större än den övre gränsen %qE"
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<thread_limit%>-värdet måste vara positivt"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "%<aligned%>-klausulens justeringsuttryck måste vara ett positivt konstant heltalsuttryck"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "%<allocator%> eller %<align%> förväntades"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr "dubblerad %qs-modifierare"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr "%<allocate%>-klausulens allokeraruttryck har typen %qT istället för %<omp_allocator_handle_t%>"
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
-msgstr "argumentet till modifieraren %<align%> av klausulen %<allocate%> måste vara ett positivt konstant heltalsuttryck som är en exponent av två"
+msgstr "argumentet till modifieraren %<align%> av klausulen %<allocate%> måste vara ett positivt konstant heltalsuttryck som är en potens av två"
 
 #: c/c-parser.cc:19730
 #, gcc-internal-format
@@ -50950,22 +50994,22 @@ msgstr "%<traits%> eller %<memspace%> förväntades"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr "den äldre egenskapssyntaxen %<%s(%s)%> är inte tillåten i klausulen %<uses_allocators%> när modifierare används"
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr "specifikationen av argument till %<uses_allocators%> där varje objekt har formen %<allocator(traits)%> är utfasad sedan OpenMP 5.2"
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr "klausulen %<uses_allocators%> accepterar endast en enda allokerare när modifierare används"
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "upprepade linear-modifierare"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "upprepade %<step%>-modifierare"
@@ -50975,7 +51019,7 @@ msgstr "upprepade %<step%>-modifierare"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "%<linear%>-klausulens steguttryck måste vara heltal"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr "att specificera listobjekten som argument till modifierarna fasas ut sedan OpenMP 5.2"
@@ -50990,311 +51034,311 @@ msgstr "%<safelen%>-klausulens uttryck måste vara ett positivt konstant heltals
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "%<simdlen%>-klausulens uttryck måste vara ett positivt konstant heltalsuttryck"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr "modifieraren %<sink%> med klausulen %<depend%> fasas ut sedan OpenMP 5.2, använd med %<doacross%>"
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr "modifieraren %<source%> med klausulen %<depend%> fasas ut sedan OpenMP 5.2, använd med %<doacross%>"
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "modifieraren %<iterator%> är inkompatibel med %qs"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "ogiltig depend-sort"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "felaktig doacross-sort"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "modifieraren %<fallback%> förväntades"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "%<abort%>, %<default_mem%> eller %<null%> förväntades som reservläge"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%<dyn_groupprivate%>-värdet måste vara positivt"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, gcc-internal-format
 msgid "illegal comma"
 msgstr "ogiltigt komma"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "för många %<always%>-modifierare"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "för många %<close%>-modifierare"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr "för många %<iterator%>-modifierare"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr "för många %<mapper%>-modifierare"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr "i direktiv %<declare mapper%> måste parametern till modifieraren %<mapper%> vara %<default%>"
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, gcc-internal-format
 msgid "expected identifier or %<default%>"
 msgstr "identifierare eller %<default%> förväntades"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "för många %<present%>-modifierare"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "en klausul %<map%> med en annan avbildningstypsmodifierare än %<always%>, %<close%>, %<iterator%>, %<mapper%> eller %<present%>"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr "klausulmodifieraren %<map%> utan kommaseparation fasas ut sedan OpenMP 5.2"
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "ogiltig map-sort"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr "%<ancestor%>-enhetsmodifierare som inte föregås av ett %<requires%>-direktiv med en klausul %<reverse_offload%>"
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "%<ancestor%> eller %<device_num%> förväntades"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "%<device%>-klausulens uttryck måste beräknas till %<1%>"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "ogiltig dist_schedule-sort"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr "affiniteten %<master%> fasas ut sedan OpenMP 5.1, använd %<primary%>"
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "ogiltig proc_bind-sort"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "%<host%>, %<nohost%> eller %<any%> förväntades"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "en klausul %qs med en annan modifierare än %<iterator%> eller %<present%>"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "argumentet till %<partial%> behöver ett positivt konstant heltalsuttryck"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr "%<detach%>-klausulens händelsehandtag har typen %qT istället för %<omp_event_handle_t%>"
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr "stränglitteraler får inte innehålla %<\\0%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "okänd främmande körtidsidentifierare %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression"
-msgstr "en strängliteral eller ett konstant heltalsuttryck förväntades"
+msgstr "en stränglitteral eller ett konstant heltalsuttryck förväntades"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr "okänd främmande körtidsidentifierare %qwd"
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "preferensväljaren %<fr%> eller %<attr%> förväntades"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr "dubblerad preferensväljare %<fr%>"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
-msgstr "stränglitteralen %<attr%> måste börja med med %<ompx_%>"
+msgstr "stränglitteralen %<attr%> måste börja med %<ompx_%>"
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr "stränglitteralen %<attr%> får inte innehålla ett kommatecken"
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, gcc-internal-format
 msgid "non-empty string literal expected"
 msgstr "icke-tom stränglitteral förväntades"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, gcc-internal-format
 msgid "duplicate %<targetsync%> modifier"
 msgstr "dubblerad %<targetsync%>-modifierare"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "dubblerad %<target%>-modifierare"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, gcc-internal-format
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "dubblerad %<prefer_type%>-modifierare"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "%<prefer_type%>, %<target%> eller %<targetsync%> förväntades"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr "saknad nödvändig modifierare %<target%> och/eller %<targetsync%>"
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "en OpenACC-klausul förväntades"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs är inte giltigt för %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr "klausuler i %<simd%>-egenskap skall separeras av %<,%>"
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs måste vara den första klausulen i %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr "klausulen %<to%> med %<declare target%> fasas ut sedan OpenMP 5.2, använd %<enter%>"
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "en OpenMP-klausul förväntades"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "inga giltiga klausuler angivna i %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "vektorsektionen i %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "%qD måste vara en global variabel i %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "ogiltig OpenACC-klausul vid filräckvidd"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "ogiltig användning av %<extern%>-variabel %qD i %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "ogiltig användning av %<global%>-variabeln %qD i %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "%qD måste vara en variabel deklarerad i samma räckvidd som %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "variabeln %qD använd mer än en gång med %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "%<data%> förväntades efter %<#pragma acc %s%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma acc %s data%> har ingen dataflyttningsklausul"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr "konstruktionen %<host_data%> kräver en klausul %<use_device%>"
@@ -51309,7 +51353,7 @@ msgstr "%qE har inte deklarerats"
 msgid "expected function name"
 msgstr "ett funktionsnamn förväntades"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD refererar inte till en funktion"
@@ -51319,22 +51363,22 @@ msgstr "%qD refererar inte till en funktion"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma acc routine%> följs inte omedelbart av en funktionsdeklaration eller -definition"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma acc routine%> följs inte omedelbart av en ensam funktionsdeklaration eller -definition"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> måste vara tillämpad före användning"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> måste vara tillämpad före definitionen"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> måste innehålla åtminstone en %<device%>- eller %<host%>- eller %<self%>-klausul"
@@ -51359,10 +51403,10 @@ msgstr "variabeln %qD använd i klausulen %<allocator%> får inte ändras mellan
 msgid "modified here"
 msgstr "modifierad här"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
-msgstr "klausulargumentet %<align%> måste vara ett positivt konstant heltalsuttryck som är en exponent av två"
+msgstr "klausulargumentet %<align%> måste vara ett positivt konstant heltalsuttryck som är en potens av två"
 
 #: c/c-parser.cc:23491
 #, gcc-internal-format
@@ -51392,112 +51436,112 @@ msgstr "klausulen %<allocator%> krävs för den statiska variabeln %qD"
 #: c/c-parser.cc:23543
 #, gcc-internal-format
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
-msgstr "%<allocate%>-klausulen kräver en fördefinierad allokerare eftersom %qD är statisk"
+msgstr "%<allocator%>-klausulen kräver en fördefinierad allokerare eftersom %qD är statisk"
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "%<read%>-, %<write%>-, %<update%>- eller %<capture%>-klausul förväntades"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "%<seq_cst%>, %<acquire%> eller %<relaxed%> förväntades"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "%<read%>-, %<write%>-, %<update%>-, %<capture%>-, %<compare%>-, %<weak%>-, %<fail%>-, %<seq_cst%>-, %<acq_rel%>-, %<release%>-, %<relaxed%>- eller %<hint%>-klausul förväntades"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "för många atomära klausuler"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "för många minnesordningsklausuler"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "en %qs-klausul är inkompatibel med en %<read%>- eller %<write%>-klausul"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "en %qs-klausul behöver en %qs-klausul"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic write%> är inkompatibelt med en %<acquire%>-klausul implicit tillhandahållen av ett %<requires%>-direktiv"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic read%> är inkompatibelt med en %<release%>-klausul implicit tillhandahållen av ett %<requires%>-direktiv"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp atomic read%> är inkompatibelt med en %<release%>-klausul"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp atomic write%> är inkompatibelt en %<acquire%>-klausul"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "en %<==%>-jämförelse förväntades i ett %<if%>-villkor"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr "jämförelse med %<==%>, %<<%> eller %<>%> förväntades i %<if%>-villkor"
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "ogiltig form på %<#pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "oväntat %<else%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "ogiltig form på %<pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "ogiltig form på %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "ogiltig operator för %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr "%<weak%>-klausul kräver atomär likhetsjämförelse"
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> använder två olika uttryck till minne"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "uttrycket %<depobj%> är inte ett l-värde-uttryck"
@@ -51507,27 +51551,27 @@ msgstr "uttrycket %<depobj%> är inte ett l-värde-uttryck"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "uttrycket %<destroy%> är inte ett l-värde-uttryck"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr "uttrycket %qE till %<destroy%> skall vara detsamma som argumentet %qE till %<depobj%>"
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "%<in%>, %<out%>, %<inout%>, %<mutexinoutset%> eller %<inoutset%> förväntades"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "%<depend%>-, %<destroy%>- eller %<update%>-klausul förväntades"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "%<seq_cst%>, %<acq_rel%>, %<release%> eller %<acquire%> förväntades"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr "%<flush%>-lista specificerat tillsammans med minnesordningsklausul"
@@ -51537,32 +51581,32 @@ msgstr "%<flush%>-lista specificerat tillsammans med minnesordningsklausul"
 msgid "expected %<(%> or end of line"
 msgstr "%<(%> eller filslut förväntades"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr "%<[[omp::directive(%s)]]%> måste vara det enda angivna attributet på en sats"
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp scan%> med noll föregående körbara satser"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "en %<inclusive%>- eller %<exclusive%>-klausul förväntades"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "%<#pragma omp scan%> förväntades"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
-msgstr "%<#pragma omp scan%> med noll flöljande körbara satser"
+msgstr "%<#pragma omp scan%> med noll följande körbara satser"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "for-sats förväntades"
@@ -51570,68 +51614,68 @@ msgstr "for-sats förväntades"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, gcc-internal-format
 msgid "loop nest expected"
 msgstr "en slingnästning förväntades"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr "andra attribut än OpenMP-direktiv är inte tillåtna på %<for%> i slingnästning"
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr "konstruktionen %<unroll%> med en klausul %<partial%> genererar bara en slinga med kanonisk form men %d slingor behövs"
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr "en generad slinga av en %<unroll%>-konstruktion utan en %<partial%>-klausul har inte kanonisk form"
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr "%<tile%>-konstruktionen genererade %d slingor med kanonisk form, men %d slingor behövs"
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr "%<for%>-slinga eller OpenMP-slingtransformationskonstruktion förväntades"
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "iterationsdeklaration eller initiering förväntades"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "inte tillräckligt med nästade slingor"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "%<ordered%>-klausulparameter är mindre än %<collapse%>"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "iterationsvariabel %qD får inte vara firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr "konstruktionen %<master%> fasas ut sedan OpenMP 5.1, använd %<masked%>"
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp ordered%> med %qs-klausul får bara användas i sammansatta satser"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "%<for%> förväntades efter %qs"
@@ -51641,7 +51685,7 @@ msgstr "%<for%> förväntades efter %qs"
 msgid "expected a function name"
 msgstr "ett funktionsnamn förväntades"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, gcc-internal-format
 msgid "expected target-function call"
 msgstr "ett målfunktionsanrop förväntades"
@@ -51651,47 +51695,47 @@ msgstr "ett målfunktionsanrop förväntades"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma omp dispatch%> måste följas av ett funktionsanrop eventuellt med en tilldelning"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "%<point%> förväntades"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target data%> med en annan map-typ än %<to%>, %<from%>, %<tofrom%> eller %<alloc%> på %<map%>-klausul"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp target data%> måste innehålla åtminstone en %<map%>-, %<use_device_ptr%>- eller %<use_device_addr%>-klausul"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp target update%> måste innehålla åtminstone en %<from%>- eller %<to%>-klausul"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target enter data%> med en annan map-typ än %<to%>, %<tofrom%> eller %<alloc%> på %<map%>-klausul"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target enter data%> måste innehålla åtminstone en %<map%>-klausul"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp target exit data%> med en annan map-typ än %<from%>, %<tofrom%>, %<release%> eller %<delete%> på %<map%>-klausul"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target exit data%> måste innehålla åtminstone en %<map%>-klausul"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target%> med en annan map-typ än %<to%>, %<from%>, %<tofrom%> eller %<alloc%> på %<map%>-klausul"
@@ -51706,57 +51750,57 @@ msgstr "%<#pragma omp declare %s%> måste följas av funktionsdeklaration eller
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> måste följas av en funktionsdeklaration eller -definition"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "trait-väljarnamn förväntades"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "okänd selektor %qs för kontextselektormängden %qs"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "väljaren %qs tar inte några egenskaper"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<score%> kan inte anges i egenskaper i trait-selector-set %qs"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "argumentet till %<score%> måste vara ett konstant heltalsuttryck"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "argumentet till %<score%> måste vara ickenegativt"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "identifierare eller strängkonstant förväntades"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "egenskapen måste vara ett heltalsuttryck"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "egenskaper för %<simd%>-väljare får inte anges i %<metadirective%>"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "selektorn %<requires%> stödjs inte ännu"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "namn på kontextväljare förväntades"
@@ -51766,27 +51810,27 @@ msgstr "namn på kontextväljare förväntades"
 msgid "variant %qD is not a function"
 msgstr "varianten %qD är inte en funktion"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr "varianten %qD är en inbyggd"
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "varianten %qD är samma som basfunktionen"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "en klausul %<match%>, %<adjust_args%> eller %<append_args%> förväntades"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "för många %<match%>-klausuler"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "%qD angivet mer än en gång"
@@ -51796,7 +51840,7 @@ msgstr "%qD angivet mer än en gång"
 msgid "%qD is not of pointer type"
 msgstr "%qD är inte av pekartyp"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "%<nothing%> eller %<need_device_ptr%> förväntades"
@@ -51806,17 +51850,17 @@ msgstr "%<nothing%> eller %<need_device_ptr%> förväntades"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%<need_device_addr%> är inte giltigt i C"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "%<nothing%> eller %<need_device_ptr%> följt av %<:%> förväntades"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "%<interop%> förväntades"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "en klausul %<match%> förväntades"
@@ -51836,12 +51880,12 @@ msgstr "%<append_args%> med basfunktion utan prototyp stödjs inte ännu"
 msgid "base function %qD declared here"
 msgstr "basfunktionen %qD är deklarerad här"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "argument %d till %qD måste vara av %<omp_interop_t%>"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "%<append_args%> angivet här"
@@ -51851,7 +51895,7 @@ msgstr "%<append_args%> angivet här"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "varianten %qD och basen %qD har inkompatibla typer efter justeringen %<append_args%>"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "varianten %qD och basen %qD har inkompatibla typer"
@@ -51861,7 +51905,7 @@ msgstr "varianten %qD och basen %qD har inkompatibla typer"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma omp declare %s%> som inte omedelbart följs av en funktionsdefinition eller -deklaration"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma omp declare %s%> som inte omedelbart följs av en ensam funktionsdeklaration eller -definition"
@@ -51876,84 +51920,84 @@ msgstr "%<#pragma omp declare %s%> får inte användas med en multiversionering
 msgid "no declaration of base function %qs"
 msgstr "ingen deklaration av basfunktionen %qs"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "variantfunktionsdefinitionen matchar inte deklarationen av %qE"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr "användningen av %<omp declare target%> som en synonym för %<omp begin declare target%> har fasats ut sedan OpenMP 5.2"
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD angivet både i deklarationsmålets %<link%>- och %qs-klausuler"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "%qD angivet både i deklarationsmålets %<link%>- och %<to%>- eller %<enter%>-klausuler"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr "direktiv med endast %<device_type%>- eller %<indirect%>-klausul"
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "klausulen %<device_type%> måste ange ”any” när den används med en %<indirect%>-klausul"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "%<match%> förväntades"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "%<target%> eller %<variant%> förväntades"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "%<declare target%>, %<declare variant%> eller %<assumes%> förväntades"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma omp end declare target%> utan en motsvarande %<#pragma omp declare target%> eller %<#pragma omp begin declare target%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr "%qs i attributsyntax som avslutas med %qs i pragma-syntax"
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%qs i pragma-syntax som avslutas med %qs i attributsyntax"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma omp end declare variant%> utan motsvarande %<#pragma omp begin declare variant%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr "%<begin declare variant%> i attributsyntax som avslutas med %<end declare variant%> i pragma-syntax"
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
-msgstr "%<begom decöare variant%> i pragma-syntax som avslutas med %<end declare variant%> i attributsyntax"
+msgstr "%<begin declare variant%> i pragma-syntax som avslutas med %<end declare variant%> i attributsyntax"
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "%<declare%> eller %<assumes%> förväntades"
@@ -51978,12 +52022,12 @@ msgstr "omdeklaration av %qs %<#pragma omp declare mapper%> för typen %qT"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%<#pragma omp declare mapper%> deklarerades tidigare här"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, gcc-internal-format
 msgid "unexpected clause"
 msgstr "oväntad klausul"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "en klausul %<map%> saknas"
@@ -52043,32 +52087,32 @@ msgstr "en av initierarens anropsargument skall vara %<&omp_priv%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "%<simd%>, %<reduction%>, %<target%> eller %<variant%> förväntades"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "%<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> eller %<seq_cst%> förväntades"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr "en klausul %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> eller %<atomic_default_mem_order%> förväntades"
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr "klausulen %qs använd lexikalt efter första målkonstruktionen eller avlastnings-API:et"
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr "mer än en klausul %<atomic_default_mem_order%> i en enskild kompileringsenhet"
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr "klausulen %<atomic_default_mem_order%> använd lexikalt efter första konstruktionen %<atomic%> utan minnesordningsklausul"
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr "%<pragma omp requires%> kräver åtminstone en klausul"
@@ -52083,160 +52127,160 @@ msgstr "nollstor typ %qT i %<reduction%>-klausul"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "typen %qT med variabel storlek i-%<reduction%>-klausul"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "%<sizes%> förväntades"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "argumentet till %<sizes%> behöver en positiv heltalskonstant"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "%<at%>-, %<severity%>- eller %<message%>-klausul förväntades"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "%qs eller %qs förväntades"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp error%> med %<at(execution)%>-klausul får bara användas i sammansatta satser"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp error%> med %<at(execution)%>-klausul får inte användas i mellanliggande kod"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr "%<pragma omp error%> påträffat: %s"
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr "%<pragma omp error%> påträffat"
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
-msgstr "åtminstone enn assumption-klausul förväntades"
+msgstr "åtminstone en assumption-klausul förväntades"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr "ett direktivnamn förväntades"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr "felaktigt OpenMP-direktivnamn i klausulargumentet %qs: direktiven declarative, informational och meta är inte tillåtna"
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr "okänt OpenMP-direktivnamn i attributargumentet %qs"
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr "%<%s%s%s%s%s%>-direktivet nämnt i både %<absent%>- %<contains%>-klausuler"
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr "%<%s%s%s%s%s%>-direktivet nämnt flera gånger i %qs-klausuler"
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "okänd assumption-klausul %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "assumption-klausul förväntades"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
-msgstr "en klausul %<when%>-, %<otherwise%>- eller %<default%> förväntades"
+msgstr "en klausul %<when%>, %<otherwise%> eller %<default%> förväntades"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr "klausulen %<default%> på metadirektiv fasas ut sedan OpenMP 5.2, använd %<otherwise%>"
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "för många %<otherwise%>- eller %<default%>-klausuler i %<metadirective%>"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "klausulen %<otherwise%> eller %<default%> måste komma sist i %<metadirective%>"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, gcc-internal-format
 msgid "unknown directive name"
 msgstr "okänt direktivnamn"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr "metadirektiv kan inte användas som varianter av ett %<metadirective%>"
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr "deklarativa varianter av ett %<metadirective%> stödjs inte"
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr "%<omp groupprivate%>"
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE är deklarerad %<threadprivate%> efter första användningen"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "automatisk variabel %qE kan inte vara %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE har ofullständig typ"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%> utan stöd för transaktionsminne aktiverat"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%> utan stöd för transaktionsminne aktiverat"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%> utan att stöd för transaktionsminne är aktiverat"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> inom en %<__transaction_relaxed%>"
@@ -52246,7 +52290,7 @@ msgstr "%<__transaction_cancel%> inom en %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "yttre %<__transaction_cancel%> som inte är inuti en yttre %<__transaction_atomic%>- eller en %<transaction_may_cancel_outer%>-funktion"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> inte inom %<__transaction_atomic%>"
@@ -52261,7 +52305,7 @@ msgstr "ingen avslutande klammer"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD har en ofullständig typ %qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "ogiltig användning av void-uttryck"
@@ -52292,167 +52336,167 @@ msgstr "ogiltig användning av ofullständig typedef %qT"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT och %qT är i skilda namngivna adressrymder"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "attributet %qs kan endast användas på funktioner med variabelt antal argument"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "funktionstyper inte riktigt kompatibla i ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "det går inte att blanda operander av typerna decimalt flyttal och vektor"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "det går inte att blanda operander av typerna flyttal och komplext tal"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "det går inte att blanda operander av typerna decimalt flyttal och annat flyttal"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr "%<_Complex _BitInt(%d)%> stödjs inte"
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "otillåten användning av pekare till vektorer med olika kvalificerare i ISO C före C23"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "typerna är inte riktigt kompatibla"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "pekares måltyper är inkompatibla i C++"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "funktionsreturtyper är inte kompatibla på grund av %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "konvertering av en sammansatt vektorlitteral till en pekare medför en hängande pekare i C++"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "attributet %<counted_by%> är inte tillåtet för en pekare till en post eller union med en flexibel vektormedlem"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT har ingen medlem med namnet %qE; menade du %qE?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT har ingen medlem med namnet %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "använder en medlem %qE av en atomär struktur %qE"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "åtkomst av medlemmen %qE i en atomär union %qE"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qE är en pekare till pekare; tänkte du dereferera den före du använde %<->%> på den?"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qE är en pekare; tänkte du använda %<->%>?"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "begäran av medlem %qE i något som inte är en post eller union"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "derefererar %<void *%>-pekare"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "indexerat värde är varken en vektor eller pekare"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "fältindex är inte ett heltal"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "indexerat värde är en funktionspekare"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, gcc-internal-format
 msgid "array subscript is negative"
 msgstr "fältindex är negativt"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, gcc-internal-format
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C förbjuder indexering av %<register%>-vektor före C2Y"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 förbjuder indexering av icke-l-värde-vektor"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr "underspecificerad %qD refererad i sin initierare"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "enum-konstanten definierad i en post eller union är inte synlig i C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "uppräkningskonstant definierad här"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr "%<sizeof%> på vektorfunktionsparametern %qE kommer returnera storleken på %qT"
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "anropat objekt %qE är inte en funktion eller funktionspekare"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "anropat objekt %qD är inte en funktion eller funktionspekare"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "anropat objekt är inte en funktion eller funktionspekare"
@@ -52460,1850 +52504,1850 @@ msgstr "anropat objekt är inte en funktion eller funktionspekare"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "funktion anropad via en inkompatibel typ"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "funktion med kvalificerad void-returtyp anropad"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "typen på formell parameter %d är ofullständig"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "skickar argument %d till %qE som heltal istället för flyttal på grund av prototyp"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "skickar argument %d till %qE som heltal istället för komplext på grund av prototyp"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "skickar argument %d till %qE som komplext istället för flyttal på grund av prototyp"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "skickar argument %d till %qE som flyttal istället för heltal på grund av prototyp"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "skickar argument %d till %qE som komplext istället för heltal på grund av prototyp"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "skickar argument %d till %qE som flyttal istället för komplext på grund av prototyp"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "skickar argument %d till %qE som %<float%> istället för %<double%> på grund av prototyp"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "skickar argument %d till %qE som %qT istället för %qT på grund av prototyp"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "skickar argument %d till %qE med annan vidd på grund av prototyp"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "skickar argument %d till %qE teckenlöst på grund av prototyp"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "skickar argument %d till %qE med tecken på grund av prototyp"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "för många argument till metoden %qE; %i förväntades, har %i"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, gcc-internal-format
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "för många argument till funktionen %qE; %i förväntades, har %i"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "för många argument till den inbyggda funktionen %qE, %d förväntades"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr "ISO C23 tillåter inte argument till metoden %qE deklarerad utan parametrar"
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "ISO C23 tillåter inte argument till funktionen %qE deklarerad utan parametrar"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "implicit konvertering från %qT till %qT när argument skickas till en funktion"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "för få argument till funktionen %qE; åtminstone %i förväntades, har %i"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, gcc-internal-format
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "för få argument till funktionen %qE; %i förväntades, har %i"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "för få argument till den inbyggda funktionen %qE, %u förväntades"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "jämförelse med stränglitteral resulterar i odefinierat beteende"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "jämförelse mellan pekare och teckenkonstanten noll"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "tänkte du dereferera pekaren?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "noll som en nollpekarkonstant"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "jämförelse mellan %qT och %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "pekare av typ %<void *%> använd i subtraktion"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "pekare till funktion använd i subtraktion"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "aritmetik på pekare till ofullständig typ"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "aritmetik på pekare till ett tomt aggregat"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> på ett booleskt uttryck"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "tänkte du använda logiskt icke?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C stödjer inte %<~%> för komplex konjugering"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "fel typ på argument till absu"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "fel typ på argument till unärt utropstecken"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "ökning av uppräkningsvärde är ogiltigt i C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "minskning av uppräkningsvärde är ogiltigt i C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "ökning av ett booleskt uttryck"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "minskning av ett booleskt uttryck"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, gcc-internal-format
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C stödjer inte %<++%> och %<--%> på komplexa typer före C2Y"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "fel typ på argument till ökning"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "fel typ på argument till minskning"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "ökning en pekare till en ofullständig typ %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "minskning av en pekare till en ofullständig typ %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "tar adressen till uttryck av typ %<void%>"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "kan inte ta adressen till bitfält %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "kan inte ta adressen till skalär med omvänd lagringsordning"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "adress till vektor med omvänd skalär lagringsordning begärd"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr "adressen till sammansatt registerlitteral begärd"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "global registervariabel %qD använd i nästad funktion"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "registervariabel %qD använd i nästad funktion"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "adress till global registervariabel %qD efterfrågad"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "adress på registervariabeln %qD efterfrågad"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "icke-l-värde-vektor i villkorsuttryck"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "olika enumtyper i ett villkor är ogiltigt i C++: %qT respektive %qT"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "implicit konvertering från %qT till %qT för att stämma med andra resultat i villkor"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr "operand till %<?:%> ändrar teckenläge från %qT till %qT på grund av teckenlöshet hos en annan operand"
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C förbjuder villkorliga uttryck med bara en sida void"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "pekare till skilda adressrymder använda i villkorsuttryck"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "pekare till vektor tappar kvalificerare i villkorsuttryck"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "pekare till vektor tappar kvalificerare i villkorsuttryck i ISO C före C23"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C förbjuder villkorliga uttryck mellan %<void *%> och funktionspekare"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "pekartyper stämmer inte i villkorsuttryck"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "första uttrycket har typen %qT"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "andra uttrycket har typen %qT"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "pekar-/heltalstyper stämmer inte i villkorsuttryck"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "typer stämmer inte i villkorsuttryck"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "ignorerar returvärdet av %qD, deklarerad med attributet %<nodiscard%>: %E"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "ignorerar returvärdet av %qD, deklarerad med attributet %<nodiscard%>"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "ignorerar returnerat värde av typen %qT, deklarerat med attributet %<nodiscard%>: %E"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "ignorerar returnerat värde av typen %qT, deklarerat med attributet %<nodiscard%>"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "i anrop av %qD, deklarerad här"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "vänster operand av kommauttryck har ingen effekt"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "höger operand av kommauttryck har ingen effekt"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr "typkonvertering lägger %q#v-kvalificerare till funktionstyp"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "typkonvertering kastar bort %qv-kvalificerare från pekarmåltyp"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "för att vara säker måste alla mellanliggande pekare i typkonvertering från %qT till %qT vara %<const%>-kvalificerade"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "typkonvertering anger vektortyp"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "typkonvertering anger funktionstyp"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C förbjuder typkonvertering av ickeskalärer till samma typ"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "oanvändbar konvertering till typen %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C förbjuder typkonvertering till unionstyper"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "typkonvertering till unionstyp från typ som ej finns i unionen"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "typkonvertering till adressrymdspekare %qs från skild generisk adressrymdspekare"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "typkonvertering till generisk adressrymdspekare från skild adressrymdspekare till %qs"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "typkonvertering från adressrymdspekare till %qs från skild adressrymdspekare till %qs"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "typkonvertering ökar kravet på justering av måltypen"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "typkonvertering från pekare till heltal av annan storlek"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "typkonvertering från funktionsanrop av typ %qT till typ %qT matchar inte"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "typkonvertering till pekare från heltal med annan storlek"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C förbjuder konvertering av funktionspekare till objektpekartyp"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C förbjuder konvertering av objektpekare till funktionspekartyp"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "typkonvertering mellan inkompatibla funktionstyper från %qT till %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "definition av en typ i en typkonvertering är ogiltigt i C++"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "tilldelning till uttryck med vektortyp"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "uppräkningskonvertering i tilldelning är ogiltigt i C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(i närheten av initiering av %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "vektor initierad från strängkonstant inom parentes"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 msgid "expected %e but argument is of type %e"
 msgstr "%e förväntades men argumentet är av typen %e"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "typen på argument %2$d till %1$qD är %3$qT där %4$qT förväntas i ett anrop av den inbyggda funktionen som deklarerats utan prototyp"
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "argument %2$d till %1$qD befordras till %3$qT där %4$qT förväntas i ett anrop till den inbyggda funktionen som deklarerats utan prototyp"
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "den inbyggda %qD är deklarerad här"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 msgid "%e declared here"
 msgstr "%e deklarerad här"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "enum-konvertering när argument %d till %qE skickades är ogiltigt i C++"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "%qT förväntades men argumentet har typ %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "enum-konvertering från %qT till %qT i tilldelning är ogiltigt i C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "enum-konvertering från %qT till %qT i initiering är ogiltigt i C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "enum-konvertering från %qT till %qT i retursats är ogiltigt i C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "implicit konvertering från %qT till %qT"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "att skicka argument %d till %qE skapar en %q#v-kvalificerad funktionspekare från en okvalificerad"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "tilldelning skapar en %q#v-kvalificerad funktionspekare från en okvalificerad"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "initiering skapar en %q#v-kvalificerad funktionspekare från en okvalificerad"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "retur skapar en %q#v-kvalificerad funktionspekare från en okvalificerad"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "att skicka argument %d till %qE kastar %qv-kvalificerare från pekarmåltyp"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "tilldelning kastar %qv-kvalificerare från pekarmåltyp"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "initiering kastar %qv-kvalificerare från pekarmåltyp"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "retur kastar %qv-kvalificerare från pekarmåltyp"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C förbjuder argumentkonvertering till unionstyp"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "begäran om implicit konvertering från %qT till %qT tillåts inte i C++"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "skickar argument %d till %qE från pekare till adressutrymme som inte är inneslutet"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "tilldelning från pekare till adressutrymme som inte är inneslutet"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "initiering från pekare till adressutrymme som inte är inneslutet"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "retur från pekare till ej omgivande adressrymd"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "%qT förväntades men pekaren har typen %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "argumentet %d till %qE kan vara kandidat för ett formatattribut"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "vänsterhandssida av tilldelning kan vara en kandidat för ett formatattribut"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "vänsterhandssida av initiering kan vara en kandidat för ett formatattribut"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "returtypen kan vara en kandidat för ett formatattribut"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "skickar argument %d till %qE från inkompatibel skalär lagringsordning"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "tilldelning till %qT från pekartypen %qT med inkompatibel skalär lagringsordning"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "initiering av %qT från pekartypen %qT med inkompatibel skalär lagringsordning"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "returnerar %qT från en pekartyp med inkompatibel skalär lagringsordning %qT"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C förbjuder att skicka argument %d till %qE mellan funktionspekare och %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C förbjuder tilldelning mellan funktionspekare och %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C förbjuder initiering mellan funktionspekare och %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C förbjuder retur mellan funktionspekare och %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr "vektorer med kvalificerare på elementet är inte kvalificerat före C23"
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "pekarmål när argument %d till %qE skickades skiljer i teckenhet"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "pekarmål i tilldelning från %qT till %qT skiljer i teckenhet"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "pekarmål i initiering från %qT till %qT skiljer i teckenhet"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "pekarmål vid retur av %qT från en funktion med returtyp %qT skiljer i teckenhet"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "skickar argument %d till %qE från inkompatibel pekartyp"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "tilldelning till %e från pekare till %qD med inkompatibel typ %e"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "tilldelning till %e från inkompatibel pekartyp %e"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "initiering av %e från pekare till %qD med inkompatibel typ %e"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "initiering av %e från inkompatibel pekartyp %e"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "returnerar pekare till %qD av typen %e från en funktion med inkompatibel typ %e"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "returnerar %e från en funktion med inkompatibel returtyp %e"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "att skicka argument %d till %qE skapar pekare av ett heltal utan typkonvertering"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "tilldelning till %qT från %qT skapar pekare av heltal utan typkonvertering"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "initiering av %qT från %qT skapar pekare från heltal utan typkonvertering"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "att returnera %qT från en funktion med returtyp %qT skapar pekare av ett heltal utan typkonvertering"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "att skicka argument %d till %qE skapar pekare från heltal utan typkonvertering"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "tilldelning till %qT från %qT skapar heltal från pekare utan typkonvertering"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "initiering av %qT från %qT skapar heltal från pekare utan typkonvertering"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "att returnera %qT från en funktion med returtyp %qT skapar pekare från heltal utan typkonvertering"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "inkompatibel typ för argument %d av %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "inkompatibla typer i tilldelning till typ %qT från typ %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "inkompatibla typer i när typ %qT initierades med typ %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "inkompatibla typer när typ %qT returnerades men %qT förväntades"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "traditionell C tillåter inte aggregatinitiering"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr "%<constexpr%>-pekarinitierare är inte null"
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "%<constexpr%>-initierare är inte representerbar i objekttypen"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "%<constexpr%>-heltal i initierare inte av ett konstant heltalsuttryck"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "%<contexpr%>-initierare inte av ett aritmetiskt konstant uttryck"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr "%<constexpr%>-initierare för en reell typ har komplex typ"
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr "%<constexpr%>-initierare för en binär flyttalstyp har en decimal typ"
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "initiering av medlem som är en flexibel vektor"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "det går inte att initiera vektorn av %qT från en stränglitteral med typvektor %qT"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "initierarsträng för en vektor av %qT är för lång (%wu tecken in i %wu tillgängliga)"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "initierarsträng för vektor av %qT är för lång för C++ (%wu tecken in i %wu tillgängliga)"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr "initierarsträngen för en vektor av %qT hugger av NUL-avslutaren men målet saknar attributet %qs (%wu tecken in i %wu tillgängliga)"
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "vektor av typ som inte passar initierad från strängkonstant"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "ogiltig användning av icke-l-värde-vektor"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "ogiltig initierare"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "initierarelement är inte konstant"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "vektor initierad från icke-konstant vektoruttryck"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "initierarelement är inte ett konstant uttryck"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, gcc-internal-format
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "konvertering från %qT till %qT ändrar värdet från %qd till %qd"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "initierarelement är inte beräkningsbart vid laddtidpunkt"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "ogenomskinliga vektortyper kan inte initieras"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "extra klammergrupp vid slutet av initierare"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "klamrar runt skalär initierare"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "initiering av medlem som är en flexibel vektor i nästat sammanhang"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "klamrar saknas runt initierare"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "initierare saknas för fält %qD i %qT"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "extra element i skalär initierare"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "vektorindex i initierare för annat än vektor"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "fältnamn i initierare för annat än post eller union"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "vektorindex i initierare inte av heltalstyp"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "vektorindex i initierare inte av ett konstant heltalsuttryck"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "ickekonstant vektorindex i initierare"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "vektorindex i initierare överskrider vektorns storlek"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "tomt indexintervall i initierare"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "vektorindexintervall i initierare överskrider vektorns gränser"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "initierat fält överskrivet"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "initierat fält med sidoeffekter överskrivet"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "enum-konvertering i initiering är ogiltigt i C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr "överflödiga element i initieraren %qT"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "överflödiga element i postinitierare"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "positionsinitiering av fält i %<struct%> deklarerad med attributet %<designated_init%>"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "icke-statisk initiering av an flexibel vektormedlem"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "överflödiga element i unioninitierare"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "traditionell C tillåter inte initiering av unioner"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "överflödiga element i vektorinitierare"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "överflödiga element i vector-initierare"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "överflödiga element i skalärinitierare"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr "begränsningen tillåter register utanför en funktion"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr "sidoeffekter i utdataoperanden utanför en funktion"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, gcc-internal-format
 msgid "output operand outside of a function is not constant"
 msgstr "utdataoperand utanför en funktion som inte är konstant"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "modifieraren %<-%> använd inuti en funktion"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
-msgstr "%<:%>-begränsningsoperanden är inte adressen till en funktion eller icka-automatisk variabel"
+msgstr "%<:%>-begränsningsoperanden är inte adressen till en funktion eller icke-automatisk variabel"
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr "sidoeffekter i indataoperanden utanför en funktion"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, gcc-internal-format
 msgid "input operand outside of a function is not constant"
 msgstr "indataoperand utanför en funktion som inte är konstant"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C förbjuder %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "beräknat goto måste vara en pekartyp"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "funktion deklarerad %<noreturn%> har en %<return%>-sats"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> utan värde i funktion som returnerar icke-void"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> med värde i funktion som returnerar void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C förbjuder %<return%> med värde i funktion som returnerar void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "funktionen returnerar adress till en etikett"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, gcc-internal-format
 msgid "function returns address of nested function referencing local context"
-msgstr "funktionen returnerar adress till en nästad funktion som referar en lokal kontext"
+msgstr "funktionen returnerar adress till en nästad funktion som refererar en lokal kontext"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch-argument är inte ett heltal"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "%<long%>-switch-uttryck konverteras inte till %<int%> i ISO C"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "case-etikett är inte ett konstant heltalsuttryck"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case-etikett är inte i en switch-sats"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "%<default%>-etikett som inte ligger i en switch-sats"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break-sats som inte är i en loop eller switch"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "ogiltig utgång från OpenMP-strukturerat block"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "break-sats använd med OpenMP-for-slinga"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue-sats som inte är i en loop"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "sats utan effekt"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "uttryckssats har ofullständig typ"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "jämförelsen kommer alltid beräknas till %<false%> för att pekaroperanden i %qE inte får vara NULL"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "jämförelsen kommer alltid beräknas till %<true%> för att pekaroperanden i %qE inte får vara NULL"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "jämförelsen kommer alltid beräknas till %<false%> för att adressen till %qE aldrig kommer att vara NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "jämförelsen kommer alltid beräknas till %<true%> för att adressen till %qE aldrig kommer att vara NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "jämför vektorer med skilda elementtyper"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "jämför vektorer med olika antal element"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "jämförelse mellan typer %qT och %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "det går inte att hitta en heltalstyp med samma storlek som %qT"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "att jämföra flyttal med %<==%> eller %<!=%> är osäkert"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "jämförelse av pekare till skilda adressutrymmen"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C förbjuder jämförelse mellan %<void *%> och funktionspekare"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "jämförelse av skilda pekartyper saknar en typkonvertering"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "jämförelse mellan pekare och heltal"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "jämförelse av kompletta och ofullständiga pekare"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C förbjuder ordningsjämförelse på pekare till funktioner"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "ordningsjämförelse av pekare med nollpekare"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "ordningsjämförelse av pekare med heltalet noll"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "implicit konvertering från %qT till %qT för att matcha den andra operanden i binärt uttryck"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "vektor använd som inte kan konverteras till en pekare där en skalär krävs"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "struct-typvärde använt där skalär krävs"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "värde av uniontyp använt där skalär krävs"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "vektortyp använd där skalär krävs"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancel%> måste ange en av klausulerna %<parallel%>, %<for%>, %<sections%> eller %<taskgroup%>"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "%<cancel%> %<if%>-klausulmodifierare förväntades"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancellation point%> måste ange en av klausulerna %<parallel%>, %<for%>, %<sections%> eller %<taskgroup%>"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD är inte en variabel i en %qs-klausul"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE är inte en variabel i en %qs-klausul"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%<_Atomic%> %qD i %qs-klausul"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD är en trådprivat variabel i en %qs-klausul"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "undre gränsen %qE i vektorsektion har inte heltalstyp"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "längden %qE i vektorsektion har inte heltalstyp"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "en enda pekare förväntades i en %qs-klausul"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "nollängds vektorsektion i en %qs-klausul"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr "för en vektor med okänd gräns måste ett längduttryck anges"
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "negativ nedre gräns i vektorsektion i %qs-klausul"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "negativ längd i vektorsektion i en %qs-klausul"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "nedre gränsen %qE över storleken på vektorsektionen i en %qs-klausul"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "längden %qE över storleken på vektorsektionen i en %qs-klausul"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "övre gräns %qE ovanför storleken på vektorsektionen i en %qs-klausul"
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "för en vektorfunktionsparameter måste ett längduttryck anges"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "för pekartyper måste ett längduttryck anges"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "vektorsektionen är inte sammanhängande i %qs-klausulen"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE har inte pekar- eller vektortyp"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "iteratorn %qD har varken heltals- eller pekartyp"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "iteratorn %qD har %<_Atomic%>-kvalificerad typ"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "iteratorn %qD har const-kvalificerad typ"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "iteratorsteg med en icke-heltalstyp"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr "iteratorn %qD har nollsteg"
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr "typ av iteratorn %qD refererar till den yttre iteratorn %qD"
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr "startuttrycket refererar till den yttre iteratorn %qD"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "slututtrycket refererar till den yttre iteratorn %qD"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "steguttrycket refererar till den yttre iteratorn %qD"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "pekare förväntades i en %qs-klausul"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "%<inscan%>- och icke-%<inscan%> %<reduction%>-klausul på samma konstruktion"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "en %<inscan%> %<reduction%>-klausul med vektorsektion"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD i %<reduction%>-klausul är en vektor med storlek noll"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE i %<reduction%>-klausul"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "nollstor typ %qT i %qs-klausul"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "typen %qT med variabel storlek i %qs-klausul"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE har ogiltig typ för %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "ingen användardefinierad reduktion funnen för %qE"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "elementtyp med variabel längd i vektor-%<reduction%>-klausul"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "en klausul %<nowait%> får inte användas tillsammans med en klausul %<copyprivate%>"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE måste vara %<threadprivate%> för %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
-msgstr "modifierare skall inte anges i %<linear%>-klausul på %<simd%>- eller %<for%>-konstruktioner när man inte använder OpenMP 5.2-modiferare"
+msgstr "modifierare skall inte anges i %<linear%>-klausul på %<simd%>- eller %<for%>-konstruktioner när man inte använder OpenMP 5.2-modifierare"
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr "en linjär klausul använd på variabel som inte är heltal och inte pekare med typen %qT"
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr "%<_Atomic%> %qD i %<linear%>-klausul"
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "%<linear%>-klausulens steg %qE är varken en konstant eller en parameter"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE är inte en variabel i klausul %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD förekommer mer än en gång i datadelningsklausuler"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD förekommer mer än en gång i reduktionsklausuler"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE förekommer mer än en gång i dataklausuler"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD förekommer mer än en gång i dataklausuler"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD förekommer både i data- och map-klausuler"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE är inte en variabel i klausul %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE är inte en variabel i klausul %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE är inte en variabel i %<aligned%>-klausul"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "%qE i %<aligned%>-klausul är varken en pekare eller en vektor"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%<_Atomic%> %qD i %<aligned%>-klausul"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE förekommer mer än en gång i %<aligned%>-klausuler"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE är inte en variabel i en %<nontemporal%>-klausul"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE förekommer mer än en gång i %<nontemporal%>-klausuler"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE är inte en variabel i %<allocate%>-klausul"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE förekommer mer än en gång i %<allocate%>-klausuler"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr "allokeraren %qE måste vara av typen %<omp_allocator_handle_t%>"
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr "allokeraren %qE måste vara antingen en variabel eller en fördefinierad allokerare"
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "modifierare kan inte användas med den fördefinierade allokeraren %qE"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr "memspace-modifieraren %qE måste vara en konstant enum av typen %<omp_memspace_handle_t%>"
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
-msgstr "egenskapsvektorn %qE måste definieras i samma omfång som konstruktionen på vilken satsen förekommer"
+msgstr "egenskapsvektorn %qE måste definieras i samma omfång som konstruktionen på vilken klausulen förekommer"
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr "egenskapsvektorn %qE måste vara av typen %<const omp_alloctrait_t []%>"
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr "egenskapsvektorn måste vara av typen %<const omp_alloctrait_t []%>"
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr "egenskapsvektorer måste initieras med konstanter"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr "klausulen %<depend%> med beroendetyp %<depobj%> på vektorsektion"
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
-msgstr "%<omp_all_memory%> använt med en annan %<depend%>-sortkind än %<out%> eller %<inout%>"
+msgstr "%<omp_all_memory%> använt med en annan %<depend%>-sort än %<out%> eller %<inout%>"
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE är varken ett l-värdeuttryck eller en vektorsektion i en %qs-klausul"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr "%qE har inte en typ %<omp_depend_t%> i klausulen %<depend%> med beroendetyp %<depobj%>"
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr "%qE skall inte ha en typ %<omp_depend_t%> i klausulen %<depend%> med annan beroendetyp än %<depobj%>"
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "vektorsektionen har inte en avbildbar typ i %qs-klausulen"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "ej stött avbildningsuttryck %qE"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD förekommer mer än en gång i rörelseklausuler"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD förekommer mer än en gång i avbildningsklausuler"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD har inte en avbildbar typ i %qs-klausul"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE är varken en variabel eller ett funktionsnamn i klausulen %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE förekommer mer än en gång i samma %<declare target%>-direktiv"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD är inte en ett argument i en %<uniform%>-klausul"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE är inte ett argument i en %<uniform%>-klausul"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "variabeln %qs är inte en pekare"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "%qs-variabeln är varken en pekare eller en vektor"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "en klausul %<order%> får inte användas tillsammans med en klausul %<ordered%>"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "för många %qs-klausuler på en task-konstruktion"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "en %<inbranch%>-klausul är inkompatibel med %<notinbranch%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD förekommer mer än en gång i åtgärdsklausuler"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, gcc-internal-format
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD måste vara av %<omp_interop_t%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "%qD skall inte vara const"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE är förutbestämd som %qs för %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "%<const%>-kvalificerad %qE kan förekomma endast i klausuler %<shared%> eller %<firstprivate%>"
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr "%<simdlen%>-klausulvärde är större än %<safelen%>-klausulvärde"
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr "%<nonmonotonic%>-schemaläggningsmodifierare angiven tillsammans med %<ordered%>-klausul"
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "en %qs-klausul angiven tillsammans med en %<inscan%> %<reduction%>-klausul"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr "%<linear%>-klausulsteg är en parameter %qD inte angiven i %<uniform%>-klausul"
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "en %<nogroup%>-klausul får inte användas tillsammans med en %<reduction%>-klausul"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "en klausul %<grainsize%> får inte användas tillsammans med en klausul %<num_tasks%>"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "en klausul %<full%> får inte användas tillsammans med en klausul %<partial%>"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "en %<detach%>-klausul får inte användas tillsammans med en %<mergeable%>-klausul"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr "händelsehanteraren för en %<detach%>-klausul skall inte finnas i en datadelningsklausul"
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr "klausulen %<depend%> kräver åtgärdsklausuler med interop-typen %<targetsync%>"
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "klausulen %<init%> saknar modifieraren %<targetsync%>"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "kan inte använda %<va_arg%> med omvänd lagringsordning"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "andra argumentet till %<va_arg%> är av ofullständig typ %qT"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "andra argumentet till %<va_arg%> är en funktionstyp %qT"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "andra argumentet till %<va_arg%> är en vektortyp %qT"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "C++ kräver en befordrad typ, inte en enum-typ, i %<va_arg%>"
@@ -54569,253 +54613,248 @@ msgstr "Vi borde aldrig se en olik dash-main i cobol1.c"
 msgid "no such exception: 0x%x"
 msgstr "inget sådant undantag: 0x%x"
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr "Trolig orsak: den refererades utan att vara definerad."
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr "Den strängen skall inte vara så lång."
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "%s skall inte vara null"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%s: Känner inte till variabeltypen %s för %s"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s: Ogiltig fälttyp %s:"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr "Inte giltigt för en ACCEPT-sats."
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr "Försöker skicka till en inmatningsenhet."
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr "Inte giltigt för en DISPLAY-sats."
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr "%<parser_logop()%> anropades med variabeln %s på rad %d, vilket inte är en FldConditional"
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr "%<parser_relop()%> anropades med variabeln %qs, vilket inte är en FldConditional"
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr "%<parser_relop()%> anropades med variabeln %s, vilket inte är en FldConditional"
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr "%<parser_if()%> anropades med variabeln %s, vilket inte är en FldConditional"
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr "kandidaten %s har oimplementerad %<CVT_type%> %d(%s)"
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "okänd %<setop_t%>-kod %d"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr "%s:%d: %u överskrider %<MAXIMUM_UNTILS%> på %d, rad %d"
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr "%s:%d: ignorerar indexvärden"
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr "%s: anropad med NULL *fil"
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr "%s:%d filen %s åtkomstläge är %<file_inaccessible_e%> i %s"
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr "%<parser_file_open%> anropad med NULL *fil"
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr "%<parser_file_open%> för %s anropad med NULL %<var_decl_node%>"
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr "EXTEND kan endast användas där %s är ACCESS MODE SEQUENTIAL"
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr "%<parser_file_close%> anropad med NULL *fil"
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr "%<parser_file_close%> för %s anropad med NULL %<file->var_decl_node%>"
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr "%s:%d fil %s ”where” är noll i %s"
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr "%<parser_file_read%> anropad med NULL *fil"
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr "%<parser_file_read%> för %s anropad med NULL %<file->var_decl_node%>"
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr "%<parser_file_read%> anropad med NULL *fält"
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr "%<parser_file_read%> för %s anropad med NULL %<field->var_decl_node%>"
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr "%s:%d filen %s är RELATIVE/SEQUENTIAL, men %<where ≥ 0%>"
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr "%s:%d filen %s är RELATIVE/RANDOM, men %<where < 0%>"
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr "%s:%d filen %s ”sequentially” är %d i %s"
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr "%s: för %s anropad med NULL %<file->var_decl_node%>"
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr "%s: anropad med NULL *field"
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr "%s: för %s anropad med NULL %<field->var_decl_node%>"
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr "Filpekaren skall inte vara null"
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr "%s:%d filen %s är INDEXED/SEQUENTIAL, men ”sequentially” är falskt"
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%s: anropad för att sortera %s, som inte är en tabell"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr "%s: syntaxfel: både (eller ingendera av) USING och input-proc är specificerade"
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr "%s: syntaxfel: både (eller ingendera av) GIVING och output-proc är specificerade"
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr "%s: syntaxfel: både (eller ingendera av) filer och output-proc är specificerade"
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr "CALL USING BY CONTENT <temporär> skulle kräva REPOSITORY PROTOTYPES."
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "%s: Vad i Neros namn gör vi här?"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr "I %<parser_move(%s till %s)%>, förflyttningen av FldLiteralN till %s är inte implementerat"
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
-msgstr "I %<mh_dest_is_float(%s till %s)%>, förflyttningen av %s till %s är inte implementerat"
+msgstr "I %<mh_dest_is_float%>(%s till %s), förflyttningen av %s till %s är inte implementerat"
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
-msgstr "LEVEL 01 (%s) OCCURS har otilräcklig data.memsize"
+msgstr "LEVEL 01 (%s) OCCURS har otillräcklig data.memsize"
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr "%<parser_symbol_add()%> anropades med en NULL %<new_var%>"
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
-msgstr "%s: %d %s är en tabell, med den har oriktigt en kapacetet på noll"
+msgstr "%s: %d %s är en tabell, med den har oriktigt en kapacitet på noll"
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr "%s: %s är sin egen anfader"
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr "%s: %d %qs har en NULL-anfader"
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr "%s(%s) har oriktigt en null-skild %<var_decl_node%>"
@@ -54824,72 +54863,82 @@ msgstr "%s(%s) har oriktigt en null-skild %<var_decl_node%>"
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr "%<our_index%> är NULL under oförutsedda omständigheter"
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr "%s: %d %s<%s> har oriktigt en data.capacity på noll"
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr "%<bytes_to_allocate%> är noll för %s (symbolnummer "
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr "Den givna typen är NULL, och det är bara inte rättvist"
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, gcc-internal-format
 msgid "The given type is not a declaration or a TYPE"
 msgstr "Den givna typen är inte en deklaration eller en TYPE"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "Okänd typ %d"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr "Försök med tilldelning av olika typer."
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr "Någon frågade efter fältet %s.%s, som inte finns"
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%s:%d: Får inte anropa här med %s"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr "%s:%d: Får inte anropa här med icke %s"
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr "Du *måste* skämta"
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr "Du glömde att sätta en %<NULL_TREE%> i slutet av en %<gg_printf()%> igen"
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr "Du glömde att sätta en %<NULL_TREE%> i slutet av en %<gg_define_function()%> igen"
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr "%d parametrar? Verkligen? Är du galen?"
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr "Återstående kontextantal"
@@ -54899,12 +54948,12 @@ msgstr "Återstående kontextantal"
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr "%<parser_op()%> vet inte hur den skall evaluera %<%s = %s %c %s%>"
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, gcc-internal-format
 msgid "Too many subscripts"
 msgstr "För många index"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "det går inte att hämta ett %<float%>-värde från %s"
@@ -54919,61 +54968,61 @@ msgstr "%s pid %ld avslutade med %s"
 msgid "%s exited with status %d"
 msgstr "%s avslutade med status %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr "%s:%d: LblNone '%s' har föräldern #%zu"
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr "%s: dataobjekt %s #"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%s: nyckeln måste vara ett fält"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s: %s %s har ogiltig kodning"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr "%s:%d: kunde inte lägga till ”%s”"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s %lu %s %lu"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr "%s: nbytes %lu %s %lu"
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr "%s:%d: typ %s, vem skulle ha trott det?"
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr "logikfel: MOVE %s %s felaktig typ:"
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: regcomp: %s"
 msgstr "%s: regcomp: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr "logikfel: saknad inod för %s"
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, gcc-internal-format, gfc-internal-format
 msgid "failed compiling %s"
 msgstr "misslyckades med att kompilera %s"
@@ -55408,7 +55457,7 @@ msgstr "ingen passande %<operator %s%> för %qT"
 msgid "%q#D is private within this context"
 msgstr "%q#D är privat inom denna kontext"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr "deklarerad privat här"
@@ -55418,7 +55467,7 @@ msgstr "deklarerad privat här"
 msgid "%q#D is protected within this context"
 msgstr "%q#D är skyddad inom denna kontext"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr "deklarerad skyddad här"
@@ -55744,7 +55793,7 @@ msgstr "argument %u i anropet av funktionen %qE har en pekare till en icke trivi
 msgid "constructor delegates to itself"
 msgstr "konstruerare delegerar till sig själv"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr "det går inte att konvertera %qH till %qI"
 
@@ -55763,7 +55812,7 @@ msgstr "ingen matchande funktion för anrop av %<%T::%s%E(%A)%#V%>"
 msgid "call to non-function %qD"
 msgstr "anrop av icke-funktion %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "kan inte anropa konstrueraren %<%T::%D%> direkt"
@@ -56350,14 +56399,14 @@ msgstr "flexibel vektormedlem %qD inte vid slutet av %q#T"
 #: cp/class.cc:7832
 #, gcc-internal-format
 msgid "flexible array member %qD in an otherwise empty %q#T is a GCC extension"
-msgstr "flexibel vektor medlem %qD i en i övrigt tom %q#T är en GCC-utvidgning"
+msgstr "flexibel vektormedlem %qD i en i övrigt tom %q#T är en GCC-utvidgning"
 
 #: cp/class.cc:7855
 #, gcc-internal-format
 msgid "next member %q#D declared here"
 msgstr "nästa medlem %q#D är deklarerad här"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "omdefinition av %q#T"
@@ -56367,7 +56416,7 @@ msgstr "omdefinition av %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr "definierar %qT, som tidigare inte var komplett i en SFINAE-kontext"
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr "här. Använd %qs för en diagnostik vid den tidpunkten"
@@ -56415,7 +56464,7 @@ msgstr "språksträng %<”%E”%> känns inte igen"
 #: cp/class.cc:8962
 #, gcc-internal-format
 msgid "cannot resolve overloaded function %qD based on conversion to type %qT"
-msgstr "det går inte att lösa upp överlagrad funktion %qD baserat på konvertering till typ %qT"
+msgstr "det går inte att slå upp överlagrad funktion %qD baserat på konvertering till typ %qT"
 
 #: cp/class.cc:9135
 #, gcc-internal-format
@@ -56498,7 +56547,7 @@ msgstr "ogiltig typ för parameter %d till %<constexpr%>-funktion %q+#D"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr "lambdan är implicit %<constexpr%> endast i C++17 och senare"
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%>-destruerare är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
@@ -56549,7 +56598,7 @@ msgstr "%<-fimplicit-constexpr%> påverkar bara %<inline%>-funktioner"
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%qD är inte användbar som en %<constexpr%>-funktion eftersom:"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr "förstör %qE utanför dess livstid"
@@ -56584,840 +56633,840 @@ msgstr "undantag som inte fångats %qE"
 msgid "uncaught exception of type %qT"
 msgstr "undantag som inte fångats av typen %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "anrop av funktionen %qD med felaktigt antal argument"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions pending"
 msgstr "%qD anropad utan väntande fångade undantag"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, gcc-internal-format
 msgid "cannot allocate exception: size not constant"
 msgstr "kan inte allokera undantaget: storleken är inte konstant"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr "första argumentet till funktionen %qD är inte resultatet av %<__cxa_allocate_exception%>"
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, gcc-internal-format
 msgid "%qD called with no caught exceptions active"
 msgstr "%qD anropad utan aktiva fångade undantag"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr "%qD anropade utan att %<std::%D%> har definierats"
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, gcc-internal-format
 msgid "%qD called without supportable %qs"
 msgstr "%qD anropad utan stödbara %qs"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr "%qD anropad med oväntat argument %qs"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr "%qD anropad med andra argument annat än 1 eller -1"
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "fel antal argument till anrop av %qs"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr "första anropsargumentet till %qs skall vara 0, 1, 2, 16, 17 eller 18"
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr "taggsträngen %qs innehåller tecknet %qc annat än bokstäver, siffror eller %<_%>"
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr "constexpr-meddelande: %.*s [%r%.*s%R]"
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr "constexpr-meddelande: %.*s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "%<constexpr%>-anrop flödar förbi slutet på funktionen"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "anrop av icke-%<constexpr%>-funktion %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "derefererar en nollpekare"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "jämförelsen reduceras till %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr "%qE beräknas till falskt"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr "misslyckat %<assume%>-attributantagande"
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "anrop av intern funktion %qE"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "ändring av ett const-objekt %qE är inte tillåten i ett konstant uttryck"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "ursprungligen deklarerad %<const%> här"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr "referensen %<dynamic_cast%> misslyckades"
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "den dynamiska typen %qT av sin operand har inte en basklass av typen %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "den virtuella tabellpekaren används oinitierad"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr "den statiska typen %qT av sin operand är en icke-publik basklass av den dynamiska typen %qT"
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT är en tvetydig basklass till den dynamiska typen %qT av sin operand"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr "den dynamiska typen %qT av sin operand har inte en otvetydig publik basklass %qT"
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "anropar constexpr-medlemsfunktionen %qD via ett virtuellt bassubobjekt"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr "kunde inte kasta %qT"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "uttrycket %qE anger inte en %<constexpr%>-funktion"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, gcc-internal-format
 msgid "cannot allocate array: size not constant"
 msgstr "kan inte allokera vektorn: storleken är inte konstant"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "vektordeallokering av objekt allokerade med icke-vektor-allokering"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr "allokeringen utförd här"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "icke-vektor-deallokering av objekt allokerade med vektorallokering"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr "avallokering av en redan avallokerad lagring"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "avallokering av lagring som inte tidigare allokerades"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD anropad i ett konstant uttryck före dess definition är komplett"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD anropad i ett konstant uttryck"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD användes före sin definition"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "anrop har cirkulärt beroende"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "beräkning av %<constexpr%> överskrider maxvärdet på %d (använd %<-fconstexpr-depth=%> för att öka maxvärdet)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "referensen till %qD är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "pekaren på %qD är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
-msgstr "adressen till den icke-statiska constexpr-variabeln %qD kan skilja vid varje uppstar av den omgivande funktionen; ligg till %<static%> för att ge den en konstant adress"
+msgstr "adressen till den icke-statiska constexpr-variabeln %qD kan skilja vid varje uppstart av den omgivande funktionen; lägg till %<static%> för att ge den en konstant adress"
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "höger operand av skiftuttrycket %q+E är negativ"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "högra operanden av skiftuttrycket %q+E är större än eller lika med precisionen %wu av den vänstra operanden"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "vänster operand av skiftuttrycket %q+E är negativ"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "skiftuttrycket %q+E spiller över"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr "aritmetik som innefattar en nollpekare i %qE"
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "vektorindexvärdet %qE är utanför gränserna för vektorn %qD av typen %qT"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "icke-noll vektorindex %qE används med vektorn %qD av typen %qT med okända gränser"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "vektorindexvärdet %qE är utanför gränserna för vektortypen %qT"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "icke-noll vektorindex %qE används med en vektor av typen %qT med okända gränser"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "använder oinitierat vektorelement"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "derefererar en nollpekare i %qE"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "muterbar %qD är inte användbart i ett konstant uttryck"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "använder oinitierad medlem %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "använder medlem %qD istället för aktiv medlem %qD i ett konstant uttryck"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "använder medlem %qD istället för initierad medlem %qD i ett konstant uttryck"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT är en uniontyp"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT innehåller en uniontyp"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT är en pekartyp"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT innehåller en pekartyp"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT är en referenstyp"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT innehåller en referenstyp"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT är en pekare-till-medlem-typ"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT innehåller en pekare-till-medlem-typ"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%qs är inte ett konstant uttryck eftersom %qT är volatil"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qs är inte ett konstant uttryck eftersom  %qT innehåller ett volatilt delobjekt"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%qs kan inte beräknas konstant på denna målarkitektur"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr "%qs kan inte vara konstant beräknat eftersom typen är för stor"
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "%qs kan inte beräknas konstant eftersom argumentet inte kan kodas"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "%qs använder oinitierad byte vid avståndet %d"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "%qs kan inte beräknas konstant eftersom argumentet inte kan tolkas"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "använder värdet av objektet %qT genom ett %qT-glvalue i ett konstant uttryck"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, gcc-internal-format
 msgid "%qT object created here"
-msgstr "en %qT-objekt skapat här"
+msgstr "ett %qT-objekt skapat här"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D är deklarerad här"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "användning av allokerad lagring efter deallokering i ett konstant uttryck"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr "allokerad här"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr "åtkomst av %qE utanför sin livstid"
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "innehållet av den oinitierade lagringen är inte användbart i ett konstant uttryck"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "värdet på %qD är inte användbart i ett konstant uttryck"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD använd i sin egen initierare"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D är inte const"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
-msgstr "%q+#D är volatile"
+msgstr "%q#D är volatile"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD initierades inte med ett konstant uttryck"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD deklarerades inte %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD har inte heltals- eller uppräkningstyp"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "ändring av allokerad lagring efter deallokering är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "ändring av %qE utanför sin livstid är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "att förstöra %qE utanför den nuvarande beräkningen är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "ändring av %qE från utanför den nuvarande beräkningen är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "ändring av den aktiva medlemmen av en union %qD till %qD är inte ett konstant uttryck före C++20"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr "%qD börjar inte implicit sin livstid eftersom %qT inte har någon oraderad trivial standardkonstruerare, använd %<std::construct_at%> istället"
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr "initiering av %qD kräver ett medlemsåtkomstuttryck som vänster operand i tilldelningen"
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "ändring av den aktiva medlemmen av en union %qD till %qD under initiering"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "%<constexpr%>-slingiterationsantal överskrider gränsen på %d (använd %<-fconstexpr-loop-limit=%> för att öka gränsen)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "inline-assembler är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr "endast oevaluerad inline:ad assembler är tillåten i en %<constexpr%>-funktion i C++20"
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, gcc-internal-format
 msgid "use of %qD"
 msgstr "användning av %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr "dess värde kan variera mellan kompilatorversioner eller med olika flaggor %<-mtune%> eller %<-mcpu%>"
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr "om denna användning är en del av ett publikt ABI, byt det till att istället använda en konstant variabel du definierar"
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr "standardvärdet för den aktuella CPU-trimningen är %d byte"
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr "man kan stabilisera detta värde med %<--param hardware_destructive_interference_size=%d%>, eller avaktivera denna varning med %<-Wno-interference-size%>"
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr "destructeraren avslutade med ett undantag"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "värdet %qE av typen %qT är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "antalet %<constexpr%>-evalueringsoperationer överskrider gränsen på %wd (använd %<-fconstexpr-ops-limit=%> för att öka gränsen)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr "kontrollen skickas via definitionen av %qD med trådlagringsvaraktighet"
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "kontrollen skickas via definitionen av %qD med statisk Lagringsvaraktighet"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "temporär av den ej litterala typen %qT i ett konstant uttryck"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "ett undantag som inte fångades avslutade från %<noexcept%>-funktionen %qD"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
-msgstr "destrueraren avslutade med ett undantag efter initialisering av undantagsobjektet"
+msgstr "destrueraren avslutade med ett undantag efter initiering av undantagsobjektet"
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr "konstrueraren avslutade med ett annat undantag när han gick in i hanteraren"
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "en %<reinterpret_cast%> är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "konvertering från pekartypen %qT till den aritmetiska typen %qT i ett konstant uttryck"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "typkonvertering från %qT är inte tillåtet i ett konstant uttryck eftersom den utpekade typen %qT inte liknar %qT"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "utpekat objekt är deklarerat här"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "typkonvertering från %qT är inte tillåtet i ett konstant uttryck före C++26"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
-msgstr "%qE är inte ett konstant uttryck när kassen %qT fortfarande är ofullständig"
+msgstr "%qE är inte ett konstant uttryck när klassen %qT fortfarande är ofullständig"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%<reinterpret_cast<%T>(%E)%> är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "uttrycket %qE är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%<goto%> är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "adressen för ett anrop av %qs är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "satsen är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "oväntat uttryck %qE av sorten %s"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr "%qE använder ett objekt utanför dess livstid"
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, gcc-internal-format
 msgid "contract condition is not constant"
 msgstr "kontraktsvillkoret är ej konstant"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "kontraktspredikatet är falskt i ett konstant uttryck"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "%<break%> utanför en slinga eller %<switch%>"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr "%<continue%> utanför en slinga"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "%<return%> in i ett satsuttryck"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qE är inte ett konstant uttryck eftersom det har referenser till muterbara delobjekt av %qT"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qE är inte ett konstant uttryck eftersom det refererar till undantagsobjekt allokerat med %<__cxa_allocate_exception%>"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qE är inte ett konstant uttryck eftersom det refererar ett resultat av %<operator new%>"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qE är inte ett konstant uttryck eftersom allokerad lagring inte har avallokerats"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr "omedelbar evaluering returnerar adressen till en omedelbar funktion %qD"
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "konstantevaluering returnerar adressen till en omedelbar funktion %qD"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr "referens in i ett objekt av typen consteval-only är inte ett konstant uttryck såvida det inte även har typen consteval-only"
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr "en pekare in i ett objekt av typen consteval-only är inte ett konstant uttryck såvida det inte även har typen consteval-only"
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qE är inte ett konstant uttryck eftersom det refererar till en ofullständigt initierad variabel"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qE är inte ett konstant uttryck eftersom det initierar en %qT istället för %qT"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "konvertering av l-värde till r-värde av ett volatilt l-värde %qE med typen %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "lambdafångst av %qE är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr "för att det används som ett gl-värde"
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "%<reinterpret_cast%> från heltal till pekare"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "adress-av på ett objekt %qE med trådlokal eller automatisk lagring är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "lambdauttryck är inte ett konstant uttryck före C++17"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "new-uttryck är inte ett konstant uttryck före C++20"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "virtuella funktioner kan inte %<constexpr%> före C++20"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "%<typeid%> är inte ett konstant uttryck eftersom %qE har polymorf typ"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "typkonvertering till %qT som inte är en heltalstyp i ett konstant uttryck"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qD är definierad %<thread_local%> i en %<constexpr%>-kontext"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%qD är definierad %<static%> i en %<constexpr%>-kontext"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "division med noll är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%<delete[]%> är inte ett konstant uttryck"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "ingendera grenen av %<if%> är ett konstant uttryck"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "ickekonstant vektorinitierare"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en etikettdefinition i en %<constexpr%>-funktion är endast tillgängligt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
 # ast = abstract syntax tree
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "oväntat AST av sorten %s"
@@ -57549,352 +57598,352 @@ msgstr "ingen operand i disjunktionen är uppfylld"
 msgid "the operand %qE is unsatisfied because"
 msgstr "operanden %qE är ouppfylld för att"
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qT är inte nothrow-kopieringstilldelningsbar"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%qT är inte nothrow-standardkonstruerbart"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qT är inte nothrow-kopieringskonstruerbar"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr "%qT är inte trivialt kopieringstilldelningsbart"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "%qT är inte trivialt standardkonstruerbart"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%qT är inte trivialt kopieringskonstruerbart"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "%qT är inte trivialt destruerbart"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qT har inte unika objektrepresentationer, eftersom"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "%qT har inte en virtuell destruerare"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "%qT är inte en abstrakt klass"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, gcc-internal-format
 msgid "%qT is not an aggregate"
 msgstr "%qT är inte ett aggregat"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, gcc-internal-format
 msgid "%qT is not an array"
 msgstr "%qT är inte en vektor"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qT är inte tilldelningsbar från %qT, eftersom"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT är inte en basklass till %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qT är inte en begränsad vektor"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "%qT är inte en klass"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "%qT är inte en const-typ"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "%qT är inte standardkonstruerbar, eftersom"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qT är inte konstruerbar från %qT, eftersom"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "%qT är inte destruerbar, eftersom"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "%qT är inte en tom klass"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, gcc-internal-format
 msgid "%qT is not an enum"
 msgstr "%qT är inte en uppräkningstyp"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "%qT är inte en slutlig klass"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "%qT är inte en funktion"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, gcc-internal-format
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT är inte en typ med implicit livslängd"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "%qT är inte anropbar, eftersom"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qT är inte anropbar av %qT, eftersom"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qT är inte layoutkompatibel med %qT, eftersom"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, gcc-internal-format
 msgid "%qT is not a literal type"
-msgstr "%qT är inte en literal typ"
+msgstr "%qT är inte en litteral typ"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, gcc-internal-format
 msgid "%qT is not a member function pointer"
 msgstr "%qT är inte en medlemsfunktionspekare"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, gcc-internal-format
 msgid "%qT is not a member object pointer"
 msgstr "%qT är inte en medlemsobjektspekare"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, gcc-internal-format
 msgid "%qT is not a member pointer"
 msgstr "%qT är inte en medlemspekare"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qT är inte nothrow-tilldelningsbar från %qT"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%qT är inte nothrow-standardkonstruerbart, eftersom"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qT är inte nothrow-konstruerbar från %qT, eftersom"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qT är inte nothrow-konvertibel från %qT, eftersom"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qT är inte nothrow-destruerbar, eftersom"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qT är inte nothrow-anropbar, eftersom"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qT är inte nothrow-anropbar av %qT, eftersom"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, gcc-internal-format
 msgid "%qT is not an object type"
 msgstr "%qT är inte en objekttyp"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT är inte en pekarinterkonvertibel bas till %qT, eftersom"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "%qT är inte en POD-typ"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "%qT är inte en pekare"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "%qT är inte en polymorf typ"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, gcc-internal-format
 msgid "%qT is not a reference"
 msgstr "%qT är inte en referens"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, gcc-internal-format
 msgid "%q#T is not the same as %q#T"
-msgstr "%q#T är inte en detsamma som %q#T"
+msgstr "%q#T är inte detsamma som %q#T"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, gcc-internal-format
 msgid "%qT is not a scoped enum"
 msgstr "%qT är inte en enum med räckvidd"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, gcc-internal-format
 msgid "%qT is not a standard layout type"
 msgstr "%qT är inte en standardlayouttyp"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "%qT är inte en trivial typ"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qT är inte trivialt tilldelningsbar från %qT, eftersom"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "%qT är inte trivialt standardkonstruerbart, eftersom"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%qT är inte trivialt konstruerbar från %qT, eftersom"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "%qT är inte trivialt kopierbar"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "%qT är inte trivialt destruerbart, eftersom"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "%qT är inte en obegränsad vektor"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, gcc-internal-format
 msgid "%qT is not a union"
 msgstr "%qT är inte en union"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, gcc-internal-format
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT är inte en virtuell bas till %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, gcc-internal-format
 msgid "%qT is not a volatile type"
 msgstr "%qT är inte en volatile-typ"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "%qT är inte consteval-only"
+msgid "%qT is not a structural type"
+msgstr "%qT är inte en strukturell typ"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, gcc-internal-format
 msgid "%qT cannot yield a rank"
 msgstr "%qT kan inte ge en ordning"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, gcc-internal-format
 msgid "%qT and %qT cannot be ordered"
 msgstr "%qT och %qT kan inte ordnas"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "%qT är inte destruerbar"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr "%qT är inte en referens som binder till ett temporärt objekt med typen %qT (direktinitiering)"
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr "%qT är inte en referens som binder till ett temporärt objekt med typen %qT (kopieringsinitiering)"
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "%qD är inte härledbar från %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, gcc-internal-format
 msgid "invalid constraints"
 msgstr "ogiltiga begränsningar"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr "begränsningen %qE har typen %qT, inte %<bool%>"
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "uttrycket %qE beräknades till %<false%>"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "begränsningar är inte uppfyllda"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr "sätt %qs till åtminstone %d för fler detaljer"
@@ -57924,47 +57973,47 @@ msgstr "deklarationen har ett annat antal kontrakt mot tidigare deklarerat"
 msgid "previous declaration with fewer contracts here"
 msgstr "tidigare deklaration med färre kontrakt här"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr "en värdeparameter som används i ett efterhandstillstånd måste vara const"
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, gcc-internal-format
 msgid "parameter declared here"
 msgstr "parameter som deklareras här"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr "värdeparametern %qE som används i ett efterhandstillstånd måste vara const"
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr "resultatnamnet i ett kontraktuellt efterhandstillstånd skuggar en funktionsparameter"
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "deklarationen lägger till kontrakt till %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, gcc-internal-format
 msgid "first declared here"
 msgstr "först deklarerad här"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr "konstrueraren returnerar inte ett värde att testa"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr "destrueraren returnerar inte ett värde att testa"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr "funktionen returnerar inte ett värde att testa"
@@ -58034,7 +58083,7 @@ msgstr "korutinlöftestypen %qT deklarerar både %<return_value%> och %<return_v
 msgid "%<return_void%> declared here"
 msgstr "%<return_void%> deklarerades här"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "ingen medlem med namnet %qE i %qT"
@@ -58106,83 +58155,83 @@ msgstr "%qs den väntbara typen %qT är inte en post"
 msgid "awaitable type %qT is not a structure"
 msgstr "den väntbara typen %qT är inte en post"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr "%<await_suspend%> måste returnera %<void%>, %<bool%> eller ett korutinhandtag"
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, gcc-internal-format
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs kan inte användas i en oevaluerad kontext"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "funktion deklarerad %<noreturn%> har en %<co_return%>-sats"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "justeringsargumentet till %<__builtin_coro_promise%> måste vara en konstant"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "riktningsargumentet till %<__builtin_coro_promise%> måste vara en konstant"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "ingen suspenderingspunktsinformation för %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "dubblerad information för %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr "antagandet ignorerat för att det innehåller ett await-uttryck"
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr "vänteuttryck är inte tillåtna i hanterare"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "vektorer med variabel längd stödjs inte ännu i korutiner"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr "%qE tillhandahålls av %qT men är inte användbart med funktionssignaturen %qD"
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr "%qE tillhandahålls av %qT men %qE är inte markerad %<throw()%> eller %<noexcept%>"
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr "%qE är markerad %<throw()%> eller %<noexcept%> men ingen användbar %<get_return_object_on_allocation_failure%> tillhandahålls av %qT"
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr "%qE tillhandahålls av %qT men %<std::nothrow%> finns inte"
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "%qE tillhandahålls av %qT men är inte användbart med funktionen %qD"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr "ingen genomförbar konvertering från %<void%> given av %<get_return_object%> till returtypen %qT"
@@ -58195,7 +58244,7 @@ msgstr "båda grenarna av en %<if%>-sats markerad som %qs"
 #: cp/cp-gimplify.cc:577
 #, gcc-internal-format
 msgid "%qD was promoted to an immediate function because its body contains an immediate-escalating expression %qE"
-msgstr "%qD befordrades till en omedelbar funktion eftersom dess kropp innehåller ett uttryck %qE som omedelbareskalerar"
+msgstr "%qD befordrades till en omedelbar funktion eftersom dess kropp innehåller ett uttryck %qE som omedelbart eskalerar"
 
 #: cp/cp-gimplify.cc:580
 #, gcc-internal-format
@@ -58207,68 +58256,73 @@ msgstr "%qD befordrades till en omedelbar funktion"
 msgid "%qs used outside of constant expressions"
 msgstr "%qs använd utanför konstanta uttryck"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "en oväntad deklaration av %<std::%s%>"
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "tar adressen till en omedelbar funktion %qD"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "anrop av consteval-funktionen %qE är inte ett konstant uttryck"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%<throw%> kommer alltid anropa %<terminate%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "i C++11 är standard för destruerare %<noexcept%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr "i C++11 kommer denna %<throw%> att anropa %<terminate%> eftersom standard för destruerare är %<noexcept%>"
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "ignorerar attributet %qE efter tidigare %qE"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "paketexpandering av attributet %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "använd vikningsuttryck i attributargumentet istället"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD är inte en typ"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qD är inte en klasstyp"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qD har inte typen %<const char *%>"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qD har inte heltalstyp"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr "%<std::source_location::__impl%> innehåller inte endast icke-statiska datamedlemmar %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> och %<_M_column%>"
@@ -58309,7 +58363,7 @@ msgstr "konvertering till icke konstant referens av typ %q#T från ett r-värde
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "konvertering från %qH till %qI kastar kvalificerare"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "typkonvertering av %qT till %qT derefererar inte pekare"
@@ -58520,37 +58574,37 @@ msgstr "variabeln %qE med ofullständig typ %qT kommer inte användas i for-ökn
 #: cp/cvt.cc:1571
 #, gcc-internal-format
 msgid "conversion to void cannot resolve address of overloaded function"
-msgstr "konvertering till void kan inte lösa upp adress till överlagrad funktion"
+msgstr "konvertering till void kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1575
 #, gcc-internal-format
 msgid "second operand of conditional expression cannot resolve address of overloaded function"
-msgstr "andra operanden i villkorsuttryck kan inte lösa upp adress till överlagrad funktion"
+msgstr "andra operanden i villkorsuttryck kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1579
 #, gcc-internal-format
 msgid "third operand of conditional expression cannot resolve address of overloaded function"
-msgstr "tredje operanden i villkorsuttryck kan inte lösa upp adress till överlagrad funktion"
+msgstr "tredje operanden i villkorsuttryck kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1583
 #, gcc-internal-format
 msgid "right operand of comma operator cannot resolve address of overloaded function"
-msgstr "högra operanden av kommaoperator kan inte lösa upp adress till överlagrad funktion"
+msgstr "högra operanden av kommaoperator kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1587
 #, gcc-internal-format
 msgid "left operand of comma operator cannot resolve address of overloaded function"
-msgstr "vänstra operanden av kommaoperator kan inte lösa upp adress till överlagrad funktion"
+msgstr "vänstra operanden av kommaoperator kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1591
 #, gcc-internal-format
 msgid "statement cannot resolve address of overloaded function"
-msgstr "en sats kan inte lösa upp adress till överlagrad funktion"
+msgstr "en sats kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1595
 #, gcc-internal-format
 msgid "for increment expression cannot resolve address of overloaded function"
-msgstr "for-ökningsuttryck kan inte lösa upp adress till överlagrad funktion"
+msgstr "for-ökningsuttryck kan inte slå upp adress till överlagrad funktion"
 
 #: cp/cvt.cc:1611
 #, gcc-internal-format
@@ -58697,7 +58751,7 @@ msgstr "än tidigare deklaration av %qF"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "omdeklaration av %qD skiljer i %qs från tidigare deklaration"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "tidigare deklaration %qD"
@@ -58810,7 +58864,7 @@ msgstr "motstridig deklaration av mallen %q#D"
 #: cp/decl.cc:2246
 #, gcc-internal-format
 msgid "conflicting declaration of C function %q#D"
-msgstr "motstridande deklaration av C-funktionen %q#D"
+msgstr "motstridig deklaration av C-funktionen %q#D"
 
 #: cp/decl.cc:2270
 #, gcc-internal-format
@@ -58820,7 +58874,7 @@ msgstr "ny deklaration av %q#D som skapar tvetydighet"
 #: cp/decl.cc:2281
 #, gcc-internal-format
 msgid "conflicting declaration %q#D"
-msgstr "motstridande deklaration av %q#D"
+msgstr "motstridig deklaration av %q#D"
 
 #: cp/decl.cc:2283
 #, gcc-internal-format
@@ -58918,12 +58972,12 @@ msgstr "standardargumentet angivet för parameter %d till %q#D"
 msgid "previous specification in %q#D here"
 msgstr "tidigare specifikation i %q#D här"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
-msgstr "motstridande exporterande för deklaration av %qD"
+msgstr "motstridigt exporterande för deklaration av %qD"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "tidigare deklarerad här utan att exporteras"
@@ -59128,7 +59182,7 @@ msgstr "  hoppar över initiering av %q#D"
 msgid "  enters %<template for%> statement"
 msgstr "  går in i %<template for%>-sats"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "%qD använd utan mallargument"
@@ -59173,2417 +59227,2427 @@ msgstr "%<typename %T::%D%> namnger %q#D, som inte är en typ"
 msgid "template parameters do not match template %qD"
 msgstr "mallparametrar stämmer inte med mallen %qD"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "%<-faligned-new=%d%> är inte en potens av två"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr "%<--param destructive-interference-size=%d%> är mindre än %d"
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param destructive-interference-size=%d%> är mindre än %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr "%<--param constructive-interference-size=%d%> är mindre än %d"
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param constructive-interference-size=%d%> är större än %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q#D ogiltig, en anonym union kan bara ha publika ickestatiska datamedlemmar"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr "denna flexibilitet bör undvikas och kommer tas bort"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr "anonym post med basklasser"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "medlem %q+#D med konstruerare inte tillåten i anonymt aggregat"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "medlem %q+#D med destruerare inte tillåten i anonymt aggregat"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "medlem %q+#D med kopieringstilldelningsoperator är inte tillåten i anonymt aggregat"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "attribut ignoreras i deklaration av %q#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "attribut för %q#T måste komma efter nyckelordet %qs"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "flera typer i en deklaration"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "omdeklaration av inbyggd C++-typ %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> kan endast anges för variabler eller funktionsdeklarationer"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "typnamn saknas i typedef-deklaration"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ förbjuder anonyma poster"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "%<inline%> kan endast anges för funktioner"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%<virtual%> kan endast anges för funktioner"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> kan endast anges inuti en klass"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> kan endast anges för konstruerare"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "en lagringsklass kan bara anges för objekt och funktioner"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%<const%> kan bara anges för objekt och funktioner"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%<volatile%> kan bara anges för objekt och funktioner"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%<__restrict%> kan bara anges för objekt och funktioner"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%<__thread%> kan bara anges för objekt och funktioner"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> ignorerades i denna deklaration"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%qs kan inte användas till typdeklarationer"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "attribut ignoreras i explicit instansiering av %q#T"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "inget attribut kan användas på en explicit instansiering"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "attributet ignorerat"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "ett attribut som gäller en viss typspecificerare ignoreras"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "ignorerar attribut använda på klasstypen %qT utanför dess definition"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "ignorerar attribut använda på beroende typ %qT utan en associerad deklaration"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD är initierad (använd %qs istället)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr "efterhandstillstånd med härledda resultatnamnstyper får endast förekomma på funktionsdefinitioner"
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "deklarationen av %q#D har %<extern%> och är initierad"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "definitionen av %q#D är markerad %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q+#D är inte en statisk datamedlem i %q#T"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "icke-medlemsmalldeklaration av %qD"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "stämmer inte med medlemsmalldeklarationen här"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ tillåter inte %<%T::%D%> att definieras som %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "dubblerad initierare av %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "deklaration av %q#D utanför en klass är inte en definition"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr "extern-deklaration %q#D med blockräckvidd får inte kopplas till en namngiven modul"
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD definierad %<thread_local%> i en %qs-funktion är endast tillgängligt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD definierad %<static%> i en %qs-funktion är endast tillgängligt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "variabeln %q#D har initierare men ofullständig typ"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "elementen i vektorn %q#D har ofullständig typ"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "aggregatet %q#D har ofullständig typ och kan inte definieras"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD är deklarerad som en referens men inte initierad"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "namn använt i en designerad initierare i GNU-stil för en vektor"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "namnet %qD använt i en designerad initierare i GNU-stil för en vektor"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "icketriviala designerade initierare stödjs inte"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "C99-beteckningen %qE är inte ett konstantuttryck av heltalstyp"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "initierare misslyckas med att bestämma storleken på %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "vektorstorlek saknas i %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "vektor med storlek noll %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "lagringsstorlek på %qD är inte känd"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "lagringsstorlek på %qD är inte konstant"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "tyvärr: semantiken för inline-variabeln %q#D är felaktig (du kommer få flera exemplar)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "tyvärr: semantiken för inline-funktioners statiska data %q#D är felaktig (du kommer få flera exemplar)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "du kan gå runt detta genom att ta bort initieraren"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "oinitierad %<const %D%>"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "oinitierad variabel %qD i %<constexpr%>-funktion"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "oinitierad variabel %qD i %<constexpr%>-kontext"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T har ingen användardefinierad standardkonstruerare"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "konstrueraren är inte användarens egna eftersom den är uttryckligen standarddefinierad i klasskroppen"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "och den implicit definierade konstrueraren initierar inte %q#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "ogiltig typ %qT som initierare för en vektor med typ %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "initierare för %qT måste vara inom klamrar"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%<[%E] =%> använt i en designerad initierare i GNU-stil för klassen %qT"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "begäran av medlem %qD är tvetydig"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT har ingen icke-statisk medlem med namnet %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD har inte en direkt medlem i %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "ogiltig initierare för %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "C99-beteckningen %qE utanför aggregatinitierare"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "för många initierare för %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "klamrar runt skalär initierare för typen %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "för många klamrar runt skalär initierare för typen %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "klamrar saknas runt initierare för %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "strukturerad bindning har en ofullständig typ %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "element i vektorn %q#T har ofullständig typ"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "sammansatta litteral med variabel storlek"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D har ofullständig typ"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "skalärt objekt %qD kräver ett element i initieraren"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "i C++98 måste %qD initieras med en konstruerare, inte med %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "vektor %qD initierad från strängkonstant inom parentes %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "initierare är ogiltig för statisk medlem med konstruerare"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "ej konstant initiering inom klassen av statisk medlem %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "ej konstant initiering inom klassen är felaktig för icke inline statisk medlem %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(en initiering utanför klassen krävs)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "adress till explicit registervariabel %qD begärd"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "referensen %qD initieras med sig själv"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "argument %d till %qE måste vara av %<omp_interop_t%>"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "kunde inte hitta en variantdeklaration"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%<declare variant%> på konstrueraren %qD"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "%<declare variant%> på destrueraren %qD"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "%<declare variant%> på standarddefinierad %qD"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr "%<declare variant%> på raderad %qD"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr "%<declare variant%> på virtuell %qD"
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "tilldelning (inte initiering) i deklaration"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++17 tillåter inte specificeraren %<register%> av lagringsklass"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "specificeraren %<register%> av lagringsklass angiven"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "deklarationen av %q#D har ingen initierare"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "initieraren för %<decltype(auto) %D%> har funktionstyp; glömde du %<()%>?"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "härledd typ %qT för %qD är ofullständig"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "%<::main%> kan inte raderas"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "skuggar tidigare typdeklaration av %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%<constinit%> kan bara tillämpas på en variabel med statisk eller trådlagringsvaraktighet"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<constinit%> kan endast tillämpas på strukturerad bindning med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "funktionen %q#D är initierad som en variabel"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "det går inte att dekomponera lambdahöljestypen %qT"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, gcc-internal-format
 msgid "lambda declared here"
 msgstr "lambda deklarerat här"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "det går inte dekomponera klasstypen %qT för att den har en anonym struct-medlem"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr "kan inte dekomponera klasstypen %qT för att den har en anonym unionsmedlem"
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "det går inte att dekomponera en oåtkomlig medlem %qD av %qT"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, gcc-internal-format
 msgid "in base class of %qT"
 msgstr "i basklass till %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr "kan inte dekomponera klasstypen %qT: både den och dess basklass %qT har ickestatiska datamedlemmar"
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr "kan inte dekomponera klasstypen %qT: dess basklasser %qT och %qT har ickestatiska datamedlemmar"
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "strukturerad bindning refererar till ofullständig typ %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "det går inte att dekomponera vektorn %qT med okänd gräns"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "det går inte att dekomponera en vektor %qT med variabel längd"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "det går inte att dekomponera en vektor %qT med variabel längd"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "%<std::tuple_size<%T>::value%> är inte ett konstantuttryck av heltalstyp"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "det går inte att dekomponera unionstypen %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "det går inte att dekomponera typen %qT som inte är en klass eller vektor"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "strukturerad bindning refererar till ofullständig klasstyp %qT"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr "vektorinitierare för deklaration av strukturerad bindning i villkor"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "%u namn angivet för strukturerad bindning"
 msgstr[1] "%u namn angivna för strukturerad bindning"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] "endast %u namn angivet för strukturerad bindning"
 msgstr[1] "endast %u namn angivna för strukturerad bindning"
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] "medan %qT dekomponeras till %wu element"
 msgstr[1] "medan %qT dekomponeras till %wu element"
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr "medan %qT dekomponeras till %E element"
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr "%<std::tuple_element<%wu, %T>::type%> är %<void%>"
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "i initieringen av paket %qD i strukturerad bindning"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "i initieringen av variabel %qD i strukturerad bindning"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "det går inte att dekomponera klasstypen %qT utan icke-statiska datamedlemmar"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr "ickelokal variabel %qD deklarerad %<__thread%> behöver dynamisk initiering"
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "den icke-lokala variabeln %qD deklarerad %<__thread%> har en icke-trivial destruerare"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
-msgstr "C++11 %<thread_local%> tillåter dynamisk initialisering och destruktion"
+msgstr "C++11 %<thread_local%> tillåter dynamisk initiering och destruktion"
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "initierare misslyckas med att bestämma storleken på %qT"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "vektorstorlek saknas i %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "vektor med storlek noll %qT"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "destruerare för främmande class %qT kan inte vara en medlem"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "konstruerare för främmande klass %qT kan inte vara en medlem"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD deklarerad som en %<virtual%>-variabel"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "%<const%>- och %<volatile%>-funktionsspecificerare på %qD är ogiltiga i variabeldeklaration"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD deklarerad som en %<virtual%>-parameter"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD deklarerad som en %<inline%>-parameter"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "%<const%>- och %<volatile%>-funktionsspecificerare på %qD är ogiltiga i parameterdeklaration"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD deklarerad som en %<virtual%>-typ"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD deklarerad som en %<inline%>-typ"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "%<const%>- och %<volatile%>-funktionsspecificerare på %qD är ogiltiga i typdeklaration"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD deklarerat som ett %<virtual%>-fält"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD deklarerat som ett %<inline%>-fält"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "%<const%>- och %<volatile%>-funktionsspecificerare på %qD är ogiltiga i fältdeklaration"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D deklarerad som en vän"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D deklarerad med en undantagsspecifikationer"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "definitionen av %qD är inte i en namnrymd som innesluter %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "statisk medlemsfunktion %q#D deklarerad med typkvalificerare"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, gcc-internal-format
 msgid "function concepts are no longer supported"
 msgstr "funktionskoncept stödjs inte längre"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "begränsning av en funktion som inte är en mall"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "begränsad vändeklaration som inte är en mall måste vara en definition"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr "en vänfunktionsmall med begränsningar som beror på yttre mallparametrar måste vara en definition"
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "definierar explicit specialisering %qD i vändeklaration"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "ogiltig användning av mall-id %qD i deklaration av primär mall"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "standardargument är inte tillåtna i deklaration av vänmallspecialisering %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> är inte tillåtet i deklaration av vänmallspecialisering %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "vändeklarationen av %qD anger standardargument och är inte en definition"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "det går inte att deklarera %<::main%> som en mall"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "det går inte att deklarera %<::main%> som inline"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "det går inte att deklarera %<::main%> som %qs"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "det går inte att deklarera %<::main%> som static"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "det går inte att deklarera %<::main%> med en annan länkningsspecifikation än %<extern \"C++\"%>"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr "det går inte att koppla %<::main%> till en namngiven modul"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr "använd %<extern \"C++\"%> för att koppla den till den globala modulen istället"
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "icke-medlemsfunktion %qD kan inte ha cv-kvalificerare"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "statisk medlemsfunktion %qD kan inte ha cv-kvalificerare"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "explicit objektmedlemsfunktion %qD kan inte ha cv-kvalificerare"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "icke-medlemsfunktion %qD kan inte ha ref-kvalificerare"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "statisk medlemsfunktion %qD kan inte ha ref-kvalificerare"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "explicit objektmedlemsfunktion %qD kan inte ha ref-kvalificerare"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "explicit objektparameter deklarerad här"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "härledningsguiden %qD måste deklareras med i samma räckvidd som %qT"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "  deklarerad här"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "härledningsguiden %qD måste ha samma åtkomst som %qT"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "härledningsguiden %qD får inte ha en funktionskropp"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "litteral operator med C-länkning"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD har en ogiltig argumentlista"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "heltalssuffixet %qs skuggas av implementationen"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "flyttalssuffixet %qs skuggas av implementationen"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "litterala operatorsuffix som inte föregås av %<_%> är reserverade för framtida standardisering"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD måste vara en icke-medlems-funktion"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> måste returnera %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "omdefinition av implicit deklarerad %qD"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "definition av explicit standarddefinierad %q+D"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q#D explicit standarddefinierad här"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "ingen medlemsfunktion %q#D deklarerad i klassen %qT"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "det går inte att deklarera %<::main%> som en global variabel"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
-msgstr "en post med namnet %<main%> kan inte deklareras med länkklassen C-språket"
+msgstr "en post med namnet %<main%> kan inte deklareras med C-länkning"
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "en icke-mallvariabel variabel kan inte vara %<concept%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "koncept måste definieras med namnrymdsräckvidd"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, gcc-internal-format
 msgid "variable concepts are no longer supported"
 msgstr "variabelkoncept stödjs inte längre"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "initiering i klassen av statisk datamedlem %q#D med ofullständig typ"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "%<constexpr%> behövs för initiering i klassen av statisk datamedlem med icke heltalstyp %q#D"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "initiering i klassen av statisk datamedlem %q#D med icke-litteral typ"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "ogiltig initiering i klassen av statisk datamedlem med icke heltalstyp %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ förbjuder initiering inom klassen av icke-konstant statisk medlem %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ förbjuder initiering av medlemskonstant %qD av icke heltalstyp %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "storlek på vektorn %qD av typen %qT är inte en heltalstyp"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "storlek på vektorn av typen %qT är inte en heltalstyp"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "storlek på vektorn %qD är inte ett konstantuttryck av heltalstyp"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "storlek på vektorn är inte ett konstantuttryck av heltalstyp"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ förbjuder vektor %qD med storlek noll"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ förbjuder vektor med storlek noll"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ förbjuder vektor %qD med variabel längd"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ förbjuder vektor med variabel längd"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "vektor %qD med variabel längd används"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "vektor med variabel längd används"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "spill i vektordimension"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD är deklarerad som en vektor av mallens platshållartyp %qT"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "skapar en vektor av mallens platshållartyp %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "deklaration av %qD som en vektor av void"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "skapar vektor av void"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "deklaration av %qD som en vektor av funktioner"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "skapar vektor av funktioner"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "deklaration av %qD som en vektor av referenser"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "skapar vektor av referenser"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "deklaration av %qD som en vektor av funktionsmedlemmar"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "skapar vektor av funktionsmedlemmar"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "deklaration av %qD som flerdimensionell vektor måste ha gränser för alla dimensioner utom den första"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "flerdimensionell vektor måste ha gränser för alla dimensioner utom den första"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr "vektor med variabel längd av %<auto%>"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "en returtypsspecifikation för konstruerare är ogiltig"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "kvalificerare är inte tillåtna vid konstruerardeklaration"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "specifikation av returtyp för destruerare är ogiltigt"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "kvalificerare är inte tillåtna vid destruerardeklaration"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "returtyp angiven för %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "kvalificerare är inte tillåtna på deklaration av %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "returtypen angiven för härledningsguiden"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "kvalificerare är inte tillåtna på deklaration av härledningsguide"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "mallmallparameter %qT i deklaration av härledningsguide"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "%<decl-specifier%> i deklaration av härledningsguide"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "namnlös variabel eller fält deklarerad void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "variabel eller fält deklarerad void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "specificeraren %<inline%> är ogiltig för variabeln %qD deklarerad med blockräckvidd"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "inline-variabler är endast tillgängliga med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr "anonym icke-C-kompatibel typ given ett namn för länkningsändamål genom en %<typedef%>-deklaration"
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr "typen är inte C-kompatibel eftersom den har en basklass"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr "typen är inte C-kompatibel eftersom %qD har standardmedlemsinitierare"
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "typen är inte C-kompatibel eftersom den innehåller en %qD-deklaration"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr "%qT som en typ snarare en enkel %<decltype(auto)%>"
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "%<decltype(auto)%> får inte vara cv-kvalificerad"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 msgid "%e and %e specified together"
 msgstr "%e och %e givna tillsammans"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "ogiltig användning av kvalificerat namn %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "ogiltig användning av kvalificerat namn %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "ogiltig användning av kvalificerat namn %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%q#T är inte en klass eller namnrymd"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "deklaration av %qE som en icke-funktion"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "deklaration av %qE som icke-medlem"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "deklarerar-id saknas, använder reserverat ord %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "funktionsdefinition deklarerar inte parametrar"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "deklaration av %qD som en icke-funktion"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "deklaration av %qD som %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "deklaration av %qD som en parameter"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr "både %qs och %qs angivna"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%qs kan inte förekomma i en typedef-deklaration"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr "man kan använda högst en av specificerarna %<constinit%> och %<constexpr%>"
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "två eller fler datatyper i deklaration av %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C++ stödjer inte bara %<complex%> i meningen %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ förbjuder deklaration av %qs utan typ"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int%d%> stödjs inte på denna målarkitektur"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ stödjer inte %<__int%d%> för %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qs specificerad med %qT"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qs specificerad med typedef-namn %qD"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs specificerad med %<decltype%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qs specificerad med %<typeof%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "complex ogiltig för %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr "mallargumentlistan saknas efter %qE; för härledning måste mallplatshållare följas av ett enkelt deklarerar-id"
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "medlem %qD kan inte deklareras både %<virtual%> och %<static%>"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "medlem %qD kan deklareras både %<virtual%> och %<constexpr%> endast i %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "typedef-deklaration ogiltig i parameterdeklaration"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "lagringsklass angiven för mallparameter %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "lagringsklass angiven för parameter %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "en parameter kan inte deklareras %qs"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> utanför klassdeklaration"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "deklaration av strukturerad bindning får inte vara %qs"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturerade bindningsdeklarationer kan vara %qs endast med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "strukturerade bindningsdeklarationer kan vara %qs endast i %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "%<volatile%>-kvalificerad strukturerad bindning bör undvikas"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "deklaration av strukturerad bindning får inte vara C++98 %<auto%>"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "deklaration av strukturerad bindning får inte ha typen %qT"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr "typen måste vara en cv-kvalificerad %<auto%> eller en referens till en cv-kvalificerad %<auto%>"
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "deklaration av strukturerad bindning får inte ha begränsat %<auto%>-typ %qT"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "flera lagringsklasser i deklaration av %qs"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "lagringsklass angiven för %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "nästad funktion %qs är deklarerad %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "toppnivådeklaration av %qs anger %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "funktionsdefinitionsområde %qs implicit auto och deklarerat %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "ogiltig specificerare av lagringsklass i vänfunktionsdeklarationer"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "onödiga parenteser i deklaration av %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr "ta bort parenteser"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "explicita objektmedlemsfunktioner är endast tillgängliga med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "en funktionstyp kan inte ha en explicit objektparameter"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "en pekare på en funktionstyp kan inte ha en explicit objektparameter"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "en pekare på en medlemsfunktionstyp kan inte ha en explicit objektparameter"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr "typen på en pekare till en explicit objektmedlemsfunktion är en vanlig pekare på en funktionstyp"
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
-msgstr "type på en explicit objektmedlemsfunktion är en normal funktionstyp"
+msgstr "typen på en explicit objektmedlemsfunktion är en normal funktionstyp"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr "endast den första parametern till en medlemsfunktion kan deklareras som en explicit objektparameter"
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr "giltig explicit objektparameter deklarerad här"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "requires-klausul på returtypen"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "funktionen %qs använder typspecificeraren %<auto%> utan avslutande returtyp"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "härledd returtyp är endast tillgänglig med %<-std=c++14%> eller %<-std=gnu++14%>"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "en virtuell funktion kan inte ha härledd returtyp"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "funktionen %qs med avslutande returtyp har %qT som sin typ istället för bara %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "funktionen %qs med avslutande returtyp har %<decltype(auto)%> som sin typ istället för bara %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "ogiltig användning av %<decltype(auto)%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "funktionen %qs med avslutande returtyp har typspecificeraren begränsad %<auto%> istället för bara %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, gcc-internal-format
 msgid "invalid use of constrained %<auto%> type"
 msgstr "ogiltig användning av begränsad typ %<auto%>"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "härledd klasstyp %qD i funktionens returtyp"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "härledningsguiden för %qT måste ha en avslutande returtyp"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr "den avslutande returtypen %qT hos deduktionsguiden är inte en specialisering av %qT"
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "avslutande returtyp är endast tillgänglig med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "funktionen %qs med avslutande returtyp är inte deklarerad med typspecificeraren %<auto%>"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "en konverteringsfunktion kan inte ha en avslutande returtyp"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "%<volatile%>-kvalificerad returtyp bör undvikas"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs är deklarerad som en funktion som returnerar en funktion"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs är deklarerad som en funktion som returnerar en vektor"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<constinit%> på en funktions returtyp är inte tillåtet"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "destruerare kan inte vara en statisk medlemsfunktion"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "konstruerare kan inte vara en statisk medlemsfunktion"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "destruerare får inte vara cv-kvalificerade"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "konstruerare får inte vara cv-kvalificerade"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "destruerare får inte vara ref-kvalificerade"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "konstruerare får inte vara ref-kvalificerade"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "konstruerare kan inte deklareras %<virtual%>"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "virtuella funktioner kan inte vara vänner"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "vändeklaration är inte i klassdefinition"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "det går inte att definiera vänfunktion %qs i en lokal klassdefinition"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr "vänfunktionsdefinitionen %qs får inte ha ett namn kvalificerat med %<::%>"
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr "vänfunktionsdefinitionen %qs får inte ha ett namn kvalificerat med %<%D::%>"
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "en icke-medlemsfunktion kan inte ha en explicit objektparameter"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "en explicit objektmedlemsfunktion får inte vara %<virtual%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "en explicit objektmedlemsfunktion kan inte vara %<static%>"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD kan inte vara en explicit objektmedlemsfunktion"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "destruerare får inte ha parametrar"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "det går inte att deklarera pekare till %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "det går inte att deklarera referens till %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "det går inte att deklarera pekare medlem av %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "det går inte att deklarera en referens till en kvalificerad funktionstyp %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "det går inte att deklarera en pekare till en kvalificerad funktionstyp %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "det går inte att deklarera en referens till %q#T, som inte är ett typedef- eller ett malltypargument"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "mall-id %qD använd som en deklarerare"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "medlemsfunktioner är implicit vänner till sin klass"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "extra kvalifikation %<%T::%> på medlem %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "det går inte att definiera medlemsfunktion %<%T::%s%> inuti %qT"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "det går inte att deklarera medlemsfunktionen %<%T::%s%> inuti %qT"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "det går inte att deklarera medlem %<%T::%s%> inuti %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "icke-parameter %qs kan inte vara ett parameterpaket"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "datamedlem får inte ha variabel typ %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "parameter får inte ha variabel typ %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<explicit%> utanför klassdeklaration"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<explicit%> i vändeklaration"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "endast deklarationer av konstruerare och konverteringsoperatorer kan vara %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "icke-medlem %qs kan inte deklareras %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "icke-objektmedlem %qs kan inte deklareras %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "funktionen %qs kan inte deklareras %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "%<static%> %qs kan inte deklareras %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "%<const%> %qs kan inte deklareras %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "referensen %qs kan inte deklareras %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "typedef kan inte vara en funktionsdefinition"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "typedef får inte vara en medlemsfunktionsdefinition"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<auto%> är inte tillåtet i en aliasdeklaration"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef deklarerad %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr "requires-klausul på typedef"
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "typedef-namn får inte vara en nästad-namnspecificerare"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ förbjuder nästad typ %qD med samma namn som en omgivande klass"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> angivet för vänklassdeklaration"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "mallparametrar kan inte vara vänner"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "vändeklaration kräver klassnyckel, d.v.s. %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "vändeklaration kräver klassnyckel, d.v.s. %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "försöker göra klassen %qT en vän med global räckvidd"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "ogiltiga kvalificerare på typ som inte är medlemsfunktion"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr "requires-klausul på type-id"
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "abstrakt deklarerare %qT använd som deklaration"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "requires-klausul vid deklaration av icke-funktionstypen %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "det går inte att använda %<::%> i parameterdeklaration"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "det går inte att deklarera en parameter med %<decltype(auto)%>"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr "saknad mallargumentlista efter %qE; platshållare för mall är inte tillåtet i en parameter"
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "eller använd %<auto%> för en förkortad funktionsmall"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "en %<auto%>-parameter är tillåten i detta sammanhang"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "parametern deklarerad %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "ogiltig användning av mallnamnet %qE utan en argumentlista"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "ej statisk datamedlem deklarerad med platshållaren %qT"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ förbjuder den flexibla vektormedlemmen %qs"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C++ förbjuder flexibla vektormedlemmar"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "ogiltig användning av %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "deklaration av funktionen %qD i ogiltig kontext"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "funktionen %qD deklarerad %<virtual%> inuti en union"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD kan inte deklareras %<virtual%>, eftersom den alltid är statisk"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "kvalificerat namn förväntades i vändeklaration för destruerare %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "deklaration av %qD som medlem av %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "en destruerare kan inte vara %qs"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "kvalificerat namn förväntades i vändeklaration för konstruerare %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "en konstruerare kan inte vara %<concept%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "ett koncept kan inte vara en medlemsfunktion"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%qD kan inte vara %qs"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "specialisering av variabelmall %qD deklarerad som en funktion"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr "variabelmallen är deklarerad här"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "fältet %qD har den ofullständiga typen %qT"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "namnet %qT har ofullständig typ"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE är varken en funktion eller medlemsfunktion, kan inte deklareras som vän"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "ett namnlöst fält är varken en funktion eller medlemsfunktion, kan inte deklareras som vän"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "annoteringen tillämpad på en icke definierande vändeklaration %qD"
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "annoteringen tillämpad på parametern %qD i en icke definerande vändeklaration"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "ett attribut som tillhör en vändeklaration som inte är en definition ignoreras"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "statisk datamedlem %qE deklarerad %qs"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "statiska %<constexpr%>-datamedlemmen %qD måste ha en initierare"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "ickestatisk datamedlem %qE deklarerad %qs"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "lagringsklassen %<auto%> är ogiltig för funktionen %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "lagringsklassen %<register%> är ogiltig för funktionen %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "lagringsklassen %<__thread%> är ogiltig för funktionen %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "lagringsklassen %<thread_local%> är ogiltig för funktionen %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "specificeraren %<constinit%> är ogiltig för funktionen %qs"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "virt-specificerare i %qs är inte tillåtet utanför en klassdefinition"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "specificerare %<static%> är ogiltigt för funktion %qs deklarerad utanför global räckvidd"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "specificerare %<inline%> är ogiltig för funktionen %qs deklarerad utanför global räckvidd"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "virtuell icke klassfunktion %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs definierad utan att vara i klassräckvidd"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs deklarerad utan att vara i klassräckvidd"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "det går inte deklarera medlemsfunktionen %qD att ha statisk länkklass"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "kan inte deklarera en statisk funktion i en annan funktion"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> får inte användas vid definition (till skillnad mot deklaration) av statisk datamedlem"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "statisk medlem %qD deklarerad %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "det går inte att deklarera medlem %q#D att ha extern länkklass"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "deklarationen av %<constexpr%>-variabeln %qD är inte en definition"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "en variabel kan inte deklareras %<consteval%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs initierad och deklarerad %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs har både %<extern%> och initierare"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "standardargument %qE använder %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "standardargument %qE använder lokal variabel %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "felaktig användning av cv-kvalificerad typ %qT i en parameterdeklaration"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "felaktig användning av typen %<void%> i en parameterdeklaration"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "%<volatile%>-kvalificerad parameter bör undvikas"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "parameter %qD ogiltigt deklarerad metodtyp"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "parameter %qD inkluderar pekare till vektor %qT med okänd gräns"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "parameter %qD inkluderar referens till vektor %qT med okänd gräns"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "ogiltig konstruerare, du menade förmodligen %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD är kanske inte deklarerad i en namnrymd"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD får inte deklareras som statisk"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "%qD måste vara en icke-statisk medlemsfunktion"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD måste vara en medlemsfunktion"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD får bara vara en statisk medlemsfunktion med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD måste vara antingen en medlemsfunktion som inte är statisk eller funktion som inte är medlem"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD måste ha ett argument med klass- eller uppräkningstyp"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ förhindrar överlagring av %<operator ?:%>"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD får inte ha variabelt antal argument"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "%qD måste ha antingen noll eller ett argument"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "%qD måste ha antingen ett eller två argument"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "postfix %qD måste ha %<int%> som sitt argument"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "postfix %qD måste ha %<int%> som sitt andra argument"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "%qD får inte ha några argument"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "%qD måste ha exakt ett argument"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "%qD måste ha exakt två argument"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD kan inte ha standardargument"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "konvertering av %qT till %<void%> kommer aldrig använda en typkonverteringsoperator"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "konvertering av %qT till en referens till samma typ kommer aldrig använda en typkonverteringsoperator"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "konvertering av %qT till samma typ kommer aldrig använda en typkonverteringsoperator"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "konvertering av %qT till en referens till basklassen %qT kommer aldrig använda en typkonverteringsoperator"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "konvertering av %qT till basklassen %qT kommer aldrig använda en typkonverteringsoperator"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "användardefinierad %qD beräknar alltid båda argumenten"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "prefix %qD skall returnera %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "postfix %qD skall returnera %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD skall returnera som värde"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "malltypparametern %qT används efter %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "användning av aliasmallspecialisering %qT efter %qs"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "typedef-namnet %qD används efter %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD har en tidigare deklaration här"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT refererad till som %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%qT har en tidigare deklaration här"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT refererad till som enum"
@@ -61595,100 +61659,100 @@ msgstr "%qT refererad till som enum"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "mallargument krävs för %<%s %T%>"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "referens till %qD är tvetydig"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "klassmallen %qD omdeklarerad som en icke-mall"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD har samma namn som klassen den är deklarerad i"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT är inte en mall"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr "kanske du vill explicit lägga till %<%T::%>"
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "enum %q#D används utan tidigare deklaration"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "omdeklaration av %qT som en icke-mall"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "härledd unionen %qT ogiltig"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT definierad med flera direkta baser"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT definierad med en direkt virtuell bas"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "bastyp %qT är ingen post- eller klasstyp"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "rekursiv typ %qT odefinierad"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "upprepat bastyp %qT ogiltig"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "uppräkningstyp med/utan räckviddsbegränsning stämmer inte överens för enum %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "tidigare definition här"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "underliggande typ stämmer inte överens i enum %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "olika underliggande typ i enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "underliggande typ %qT till %qT måste vara en heltalstyp"
@@ -61697,87 +61761,92 @@ msgstr "underliggande typ %qT till %qT måste vara en heltalstyp"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "ingen heltalstyp kan representera alla uppräkningsvärdena i %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "uppräkningsvärde för %qD är inte en heltalstyp eller uppräkningstyp utan räckviddsbegränsning"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "uppräkningsvärde för %qD är inte en heltalskonstant"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "ökat uppräkningsvärde är för stort för %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "ökat uppräkningsvärde är för stort för %<long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "överspill i uppräkningsvärden vid %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "uppräkningsvärdet %qE är utanför intervallet för den underliggande typen %qT"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "fler definitioner av %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "returtypen %q#T är ofullständig"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> skall returnera en referens till %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "inga retursatser i funktion som returnerar %qT"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "endast enkel returtyp %<auto%> kan härledas till %<void%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr "definierar %qD, som tidigare inte kunde härledas i en SFINAE-kontext"
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "ingen retursats i %<constexpr%>-funktion som returnerar icke-void"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD är redan definierad i klassen %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr "använder %qs"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, gcc-internal-format
+msgid "%qs used without %qs declaration"
+msgstr "%qs använt utan en %qs-deklaration"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "användning av %qD före härledning av %<auto%>"
@@ -62207,335 +62276,335 @@ msgstr "användning av funktionen %qD med ej uppfyllda begränsningar"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "användning av det inbyggda parameterpaketet %qD utanför en mall"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    inline:ad från %qD vid %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    inline:ad från %qD vid %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "    inline:ad från %qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "I statisk medlemsfunktion %qD"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "I kopieringskonstruerare %qD"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "I konstruerare %qD"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "I destruerare %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "I lambdafunktion"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "I explicit objektmedlemsfunktion %qD"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, gcc-internal-format
 msgid "In member function %qD"
 msgstr "I medlemsfunktion %qD"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr "I funktion %qD"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "men %qE är en typ"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "men %qE är ett uttryck"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "men %qE är en strukturerad bindning"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr "men %qE är en variabel"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, gcc-internal-format
 msgid "but %qE is a parameter"
 msgstr "men %qE är en parameter"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, gcc-internal-format
 msgid "but %qE is a function"
 msgstr "men %qE är en funktion"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, gcc-internal-format
 msgid "but %qE is a data member"
 msgstr "men %qE är en datamedlem"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, gcc-internal-format
 msgid "but %qE is a function template"
 msgstr "men %qE är en funktionsmall"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "men %qE är en klassmall"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "men %qE är en variabelmall"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, gcc-internal-format
 msgid "but %qE is a namespace"
 msgstr "men %qE är en namnrymd"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "men %qE är en uppräknare"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s%s%sVid instansiering av %<template for%> iteration %E:\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s%s%sVid substituering av %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s%s%sVid instansiering av %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "rekursivt begärd härifrån %<template for%> iteration %E\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr "krävs från %<template for%> iteration %E\n"
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "krävs rekursivt av substitution av %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "krävs av substitution av %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "rekursivt begärd från %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "begärs från %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "rekursivt begärd härifrån\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "begärd härifrån\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "[ hoppar över %d instansieringskontexter, använd -ftemplate-backtrace-limit=0 för att avaktivera ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "i expansion av %<constexpr%> i %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "krävs av begränsningarna på %q#D\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "krävs för att uppfylla %qE"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "krävs för att uppfylla begränsningar\n"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr "i krav med "
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, gcc-internal-format
 msgid "in requirements "
 msgstr "i kraven "
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr "(inga argument)"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr "[…]"
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "utökade initierarlistor är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "explicita konverteringsoperatorer är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "variadiska mallar är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "lambdauttryck är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 auto är endast tillgängligt med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "enum med räckvidd är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "standarddefinierade och borttagna funktioner är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline-namnrymder är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "styrning av åsidosättande (override/final) är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "initierare av datamedlemmar som inte är statiska är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "användardefinierade litteraler är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "delegerande konstruerare är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ärvande konstruerare är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11-attribut är endast tillgängligt med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-kvalificerare är endast tillgängliga med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "ofullständig typ %qT använd i nästad namnspecificerare"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "referens till %<%T::%D%> är tvetydig"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD är inte en medlem av %qT; menade du %qs?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD har inte en medlem av %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD är inte en medlem av %qD; menade du %qs?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD är inte en medlem av %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> har inte deklarerats; menade du %qs?"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> har inte deklarerats"
@@ -62756,7 +62825,7 @@ msgstr "referensen %qD är inte ännu bunden till ett värde när den används h
 msgid "member %qD is used uninitialized"
 msgstr "medlemmen %qD används oinitierad"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "vektorer måste initieras med en initierare inom klamrar"
@@ -62872,7 +62941,7 @@ msgstr "typ %qT är inte en direkt eller virtuell bas till %qT"
 msgid "type %qT is not a direct base of %qT"
 msgstr "typ %qT är inte en direkt bas till %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -63063,42 +63132,42 @@ msgstr "möjligt problem upptäckt vid anrop av operatorn %<delete []%>"
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "varken destrueraren eller den klasspecifika operatorn %<delete []%> kommer anropas, även om de är deklarerade när klassen definieras"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "initierare tar slut i förtid"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "okänd vektorstorlek i delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, gcc-internal-format
 msgid "operator %<delete%> used on incomplete type"
-msgstr "operatorn %<delete%> anvånd på en ofullständig typ"
+msgstr "operatorn %<delete%> använd på en ofullständig typ"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "möjligt problem upptäckt vid anrop av %<operator delete%>"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "varken destrueraren eller den klasspecifika %<operator delete%> kommer anropas, även om de är deklarerade när klassen definieras"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "radering av objekt av den abstrakta klasstypen %qT som har en ej virtuell destruerare kommer medföra odefinierat beteende"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "radering av objekt av den polymorfa klasstypen %qT som har en ej virtuell destruerare kommer medföra odefinierat beteende"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "typ till vektor-delete är varken pekar- eller vektortyp"
@@ -63133,82 +63202,90 @@ msgstr "fångst av kopia av ofullständig typ %qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "fångad strukturerad bindning är en C++20-utvidgning"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr "försök att fånga %qD i instansiering av en generisk lambda"
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr "implicit fångst av %qE via %<[=]%> bör undvikas i C++20"
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr "lägg till explicit fångst av %<this%> eller %<*this%>"
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> fångades inte för denna lambdafunktion"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
-msgstr "det manglade namnet för %qT ändrad i %<-fabi-version=20%> (GCC 15.1)"
+msgstr "det manglade namnet för %qT ändrades i %<-fabi-version=20%> (GCC 15.1)"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "det manglade namnet för %qT ändras i %<-fabi-version=20%> (GCC 15.1)"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr "%qD fångas inte längre i noexcept-lambda i ABI v21 (GCC 16)"
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "ogiltigt %<#pragma %s%>"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "%<#pragma vtable%> stödjs inte längre"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%<#pragma implementation%> för %qs förekommer efter att filen inkluderats"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD inte definierad"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<requires%> är endast tillgängligt med %<-std=c++20%> eller %<-fconcepts%>"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD deklarerades inte i detta definitionsområde; menade du %qs?"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD deklarerades inte i detta definitionsområde"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "det finns inga argument till %qD som beror på en mallparameter, så en deklaration av %qD måste finnas tillgänglig"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(om du använder %<-fpermissive%>, kommer G++ acceptera din kod, men man bör undvika att tillåta användning av ett odeklarerat namn)"
@@ -63218,64 +63295,57 @@ msgstr "(om du använder %<-fpermissive%>, kommer G++ acceptera din kod, men man
 msgid "  # %E"
 msgstr "  # %E"
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "manglar %<typeof%>, använd %<decltype%> istället"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr "användning av inbyggd egenskap %qT i funktionssignatur; använd biblioteksegenskaper istället"
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr "manglar typpaketindex"
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr "användning av inbyggd egenskap %qE i funktionssignatur; använd biblioteksegenskaper istället"
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "manglar %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "utelämnad mittoperand till %<?:%> kan inte manglas"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr "det manglade namnet för %qD kommer ändras i C++17 eftersom undantagsspecifikationen är en del av funktionstypen"
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "det manglade namnet på %qD ändrades mellan %<%s=%d%> (%qD) och %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "det manglade namnet på %qD ändras mellan %<%s=%d%> (%qD) och %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "det manglade namnet på en snutt för %qD ändras mellan %<-fabi-version=%d%> och %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "det manglade namnet på %qD ändras mellan %<-fabi-version=%d%> och %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "det manglade namnet på initieringsvaktsvariabeln för %qD ändras mellan %<-fabi-version=%d%> och %<-fabi-version=%d%>"
@@ -63463,7 +63533,7 @@ msgstr "%qT är en kvalificerad funktionstyp"
 #: cp/method.cc:2455
 #, gcc-internal-format
 msgid "cannot construct an array of unknown bound"
-msgstr "kan inte konstruera en med okända begränsning"
+msgstr "kan inte konstruera en vektor med okänd begränsning"
 
 #: cp/method.cc:2478
 #, gcc-internal-format
@@ -63558,7 +63628,7 @@ msgstr "förväntad signatur: %qD"
 #: cp/method.cc:3747
 #, gcc-internal-format
 msgid "explicitly defaulted copy constructor is implicitly deleted because its declared type does not match the type of an implicit copy constructor"
-msgstr "explicit standarddefinierad kopieringskonstruerare raderas implicit för att dess deklarerade typ inte stämmer inte med typen på en implicita kopieringskonstruerare"
+msgstr "explicit standarddefinierad kopieringskonstruerare raderas implicit för att dess deklarerade typ inte stämmer med typen på en implicita kopieringskonstruerare"
 
 #: cp/method.cc:3752
 #, gcc-internal-format
@@ -63660,439 +63730,439 @@ msgstr "en befintlig deklaration här utan taggar"
 #: cp/module.cc:12573
 #, gcc-internal-format
 msgid "conflicting language linkage for imported declaration %#qD"
-msgstr "motstridande språklänkning för den importerade deklarationen %q#D"
+msgstr "motstridig språklänkning för den importerade deklarationen %#qD"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
-msgstr "motstridande typ för den importerade deklarationen %#qD"
+msgstr "motstridig typ för den importerade deklarationen %#qD"
 
 #: cp/module.cc:12601
 #, gcc-internal-format
 msgid "conflicting argument list for imported declaration %#qD"
-msgstr "motstridande argumentlista för den importerade deklarationen %#qD"
+msgstr "motstridig argumentlista för den importerade deklarationen %#qD"
 
 #: cp/module.cc:12608
 #, gcc-internal-format
 msgid "conflicting argument types for imported declaration %#qD"
-msgstr "motstridande argumenttyper för den importerade deklarationen %#qD"
+msgstr "motstridiga argumenttyper för den importerade deklarationen %#qD"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
-msgstr "motstridande specificerare %<noexcept%> för den importerade deklarationen %#qD"
+msgstr "motstridig specificerare %<noexcept%> för den importerade deklarationen %#qD"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
-msgstr "motstridande härledd returtyp för den importerade deklarationen %#qD"
+msgstr "motstridig härledd returtyp för den importerade deklarationen %#qD"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
-msgstr "motstridande %<constexpr%> för den importerade deklarationen %#qD"
+msgstr "motstridigt %<constexpr%> för den importerade deklarationen %#qD"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
-msgstr "motstridande impotrerad deklaration %q#D"
+msgstr "motstridig importerad deklaration %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "befintlig deklaration %#qD"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "standardargument i konflikt för %#qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, gcc-internal-format
 msgid "existing default declared here"
 msgstr "befintligt standardvärde är deklarerat här"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
-msgstr "standardargument står i konflikt för parameter %P till %q#D"
+msgstr "standardargument står i konflikt för parameter %P till %#qD"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "definitionen av %qD matchar inte"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "befintlig definition %qD"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "uppräkningstypen %qD stämmer inte med …"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "… denna uppräkningstyp %qD"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr "ytterligare uppräknare som börjar med %qD"
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr "uppräkningsintervallen skiljer"
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qD är ett alias för den TU-lokala typen %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%qD är en specialisering av den TU-lokala mallen %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "%qD är deklarerad med intern länkning"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD har ingen länkning och är deklarerad i en anonym namnrymd"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD har ingen länkning och är deklarerad inom en TU-lokal enhet %qT"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD har ingen länkning och är deklarerad inom en TU-lokal enhet %qD"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr "%qT har inget namn och kan inte skiljas från liknande lambdan i andra TU:n"
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
-msgstr "%qT har inget namn och är inte definierad inute in klass, funktion eller initierare"
+msgstr "%qT har inget namn och är inte definierad inuti en klass, funktion eller initierare"
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD har ett TU-lokalt mallargument %qD"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
-msgstr "%qD har ett lokalt mallargument %qT"
+msgstr "%qD har ett TU-lokalt mallargument %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr "%qD refererar till ett TU-lokalt objekt %qD"
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD refererar till en TU-lokal funktion %qD"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "instansiering exponerar den TU-lokala enheten %qD"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr "%qD exponerar den TU-lokala enheten %qD"
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr "%qD är också TU-lokal men har exponerats på annat håll"
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
-msgstr "%qD refererar till en TU-lokal enhet %qD, vilket kan skapa problem vid instantiering i andra TU:n"
+msgstr "%qD refererar till en TU-lokal enhet %qD, vilket kan skapa problem vid instansiering i andra TU:n"
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
-msgstr "%qD refererar till en TU-lokal enhet %qD och kan inte instantieras i andra TU:n"
+msgstr "%qD refererar till en TU-lokal enhet %qD och kan inte instansieras i andra TU:n"
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD är deklarerad %<constexpr%> och är initierad till ett TU-lokal värde"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr "%qD är en referens deklarerad %<inline%> och är konstantinitierad till ett TU-lokalt värde"
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr "rekursiv lat laddning"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr "modulen %qs beror på sig själv"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "modulen %qs är deklarerad här"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "indirekt import %qs är inte laddad redan"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr "import %qs har CRC som inte stämmer"
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr "exporterar inte %<#define %E%> eftersom det är ett nyckelord"
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "makrodefinitionen av %qE är trasig"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "inkonsistent importerad makrodefinition %qE"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr "%<#undef %E%>"
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr "%<#define %s%>"
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "kompilerad modulfil är %qs"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "kompilerad modul är %sversion %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr "kompilatorn är %sversion %s%s%s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr "modulen %qs finns"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr "huvudmodul förväntades, modul %qs fanns"
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr "modul %qs förväntades, huvudmodul fanns"
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr "modul %qs har CRC som inte stämmer"
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr "mål & värd är %qs:%qs, %qs:%qs förväntades"
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr "språkdialekten skiljer %qs, %qs förväntades"
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "modulen innehåller OpenMP, använd %<-fopenmp%> för att aktivera"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr "modulen innehåller OpenMP, använd %<-fopenmp%> eller %<-fopenmp-simd%> för att aktivera"
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "modulen innehåller OpenACC, använd %<-fopenacc%> för att aktivera"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "fixade träd som inte stämde"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "gränssnittspartitionen exporteras inte"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "misslyckades att läsa det kompilerade modulklustret %u: %s"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "misslyckades att läsa en kompilerad modul: %s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr "överväg att använda %<-fno-module-lazy%>, att öka värdet på %<-param-lazy-modules=%u%> eller att öka gränsen på beskrivare per process"
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr "importer måste byggas före de importeras"
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr "återvänder till grinden för ett mekaniskt problem"
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "deklaration av %qD i modulen %qs står i konflikt med inbyggd i den globala modulen"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "deklarationen %qD står i konflikt med inbyggd"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "omdeklaration av %qD i modulen %qs står i konflikt med import"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "omdeklaration av %qD i den globala modulen står i konflikt med import"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "import deklarerad ansluten till modulen %qs"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr "import deklarerad i den globala modulen"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "motstridig deklaration av %qD i modulen %qs"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "motstridig deklaration av %qD i den globala modulen"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "tidigare deklarerad i modulen %qs"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "tidigare deklarerad i den globala modulen"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr "definition av extern länkning av %qD i en huvudmodul måste deklareras %<inline%>"
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "en exporterande deklaration %qD deklarerad i en namnlös namnrymd"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "en exporterande deklaration %qD med intern länkklass"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "läser CMI %qs"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "misslyckades att ladda bindningen %<%E%s%E%>"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr "misslyckades att ladda bindningen %<%E%s%E@%s%>"
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr "under laddning av bindningen %<%E%s%E%>"
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr "under laddning av bindningen %<%E%s%E@%s%>"
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "misslyckades att ladda väntande för %<%E%s%E%>"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "under laddning av väntande för %<%E%s%E%>"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "import av %qs inom sin egen implementeringsenhet"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, gcc-internal-format
 msgid "module declared here"
 msgstr "modulen är deklarerad här"
@@ -64104,107 +64174,107 @@ msgstr "modulen är deklarerad här"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr "import av den namngivna modulen %qs inuti språklänkningsblock"
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr "modulen är redan deklarerad"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr "modulen är redan importerad"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "modulen %qs importerades här"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr "kompilerat modulgränssnitt som inte stämmer: hade %qs, fick %qs"
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "okänt kompilerat modulgränssnitt: %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr "det går inte att avgöra %<#include%>-översättning av %s: %s"
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr "inkluderingen %qs översatt till import"
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr "import av %qs misslyckades, faller tillbaka till att inkludera"
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr "inkluderingen %qs bearbetad textuellt"
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "C++-moduler är inkompatibla med förkompilerade huvuden"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "C++-moduler är inkompatibla med traditionell preprocessning"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "felaktigt huvudnamn %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "felaktig modulnamn %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr "%<-fmodule-only%> använd för annat än gränssnitt"
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "skriver CMI %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr "skriver inte modulen %qs på grund av fel i mallkroppar"
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr "aktivera %<-Wtemplate-body%> för fler detaljer"
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "första felet i %qD uppstod här"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "misslyckades att skriva en kompilerad modul: %s"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "okänd huvudsort %qs"
@@ -64219,7 +64289,7 @@ msgstr "överlagringsuppsättningen för argumentberoende uppslagning av %<%D::%
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "ignorerar %qD deklarerad här med intern länkning"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "namnoberoende deklarationer är endast tillgängliga med %<-std=c++2c%> eller %<-std=gnu++2c%>"
@@ -64242,7 +64312,7 @@ msgstr "%q#D döljer konstruerare för %q#D"
 #: cp/name-lookup.cc:3310
 #, gcc-internal-format
 msgid "conflicting C language linkage declaration %q#D"
-msgstr "motstridande deklaration av C-länkning av %q#D"
+msgstr "motstridig deklaration av C-länkning av %q#D"
 
 #: cp/name-lookup.cc:3315
 #, gcc-internal-format
@@ -64264,260 +64334,270 @@ msgstr "deklaration av %q#D skuggar en parameter"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "deklarationen av %qD skuggar en medlem av %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr "annoteringen tillämpad på extern %qD med blockräckvidd"
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "annoteringen tillämpad på parametern %qD till en extern med blockräckvidd"
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "vändeklaration %qD i lokal klass utan en tidigare lokal deklaration"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %<%s(%E)%> %p %d"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "exporterar %q#D som inte har extern länkning"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q#D är deklarerad här utan någon länkning"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%q#D är deklarerad här med intern länkning"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q#D är deklarerad här med modullänkning"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T%s%D%> namnger en destruerare"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "using-deklaration för icke-medlem vid klassräckvidd"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using%> med uppräkningsräckvidd %q#T är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT är inte en klass, namnrymd eller uppräkning"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "icke-medlems using-deklaration namnger konstrueraren för %qT"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "using-deklaration för medlem vid icke-klass-räckvidd"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "%qT är inte en direkt bas till %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr "menade du %<using enum %T::%D%>?"
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD har inte deklarerats i %qD"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "en using-deklaration får inte namnge namnrymden %qD"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> namnger konstruerare i %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "deklaration av %qD inte i namnrymd som omger %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "explicit-kvalifikation i deklaration av %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD borde ha deklarerats inuti %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD har inte deklarerats inom %qD"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "endast här som %<friend%>"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "attributet %qD kräver ett ensamt NTBS-argument"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "attributet %qD är meningslöst eftersom medlemmar av den anonyma namnrymden får lokala symboler"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "ignorerar attributet %qD på en anonym namnrymd"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "ignorerar attributet %qD på en namnrymd som inte är inline"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "attributdirektivet %qD ignorerat"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "maxgräns på %d namnrymder sökta %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "föreslaget alternativ:"
 msgstr[1] "föreslagna alternativ:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr "%<std::%s%> är definierad i huvudet %qs; detta går förmodligen att lösa genom att lägga till %<#include %s%>"
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<std::%s%> är bara tillgänglig från %s och framåt"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "makrot %qs har inte definierats ännu"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr "det definierades senare här"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "definitionen av %<std::initializer_list%> matchar inte %<#include <initializer_list>%>, är inte en mall"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "ett %<strong%> using-direktiv stödjs inte längre"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr "du kan använda en inline-namnrymd istället"
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<omp::%E%> är inte tillåtet att anges i detta sammanhang"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "annotering om användning av direktiv"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "det går inte att nästa mer än %d namnrymder"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%<namespace %E%> är tvetydig"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "namnrymdsalias %qD inte tillåtet här, antar %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "en exporterande namnrymd %qD med intern länkning"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD har intern länkning för att den deklarerades i en namnlös namnrymd"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr "exporterar namnlös namnrymd"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "inline-namnrymder måste anges vid den ursprungliga definitionen"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%s-namnrymd %qD står i konflikt med nåbar definition"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "nåbar %s-definition här"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX går in i %<pop_everything ()%>"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr "XXX lämnar %<pop_everything ()%>"
@@ -64547,7 +64627,7 @@ msgstr "identifieraren %qE är ett nyckelord i C++26"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr "%<LEXER_DEBUGGING_ENABLED_P%> är inte satt till true"
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> som inte omedelbart följs av en funktionsdeklaration eller -definition"
@@ -64592,7 +64672,7 @@ msgstr "%<::%E%> har inte deklarerats"
 msgid "request for member %qE in non-class type %qT"
 msgstr "begäran av medlem %qE i typ %qT som inte är en klasstyp"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> har inte deklarerats"
@@ -64662,7 +64742,7 @@ msgstr "(kanske ett semikolon saknas efter definitionen av %qT)"
 msgid "%qE is not a class template"
 msgstr "%qE är inte en klassmall"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE är inte en mall"
@@ -64973,1691 +65053,1701 @@ msgstr "paketindexering är endast tillgängliga med %<-std=c++2c%> eller %<-std
 msgid "pack index missing"
 msgstr "paketindex saknas"
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr "reflektioner är endast tillgängliga med %<-freflection%>"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "en reflektion av en typ förväntades"
 
-#: cp/parser.cc:6341
-#, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "en reflektion av en funktionsmall förväntades"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr "extra %<template%> i en räckviddssplitsning"
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "%<template%> saknas i en räckviddssplitsning med mallargument"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr "%<template%> får endast utelämnas när räckviddssplitsningen föregås av %<typename%>"
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "en reflektion av klass, namnrymd eller uppräkning förväntades"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "fixdecimaltyper stödjs inte i C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ förbjuder klammergrupper inuti uttryck"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "satsuttryck är inte tillåtna utanför funktioner eller i mallargumentlistor"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "vikningsuttryck är endast tillgängliga med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "primäruttryck förväntades"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> kan inte användas i detta sammanhang"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "en malldeklaration får inte förekomma på blocknivå"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "parametern %qD får inte förekomma i detta sammanhang"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "lokal variabel %qD får inte förekomma i detta sammanhang"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "reflektion är endast tillgänglig i C++26 med %<-freflection%>"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr "nyckelordet %qs förväntades före ett beroende mallnamn"
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "id-uttryck förväntades"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "räckvidd %qT före %<~%> är inte ett klassnamn"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "nyckelordet %<template%> är tillåtet i destruerarnamn"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> är endast tillgängligt med %<-std=c++14%> eller %<-std=gnu++14%>"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr "mall-id är inte tillåtet för destruerare i C++20"
 
 # %qs blir den fixa strängen "< >"
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr "ta bort %qs"
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "deklaration av %<~%T%> som medlem av %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef-namnet %qD använt som destruerardeklarerare"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "okvalificerat id förväntades"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD är inte en mall"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "%<:%> hittades i kapslad namnspecifikation, %<::%> förväntades"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%<decltype%> beräknas till %qT, som inte är en klass eller uppräkningstyp"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "funktionsmalls-id %qD i nästad namnspecificerare"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "concept-id %qD i nästad namnspecificerare"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "variabelmall-id %qD i nästad namnspecificerare"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "nästat namn-specificerare förväntades"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "typer får inte definieras i typkonverteringar"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "typer får inte definieras i ett %<typeid%>-uttryck"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "fel antal argument till %<__builtin_addressof%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "fel antal argument till %<__builtin_launder%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "fel antal argument till %<__builtin_assoc_barrier%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "fel antal argument till %<__builtin_shufflevector%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr "anrop av %<__builtin_operator_new%> väljer inte en ersättningsbar global allokeringsfunktion"
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "anrop av %<__builtin_operator_delete%> väljer inte en ersättningsbar global avallokeringsfunktion"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, gcc-internal-format
 msgid "selected function declared here"
 msgstr "den valda funktionen deklarerad här"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ förbjuder sammansatta litteraler"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr "två på varandra följande %<[%> får bara introducera ett attribut"
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "typer får inte definieras inuti anrop av %<__builtin_classify_type%>"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr "kan inte använda multidimensionellt index i OpenMP-vektorsektionen"
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "ogiltig användning av %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> är inte en klassmedlem"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "icke skalär typ"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%<template%> måste följa en nästad-namnspecificerare"
 
+#: cp/parser.cc:10142
+#, gcc-internal-format
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "%<^^%> kan inte användas på en platshållartyp"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<^^%> kan inte tillämpas på denna operand"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ tillåter inte %<alignof%> med annat än en typ"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "typer får inte definieras i %<noexcept%>-uttryck"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, gcc-internal-format
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%<co_await%> kan inte användas i standardargument"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "typer får inte definieras i en %qs-uttryck"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "%<__builtin_has_attribute%> med beroende argument stödjs inte ännu"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "typer får inte definieras i en new-uttryck"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "vektorgräns är förbjuden efter typ-id i parenteser"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "försök ta bort parenteserna runt typ-id:t"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr "initiering av new-uttryck för typen %<auto%> tar precis ett element"
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "uttryckslista eller typ-id förväntades"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "typer får inte definieras i en new-type-id"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "attribut ignoreras på yttersta vektortypen i new-uttryck"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "uttryck i new-deklarerare måste ha heltals- eller uppräkningstyp"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "användning av gammaldags typkonvertering till %q#T"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "operatorn %<>>%> hanteras som två högervinkelparenteser i C++11"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "föreslår parenteser runt %<>>%>-uttryck"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ tillåter inte %<?:%> med mellersta operanden utelämnad"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "kommauttryck på toppnivå i vektorindex bör undvikas"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "typer får inte definieras i %<__builtin_offsetof%>"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr "avslutande argument till %<__type_pack_element%> är inte en typ"
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambdauttryck i oberäknade sammanhang är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambdauttryck i mallargument är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "icke-lokala lambda-uttryck kan inte ha en standardfångst"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "slut på fångstlista förväntades"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "explicit fångst via kopiering av %<this%> med standardfångst via kopiering är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "redan infångad %qD i lambdauttryck"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "fångst av %<*this%> är endast tillgängligt med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "det går inte att fånga %<this%> via referens"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "pack init-fångst är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr "%<&%> skall komma före %<...%>"
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "lambdafångstinitierare är endast tillgängliga med %<-std=c++14%> eller %<-std=gnu++14%>"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr "tom initierare för lambdas init-fångst"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "fångst av en icke-variabel %qE"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "fångst av variabeln %qD med ej automatisk lagringsvaraktighet"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr "för många %<...%> i lambdafångst"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "explicit fångst via kopiering av %qD överflödigt vid standardfångst via kopiering"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "explicit fångst via referens av %qD överflödigt med standardfångst via referens"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambdamallar är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "standardargumentet angivet för lambdaparameter"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en parameterdeklaration före lambdadeklarationsspecificerare är endast valfritt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr "ett lambda med fångster kan inte ha en explicit objektparameter av en orelaterad typ"
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "lambdaspecificeraren %<mutable%> med en explicit objektparameter"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr "det inskickade höljesobjektet kommer inte muteras eftersom det tas via värde"
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr "deklarera den explicita objektparametern som en icke-const-referens istället"
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr "explicit objektparameter är redan en muterbar referens"
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "lambdaspecificeraren %<static%> med en explicit objektparameter"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr "lambdaspecificeraren %<static%> med lambdafångst"
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en parameterdeklaration före lambdatransaktionskvalificerare är endast valfritt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en parameterdeklaration före en lambdaundantagsspecifikation är endast valfritt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en parameterdeklaration före lambdas efterföljande returtyp är endast valfritt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<constexpr%> lambda är endast tillgängligt med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr "%qE fångas inte implicit av en kontraktsförsäkran"
+
+#: cp/parser.cc:13754
+#, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "%q#E är deklarerad här"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en etikett vid slutet av en sammansatt sats är endast tillgängligt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "attribut vid början av satser ignoreras"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "etikettsats förväntades"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case-etikett %qE är inte i en switch-sats"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr "en identifieraretikett %qE i %<template for%>-brödtext"
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "%<typename%> behövs före %qE för att %qT är en beroende räckvidd"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "%qE namnger konstrueraren, inte typen"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "sammansatt sats i en %<constexpr%>-funktion"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr "inre slingor måste vara perfekt nästade med direktivet %<tile%>"
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<if constexpr%> är endast tillgängligt med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<if consteval%> är endast tillgängligt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr "%<if consteval%> kräver en sammansatt sats"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "init-satsen i valsatser är endast tillgängliga med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "selektionssats förväntades"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr "villkor deklarerar en vektor"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, gcc-internal-format
 msgid "condition declares a function"
 msgstr "villkor deklarerar en funktion"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "typer får inte definieras i villkor"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "initierare förväntades"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "intervallbaserade %<for%>-slingor med initierare är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr "slingvariabeln %qD av typen %qT binder till en temporär konstruerad från typen %qT"
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr "använd icke-referens-typ %qT för att göra kopieringen explicit eller %qT för att förhindra kopiering"
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "slingvariabeln %qD skapar en kopia från typen %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr "använd referenstyp för att förhindra kopiering"
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "intervallbaserat %<for%>-uttryck av typen %qT har ofullständig typ"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "inkonsistenta start-/sluttyper i intervallbaserad %<for%>-sats: %qT och %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "iterationssats förväntades"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "en aliasdeklaration i en initieringssats är endast tillgängliga med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "intervallbaserad %<for%>-slinga är endast tillgänglig med %<-std=c++11%> eller %<-std=gnu++11%>"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<template for%> är endast tillgängligt med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr "designerare i %<template for%>-initierare"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "en for-range-dellaration kan inte vara ”constinit”"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<goto%> i %<constexpr%>-funktioner är endast tillgängligt med %<-std=c++23%> eller %<-std=gnu++23%>"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ förbjuder beräknade goto"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "hoppsats förväntades"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr "modulpartition förväntades"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr "modulnamn förväntades"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "en moduldeklaration är inte tillåten i en huvudenhet"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr "en moduldeklaration måste vara på global räckvidd"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, gcc-internal-format
 msgid "scope opened here"
 msgstr "räckvidden öppnad här"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr "privat modulfragment"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr "privata modulfragment är endast tillåtna inom räckvidden för modulgränssnittet eller -partitionen"
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr "moduldeklarationer är endast tillåtna som första deklaration, eller som avslutning av ett globalt modulfragment"
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr "post-modul-deklarations-importer måste vara sammanhängande"
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr "kanske infoga en radbrytning efter %<import%>, eller annat sätt att särskilja, för att förhindra att detta betraktas om en modul-styr-rad"
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "import-deklaration måste vara på global räckvidd"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
-msgstr "att importspecificera en mudulpartition måste förekomma efter en namngiven moduldeklaration"
+msgstr "att importspecificera en modulpartition måste förekomma efter en namngiven moduldeklaration"
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr "post-modul-deklarations-importer får inte vara include-översatta"
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr "post-modul-deklarations-importer får inte vara från huvudinkludering"
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr "%qE får endast förekomma efter en modulgränssnittsdeklaration"
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "%qE får bara förekomma en gång i en exportdeklaration"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr "%<export%> är inte del av ett följande moduldirektiv"
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "extra %<;%> utanför funktioner är endast tillåtet i C++11"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function"
 msgstr "extra %<;%> utanför en funktion"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr "extra %<;%> inuti en post är endast tillåtet i C++11"
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr "extra %<;%> inuti en post"
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "extra %<;%> efter funktionsdefinition i klassen"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "attribut är inte tillåtna på denna position"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "attribut får infogas här"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr "explicita specialiseringar tillåts inte här"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr "en specialisering exporteras alltid tillsammans med sin primära mall"
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr "explicita instansieringar tillåts inte här"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "exportdeklarationer tillåts inte här"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> som inte inleder ett block"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr "icke-variabel %qD i deklaration med mer än en deklarerare med platshållartyp"
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "inkonsistent härledning för %qT: %qT och sedan %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "att blanda deklarationer och funktionsdefinitioner är förbjudet"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "typer får inte definieras i en for-range-deklaration"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "initierare i intervallbaserad %<for%>-slinga"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "flera deklarationer i intervallbaserad %<for%>-slinga"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr "strukturerat bindningspaket utanför en mall"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "multipla paket i deklaration av strukturerad bindning"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturerade bindningspaket är endast tillgängliga med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturerade bindningar med identifierare med attribut är endast tillgängliga med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr "annotering på en strukturerad bindning"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "strukturerade bindningar i villkor är endast tillgängliga med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "strukturerade bindningar är endast tillgängliga med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "tom deklaration av strukturerad bindning"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "ogiltig initierare för deklaration av strukturerad bindning"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "for-range-deklaration får inte vara %qs"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
-msgstr "%<this%> måste anges vara den första specificeraren i en parameterdeklaration"
+msgstr "%<this%> måste vara den första specificeraren i en parameterdeklaration"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> använd utanför en klass"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "nyckelordet %<bool%> är inte tillåtet i en C++20 konceptdefinition"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr "syntaxen för en C++20 konceptdefinition är %<concept <namn> = <uttr>%>"
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "%<typedef%>-specificerare står i konflikt med %qs"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> ändrar betydelse i C++11; var god ta bort det"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "%qD är ogiltigt i villkor"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD är ogiltigt i lambda"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD är endast giltig i lambda med %<-std=c++23%> eller %<-std=gnu++23%>"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "typspecificerare är ogiltig i lambda"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr "standardattribut i mitten av decl-specificerare"
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr "standardattribut måste föregå decl-specificerarna för att gälla för deklarationen, eller följa dem för att gälla för typen"
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "klassdefinition kan inte deklareras som en vän"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "mallar får inte vara %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "typer får inte definieras i en explicit-specificerare"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<explicit(bool)%> är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "ogiltig länkklasspecifikation"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<static_assert%> utan ett meddelande är endast tillgänglig med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<static_assert%> med ett meddelande som inte är en sträng är endast tillgänglig med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "typspecificeraren %<decltype(auto)%> är endast tillgängligt med %<-std=c++14%> eller %<-std=gnu++14%>"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "typer får inte definieras i %<decltype%>-uttryck"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "typer får inte definieras i en conversion-type-id"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "ogiltig användning av %<auto%> i konverteringsoperator"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "användning av %<auto%> i medlemsmallskonverteringsoperator kan aldrig vara härledd"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "endast konstruerare tar medlemsinitierare"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "det går inte att expandera initierare för medlem %qD"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "minnesinitierare för %qD följer en konstruerardelegering"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "konstruerardelegering följer mem-initierare för %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "anakronistisk gammaldags basklassinitierare"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "nyckelordet %<typename%> är inte tillåtet i detta sammanhang (en kvalificerad medlemsinitierare är implicit en typ)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "mellanrum mellan citationstecken och suffix bör undvikas enligt C++23"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "oväntat nyckelord; ta bort mellanrum mellan citationstecken och suffixidentifierare"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "suffixidentifierare förväntades"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "en tom sträng förväntades efter nyckelordet %<operator%>"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "ogiltigt kodningsprefix i litteral operator"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "operator förväntades"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "nyckelordet %<export%> är inte implementerat och kommer ignoreras"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "nyckelordet %<export%> bör undvikas, och ignoreras"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "nyckelordet %<export%> är aktiverat med %<-fmodules%>"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "ogiltig begränsad typparameter"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "cv-kvalificerad typparameter"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "felaktig användning av %<auto%> i standardmallargument"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "mallparameterpaket %qD kan inte ha ett standardargument"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "mallparameterpaket kan inte ha standardargument"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "mall-id förväntades"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> kan inte inleda en argumentlista till en mall"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> är en alternativ stavning av %<[%>.  Lägg in mellanrum mellan %<<%> och %<::%>"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(om du använder %<-fpermissive%> eller %<-std=c++11%> eller %<-std=gnu++11%> kommer G++ acceptera din kod)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "felaktig mallargumentlista"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr "ett funktionsnamn som vänster operand av %<<%> är felformad i C++20; slå in funktionsnamnet i %<()%>"
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "%<(%> förväntades efter mallargumentlista"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "parsningsfel i mallargumentlista"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "mallnamn förväntades"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "icke-mall %qD använd som mall"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "använd %<%T::template %D%> för att indikera att det är en mall"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "parameterpaket förväntades före %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "mallargument förväntades"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "ogiltigt mallargument som inte är en typ"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "splitsningsuttryck utan parentes kan inte användas som ett mallargument"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "en explicit instansiering skall inte använda %<inline%>-specificerare"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "en explicit instansiering skall inte använda %<constexpr%>-specificerare"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "en explicit instansiering skall inte använda %<consteval%>-specificerare"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "mallspecialisering med C-länkning"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "typspecificerare förväntades"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "användning av %<auto%> i lambdaparameterdeklarationer är endast tillgängligt med %<-std=c++14%> eller %<-std=gnu++14%>"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "användning av %<auto%> i parameterdeklarationer är endast tillgängligt med %<-std=c++20%> eller %<-fconcepts%>"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "användning av %<auto%> i parameterdeklarationer är endast tillgängligt med %<-std=c++14%> eller %<-std=gnu++14%>"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "användning av %<auto%> i mallargument"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "mall-id för typ förväntades"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "typnamn förväntades"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "%qE begränsar inte en typ"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr "konceptet är definierat här"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, gcc-internal-format
 msgid "invalid use of concept-name %qD"
 msgstr "ogiltig användning av konceptnamnet %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "%<auto%> eller %<decltype(auto)%> förväntades efter %qE"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr "oväntad platshållare i en begränsad resultattyp"
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "beräknad typspecifikation för en enum med räckvidd får inte använda nyckelordet %qD"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "deklaration %qD deklarerar inte något"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "attributet ignorerat på oinstansierad typ"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "attribut ignoreras vid mallinstansiering"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "attribut ignoreras för bearbetade typspecificerare som inte är en framåtdeklaration"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD är en uppräkningsmall"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD är inte namnet på en uppräkningstyp i %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "namnlös enum med räckvidd är inte tillåtet"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "typer får inte definieras i enum-bas"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr "deklaration av en uppräkning med fixerad underliggande typ och ingen uppräknarlista är endast tillåtet som en fristående deklaration"
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "%<;%> eller %<{%> förväntades"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "det går inte att lägga till en uppräkningslista till en mallinstansiering"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "nästad namnspecificerare %qT för enum-deklaration som inte namnger en klass eller namnrymd"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "deklaration av %qD i namnrymd %qD som inte innesluter %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "deklaration av %qD i %qD som inte innesluter %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "extra kvalifikation inte tillåten"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ förbjuder tomma namnlösa enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "ogenomskinlig enum-specifikation utan namn"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "en ogenomskinlig enum-specifikation måste använda en enkel identifierare"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr "oexpanderat parameterpack i uppräkningstyp i lambda"
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD är inte ett namnrymdsnamn; menade du %qs?"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD är inte ett namnrymdsnamn"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "namnrymdsnamn förväntades"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "nästade inline-namnrymdsdefinitioner är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr "standardattribut på namnrymder måste föregå namnrymdsnamnet"
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "nästade namnrymdsdefinitioner är endast tillgängliga med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "nästat namnrymdsnamn krävs"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr "namnrymdsnamn krävs"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "en nästad namnrymdsdefinition kan inte ha attribut"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "en nästad namnrymdsdefinition kan inte inline:as"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "gick in i namnrymden %qD"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<namespace%>-definition är inte tillåten här"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "paketexpansion i using-deklaration är endast tillgängligt med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "ett mall-id får inte förekomma i en using-deklaration"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "en kommaseparerad lista i using-deklaration är endast tillgängligt med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "åtkomstdeklarationer bör undvikas till förmån för using-deklarationer; förslag: lägg till nyckelordet %<using%>"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using enum%> är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "%<using enum%> av beroende typ %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%<using enum%> av icke-uppräkningstypen %q#T"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "%<using enum%> av ofullständig typ %qT"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr "%<using enum%> av %qT före dess enum-specificerare"
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "ogenomskinlig enum-deklaration här"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "typer får inte definieras i aliasmalldeklarationer"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
-msgstr "en strängliteral constexpr i parenteser förväntades"
+msgstr "en stränglitteral constexpr i parenteser förväntades"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<asm%> i en %<constexpr%>-funktion är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "dubblerad %<asm%>-kvalificerare %qT"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%<asm%>-kvalificeraren %qT ignoreras utanför en funktionskropp"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT är inte en %<asm%>-kvalificerare"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%<asm%>-kvalificerare utanför funktionskropp"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "attribut ignoreras på en %<asm%>-deklaration"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "tvetydigheten i tomma parenteser löstes upp som en funktionsdeklaration"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "ta bort parenteser för att standardinitiera en variabel"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr "eller ersätt parenteser med klamrar för att aggregatinitiera en variabel"
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr "eller ersätt parenteser med klamrar för att värdeinitiera en variabel"
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "tvetydigheten i parenteser löstes upp som en funktionsdeklaration"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr "ersätt parenteser med klamrar för att deklarera en variabel"
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "lägg till parenteser för att deklarera en variabel"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, gcc-internal-format
 msgid "cannot handle qualified name for variant function"
 msgstr "kan inte hantera kvalificerat namn för en variantfunktion"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr "deklaration av variantdirektiv är inte tillåtna för konstruerare"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr "deklaration av variantdirektiv är inte är tillåtna på destruerare"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "kan inte hantera identifierarnamnet %s"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "ingen deklaration av basfunktionen %qs i denna räckvidd"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, gcc-internal-format
 msgid "base function is ambiguous"
 msgstr "basfunktionen är tvetydig"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr "variantfunktionen måste vara i samma räckvidd som basfunktionen %qs"
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr "variantfunktionen måste vara i samma räckvidd som basfunktionen %qE"
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "deklaration av variantdirektiv är inte tillåtna på virtuella funktioner"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "deklaration av variantdirektiv är inte tillåtna på standardfunktioner"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "deklaration av variantdirektiv är inte tillåtna på raderade funktioner"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "deklaration av variantdirektiv är inte tillåtna på omedelbara funktioner"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "en funktionsdefinition är inte tillåten här"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "en %<asm%>-specifikation är inte tillåten på en funktionsdefinition"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "attribut är inte tillåtna vid en funktionsdefinition"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "konstruerare, destruerare eller typkonvertering förväntades"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "initierare angiven för funktion"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "attribut efter initierare inom parentes ignoreras"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "icke-funktionen %qD deklarerad som implicit mall"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "vektorgräns är inte en heltalskonstant"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "det går inte att definiera medlem av beroende typedef %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> är inte en typ"
@@ -66666,275 +66756,275 @@ msgstr "%<%T::%E%> är inte en typ"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "ogiltig deklarator"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "ogiltig användning av konstruerare som en mall"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "använd %<%T::%D%> istället för %<%T::%D%> för att namnge konstrueraren i ett kvalificerat namn"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "kvalificerad id i deklaration"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "deklarator förväntades"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD är en namnrymd"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "kan inte skapa en pekare till medlem av %q#T som inte är en klass"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "oväntad pekaroperator"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "upprepade cv-kvalificerare"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "upprepade ref-kvalificerare"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "%qE kräver %<-fgnu-tm%>"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "upprepade virt-specificerare"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "mallargument saknas efter %qE"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "%qT är inte tillåtet i mallargument"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "ogiltig användning av %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "typer får inte definieras i mallargument"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "felaktig användning av %<auto%> i mallargument"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "typspecificerare förväntades"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr "att utelämna %<,%> före varargs %<...%> bör undvikas enligt C++26"
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "%<,%> eller %<...%> förväntades"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "typer får inte definieras i parametertyper"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "specificeraren %<this%> i en mallparameterdeklaration"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr "specificeraren %<this%> i en parameter till ett requires-uttryck"
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "en explicit objektparameter kan inte vara ett funktionsparameterpaket"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "standardargument är endast tillåtna för funktionsparametrar"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "parameterpaket %qD kan inte ha ett standardargument"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "mallparameterpaket kan inte ha ett standardargument"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "parameterpaket kan inte ha ett standardargument"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "en explicit objektparameter får inte ha ett standardargument"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "funktions-try-blockskropp av %<constexpr%>-konstruerare är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "funktions-try-blockskropp av %<constexpr%>-funktioner är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr "förmodligen saknas ett komma eller en operator före"
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++ designerade initierare är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ tillåter inte GNUs designerade initierare"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ tillåter inte C99:s designerade initierare"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr "antingen skall alla initierarklausuler vara designerade eller så skall ingen av dem vara det"
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "%<...%> är inte tillåtet i en designerad initierarlista"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr "designeraren %<.%s%> använd flera gånger i samma initierarlista"
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "klassnamn förväntades"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "%<;%> förväntades efter klassdefinition"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "%<;%> förväntades efter postdefinition"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "%<;%> förväntades efter uniondefinition"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "dubblerade %qD-specificerare"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "%<{%> eller %<:%> förväntades"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "globala kvalificering av klassnamn är ogiltigt"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "kvalificerat namn namnger inte en klass"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "nyckelordet %<template%> är inte tillåtet i klasshuvudnamn"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "ogiltigt klassnamn i deklaration av %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "deklaration av en partiell specialisering i exportdeklaration utan klamrar"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr "en explicit instansiering kan inte ha en definition; använd %<template <>%> för att deklarera en specialisering"
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "en explicit specialisering måste föregås av %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "funktionsmall %qD omdeklarerad som en klassmall"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
-msgstr "det gick inte att lösa upp typnamnstyp"
+msgstr "det gick inte att slå upp typnamnstyp"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "föregående definition av %q#T"
@@ -66942,268 +67032,268 @@ msgstr "föregående definition av %q#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr "oexpanderat parameterpack i en lokal klass i lambda"
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "klassnyckel förväntades"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ISO C++ förbjuder nyckelordet typename i mall-mall-parameter; använd %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "%<class%> eller %<typename%> förväntades"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "i C++03 måste en klassnyckel användas när en vän deklareras"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
-msgstr "deklarationer av variadiska vänner väntyp med flera typer är endast tillgängligt med %<-std=c++2c%> eller %<-std=gnu++2c%>"
+msgstr "variadiska vänner eller deklarationer av väntyper med flera typer är endast tillgängligt med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "vändeklaration som inte namnger en klass eller funktion"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr "en lagringklass på ett anonymt aggregat i klassräckvidd tillåts inte"
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "standardmedlemsinitierare för bitfält är endast tillgängliga med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "standardmedlemsinitierare för namnlöst bitfält"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr "ISO C++ tillåter endast bitfältsattribut före symbolen %<:%>"
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "bitfältet %qD har icke-heltalstypen %qT"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "pure-specificerare på funktionsdefinition"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "överblivet %<,%> vid slutet av medlemsdeklaration"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "%<;%> förväntades vid slutet av medlemsdeklaration"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "orsaken till %<delete%> är endast tillgänglig med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "ogiltig pure-specificerare (endast %<= 0%> är tillåtet)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "en klammeromsluten initierare är inte tillåten här"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "attribut på basspecificerare ignoreras"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "%<virtual%> anges mer än en gång i basspecificerare"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "mer än en åtkomstspecifikation i basspecificerare"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "nyckelordet %<typename%> är inte tillåtet i detta sammanhang (basklassen är implicit en typ)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "typer får inte definieras i en undantagsspecifikation"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "ISO C++17 tillåter inte dynamiska undantagsspecifikationer"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "dynamiska undantagsspecifikationer undanbedes i C++11"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "ogiltig användning av %<auto%> i undantagsspecifikation"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<try%> i %<constexpr%>-funktioner är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "typer får inte definieras i undantagsdeklarationer"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, gcc-internal-format
 msgid "%<alignas%> on exception declaration"
 msgstr "%<alignas%> på en undantagsdeklaration"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, gcc-internal-format
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%<co_yield%> kan inte användas i standardargument"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "attributargument förväntades som en balanserad symbolsekvens"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "attribut som använder prefix använt tillsammans med attributsymboler med räckvidd"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "en identifierare förväntades som attributnamn"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr "parenteser måste utelämnas om argumentlistan till attributet %qE är tom"
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "attributet %qs angivet flera gånger"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
-msgstr "blandning av annotationer och attribut i samma lista"
+msgstr "blandning av annoteringar och attribut i samma lista"
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "attribut förväntades före %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "attribut utan några argument innehåller inga parameterpaket"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, gcc-internal-format
 msgid "expected conditional-expression"
 msgstr "ett villkorsuttryck förväntades"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "%qs är endast tillgängligt med %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, gcc-internal-format
 msgid "attributes are ignored on %qs"
 msgstr "attribut ignoreras på %qs"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "attribut ignoreras på funktionskontraktsspecifikationer"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr "kontrakt är endast tillgängliga med %qs"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
-msgstr "annotationer är endast tillgängligaa med %<-std=c++2c%> eller %<-std=gnu++2c%>"
+msgstr "annoteringar är endast tillgängliga med %<-std=c++2c%> eller %<-std=gnu++2c%>"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "attribut som använder prefix är endast tillgängligt med %<-std=c++17%> eller %<-std=gnu++17%>"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "uttrycket måste vara inneslutet i parenteser"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr "ytterligare %<requires%> saknas för att inleda ett requires-uttryck"
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr "testar om ett koncept-id är ett giltigt uttryck; lägg till %<requires%> för att kontrollera uppfyllnad"
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "resultattypen är inte en enkel typbegränsning"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "returtypskravet är inte en typbegränsning"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "specialisering av medlem %<%T::%E%> kräver %<template<>%>-syntax"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "ogiltig omdeklaration av %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "för få mallparameterlistor"
@@ -67212,433 +67302,433 @@ msgstr "för få mallparameterlistor"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "för många mallparameterlistor"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr "mall-id är inte tillåtet för konstruerare i C++20"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "namngivna returvärden stödjs inte längre"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr "ISO C++ antog inte mallar för stränglitteralsoperatorer som tar argumentpaket av tecken"
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "den litterala operatormallen %qD har ogiltig parameterlista; ett mallargument som inte är en typ pack %<<char...>%> eller en ensam icke-typparameter av klasstyp förväntades"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "den litterala operatormallen %qD har ogiltig parameterlista; en mallparameter som inte är en typ pack %<<char...>%> förväntades"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "ogiltig deklaration av medlemsmall i lokal klass"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "mall med C-länkning"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "ogiltig explicit specifikation"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "malldeklaration av %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "en klassmallsdeklaration får inte deklarera något annat"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "explicit mallspecialisering kan inte ha en lagringsklass"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%> skulle vara %<> >%> inuti en nästad mallargumentlista"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "vilsekommet %<>>%>, använd %<>%> för att avsluta en mallargumentlista"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%qs skall vara %qs för att avsluta en mallargumentlista"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "argument till %<sizeof...%> måste omges av parenteser"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "ogiltig användning av %qD i länkklasspecifikation"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "%qD-specificerare står i konflikt med %qs"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> före %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%qD-specificerare står i konflikt med %<typedef%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 stödjer inte %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "både %<__thread%> och %<thread_local%> angivna"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "dubblerad %qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "dubblerad %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "%<new%> förväntades"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "%<delete%> förväntades"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "%<return%> förväntades"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "%<extern%> förväntades"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "%<static_assert%> förväntades"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "%<decltype%> förväntades"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "%<operator%> förväntades"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "%<class%> förväntades"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "%<template%> förväntades"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "%<namespace%> förväntades"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "%<using%> förväntades"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "%<asm%> förväntades"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "%<try%> förväntades"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "%<catch%> förväntades"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "%<throw%> förväntades"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "%<auto%> förväntades"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "%<__label__%> förväntades"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "%<@try%> förväntades"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "%<@synchronized%> förväntades"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "%<@throw%> förväntades"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "%<__transaction_atomic%> förväntades"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "%<__transaction_relaxed%> förväntades"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "%<co_yield%> förväntades"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "%<::%> förväntades"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "%<...%> förväntades"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "%<*%> förväntades"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "%<~%> förväntades"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "%<:%> eller %<::%> förväntades"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "%<class%>, %<typename%> eller %<template%> förväntades"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "%<:]%> förväntades"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr "överflödig enum-nyckel %<enum%s%> i referens till %q#T"
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "%qs-tagg använd vid namngivning av %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T deklarerades tidigare här"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "överflödig klassnyckel %qs i referens till %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT är deklarerad med en klassnyckel som inte stämmer %qs"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr "ta bort klassnyckeln eller ersätt den med %qs"
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "ersätt klassnyckeln med %qs"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "%qT är definierad som %qs här"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qT är först deklarerad som %qs här"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD omdeklarerad med annan åtkomst"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "i C++98 är %<template%> (för att lösa upp tvetydighet) är endast tillåtet inuti mallar"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "filen slutar i standardargument"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "felplacerad Objective-C++-konstruktion %<@%D%>"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "objective-c++-meddelandemottagare förväntades"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "objective-c++-meddelandeargument förväntades"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> måste ange en typ som ett argument"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "ogiltigt Objective-C++-väljarnamn"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "metoddeklaration i objective-c++ förväntades"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "metodattribut måste anges på slutet"
 
 # %qs blir "{" eller "}"
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "vilsekommet %qs mellan Objective-C++ metoder"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "ogiltig typ för iterationsvariabel"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "identifierare förväntades efter %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "attribut får inte anges före Objective-C++-nyckelordet %<@%D%>"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "prefixattribut ignoreras före %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "ogiltig typ på egenskap"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "okänt egenskapsattribut %qE"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "heltalsuttryckslista förväntades"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "%<wait%>-uttryck måste vara heltal"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "%<scalar%>, %<aggregate%>, %<all%> förväntades"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "ogiltig reduktionsidentifierare"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr "äldre egenskapssyntax %<%E(%E)%> är inte tillåten i %<uses_allocators%>-satsen vid användning av modifierare"
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "typer får inte definieras i iteratortyp"
@@ -67647,173 +67737,173 @@ msgstr "typer får inte definieras i iteratortyp"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "%<#pragma omp allocate%> stödjs inte ännu"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "initiering i parenteser är inte tillåtet i en OpenMP-%<for%>-slinga"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "en %<ordered%>-klausul med parameter på en intervallbaserad %<for%>-slinga"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "iterationsvariabel %qD skall inte vara reduction"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp declare %s%> följt av %<#pragma omp declare %s%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma omp dispatch%> måste följas av ett direkt funktionsanrop med en möjlig tilldelning"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD är inte en C-pekare"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr "en %qs-klausul kan endast anges om väljaren %<dispatch%> i konstruktionsväljarmängden förekommer i klausulen %<match%>"
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr "OpenMP-direktiv andra än %<declare simd%> eller %<declare variant%> hör till en deklaration"
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "%<target%> förväntades"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "ogiltig initierarklausul"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "id-uttryck förväntades (argument)"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr "en av initieraranropets argument skall vara %<omp_priv%> eller %<&omp_priv%>"
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "typer får inte definieras i en declare reduction-typlista"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr "en fördeklarerad aritmetisk typ %qT i %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr "funktions- eller vektortyp %qT i %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr "referenstyp %qT i %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "%<const%>-, %<volatile%>- eller %<__restrict%>-kvalificerad typ %qT i %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
-msgstr "typer får inte definieras i inom %<declare mapper%>"
+msgstr "typer får inte definieras inom %<declare mapper%>"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "%<simd%>, %<reduction%>, %<target%>, %<mapper%> eller %<variant%> förväntades"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr "%<#pragma acc routine%> namnger en mängd överlagrade"
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD refererar inte till en funktion med namnrymdsräckvidd"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "OpenMP-direktiv får inte förekomma i %<constexpr%>-funktioner"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr "%<atomic_cancel%>"
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "yttre %<__transaction_cancel%> som inte är inom en yttre %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  eller en %<transaction_may_cancel_outer%>-funktion"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "felformat %<#pragma GCC pch_preprocess%>"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp requires%> kan endast användas med fil- eller namnrymdsräckvidd"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp assumes%> kan endast användas med fil- eller namnrymdsräckvidd"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "%<#pragma GCC %s%> måste vara inuti en funktion"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "flerkällskompileringar är inte implementerade för C++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "en platshållartyp är inte tillåtet i denna kontext"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "implicita mallar får inte vara %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr "%<extern \"C\"%>-länkning startade här"
@@ -68285,495 +68375,500 @@ msgstr "använd %<template<>%> för en explicit specialisering"
 msgid "redeclaration of %qD with different constraints"
 msgstr "omdeklaration av %qD med andra begränsningar"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "lokal klass i lambda i mallparameterlista"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT är inte en malltyp"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "mallspecificerare inte angivna i deklarationen av %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "omdeklarerad med %d mallparameter"
 msgstr[1] "omdeklarerad med %d mallparametrar"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "tidigare deklaration av %qD använde %d mallparameter"
 msgstr[1] "tidigare deklaration av %qD använde %d mallparametrar"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "mallparameter %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "omdeklarerad här som %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr "omdeklarerad här"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "deklaration av mallparametern %q+#D med andra begränsningar"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "ursprunglig deklaration fanns här"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "omdeklaration av %q#D med andra begränsningar"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE är inte ett giltigt mallargument för typen %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "det måste vara adressen till en funktion med extern lagringsklass"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "det måste vara namnet på en funktion med extern lagringsklass"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE är inte ett giltigt mallargument för typ %qT eftersom %qD inte har någon länkklass"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom %qD inte har extern länkklass"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "det måste vara en pekare-till-medlem på formen %<&X::Y%>"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "för att den är en medlem av %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  kunde inte härleda mallparametrar %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  typerna %qT och %qT har inkompatibla cv-kvalificerare"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  typerna %qT och %qT stämmer inte överens"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "  mallparameter %qD är inte ett parameterpaket, men argument %qD är det"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "  mallargument %qE stämmer inte med pekare till medlem-konstanten %qE"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE är inte ekvivalent med %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  inkonsistent härledning av parameterpaket med %qT och %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  härledda typer i konflikt för parametern %qT (T%qT och %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  härledda värden i konflikt för icke-typ-parametern %qE (%qE och %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "  vektortypen %qT med variabel storlek är inte ett giltigt mallargument"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  medlemsfunktionstypen %qT är inte ett giltigt mallargument"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  kandidaten förväntade sig åtminstone %d argument, %d fanns"
 msgstr[1] "  kandidaten förväntade sig åtminstone %d argument, %d fanns"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  kandidaten förväntade sig %d argument, %d fanns"
 msgstr[1] "  kandidaten förväntade sig %d argument, %d fanns"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  kan inte konvertera %qE (typen %qT) till typ %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT är en tvetydig basklass till %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT är inte härledd från %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  mallparametrarna till ett mallmallargument är inkonsistenta med andra härledda mallargument"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  det går inte att härleda en mall för %qT från typen %qT som inte är en mall"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "  mallargument %qE stämmer inte med %qE"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom %qE inte är en variabel eller funktion"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE är inte ett giltigt mallargument av typ %qT i C++98 eftersom %qD inte har extern länkklass"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom %qD inte har någon länkklass"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "adressen till %qD är inte ett giltigt mallargument"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "adressen till underobjektet %qT till %qD är inte ett giltigt mallargument"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "adressen till %qD är inte ett giltigt mallargument eftersom den inte har statisk lagringsvaraktighet"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD är inte ett giltigt mallargument för att %qD är en variabel, inte adressen till en variabel"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE är inte ett giltigt mallargument till %qT för det är inte adressen till en variabel"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE är inte ett giltigt mallargument för typ %qT eftersom strängkonstanter aldrig kan användas i detta sammanhang"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "i mallargument för typen %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "mallargumentet %qE för typen %qT är inte ett kompileringstidskonstant"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE är inte ett giltigt mallargument för typ %qT eftersom det står i konflikt med cv-kvalificeringar"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE är inte ett giltigt mallargument för typ %qT eftersom inte är ett l-värde"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D är inte ett giltigt mallargument till typen %qT eftersom en referensvariabel inte har en konstant adress"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom det är en pekare"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "försök att använda %qE istället"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom det är av typen %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "ignorerar attribut på mallargumentet %qT"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "ignorerar attribut i mallargumentet %qE"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "inskjutet klassnamn %qD använt som mallmallargument"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "ogiltig användning av destrueraren %qE som en typ"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "för att referera till en typmedlem av en mallparameter, använd %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "typ/värde stämmer inte vid argument %d i mallparameterlistan till %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  förväntade en konstant av typen %qT, fick %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "  tvetydigt mallargument till en mallparameter som inte är en typ hanteras som en funktionstyp"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  förväntade en klassmall, fick %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  förväntade en typ, fick %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  förväntade en typ, fick %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  förväntade en klassmall, fick %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  förväntade en mall av typen %qD, fick %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "begränsningar stämmer inte vid argument %d i mallparameterlistan till %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  %qD förväntades men fick %qD"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "kunde inte konvertera mallargument %qE från %qT till %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "mallargument %d är ogiltigt"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "fel antal mallargument (%d, skulle vara %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "fel antal mallargument (%d, skulle vara åtminstone %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr "angivna till %qD"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "pack-expansionsargument för icke-pack-parametern %qD till aliasmall %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "pack-expansionsargument för icke-pack-parametern %qD till konceptet %qD"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr "så varje instansiering med ett icke-tomt parameterpaket vore felformulerad"
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D är inte en funktionsmall"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "icke-malltyp %qT använd som en mall"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "för malldeklaration %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "mallbegränsningsfel för %qD"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "användning av felaktig variabelmall %qE"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "mallinstansieringsdjupet överskrider maxvärdet på %d (använd %<-ftemplate-depth=%> för att öka maxvärdet)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "värdesargument måste vara ett konstant heltalsuttryck"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "värdesargumentet måste vara ickenegativt"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "egenskaper måste vara ett konstant heltalsuttryck eller en strängkonstant"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "egenskapen måste vara ett konstant heltalsuttryck"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "instansiering av felaktig mall"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, gcc-internal-format
 msgid "first error appeared here"
-msgstr "först felet uppstod här"
+msgstr "första felet uppstod här"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "flexibel vektormedlem %qD i union"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr "fold över tom expansion över %O"
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE är inte hela mönstret av paketexpansionen"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "argumentpaketlängder stämmer inte överens vid expansion av %qT"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "argumentpaketlängder stämmer inte överens vid expansion av %qE"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr "det går inte att indexera ett tomt paket"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "  vid instansiering av standardargument för anrop av %qD"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "skapar pekare till medlemsfunktion i typ %qT som inte är en klass"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr "argumentpaketlängder stämmer inte överens (%d mot %d)"
@@ -68791,122 +68886,122 @@ msgstr "argumentpaketlängder stämmer inte överens (%d mot %d)"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "variabeln %qD har funktionstyp"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "ogiltig parametertyp %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "i deklaration %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "funktion som returnerar en vektor"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "funktion som returnerar en funktion"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, gcc-internal-format
 msgid "%qE is not usable in a splice type"
 msgstr "%qE kan inte användas i en splitsningstyp"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE kan inte användas i en splitsningsräckvidd"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "formar referens till void"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "formar pekare till en referenstyp %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "formar referens till en referenstyp %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "formerar en pekare till en kvalificerad funktionstyp %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "formerar en referens till en kvalificerad funktionstyp %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "skapar pekare till medlem av typ %qT som inte är en klass"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "skapar pekare till medlemsreferenstyp %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "skapar pekare till medlem av typ void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "skapar vektor av %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
-msgstr "%qD expanderde till mer än ett element"
+msgstr "%qD expanderade till mer än ett element"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr "%qD instansieras för ett tomt paket"
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT är inte en klass-, post- eller unionstyp"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT slås upp till %qT som inte är en uppräkningstyp"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
-msgstr "%qT löses upp till %qT, som inte är en icke-unions-klasstyp"
+msgstr "%qT slås upp till %qT, som inte är en icke-unions-klasstyp"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT slås upp till %qT som inte är en unionstyp"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "en återspegling av en typmall förväntades"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "användning av %qs i mall"
@@ -68914,206 +69009,206 @@ msgstr "användning av %qs i mall"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "deklarationen av %<%T::%D%> beror på sig själv"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "kvalificerande typ %qT matchar inte destruerarnamnet ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "namnet %qE i den beroende tolkas som något annat än en typ, men instansiering ger en typ"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "säg %<typename %E%> om en typ avses"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "initierare för %q#D expanderar till en tom uttryckslista"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "ogiltig användning av paketexpansionsuttryck"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "använd %<...%> för att expandera argumentpaket"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "tom initierare i lambdas init-fångst"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD deklarerades inte i detta definitionsområde, och inga deklarationer hittades av en argumentberoende uppslagning vid instansieringspunkten"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "deklarationer i beroende bas %qT hittas inte av en okvalificerad uppslagning"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "använd %<this->%D%> istället"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "använd %<%T::%D%> istället"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qD är deklarerad här, senare i översättningsenheten"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "fel antal argument till %<__builtin_convertvector%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "fel antal argument till attributet %<assume%>"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT är inte en klass eller namnrymd"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD är inte en klass eller namnrymd"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "användning av ogiltigt fält %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT är/använder en namnlös typ"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "mallargumentet för %qD använder lokal typ %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT är en variabel typ"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "heltalsuttryck %qE är inte konstant"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  försöker instansiera %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "tvetydig mallinstansiering av %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "tvetydig mallinstansiering av %q#D"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr "%s %#qS"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "explicit instansiering av icke-mall %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD är inte en statisk datamedlem i en klassmall"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "det finns ingen matchande mall för %qD"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "typ %qT för explicit instansiering %qD stämmer inte med deklarerad typ %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "explicit instansiering av %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "dubblerad explicit instansiering av %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ 1998 förbjuder användning av %<extern%> vid explicita instansieringar"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "lagringsklass %qD tillämpad på mallinstansiering"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "explicit instansieringar av mallen %q#D som inte är en klass"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "explicit instansieringar av icke-malltyp %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "explicit instansiering av %q#T före definitionen av mallen"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ förbjuder användning av %qE vid explicita instansieringar"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "dubblerad explicit instansiering av %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "explicit specifikation av %qD beror på sig själv"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "undantagspecifikationen för %qD är inte tillgänglig förrän slutet av klassdefinitionen"
@@ -69125,512 +69220,567 @@ msgstr "undantagspecifikationen för %qD är inte tillgänglig förrän slutet a
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "explicit instansiering av %qD men ingen definition tillgänglig"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "mallinstansieringsdjupet överskrider maxvärdet på %d vid instansiering av %q+D, möjligen från generering av virtuell tabell (använd %<-ftemplate-depth=%> för att öka maxvärdet)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mallparameter av härledd klasstyp som inte är en typ är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%qT är inte en giltig typ för en mallparameter som inte är en typ eftersom det inte är en struktur"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mallparameter av klasstyp som inte är en typ är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "ogiltig mallparameter som inte är en typ"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T är inte en giltig typ för en mallparameter som inte är en typ"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "nyckelordet %<template%> är inte tillåtet i deklarerar-id"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "ett koncept kan inte begränsas"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "konceptet %qE är inte i namnrymdsräckvidd"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "konceptet %qE har multipla mallparameterlistor"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "härledning från klammeromsluten initierarlista kräver %<#include <initializer_list>%>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "icke härledbar mall %qT använd utan mallargument"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "aliasmallhärledning är endast tillgängligt med %<-std=c++20%> eller %<-std=gnu++20%>"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "använd %qD direkt istället"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr "kan inte härleda mallargument för kopieinitiering av %qT, eftersom den inte har några icke-explicita härledningsguider eller användardeklarerade konstruerare"
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "kan inte härleda mallargument till %qT, eftersom den inte några användbara härledningsguider"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "härledning av klassmallargument misslyckades:"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "explicita härledningsguider övervägs inte vid kopieinitiering"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "klassmallargumentshärledningen för %qT misslyckades: explicit härledningsguide vald i kopieringslistinitiering"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "explicit härledningsguide deklarerad här"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "%qT är kanske inte avsett att stödja härledning av klassmallargument"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr "lägg till en härledningsguide för att undertrycka denna varning"
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr "direkt listinitiering av %<auto%> tar precis ett element"
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr "för härledning till %<std::initializer_list%>, använd kopielistinitiering (d.v.s. lägg till %<=%> före %<{%>)"
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "kan inte härleda lambdareturtyp från %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "kan inte härleda %qT från %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "platshållarbegränsningar är inte uppfyllt"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "härledd initierare uppfyller inte sina platshållarbegränsningar"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "härledd returtyp uppfyller inte sina platshållarbegränsningar"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "härledd uttryckstyp uppfyller inte sina platshållarbegränsningar"
 
 #: cp/reflect.cc:130
 #, gcc-internal-format
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "%<^^%> kan inte användas på en platshållartyp"
-
-#: cp/reflect.cc:137
-#, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "%<^^%> kan inte användas på ett paketindex"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%<^^%> kan inte användas på en mallparameter %qD som inte är en typ"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "%<^^%> kan inte användas på en fångst %qD"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr "%<^^%> kan inte tillämpas på en lokal parameter i ett requires-uttryck %qD"
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr "%<^^%> kan inte tillämpas på en lokal enhet för vilken det finns ett mellanliggande lambda-uttryck"
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "%<^^%> kan inte användas på en using-deklaration"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "%<^^%> kan inte användas på en konceptkontroll"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr "kan inte ta reflektionen av en överlagringsuppsättning"
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "felaktig typ %qT på argument %d, %qT förväntades"
+
+#: cp/reflect.cc:476
 #, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<std::ranges%> är inte en namnrymd"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr "%<reflect_constant_string%> anropad med %qT istället för %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> eller %<char32_t%>"
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "%<reflect_constant_array%> argument med %qT som inte är en strukturell typ"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr "%<reflect_constant_array%> argument med %qT som inte är kopieringskonstruerbar"
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr "%<reflect_constant_array%> argument med %qT som inte är kompatibel med %qT %<std::ranges::range_reference_t%>"
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr "%<reflect_constant_array%> argument med %qT som inte kan konstrueras från %qT %<std::ranges::range_reference_t%>"
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr "%<std::ranges::data%> eller %<std::ranges::size%> är inte anpassningspunktobjekt"
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr "%<std::ranges::begin%> eller %<std::ranges::end%> saknas"
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr "felaktig typ %qT på %<std::ranges::begin(arg)%>"
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr "felaktig typ %qT på %<std::ranges::end(arg)%>"
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr "%qD skall kasta %qs; %<what()%>: %qs"
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr "undantag är avaktiverade, hanteras som en icke-konstant"
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr "kunde inte kasta %qs"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr "oväntad %<std::meta::operators%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr "kunde inte slå upp %<%D::%D%>"
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, gcc-internal-format
 msgid "couldn%'t look up %qs"
 msgstr "kunde inte slå upp %qs"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, gcc-internal-format
 msgid "unexpected return type of %qs"
 msgstr "oväntad returtyp %qs"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr "%qT måste vara en cv-okvalificerad strukturell typ som inte är en referenstyp"
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, gcc-internal-format
 msgid "%qT must be an object type"
 msgstr "%qT måste vara en objekttyp"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "%qT måste vara en funktionstyp"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr "kunde inte instansiera %<std::%s<%T>%>"
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "oväntat argument till %<data_member_options%>"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "första argumentet till %<define_aggregate%> är inte en klasstypsreflektion"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr "första argumentet till %<define_aggregate%> är en reflektion av ett typalias"
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr "första argumentet till %<define_aggregate%> är en cv-kvalificerad klasstypsreflektion"
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr "första argumentet till %<define_aggregate%> är en komplett klasstypsreflektion"
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr "första argumentet till %<define_aggregate%> är en reflektion av en klasstyp %qT som definieras"
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr "argumentet till %<define_aggregate%> är inte en datamedlemsbeskrivning"
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr "argumentet till %<define_aggregate%> är en datamedlemsbeskrivning utan fullständig typ"
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr "namnet %qD används i flera datamedlemsbeskrivningar"
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, gcc-internal-format
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "det går inte att deklarera ett bitfält i typen %<warn_if_not_aligned%>"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr "%<define_aggregate%> inte beräknad från ett %<consteval%>-block"
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr "%<define_aggregate%> beräknad från ett %<consteval%>-block som omsluter %qT som definieras"
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "%<consteval%>-blocket definieras här"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr "%qD intervenerar mellan räckvidden %qT och %<consteval%>-blocket %<define_aggregate%> beräknas ifrån"
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr "%qT intervenerar mellan räckvidden %qT och %<consteval%>-blocket %<define_aggregate%> beräknas ifrån"
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr "%qD intervenerar mellan %<consteval%>-blocket %<define_aggregate%> beräknas ifrån och räckvidden %qT"
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr "%qT intervenerar mellan %<consteval%>-blocket %<define_aggregate%> beräknas ifrån och räckvidden %qT"
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr "%<define_aggregate%> beräknad ifrån %<consteval%>-blocket som omges av %qD medan typen %qT som definieras omges av %qD"
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr "%<define_aggregate%> beräknas ifrån %<consteval%>-blocket som omges av %qD medan typen %qT som definieras omges av %qT"
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr "%<define_aggregate%> beräknas ifrån %<consteval%>-blocket som omges av %qT medan typen %qT som definieras omges av %qD"
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr "%<define_aggregate%> beräknas ifrån %<consteval%>-blocket som omges av %qT medan typen %qT som definieras omges av %qT"
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
-msgstr "%<access_context::current%> används utanför en uppenbar konstantberäkning"
+msgid "%qs used outside of manifestly constant-evaluation"
+msgstr "%qs används utanför en uppenbar konstantberäkning"
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "ogiltigt %<access_context%>-argument"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr "oväntat %<access_context::scope()%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr "oväntat %<access_context::designating_class()%>"
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "oväntat argument till %qs"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "felaktig typ %qT på argument %d, %qs förväntades"
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "felaktig returtyp %qT, %qs förväntades"
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "felaktig returtyp %qT, %qT förväntades"
+
+#: cp/reflect.cc:7826
 #, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "okänd metafunktion %qD"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "splitsningsargument måste vara ett uttryck av typen %qs"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, gcc-internal-format
+msgid "cannot splice a null reflection"
+msgstr "kan inte splitsa en null-reflektion"
+
+#: cp/reflect.cc:8540
+#, gcc-internal-format
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "kan inte använda funktionsparameterreflektionen %qD i ett splitsningsuttryck"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr "använd %<std::meta::variable_of%> på den före splitsning"
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr "consteval-only variabeln %qD som inte är deklarerad %<constexpr%> använd utanför en konstantberäknad kontext"
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "lägg till %<constexpr%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "consteval-only uttryck är endast tillåtna i en konstant beräknad kontext"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "funktionen av typen consteval-only måste deklareras %qs"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr "en reflektion av ett uttryck förväntades"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "lägg till %<typename%> för att beteckna en typ utanför en endast typkontext"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "kan inte använda konstrueraren eller destrueraren %qD i ett splitsningsuttryck"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "kan inte använda ett namnlöst bitfält %qD i ett splitsningsuttryck"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "kan inte implicit referera till en klassmedlem %qD genom en splitsning"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "ogiltig klassmedlemsåtkomst till en typmall %qE"
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr "kan inte använda %qE för att komma åt en klassmedlem"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
-msgstr "unärt %<&%> tillämpt på en anonym unionmedlem %qD som inte är direkt medlem i en namngiven klass"
+msgstr "unärt %<&%> tillämpat på en anonym unionmedlem %qD som inte är direkt medlem i en namngiven klass"
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
-msgstr "användning av lokal variabel med automatisk lagringsklass från en kringliggande funktion i ett splice-uttryck"
+msgstr "användning av lokal variabel med automatisk lagringsklass från en kringliggande funktion i ett splitsningsuttryck"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
-msgstr "kan inte använda en annotatonen %qE i ett splitsningsuttryck"
+msgstr "kan inte använda en annotering %qE i ett splitsningsuttryck"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr "kan inte använda en datamedlemsspecifikation i ett splitsningsuttryck"
 
+#: cp/reflect.cc:9114
+#, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "en reflektion av en funktionsmall förväntades"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr "en reflektion av en funktions- eller variabelmall förväntades"
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -69874,7 +70024,7 @@ msgstr "använd en explicit objektparameter %qs istället"
 #: cp/semantics.cc:3668
 #, gcc-internal-format
 msgid "name the explicit object parameter"
-msgstr "namnge den explicita objektdparametern"
+msgstr "namnge den explicita objektparametern"
 
 #: cp/semantics.cc:3673
 #, gcc-internal-format
@@ -69961,584 +70111,584 @@ msgstr "ogiltig definition av kvalificerad typ %qT"
 msgid "invalid base-class specification"
 msgstr "ogiltig basklasspecifikation"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "kan inte fånga medlemmen %qD i anonym union"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD är inte fångad"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "lambdat har ingen standardfångst"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr "lambda i lokal klass %q+T kan inte fånga variabler från det omgivande sammanhanget"
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "användning av lokal variabel med automatisk lagringsklass från en kringliggande funktion"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "användning av parameter från den kringliggande funktionen"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "användning av parameter utanför funktionskroppen"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr "mallargument saknas"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "mallparameter %qD av typ %qT är inte tillåten i ett konstant heltalsuttryck eftersom den inte är av heltals- eller uppräkningstyp"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "användning av klassmall %qT som uttryck"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "begäran av medlem %qD är tvetydig i gitter av multipelt arv"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD får inte finnas i ett konstantuttryck"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
-msgstr "%qD ”this” krävs vid åtkomst till en medlem inom en kontrakskontroll i en konstruerares förvillkor eller destruerares eftervillkor"
+msgstr "%qD ”this” krävs vid åtkomst till en medlem inom en kontraktskontroll i en konstruerares förvillkor eller destruerares eftervillkor"
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "typen på %qE är okänd"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT är inte en uppräkningstyp"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr "paketindex är inte en heltalstyp %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "paketindexet är inte en heltalskonstant"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "paketindexet %qE är negativt"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr "paketindexet %qE är utanför intervallet för paket av längden %qd"
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "parameterpaketets %<__bases%> är endast giltiga i malldeklarationer"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "det går inte att applicera %<offsetof%> på destrueraren %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "det går inte att använda %<offsetof%> på medlemsfunktion %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "det går inte att använda %<offsetof%> på en medlemsfunktion"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "det går inte att använda %<offsetof%> på en uppräknare %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "%<offsetof%> inom icke-standardlayouttypen %qT är villkorligt stött"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "pekar-till-medlems-avbildningen %qE stödjs ej"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "användardefinierad reduktionsuppslagning är tvetydig"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %#qD"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "%qE i %<reduction%>-klausul är en vektor med storlek noll"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE har const-typ för %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr "användardefinierad reduktion med konstruerarinitierare för basklassen %qT"
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "%qT är inte en post, union eller klasstyp i %<#pragma omp declare mapper%>"
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "%qT får inte vara en virtuell basklass i %<#pragma omp declare mapper%>"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
-msgstr "en strängliteral eller ett konstant heltalsuttryck förväntades istället för %qE"
+msgstr "en stränglitteral eller ett konstant heltalsuttryck förväntades istället för %qE"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
-msgstr "en annan modifierare än %<val%> ingiven i en %<linear%>-klausul på %<simd%>- eller %<for%>-konstruktioner när OpenMP 5.2-modifierare används"
+msgstr "en annan modifierare än %<val%> angiven i en %<linear%>-klausul på %<simd%>- eller %<for%>-konstruktioner när OpenMP 5.2-modifierare används"
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr "linjär klausul med modifieraren %qs tillämpad på en variabel som inte är en referens med typen %qT"
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr "linjär klausul tillämpad på en variabel som inte är heltal och inte pekare med typen %qT"
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "ett linjärt steguttryck måste vara ett heltal"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr "%<this%> tillåtet i OpenMP endast i %<declare simd%>-klausuler"
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD är inte en variabel i klausul %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD är inte en variabel i klausul %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD är inte en variabel i klausul %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "%<gang%>-statiskt uttryck måste vara heltal"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%<gang%>-statiskt värde måste vara positivt"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "%<gang%>-numeriskt uttryck måste vara ett heltal"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "%<vector%>-längduttryck måste vara ett heltal"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "%<worker%>-numeriskt uttryck måste vara ett heltal"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<gang%>-numeriskt värde måste vara positivt"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "%<vector%>-längdvärdet måste vara positivt"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "%<worker%>-numeriskt värde måste vara positivt"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "uttryck för styckesstorlek för schemaläggning måste vara heltal"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "%qs-längduttryck måste vara ett heltal"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "%qs längduttryck måste vara ett positivt konstant heltalsuttryck"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "%<async%>-uttryck måste vara heltal"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "%<thread_limit%>-uttryck måste vara heltal"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "%<device%>-id måste vara ett heltal"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "%<dist_schedule%> styckesstorleksuttryck måste vara heltal"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD är inte en variabel i %<aligned%>-klausul"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr "%qE i %<aligned%>-klausul är varken en pekare eller en vektor eller en referens till pekare eller vektor"
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD förekommer mer än en gång i %<aligned%>-klausuler"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "%<aligned%>-klausuls justeringsuttryck måste vara heltal"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD är inte en variabel i %<nontemporal%>-klausul"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD förekommer mer än en gång i %<nontemporal%>-klausuler"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%<this%> är inte en tillåtet i en %<allocate%>-klausul"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD är inte en variabel i %<allocate%>-klausul"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD förekommer mer än en gång i %<allocate%>-klausuler"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "klassmedlemmen %qE stödjs inte ännu i klausulen %<uses_allocators%>"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
-msgstr "modifierare kan inte användas med fördefinierade allokatorer"
+msgstr "modifierare kan inte användas med fördefinierade allokerare"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr "egenskapsvektorer med variabel längd stödjs inte"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD är inte ett l-värdeuttryck eller vektorsektion i en %qs-klausul"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "mallen %qE i-klausulen %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr "överlagrad funktion med namnet %qE i klausulen %qs"
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "%<grainsize%>-uttryck måste vara ett heltal"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "%<priority%>-uttryck måste vara ett heltal"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "%<hint%>-uttryck måste vara heltal"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%<hint%>-uttryck måste vara ett konstant heltalsuttryck"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "%<filter%>-uttryck måste vara heltal"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "variabeln %qs är varken en pekare eller en referens till en pekare"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "%qs-variabeln är varken en pekare, eller en vektor eller en referens till pekare eller vektor"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tile%>-argumentet behöver en heltalstyp"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "%<const%>-kvalificerad %qE utan en %<mutable%>-medlem kan endast förekomma i klausuler %<shared%> eller %<firstprivate%>"
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD är inte fil-, namnrymds- eller blockräckviddsvariabel"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%<threadprivate%> %qE-direktiv inte i %qT-definition"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "skillnaden mellan %qE och %qD har inte heltalstyp"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<#pragma omp simd%> använt med klassiterationsvariabeln %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic update%> använder två olika uttryck för minne"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
-msgstr "constexpr-strängen måste vara en strängliteral eller ett objekt med medlemmarna %<size%> och %<data%>"
+msgstr "constexpr-strängen måste vara en stränglitteral eller ett objekt med medlemmarna %<size%> och %<data%>"
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr "constexpr-strängen %<size()%> måste vara implicit konverterbar till %<std::size_t%>"
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr "constexpr-strängen %<data()%> måste vara implicit konverterbart till %<const char*%>"
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "constexpr-strängen %<size()%> måste vara ett konstant uttryck"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr "constexpr-strängmeddelandet %<size()%> %qE är för stort"
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr "ohanterad retur från %<data()%>"
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "constexpr-strängen %<data()[%d]%> måste vara ett konstant uttryck"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
-msgstr "constexprsträngen %<data()%> måste vara ett kärnkonstant uttryck"
+msgstr "constexpr-strängen %<data()%> måste vara ett kärnkonstant uttryck"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr "kunde inte konvertera constexpr-strängen från UTF-8-kodning till källteckenuppsättningen"
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr "kunde inte konvertera constexpr-strängen från vanlig bokstavlig kodning till källteckenuppsättningen"
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "statisk försäkran misslyckades: %.*s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "icke-konstant villkor i statisk deklaration"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "argument till %<decltype%> måste vara ett uttryck"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
-msgstr "%<decltype%> kan inte lösa upp adressen till en överlagrad funktion"
+msgstr "%<decltype%> kan inte slå upp adressen till en överlagrad funktion"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "%qT är inte en icke-unions-klasstyp"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, gcc-internal-format
 msgid "%qT is not a standard-layout type"
 msgstr "%qT är inte en standardlayouttyp"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr "%<__builtin_is_pointer_interconvertible_with_class%> behöver ett ensamt argument"
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr "argumentet till %<__builtin_is_pointer_interconvertible_with_class%> är inte en pekare till en medlem"
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr "%<__builtin_is_corresponding_member%> är inte väldefinierat för anonyma unioner"
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_is_corresponding_member%> behöver två argument"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr "argumentet till %<__builtin_is_corresponding_member%> är inte en pekare till en medlem"
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_is_string_literal%> behöver ett ensamt argument"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr "argumentet till %<__builtin_is_string_literal%> är inte %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> eller %<const char32_t*%>"
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr "kontrollerar %qs för typen %qT med en destruerare som inte kan anropas"
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "argumentet %qs till  %qT är en referens"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qD är inte en klass- eller aliasmall"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "operanden till vikningsuttrycket har inget oexpanderat parameterpaket"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "båda argumenten i en binär vikning har oexpanderade parameterpaket"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr "inga oexpanderade parameterpack i binär fold"
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "typen %qT på argumentet till %<__builtin_launder%> är inte en pekare på en objekttyp"
@@ -70546,342 +70696,342 @@ msgstr "typen %qT på argumentet till %<__builtin_launder%> är inte en pekare p
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr "%<__builtin_bit_cast%>-måltyp %qT är en vektortyp"
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr "%<__builtin_bit_cast%>-måltyp %qT är inte trivialt kopierbar"
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "%<__builtin_bit_cast%> kan inte användas med consteval-only-typer"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr "%<__builtin_bit_cast%>-källtyp %qT är inte trivialt kopierbar"
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr "%<__builtin_bit_cast%>-källstorlek %qE är inte lika med måltypstorleken %qE"
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV-kvalificerare kan inte tillämpas på %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr "%<-fabi-version=13%> (GCC 8.2) fixar anropskonventionen för %qT, som ändrades av misstag i 8.1"
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr "%<-fabi-version=12%> (GCC 8.1) ändrar av misstag anropskonventionen för %qT"
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr " deklarerad här"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "anropskonventionen för %qT ändras i %<-fabi-version=13%> (GCC 8.2)"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr " för att alla dess kopierings- och flyttkonstruerare är borttagna"
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "%qT är en flyttalstyp"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, gcc-internal-format
 msgid "%qT is a fixed-point type"
 msgstr "%qT är en fixdecimaltyp"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, gcc-internal-format
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qD fyller inte alla bitar i %q#T"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr "%qD har typen %qT som inte har unika objektrepresentationer"
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, gcc-internal-format
 msgid "%q#T has no data fields"
 msgstr "%q#T har inga datafält"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr "%<std::nullptr_t%> har utfyllnadsbitar och inga värdebitar"
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr "basen %qT har inte unika objektrepresentationer"
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr "%qD med typen %qT har inte unika objektrepresentationer"
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr "utfyllnad sker mellan %qD och %qD"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr "namnlöst bitfält infogar utfyllnad före %qD"
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr "utfyllnad sker före %qD"
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr "utfyllnad sker efter %qD"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, gcc-internal-format
 msgid "%qT has padding and no data fields"
 msgstr "%qT har utfyllnad och inga datafält"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "basklassen %qT är inte publik"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%qD är inte publik"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD är muterbar"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qD är en icke-strukturell typ"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "attributet %qE kan bara användas på funktioner eller parametrar"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "argument till attribut %qE måste vara en strängkonstant"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "attributet %qE kan bara användas på funktioner eller på klass- eller uppräkningstyper"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "attributet %qE kan bara användas på icke-statiska datamedlemmar"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "attributet %qE kan inte tillämpas på ett bitfält"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "attributet %qE tar inga argument"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "ISO C++-attributet %qE är inte tillämpligt på funktioner; hanteras som %<[[gnu::%E]]%>"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, gcc-internal-format
 msgid "%<alignas%> on function declaration"
 msgstr "%<alignas%> på en funktionsdeklaration"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%<alignas%> på en uppräkningstyp"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr "%<alignas%> på en annan typ än en klass"
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, gcc-internal-format
 msgid "%<alignas%> on bit-field"
 msgstr "%<alignas%> på ett bitfält"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr "%<alignas%> på ett typalias"
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qE på en annan typ än en klass- eller uppräkningsdefinition"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "%qE på ett namnlöst bitfält"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr "%qE på en %<case%>- eller %<default%>-etikett"
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "%qE vid annan deklaration än parameter eller automatisk variabel"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "begärd %<init_priority%> är inte en heltalskonstant"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "det går bara att använda attributet %qE på definitioner av objekt- eller klasstyp med filräckvidd"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "begärd %<init_priority%> %i är utanför sitt intervall [0, %i]"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "begärd %<init_priority%> %i är reserverad för internt bruk"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "omdeklaration av %qD lägger till abi-taggen %qE"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "attributet %qE behöver argument"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "argumenten till attributet %qE måste vara smala strängkonstanter"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "argumenten till attributet %qE måste innehålla giltiga identifierare"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%c%> är inte ett giltigt första tecken för en identifierare"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%c%> är inte ett giltig bokstav i en identifierare"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "attributet %qE använt på typen %qT som inte är en klass eller uppräkningstyp"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "attributet %qE använt på %qT efter dess definition"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "ignorerar attributet %qE använt på mallinstansieringen %qT"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "ignorerar attributet %qE använt på mallspecialiseringen %qT"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "attributet %qE tillämpat på %qD som inte är en funktion eller variabel"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "attributet %qE tillämpat på extern \"C\"-deklaration %qD"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "argument till attribut %qE måste vara ett uttryck som beräknas till sant eller falskt"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "annotering på en annan typ än en klass- eller uppräkningsdefinition"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, gcc-internal-format
 msgid "annotation applied to a label"
-msgstr "annotation tillämpad på en etikett"
+msgstr "annotering tillämpad på en etikett"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "annotering på ett namnlöst bitfält"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, gcc-internal-format
 msgid "annotation on void parameter"
-msgstr "annotation på en void-parameter"
+msgstr "annotering på en void-parameter"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr "annoteringen har inte strukturtyp"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, gcc-internal-format
 msgid "annotation does not have copy constructible type"
-msgstr "annotationen har inte en kopieringskonstruerbar typ"
+msgstr "annoteringenen har inte en kopieringskonstruerbar typ"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "%<lang_*%>-kontroll: misslyckades i %s, vid %s:%d"
@@ -71081,795 +71231,800 @@ msgstr "%q#T har ingen medlem med namnet %qE, menade du %q#D? (inte åtkomlig fr
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%q#T har ingen medlem med namnet %qE, menade du %qE?"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> är inte en medlem av %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, gcc-internal-format
+msgid "%q#D is not a member of %qT"
+msgstr "%q#D har inte en medlem av %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD är inte en medlemsmallfunktion"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT är inte en pekare-på-objekt-typ"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "ogiltig användning av vektorindexering på pekare till medlem"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "ogiltig användning av unärt %<*%> på pekare till medlem"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "ogiltig användning av implicit konvertering av pekare till medlem"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr "vänstra operanden till %<->*%> måste vara en pekare på en klass, men är en pekare på en medlem av typen %qT"
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "index saknas i vektorreferens"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "indexering av vektor deklarerad %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "indexerat värde är varken en vektor eller pekare"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "objekt saknas i användning av %qE"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, gcc-internal-format
 msgid "no default version in scope"
 msgstr "ingen standardversion i räckvidden"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ förbjuder anrop av %<::main%> inifrån program"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "man måste använda %<.*%> eller %<->*%> för att anropa en pekare-till-medlems-funktion i %<%E (...)%>, t.ex. %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, gcc-internal-format
 msgid "%qT cannot be used as a function"
 msgstr "%qT kan inte användas som en funktion"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE kan inte användas som en funktion"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD kan inte användas som en funktion"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "uttryck kan inte användas som en funktion"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "för många argument till konstrueraren %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "för få argument till konstrueraren %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "för många argument till medlemsfunktionen %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "för få argument till medlemsfunktionen %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "för många argument till funktionen %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "för få argument till funktionen %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "för många argument till metoden %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "för få argument till metoden %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "för många argument till funktion"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "för få argument till funktion"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "parameter %P till %qD har ofullständig typ %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "parametern %P har ofullständig typ %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "adressen %qE kommer aldrig vara NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "adressen till %qD kommer aldrig vara NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "kompilatorn kan anta att adressen till %qE aldrig kommer att vara NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr "jämför resultatet av pekaraddition %qE och NULL"
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "kompilatorn kan anta att adressen till %qD aldrig kommer att vara NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "bitvis operation mellan olika uppräkningstyper %qT och %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "bitvis konvertering mellan olika uppräkningstyper %qT och %qT bör undvikas"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "aritmetik mellan olika uppräkningstyper %qT och %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "aritmetik mellan olika uppräkningstyper %qT och %qT bör undvikas"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "jämförelse av uppräkningstypen %qT med flyttalstypen %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "jämförelse av flyttalstypen %qT med uppräkningstypen %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr "jämförelse av uppräkningstypen %qT med flyttalstypen %qT är föråldrad"
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "jämförelse av flyttalstypen %qT med uppräkningstypen %qT bör undvikas"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "aritmetik mellan uppräkningstypen %qT och flyttalstypen %qT"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "aritmetik mellan flyttalstypen %qT och uppräkningstypen %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr "aritmetik mellan uppräkningstypen %qT och flyttalstypen %qT är föråldrad"
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr "aritmetik mellan flyttalstypen %qT och uppräkningstypen %qT är föråldrad"
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "antar typkonvertering till %qT från överlagrad funktion"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL använd i aritmetik"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ förbjuder jämförelse mellan pekare och heltal"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "operandtyper är %qT och %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr "trevägsjämförelse av vektorer"
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "ordningsjämförelse av pekare med heltalet noll (%qT och %qT)"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "oordnad jämförelse av argument som inte är flyttal"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "implicit konvertering från %qH till %qI för att matcha den andra operanden i binärt uttryck"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "ogiltiga operander av typ %qT och %qT till binär %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ förbjuder användning av pekare av typ %<void *%> i subtraktion"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ förbjuder användning av pekare till en funktion i subtraktion"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ förbjuder användning av pekare till en metod i subtraktion"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "ogiltig användning av en pekare till en ofullständig typ i pekararitmetik"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "tar adressen till konstrueraren %qD"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "tar adressen till destrueraren %qD"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "ogiltig användning av %qE för att skapa en pekare-till-medlem-funktion"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  ett kvalificerat id krävs"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "parenteser runt %qE kan inte användas för att skapa en pekare-till-medlem-funktion"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ förbjuder att ta adressen till en okvalificerad eller parentetiserad icke-statisk medlemsfunktion för att skapa en pekare till en medlemsfunktion.  Säg %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ förbjuder att ta adressen till en okvalificerad eller parentetiserad icke-statisk medlemsfunktion för att skapa en pekare till en explicit objektmedlemsfunktion"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ förbjuder att ta adressen till en bunden medlemsfunktion för att skapa en pekare till medlemsfunktion.  Säg %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ förbjuder att ta adressen till en bunden medlemsfunktion för att skapa en pekare på en explicit objektmedlemsfunktion"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "en pekare på en explicit objektmedlemsfunktion kan bara skapas med %<&%T::%D%>"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "tar adress till ett r-värde"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ förbjuder att ta adressen till funktionen %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "kan inte skapa pekare till referensmedlem %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "försök att ta adressen till bitfält"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<~%> på ett uttryck av typen %<bool%>"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr "tänkte du använda logiskt icke (%<!%>)?"
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ förbjuder ökning av enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ förbjuder minskning av enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "det går inte att öka en pekare på en ofullständig typ %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "det går inte att minska en pekare på en ofullständig typ %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ förbjuder ökning av pekare på typ %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ förbjuder minskning av pekare på typ %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr "%qs-uttryck av en %<volatile%>-kvalificerad typ bör undvikas"
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr "användning av en operand av typen %qT i %<operator--%> är förbjudet"
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr "användning av en operand av typen %qT i %<operator++%> är förbjudet i C++17"
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr "användning av en operand av typen %qT i %<operator++%> bör undvikas"
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "kan inte ta adressen till %<this%>, som är ett rvalue-uttryck"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "adress begärd till %qD, som är deklarerad %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "listinitierare för en typ som inte är en klass får inte vara inom parenteser"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "uttryckslista behandlas som sammansatt uttryck i initierare"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "uttryckslista behandlas som sammansatt uttryck i medlemsinitierare"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "uttryckslista behandlas som sammansatt uttryck i funktionstypkonvertering"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "uttryckslistan %s behandlas som sammansatt uttryck"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
-msgstr "ingen kontext för att lösa upp typen på %qE"
+msgstr "ingen kontext för att slå upp typen på %qE"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "konvertering från typ %qT till typ %qT slänger bort kvalificerare"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%<static_cast%> från typ %qT till typ %qT slänger bort kvalificerare"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%<reinterpret_cast%> från typ %qT till typ %qT slänger bort kvalificerare"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "oanvändbar konvertering till typen %q#T"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "typkvalificerare ignoreras för typkonverterings resultattyp"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "ogiltig %<static_cast%> från typ %qT till typ %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "returtypen %qT är ofullständig"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr "konvertering från %qH till %qI"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "ogiltig typkonvertering av ett pr-värdeuttryck av typ %qT till typ %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr "konvertering från %qH till %qI förlorar precision"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr "konvertering mellan inkompatibla funktionstyper från %qH till %qI"
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "typkonvertering mellan inkompatibla pekare till medlemstyper från %qH till %qI"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "typkonvertering från %qH till %qI ökar kravet på justering för måltypen"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "typkonvertering mellan pekare-till-funktion och pekare-till-objekt stödjs villkorligt"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "ogiltig konvertering från typ %qT till typ %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "ogiltig användning av %<const_cast%> med typ %qT, som inte är en pekare, referens, eller pekare-till-datamedlem-typ"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "ogiltig användning av %<const_cast%> med typ %qT, som är en pekare eller referens till en funktionstyp"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "ogiltig %<const_cast%> av ett rvärde av typ %qT till typ %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "ogiltig %<const_cast%> från typ %qT till typ %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ förbjuder typkonvertering till en vektortyp %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "ogiltig konvertering till funktionstyp %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr "flyttar %qE av typen %qT till sig själv"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  i beräkningen av %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "tilldelning till en vektor från en initierarlista"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "inkompatibla typer i tilldelning av %qT till %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "vektor använd som initierare"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "ogiltig vektortilldelning"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   i konvertering av pekare till medlemsfunktion"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "konvertering av pekare till medlem via virtuell bas %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   i konvertering av pekare till medlem"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "ogiltig konvertering till typ %qT från typ %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "det går inte att konvertera %qH till %qI i standardargument"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "det går inte att konvertera %qH till %qI när argument skickas"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "det går inte att konvertera %qH till %qI i initiering"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr "det går inte att konvertera %qH till %qI i retur"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "det går inte att konvertera %qH till %qI i tilldelning"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "parameter %qP till %qD kan vara en kandidat för ett formatattribut"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "parameter kan vara en kandidat för ett formatattribut"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "målet för konvertering kan vara en kandidat för ett formatattribut"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
-msgstr "målet för initialisering kan vara en kandidat för ett formatattribut"
+msgstr "målet för initiering kan vara en kandidat för ett formatattribut"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "vänsterhandssida av tilldelning kan vara en kandidat för ett formatattribut"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "när argument %P till %qD skickades"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "returnerar referens till en temporär"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "returnerar pekare på en temporär"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr "att returnera en temporär %<initializer_list%> utökar inte livslängden på den underliggande vektorn"
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "referens till lokal variabel %qD returnerad"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr "att returnera en lokal %<initializer_list%>-variabel %qD utökar inte livslängden på den underliggande vektorn"
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "adressen till etiketten %qD returnerad"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "adress till lokal variabel %qD returnerad"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr "att flytta ett temporärobjekt förhindrar att kopiering undviks"
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr "ta bort anrop av %<std::move%>"
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr "att flytta ett lokalt objekt i en retursats förhindrar att kopiering undviks"
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "redundant förflyttning i retursats"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "redundant förflyttning i initiering"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "returnerar ett värde från en destruerare"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "det går inte att returnerar från en hanterare i ett funktions-try-block eller en konstruerare"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "returnerar ett värde från en konstruerare"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "return-sats utan värde i funktion som returnerar %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr "returnerar en initierarlista"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "inkonsistenta typer %qT och %qT härledda för lambda-returtypen"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "inkonsistent härledning för auto-returtyp: %qT och sedan %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "return-sats med ett värde i funktion som returnerar %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> får inte returnera NULL om den inte är deklarerad %<throw()%> (eller %<-fcheck-new%> är aktivt)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "utelämnar inte kopiering vid retur från %qD"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr "utelämnar inte kopiering vid retur i %qD"
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "använder r-värde som l-värde"
@@ -72221,12 +72376,12 @@ msgstr "pekare-till-medlemsfunktionstyp %qT kräver ett r-värde"
 #: cp/typeck2.cc:2543
 #, gcc-internal-format
 msgid "pointer-to-member-function type %qT requires an lvalue"
-msgstr "pekare-till-medlemsfunktiontyp %qT kräver ett l-värde"
+msgstr "pekare-till-medlemsfunktionstyp %qT kräver ett l-värde"
 
 #: cp/typeck2.cc:2551
 #, gcc-internal-format
 msgid "pointer-to-member-function type %qT requires an lvalue before C++20"
-msgstr "pekare-till-medlemsfunktiontyp %qT kräver ett l-värde före C++20"
+msgstr "pekare-till-medlemsfunktionstyp %qT kräver ett l-värde före C++20"
 
 #: cp/typeck2.cc:2592
 #, gcc-internal-format
@@ -72273,17 +72428,17 @@ msgstr "kan inte öppna loggfilen %<vtv_set_ptr_data.log%>: %m"
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "kan inte öppna loggfilen %<vtv_count_data.log%>: %m"
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "okänt attribut %qs"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%q+D deklarerad svag efter att ha använts"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr "endast %<inbranch%>- och %<notinbranch%>-flaggor är tillåtna till attributet %<simd%>"
@@ -72308,43 +72463,43 @@ msgstr "överlappande initierare för fältet %qT.%qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "adressen till %qD kommer aldrig vara %<null%>"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr "behöver %<this%> för att komma åt medlemmen %qE"
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr "försökte utföra flyttalsmodulodivision på %qT"
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "det går inte att få rampekaren till %qs"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr "nästad funktion saknar kropp"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qs är en nästad funktion och kan inte nås från %qs"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr "variabeln %qs har räckviddsdestruktion, kan inte bygga hölje"
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "den explicita registervariabeln %qs kan inte användas i nästad funktion"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "framåtreferens till ramen för %qs"
@@ -72400,7 +72555,7 @@ msgstr "det går inte att konvertera parametern %qs från typen %qs till typen %
 #: d/d-convert.cc:753
 #, gcc-internal-format
 msgid "parameters of type %<va_list%> {aka %qs} are decayed to pointer types, and require %<va_copy%> to be converted back into a static array type"
-msgstr "parametrar av typen %<va_list%> {ävän kända som %qs} degenereras till pekartyper, och kräver %<va_copy%> för att konverteras tillbaka till en statisk vektortyp"
+msgstr "parametrar av typen %<va_list%> {även kända som %qs} degenereras till pekartyper, och kräver %<va_copy%> för att konverteras tillbaka till en statisk vektortyp"
 
 #: d/d-lang.cc:464
 #, gcc-internal-format
@@ -72422,32 +72577,32 @@ msgstr "felaktigt argument till %<-fmodule-file=%>: %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "felaktigt argument till %<-fversion=%>: %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "kan inte öppna %s för skrivning: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "när utdatafil %s skrevs: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, gcc-internal-format
 msgid "unable to open %s for reading: %m"
-msgstr "kan inte öppna %s för skrivning: %m"
+msgstr "kan inte öppna %s för läsning: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, gcc-internal-format
 msgid "reading ddoc file %s: %m"
-msgstr "när ddoc-filen %s skrevs: %m"
+msgstr "när ddoc-filen %s lästes: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr "argumentet till %<-fonly=%> skiljer sig från det första indatafilnamnet"
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr "kan inte slå upp en framåtreferens i en definition"
@@ -72544,7 +72699,7 @@ msgstr "vet inte hur %qs kan raderas"
 msgid "%qs is not an associative array"
 msgstr "%qs är inte en associativ vektor"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr "behöver %<this%> för att komma åt medlemmen %qs"
@@ -72559,22 +72714,22 @@ msgstr "delegater är endast till för icke-statiska funktioner"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs är inte ett fält, utan en %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "rekursiv referens %qs"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr "ej konstant uttryck %qs"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%qs är inte ett uttryck"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "typen %qs är inte ett uttryck"
@@ -72665,17 +72820,17 @@ msgstr "det går inte att kasta COM-objekt"
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "D:s inline-assemblersatser stödjs inte i GDC."
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr "uttrycket %qs kräver %<object.TypeInfo%> och kan inte användas med %<-fno-rtti%>"
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<object.TypeInfo%> kan inte användas med %<-fno-rtti%>"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr "%<object.TypeInfo%> kunde inte hittas, men är implicit använt"
@@ -72753,7 +72908,7 @@ msgstr "En teckenlös konstant avhuggen vid %L"
 #: fortran/arith.cc:138
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned constant at %L not permitted"
-msgstr "Negering av en teckenlös konstant vid %L är inte tillåtet"
+msgstr "Negation av en teckenlös konstant vid %L är inte tillåtet"
 
 #: fortran/arith.cc:141 fortran/arith.cc:2297
 #, gcc-internal-format
@@ -72997,8 +73152,8 @@ msgstr "Vektorreferens vid %C kan inte ha mer än %d dimensioner"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "Co-vektorer avaktiverade vid %C, använd %<-fcoarray=%> för att aktivera"
@@ -73052,7 +73207,7 @@ msgstr "Uttrycket vid %L i detta sammanhang måste vara konstant"
 #: fortran/array.cc:594
 #, gcc-internal-format, gfc-internal-format
 msgid "A lower bound must precede colon in assumed-size array specification at %L"
-msgstr "En undre gräns måste föregå kolonet i vektorspecifikation med antagen storlek saknas vid %L"
+msgstr "En undre gräns måste föregå kolonet i vektorspecifikation med antagen storlek vid %L"
 
 #: fortran/array.cc:606
 #, gcc-internal-format, gfc-internal-format
@@ -73275,7 +73430,7 @@ msgstr "BOZ-litteralkonstanten vid %L kan inte vara ett aktuellt argument till %
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "Argument till %qs vid %L och %L kan inte båda vara litterala BOZ-konstanter"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "Felaktig användning av en BOZ-litteralkonstant vid %L"
@@ -73350,7 +73505,7 @@ msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara REAL eller COMPLEX"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara INTEGER eller PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara en konstant"
@@ -73448,7 +73603,7 @@ msgstr "Stödjs inte: argumentet %qs till inbyggd %qs vid %L med sorten %d"
 #: fortran/check.cc:1135
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have a decimal exponent range of at least four"
-msgstr "Argumentet %qs till %qs vid %L måste ha ett decimalt exponentinterval på åtminstone fyra"
+msgstr "Argumentet %qs till inbyggd %qs vid %L måste ha ett decimalt exponentintervall på åtminstone fyra"
 
 #: fortran/check.cc:1154
 #, gcc-internal-format
@@ -73490,7 +73645,7 @@ msgstr "BOZ-litteralkonstanten vid %L kan inte förekomma i det inbyggda underpr
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "%qs- och %qs-argumenten till inbyggd %qs vid %L måste ha samma typ"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "Olika typsorter vid %L"
@@ -73505,7 +73660,7 @@ msgstr "NULL vid %L är inte tillåtet som aktuellt argument till den inbyggda f
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "argumentet %qs till inbyggd %qs vid %L skall inte vara co-indexerat"
@@ -73568,7 +73723,7 @@ msgstr "Argument %qs till inbyggd %qs vid %L skall ha typen %<team_type%> från
 #: fortran/check.cc:1891
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall have a type of CHARACTER(KIND=C_CHAR)"
-msgstr "%qs-argumentet till inbyggd %qs vid %L skal ha typen CHARACTER(KIND=C_CHAR) "
+msgstr "%qs-argumentet till inbyggd %qs vid %L skall ha typen CHARACTER(KIND=C_CHAR) "
 
 #: fortran/check.cc:1931
 #, gcc-internal-format
@@ -73646,8 +73801,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "errmsg=-argumentet vid %L måste vara en teckenvariabel av standardsort"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "Co-vektorer avaktiverade vid %L, använd %<-fcoarray=%> för att aktivera"
@@ -73746,9 +73901,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "BOZ-konstant vid %L får inte förekomma i det inbyggda underprogrammet COMPLEX"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "inbyggd %qs med KIND-argument vid %L"
@@ -73763,12 +73918,12 @@ msgstr "%qs-argumentet till inbyggd %qs vid %L har ogiltig form i dimensions %d
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste ha ordning %d eller vara en skalär"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara numeriskt eller LOGICAL"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "Argumenttyper till inbyggd %qs vid %L måste stämma överens (%s/%s)"
@@ -73863,618 +74018,618 @@ msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara en dataentitet"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Inbyggd %qs vid %L måste ha åtminstone två argument"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Saknat argument %qs till inbyggd %s vid %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Dubblerat argument %qs vid %L till inbyggd %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Okänt argument %qs vid %L till inbyggd %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "Olika teckensorter vid %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "%<a%d%>-argumentet till inbyggd %qs vid %L måste vara %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "inbyggd %qs med CHARACTER-argument vid %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "%<a1%>-argumentet till inbyggd %qs vid %L måste vara INTEGER, REAL, CHARACTER eller UNSIGNED"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "%<a1%>-argumentet till inbyggd %qs vid %L måste vara INTEGER, REAL eller CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Olika form på dimension 1 för argumenten %qs och %qs vid %L för inbyggd matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Olika form på dimension 2 för argument %qs och dimension 1 för argument %qs vid %L för inbyggd matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste ha ordning 1 eller 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "Argumentet %qs till inbyggd %qs vid %L måste vara typkonformt med argument %qs vid %L"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara INTEGER eller UNSIGNED"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara INTEGER"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr "STAT= eller ERRMSG= vid %L stödjs inte"
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Argumentet FROM till MOVE_ALLOC %L skall inte vara co-indexerat"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Argumentet TO till MOVE_ALLOC %L skall inte vara co-indexerat"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "Argumentet TO i MOVE_ALLOC vid %L måste vara polymorft om FROM är polymorft"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "Argumenten FROM och TO till den inbyggda MOVE_ALLOC vid %L måste ha samma ordning %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "Argumenten FROM och TO till den inbyggda MOVE_ALLOC vid %L måste ha samma co-ordning %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr "Argumenten FROM och TO vid %L bryter aliasrestriktioner (F2003 12.4.1.7)"
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "Argument %<S%> till NEAREST vid %L får inte vara noll"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "Argument %qs till inbyggd %qs vid %L måste vara en POINTER, ALLOCATABLE eller procedurpekare"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "Inbyggd NULL med allokerbar MOLD vid %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "argumentet %qs till inbyggd %qs vid %L skall förekomma endast om %s har typen REAL och %qs har typen INTEGER eller UNSIGNED"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste ge åtminstone lika många element som det finns .TRUE.-värden i %qs (%ld/%d)"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara en attrappvariabel"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara en OPTIONAL attrappvariabel"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "%qs-argumentet till inbyggd %qs vid %L får inte vara ett underobjekt till %qs"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "Argumentet till inbyggd RANK vid %L måste vara ett dataobjekt"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "ARRAY-argumentet vid %L till REDUCE får inte vara polymorft"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
-msgstr "Argumentet DIM vid %L måste, om det finns, måste vara en heltalsskalär"
+msgstr "Argumentet DIM vid %L måste, om det finns, vara en heltalsskalär"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr "Argumentet MASK vid %L måste, om det finns, vara en logisk vektor med samma ordning som ARRAY"
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr "MASK finns vid %L utan IDENTITY"
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, gcc-internal-format, gfc-internal-format
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "Argumentet ORDERED vid %L måste, om det ges, vara en logisk skalär"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
-msgstr "Argumentet IDENTITY vid %L, om det finns, måste vara en skalär med samma ordning som ARRRAY"
+msgstr "Argumentet IDENTITY vid %L, om det finns, måste vara en skalär med samma ordning som ARRAY"
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "%<shape%>-argumentet till inbyggd %<reshape%> vid %L måste vara en vektor av konstant storlek"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "%qs-argumentet till inbyggd %qs vid %L är tomt"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "%<shape%>-argumentet till inbyggd %<reshape%> vid %L har mer än %d element"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "%qs-argumentet till inbyggd %qs vid %L har negativa element (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "%qs-argumentet till inbyggd %qs vid %L har fel antal element (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "%qs-argumentet till inbyggd %qs vid %L har dimension utanför giltigt intervall (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "%qs-argumentet till inbyggd %qs vid %L har en ogiltig permutation av dimensioner (dimension %qd dubblerad)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Utan utfyllnad finns det för få element i inbyggda RESHAPE-källan vid %L för att stämma med formen"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "Argumentet %qs till inbyggd %qs vid %L kan inte ha typen %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara en utvidgningsbar typ"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "SELECTED_REAL_KIND med varken %<P%>- eller %<R%>-argument vid %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "inbyggd %qs med RADIX-argument vid %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "%<source%>-argumentet till inbyggd %<shape%> vid %L får inte vara en vektor med antagen storlek"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "Argument %qs till inbyggd %qs vid %L får inte vara en procedur"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "Argumentet %qs till inbyggd %qs vid %L skall inte vara TYPE(*)"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "Argumentet %qs till inbyggd %qs vid %L får inte vara en vektor med antagen storlek"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr "is_c_interoperable(): gfc_simplify_expr misslyckades"
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "Argumentet %qs till inbyggd %qs vid %L måste vara en interoperabel dataentitet: %s"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr "Argumentet C_PTR_1 vid %L till C_ASSOCIATED skall ha typen TYPE(C_PTR) eller TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr "Argumentet C_PTR_2 vid %L till C_ASSOCIATED skall ha samma typ som C_PTR_1, hittade %s istället för %s"
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr "Argumentet CPTR vid %L till C_F_POINTER skall ha typen TYPE(C_PTR)"
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Argumentet FPTR vid %L till C_F_POINTER måste vara en pekare"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "Argumentet FPTR vid %L till C_F_POINTER får inte vara polymorft"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "Argumentet FPTR vid %L till C_F_POINTER skall inte vara co-indexerat"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Oväntat SHAPE-argumentet vid %L till C_F_POINTER med skalär FPTR"
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr "SHAPE-argument förväntades till C_F_POINTER med vektor FPTR vid %L"
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "SHAPE-argumentet vid %L till C_F_POINTER måste ha samma storlek som FPTR:s RANK"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "Argumentet LOWER vid %L till C_F_POINTER"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Oväntat LOWER-argumentet vid %L till C_F_POINTER med skalär FPTR"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "Argumentet LOWER vid %L till C_F_POINTER måste ha samma storlek som FPTR:s RANK"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr "Polymorf FPTR vid %L till C_F_POINTER"
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "argumentet FPTR till C_F_POINTER vid %L är en funktion som returnerar en pekare"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Ej interoperabel vektor-FPTR är argument till C_F_POINTER vid %L: %s"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr "Argumentet CPTR vid %L till C_F_PROCPOINTER skall ha typen TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "Argumentet FPTR vid %L till C_F_PROCPOINTER skall vara en procedurpekare"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "Argumentet FPTR vid %L till C_F_PROCPOINTER får inte vara co-indexerat"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr "Ej interoperabel procedurpekare vid %L till C_F_PROCPOINTER"
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "Argumentet X vid %L till C_FUNLOC får inte vara co-indexerat"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "Funktionsresultatet %qs vid %L är ogiltigt som X-argument till C_FUNLOC"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr "Argumentet X vid %L till C_FUNLOC skall vara en procedur eller en procedurpekare"
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Ej interoperabel procedur vid %L till C_FUNLOC"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "Argumentet X vid %L till C_LOC får inte vara co-indexerat"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "X-argumentet vid %L till C_LOC får inte vara polymorft"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "Argumentet X vid %L till C_LOC skall antingen ha attributet POINTER eller TARGET"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "Argumentet X vid %L till C_LOC får inte vara en sträng med längden noll"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "Argumentet vid %L till C_LOC får inte vara polymorft"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "Ej interoperabel vektor vid %L som argument till C_LOC: %s"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr "Vektor med interoperabla typer vid %L till C_LOC som inte är allokerbar och varken antagen storlek eller explicit storlek"
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "Vektorsektion vid %L till C_LOC"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "REAL-argument utan dubbel precision till inbyggd %s vid %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara av lägre ordning än %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "%qs-argumentet till inbyggd %qs vid %L är inte ett giltigt dimensionsindex"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste åtminstone ha längden 1"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "%s-argument till IMAGE_INDEX skall vara en vektor av ordning ett vid %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "Antalet vektorelement i argumentet SUB till IMAGE_INDEX vid %L skall vara %d (co-ordning) inte %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, gcc-internal-format
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "argumentet %<team%> eller %<team_number%> till %qs vid %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr "Det första argumentet till den inbyggda %<this_image%> vid %L måste vara en co-vektorvariabel eller ett objekt av typen %<team_type%> från den inbyggda modulen %<ISO_FORTRAN_ENV%>"
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr "Det andra argumentet till den inbyggda %<this_image%> vid %L måste vara en skalär med typen %<INTEGER%> eller ett objekt av typen %<team_type%> från den inbyggda modulen %<ISO_FORTRAN_ENV%>"
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "Argumentet %<dim%> utan ett argument %<coarray%> är inte tillåtet för inbyggd %<this_image%> vid %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "argumentet %<team%> till %<this_image%> vid %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr "Högst ett argument av typen %<team_type%> från den inbyggda modulen %<ISO_FORTRAN_ENV%> till %<this_image%> vid %L tillåts"
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr "argumentet %<MOLD%> till den inbyggda %<TRANSFER%> vid %L är en vektor och skall inte ha lagringsstorlek 0 när argumentet %<SOURCE%> har en storlek större än 0"
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "%<SOURCE%>-argumentet till inbyggd %<TRANSFER%> vid %L får inte vara %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "%<MOLD%>-argumentet till inbyggd %<TRANSFER%> vid %L måste vara en %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "%<MOLD%>-argumentet till inbyggd %<TRANSFER%> vid %L får inte vara %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "Inbyggd TRANSFER vid %L har delvis odefinierat resultat: källstorlek %zd < resultatstorlek %zd"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste ha samma ordning som %qs eller vara en skalär"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "%qs- och %qs-argumenten till inbyggd %qs vid %L måste ha identiska former."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "Argumentet VALUES till  DATE_AND_TIME vid %L har icke-standardsort"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Argumentet VALUES till  DATE_AND_TIME vid %L måste ha ett decimalt exponentinterval på åtminstone fyra"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Storlek på %qs-argumentet till inbyggd %qs vid %L är för liten (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "För många argument till %s vid %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr "fe_runtime_error-sträng måste vara null-avslutad"
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "fe_runtime_error: Fel antal argument (%d istället för %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L har icke-standardsort"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Argumentet COUNT till SYSTEM_CLOCK vid %L med en sort som är mindre än standardheltal"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr "Reellt COUNT_RATE-argument till SYSTEM_CLOCK vid %L"
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Argumentet COUNT_RATE till SYSTEM_CLOCK vid %L har en icke-standardsort"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Argumentet COUNT_RATE till SYSTEM_CLOCK vid %L har en sort som är mindre än standardheltal"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Argumentet COUNT_MAX till SYSTEM_CLOCK vid %L har en icke-standardsort"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Argumentet COUNT_MAX till SYSTEM_CLOCK vid %L har en sort som är mindre än standardheltal"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "heltalsargumentet till SYSTEM_CLOCK vid %L med en annan parametersort"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste ha en sort som inte är bredare än standardsorten (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "Det aktuella argumentet vid %L till den inbyggda funktionen %qs måste vara en associerad pekare"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara INTEGER, LOGICAL eller en BOZ-litteralkonstant"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr "Den inbyggda funktionen NULL vid %L kan inte vara ett aktuellt argument till STORAGE_SIZE, eftersom den returnerar en disassocierad pekare"
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "Maximal utökningsnivå nådd med typen %qs vid %L"
@@ -74539,12 +74694,12 @@ msgstr "Oanvänd initieringssträng vid %L för att variabeln har nollängd"
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "Initieringssträng vid %L höggs av för att stämma med variabeln (%wd/%wd)"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Delsträngs startindex vid %L är mindre än ett"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "Slutindex för delsträng vid %L överstiger strängens längd"
@@ -74594,2058 +74749,2058 @@ msgstr "Objektet %qs som inte är en pekare, med standardinitierare skall inte f
 msgid "Simplification error"
 msgstr "Förenklingsfel"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr "En frågeparameter kan inte förekomma i en datasatsobjektlista vid %C"
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Värdassocierad variabel %qs får inte finnas i DATA-sats vid %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "initiering av common-blockvariabel %qs i DATA-sats vid %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Symbolen %qs måste vara en PARAMETER i DATA-sats vid %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Ogiltig initierare %s på DATA-sats vid %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "BOZ vid %L får inte förekomma i en initiering i gammal stil"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr "litteral BOZ-konstant nära %L kan inte tilldelas till en %qs-variabel i en initiering i gammal stil"
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "Initieringen vid %C får inte förekomma i en PURE-procedur"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "DATA-sats vid %C kan inte förekomma inuti ett INTERFACE"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Ogiltig delsträng i data-implicerat-do vid %L i DATA-sats"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr "Allokerbar komponent eller vektor med fördröjd form nära %C i DATA-sats"
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "BOZ-litteralkonstanten vid %L kan inte förekomma i en strukturkonstruerare"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "DATA-sats vid %C får inte förekomma i en PURE-procedur"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr "part-ref med pekarattribut nära %L är inte högraste part-ref av datasatsobjekt"
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "Tom gammaldags initierarlista vid %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Vektor i initierarlista vid %L måste ha en uttrycklig form"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "Repetitionsspecifikationen är felaktig i skalär initierare vid %C"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "Repetitionsspecifikationen måste vara ett heltal vid %C"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Datakonstant förväntades efter repetitionsspecifikation vid %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "Slut på skalärt initieringsuttryck förväntades vid %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "Inte tillräckligt med element i vektorinitieraren vid %C"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "För många element i vektorinitieraren vid %C"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Syntaxfel i gammaldags initierarlista vid %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "Vektorn med antagen ordning vid %C får inte ha en co-dimension"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr "Summan av vektorn med ordning %d och co-ordning %d vid %C överskrider maximalt tillåtna dimensioner på %d"
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Felaktig INTENT-specifikation vid %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "fördröjd typparameter vid %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr "Skalärt INTEGER-uttryck förväntades vid %L"
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Gammaldags teckenlängd vid %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Syntaxfel i specifikation av teckenlängd vid %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Proceduren %qs vid %C är redan definierad vid %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Den inneslutna proceduren %qs vid %C krockar med proceduren definierad vid %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Namnet %qs vid %C är redan definierat som ett generiskt gränssnitt vid %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Proceduren %qs vid %C har ett explicit gränssnitt från en tidigare deklaration"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr "Proceduren %qs som är definierad i gränssnittskroppen vid %L kolliderar med den interna proceduren definierad vid %C"
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Proceduren %qs vid %L måste ha attributet BIND(C) för att vara C-interoperativ"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "Typen %qs vid %L är ett attrappargument till BIND(C)-proceduren %qs men är inte interoperativ med C för att den härledda typen %qs inte är interoperativ med C"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "Variabeln %qs vid %L är ett attrappargument till BIND(C)-proceduren %qs men är inte interoperativ med C eftersom den är polymorf"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Variabeln %qs vid %L är en attrapparameter till BIND(C)-proceduren %qs men är kanske inte interoperativ med C"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "Attrappargumentet %qs vid %L kan inte vara en pekare med attributet CONTIGUOUS eftersom proceduren %qs är BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "Det standardinitierade attrappargumentet %qs med attributet %s vid %L är inte tillåtet i BIND(C)-proceduren %qs"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Det allokerbara teckenattrappargumentet %qs vid %L måste ha fördröjd längd eftersom proceduren %qs är BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Pekarteckenattrappargumentet %qs vid %L måste ha fördröjd längd eftersom proceduren %qs är BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Teckenattrappargumentet %qs med fördröjd längd vid %L till proceduren %qs med attributet BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "Teckenattrappargumentet %qs vid %L måste ha längden 1 eftersom det har attributet VALUE"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Teckenattrappargumentet %qs med förmodad längd vid %L till proceduren %qs med attributet BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr "Teckenattrappargument %qs vid %L måste ha konstant längd på ett eller antagen längd, om inte den har antagen form eller antagen ordning, eftersom proceduren %qs har attributet BIND(C)"
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Variabeln %qs vid %L med attributet ALLOCATABLE i proceduren %qs med BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Variabeln %qs vid %L med attributet POINTER i proceduren %qs med BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "Variabeln %qs vid %L kan inte både ha attributet OPTIONAL och VALUE eftersom proceduren %qs är BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Variabeln %qs vid %L med attributet OPTIONAL i proceduren %qs som är BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Vektorn %qs med antagen form vid %L som attrappargument till BIND(C)-proceduren %qs vid %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr "F2018: C8102 %s vid %L är redan importerad av en %s-sats och får inte deklareras om"
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Symbolen %qs vid %C är också deklarerad som en typ vid %L"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "Variabeln %qs i common-blocket %qs vid %C måste deklareras med en sort som är C-interoperativ eftersom common-blocket %qs är BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "CHARACTER-längden måste vara en konstant vid %L"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "CHARACTER-uttryck vid %L huggs av (%ld/%ld)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "CHARACTER-elementen i vektorkonstrueraren vid %L måste ha samma längd (%ld/%ld)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Initierare är inte tillåten för PARAMETER %qs vid %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "PARAMETER vid %L saknar en initierare"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Variabeln %qs vid %C med en initierare finns redan i en DATA-sats"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Det går inte att initiera en parametervektor vid %L med element med variabel längd"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Ordningen stämmer inte för vektorn vid %L och dess initierare (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "Det går inte att initiera en vektor med antagen form vid %L med en skalär"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "Dålig form på initierare vid %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "Det går inte att avgöra formen på initieraren vid %L"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Lägre gräns som inte är konstant i förmodat formad deklaration vid %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "Entiteten %qs vid %L är inkompatibel med en litteral BOZ-konstant"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Komponent vid %C måste ha attributet POINTER"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Komponenten %qs med CLASS vid %C måste vara allokerbar eller en pekare"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Vektorkomponent i post vid %C måste ha fördröjd form"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Komponenten %qs vid %C är redan deklarerad vid %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Pekarvektorkomponent i post vid %C måste ha fördröjd form"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Allokerbar komponent i post vid %C måste ha fördröjd form"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Vektorkomponent i post vid %C måste ha uttrycklig form"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "Typparametern %qs vid %C har ingen motsvarande post i typparameternamnlistan vid %L"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "NULL()-initiering vid %C är tvetydig"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "NULL()-initiering vid %C kan inte ha MOLD"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Initiering av pekare vid %C är inte tillåtet i en PURE-procedur"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Fel i pekarinitiering vid %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "annan pekarinitiering än NULL vid %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr "RESULT-variabeln %qs vid %L förhindrar FUNCTION-namnet %qs vid %C från att förekomma i en specifikationssats"
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "%qs är inte tillåtet utanför STRUCTURE vid %C"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%qs vid %C är en DEC-utökning, aktivera den med %<-fdec-structure%>"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "Enheten %qs kan inte ha attribut vid %C"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Felaktigt tecken %qc i ett variabelnamn vid %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Icke-PARAMETER-symbolen %qs vid %L kan inte ha antagen form"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Vektor med antagen form vid %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Explicit vektorform vid %C måste vara en konstant av typen INTEGER och inte av typen %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr "Explicit formad vektor med ickekonstanta gränser vid %C"
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr "%qs vid %L är en omdefinition av deklarationen i motsvarande gränssnitt för MODULE PROCEDURE %qs"
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, gcc-internal-format
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Enheten %qs kan inte ha en initierare vid %L"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Dubblerad vektorspecifikation för Cray-utpekad vid %L"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "Kan inte sätta utpekads vektorspecifikation."
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Gammaldags initiering vid %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "Felaktig gammaldags initiering av härledd typkomponent vid %C"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Syntaxfel i gammaldags initiering av %s vid %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Initieringen vid %C är inte för en pekarvariabel"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Pekarinitiering vid %C kräver %<=>%>, inte %<=%>"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Ett initieringsuttryck förväntades vid %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Initiering av variabel vid %C är inte tillåtet i en PURE-procedur"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Initiering av allokerbar komponent vid %C är inte tillåtet"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
-msgstr "Initiering av en strukturkomponent med en HOLLERITH-konstant vid %L är inte tillåtet"
+msgstr "Initiering av en postkomponent med en HOLLERITH-konstant vid %L är inte tillåtet"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr "Komponenten med attributet KIND eller LEN vid %C förekommer inte i typparameterlistan vid %L"
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr "Komponenten vid %C som förekommer i typparameterlistan vid %L har varken attributet KIND eller LEN"
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Pekarkomponenten vid %C som är en typparameter måste vara en skalär"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "BOZ-litteralkonstanten vid %L kan inte förekomma som en initierare"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr "Inkompatibel initiering mellan en härledd typentitet och en entitet med typen %qs vid %C"
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Gammaldags typdeklaration %s*%d stödjs inte vid %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Typdeklaration ej enligt standard %s*%d vid %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Saknad högerparentes vid %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Initieringsuttryck förväntades vid %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Ett skalärt initieringsuttryck förväntades vid %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Sorten %d stödjs inte för typen %s vid %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Parameter med sort C är för typ %s men typen vid %L är %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Högerparentes eller komma saknas vid %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Sorten %d stödjs inte för typen CHARACTER vid %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Syntaxfel i CHARACTER-deklaration vid %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "RECORD vid %C är en utökning, aktivera den med %<-fdec-structure%>"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Postnamn förväntades efter RECORD vid %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr "Typparameterspecifikationslistan vid %C får inte innehålla både ASSUMED- och DEFERRED-parametrar"
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "Typparameterspecifikationslistan vid %C innehåller för få parameteruttryck"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "Den härledda parametern %qs vid %C har inte ett standardvärde"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Typparameteruttrycket vid %L måste vara av typen INTEGER och inte %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "Parameteruttrycket vid %C måste vara av typen INTEGER och inte av typen %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "Parameteruttrycket vid %C förenklas inte till en INTEGER-konstant"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr "KIND-parametern %qs vid %C kan varken vara ASSUMED eller DEFERRED"
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "Värdet på KIND-parametern %qs vid %C reduceras inte till ett konstant uttryck"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr "Typparameterspecifikationslistan vid %C innehåller för många parameteruttryck"
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "Parametriserad härledd typ vid %C är tvetydig"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "BYTE-typ vid %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "BYTE-typ använd vid %C är inte tillgänglig på målmaskinen"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Förmodad typ vid %C är inte tillåtet för komponenter"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "Antagen typ vid %C"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "TYPE med inbyggd typspecifikation vid %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "Felformad typspecifikation vid %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "DOUBLE COMPLEX vid %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Typnamnet %qs vid %C är tvetydigt"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "CLASS-sats vid %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "Typnamnet %qs vid %C står i konflikt med tidigare deklarerad entitet vid %L, som har samma namn"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr "Typen %qs är inte parametriserad och därför får inte listan med typparameterspecifikationer vid %C förekomma"
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Dubblerad IMPLICIT NONE-sats vid %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "IMPLICIT NONE med specifikationslista vid %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Teckenintervall saknas i IMPLICIT vid %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Bokstäver måste vara i alfabetisk ordning i IMPLICIT-sats vid %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "IMPLICIT-sats vid %C följer en IMPLICIT NONE (type)-sats"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Tom IMPLICIT-sats vid %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "IMPORT-sats vid %C endast tillåten inuti en INTERFACE-kropp"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "F2008: C1210 IMPORT-sats vid %C är inte tillåten i en moduls procedurgränssnittskropp"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "IMPORT-sats vid %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr "importnamnet %qs vid %C är i det lokala omfånget"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "Det går inte att IMPORT:era %qs från värdräckviddsenhet vid %C — finns inte."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "%qs är redan IMPORT:erad från värdräckviddsenhet vid %C"
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Syntaxfel i IMPORT-sats vid %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "F2018: C897 IMPORT-satsen vid %C får inte förekomma i ett huvudprogram, ett externt underprogram, en modul eller blockdata"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr "F2018: C898 IMPORT-satsen vid %C är inte tillåten eftersom en räckviddsenhet har en specificerare ONLY, det går bara att ha IMPORT med en specificerare ONLY"
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
-msgstr "F2018: C899 IMPORT, NONE skall inte förekomma i räckvidsenheten för en undermodul som vid %C"
+msgstr "F2018: C899 IMPORT, NONE skall inte förekomma i räckviddsenheten för en undermodul som vid %C"
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "F2018: C8100 IMPORT-satsen vid %C är inte tillåten eftersom %s redan har deklarerats, vilket måste vara unikt i räckviddsenheten"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Lista med namngivna entiteter förväntades vid %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Co-dimensionsspecifikation saknas vid %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Dimensionsspecifikation saknas vid %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Dubblerat %s-attribut vid %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s vid %L är en DEC-utökning, aktivera den med %<-fdec-static%>"
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Attributet ALLOCATABLE vid %C i en TYPE-definition"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Attributet ALLOCATABLE vid %C i en STRUCTURE-definition"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Attributet KIND vid %C i en TYPE-definition"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Attributet KIND vid %C i en STRUCTURE-definition"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "Komponent med attributet KIND vid %C måste vara INTEGER"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Attributet LEN vid %C i en TYPE-definition"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Attributet LEN vid %C i en STRUCTURE-definition"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "Komponenten med attributet LEN vid %C måste vara INTEGER"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Attribut vid %L är inte tillåtet i en TYPE-definition"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Attribut vid %L är inte tillåtet i en STRUCTURE-definition"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Attributet %s vid %L i en TYPE-definition"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%s-attribut vid %L är inte tillåtet utanför specifikationsdelen av en modul"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "Attribut vid %L är inte tillåtet utanför en TYPE-definition"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "Attributet ASYNCHRONOUS vid %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "Attributet CONTIGUOUS vid %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "PROTECTED vid %C är endast tillåtet i specifikation av en del av en modul"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "Attributet PROTECTED vid %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "Attributet VALUE vid %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "Attributet VOLATILE vid %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr "match_attr_spec(): Felaktigt attribut"
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Flera identifierare angivna med en ensam NAME=-specificerare vid %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "Implicit deklarerad BIND(C)-funktion %qs vid %L kan inte vara C-interoperativ"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "Variabeln %qs i common-blocket %qs vid %L får inte vara en sort interoperativ med C men common-blocket %qs är BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "Typdeklaration %qs vid %L är inte C-interoperativ men den är BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "Variabeln %qs vid %L får inte ha en C-interoperativ sort men den är BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "Variabeln %qs i common-blocket %qs vid %L får inte deklareras med BIND(C) eftersom den inte är en global"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Variabeln %qs vid %L får inte ha både attributet POINTER och BIND(C)"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "Variabeln %qs vid %L får inte ha både attributet ALLOCATABLE och BIND(C)"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Returtyp till BIND(C)-funktion %qs vid %L kan inte vara en vektor"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Returtyp till BIND(C)-funktion %qs med teckentyp vid %L måste ha längden 1"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "Symbolen %qs vid %L är markerad PRIVATE men är tillgänglig via dess standardbindningsnamn %qs"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Det behövs antingen entitet- eller common-blocknamn för attributspecifikationssatsen vid %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Entitets- eller common-blocknamn saknas till attributspecifikationssats vid %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Symbol saknas"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "BIND(C)-sats vid %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "CLASS-entiteten vid %C får inte ha attributet PARAMETER"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Härledd typ vid %C har inte definierats tidigare och kan därför inte förekomma i en härledd typdefinition"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Syntaxfel i anonym postdeklaration vid %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Syntaxfel i datadeklaration vid %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "MODULE-prefix vid %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "MODULE-prefix vid %C hittat utanför en modul, undermodul eller gränssnitt"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "IMPURE-procedur vid %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE och IMPURE får inte båda finnas vid %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "ELEMENTAL-prefixet i MODULE PROCEDURE-gränssnittet saknas vid %L"
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "PURE-prefixet i MODULE PROCEDURE-gränssnittet saknas vid %L"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "RECURSIVE-prefixet i MODULE PROCEDURE-gränssnittet saknas vid %L"
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "En typparameterlista krävs vid %C"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "Alternativt returargument vid %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "Ett parameternamn krävs vid %C"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Namnet %qs vid %C är namnet på proceduren"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "En parameterlista förväntades i typdeklarationen vid %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Oväntat skräp i formell argumentlista vid %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Dubblerat namn %qs i parameterlistan vid %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Dubblerad symbol %qs i formell argumentlista vid %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "Formella argumentet %qs till MODULE PROCEDURE står i konflikt med alternativ retur vid %C"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr "Formella argument till MODULE PROCEDURE är alternativ retur och i konflikt med %qs i den separata deklarationen vid %C"
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr "Formella argumentnamnen till MODULE PROCEDURE stämmer inte (%s/%s) vid %C"
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Antalet formella MODULE PROCEDURE-argument vid %C stämmer inte"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "RESULT-variabel vid %C måste vara skilt från funktionsnamnet"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Oväntat skräp efter funktionsdeklaration vid %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Attributet BIND(C) vid %L kan inte anges för en intern procedur"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "Attribut BIND(C) vid %C kräver ett gränssnitt med BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "BIND(C)-procedur med NAME får inte ha attributet POINTER vid %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Attrapprocedur vid %C kan inte ha attributet BIND(C) tillsammans med NAME"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Proceduren %qs vid %L har redan en grundtyp %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Syntaxfel i PROCEDURE-sats vid %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "%<::%> förväntades efter bindningsattribut vid %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "NOPASS eller explicit gränssnitt krävs vid %C"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Procedurpekarkomponent vid %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Syntaxfel i procedurpekarkomponent vid %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE vid %C måste vara i ett generiskt gränssnitt"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "dubbelkolon i MODULE PROCEDURE-sats vid %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "PROCEDURE-sats vid %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Formell argumentlista förväntades i funktionsdefinitionen vid %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "Attribut BIND(C) vid %L kan endast användas för variabler och common-block"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr "BIND(C)-namnen stämmer inte (%qs/%qs) vid %C"
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "ENTRY-sats vid %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett PROGRAM"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti en MODULE"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti en SUBMODULE"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett BLOCK DATA"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett INTERFACE"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett STRUCTURE-block"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti en ett DERIVED TYPE-block"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett IF-THEN-block"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett DO-block"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett SELECT-block"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett FORALL-block"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett WHERE-block"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett inneslutet underprogram"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Oväntad ENTRY-sats vid %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "ENTRY-sats vid %C kan inte förekomma i en innesluten procedur"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Nödvändig parentes saknas före BIND(C) vid %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "ENTRY-sats vid %L med BIND(C) är otillåten i en elementär procedur"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "Alternativt returattrappargument får inte förekomma i en SUBROUTINE med attributet BIND(C) vid %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Ogiltig C-identifierare i NAME=-specificerare vid %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Syntaxfel i NAME=-specifikation för att binda etikett vid %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "NAME=-specificerare vid %C skall vara ett konstant uttryck"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr "NAME=-specificerare vid %C skall vara en skalär av standardteckensort"
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Slutparentes saknas för att binda etikett vid %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "Inget bindningsnamn är tillåtet i BIND(C) vid %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "För attrapprocedur %s är inget bindningsnamn tillåtet i BIND(C) vid %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "NAME är inte tillåtet på BIND(C) för ABSTRACT INTERFACE vid %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Oväntad END-sats vid %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "END-sats istället för %s-sats vid %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "%s-sats förväntades vid %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "%s-sats förväntades vid %L"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Blocknamn på %qs i %s-sats förväntades vid %L"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Avslutande namn förväntades vid %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Etikett %qs för %s-sats förväntades vid %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Vektorspecifikation saknas vid %L i DIMENSION-sats"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Dimensioner angivna för %s vid %L efter dess initiering"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Vektorspecifikation saknas vid %L i CODIMENSION-sats"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Vektorspecifikation måste vara fördröjd vid %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Oväntat tecken i variabellista vid %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "%<(%> förväntades vid %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Variabelnamn förväntades vid %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Cray-pekare vid %C måste vara ett heltal"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Cray-pekare vid %C har %d bytes precision, minnesadresser kräver %d byte"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "”,” förväntades vid %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "Kan inte sätta Cray-utpekad vektorspecifikation."
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Dubblerad vektorspecifikation för Cray-utpekad vid %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "”)” förväntades vid %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "%<,%> eller slut på sats förväntades vid %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT är inte tillåtet inuti BLOCK vid %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "OPTIONAL är inte tillåtet inuti BLOCK vid %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Cray-pekardeklaration vid %C kräver flaggan %<-fcray-pointer%>"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "CONTIGUOUS-sats vid %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "Åtkomstspecifikation av operatorn %s vid %C har redan angivits"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "Åtkomstspecifikation för operatorn .%s. vid %C har redan angivits"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "PROTECTED-sats vid %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Syntaxfel i PROTECTED-sats vid %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "PRIVATE-sats vid %C får endast förekomma i specifikationsdelen av en modul"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "PUBLIC-sats vid %C får endast förekomma i specifikationsdelen av en modul"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Variabelnamn förväntades vid %C i PARAMETER-sats"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "=-tecken i PARAMETER-sats förväntades vid %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Uttryck förväntades vid %C i PARAMETER-sats"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Initierar redan initierad variabel vid %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr "PARAMETER utan ”()” vid %C"
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Oväntade tecken i PARAMETER-sats vid %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s vid %C är en DEC-utökning, aktivera den med %<-fdec-static%>"
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Entitetslista förväntades i AUTOMATIC-sats vid %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Syntaxfel i AUTOMATIC-sats vid %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Entitetslista förväntades i STATIC-sats vid %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Syntaxfel i STATIC-sats vid %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Allmän SAVE-sats vid %C följer tidigare SAVE-sats"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "SAVE-sats vid %C följer allmän SAVE-sats"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "SAVE i COMMON-blocket %qs vid %C är inte tillåtet i en konstruktion BLOCK"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Syntaxfel i SAVE-sats vid %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "VALUE är inte tillåtet inuti BLOCK vid %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "VALUE-sats vid %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Syntaxfel i VALUE-sats vid %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "VOLATILE-sats vid %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "VOLATILE anges för co-vektorvariabel %qs vid %C, vilket är use-/host-associerat"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Syntaxfel i VOLATILE-sats vid %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "ASYNCHRONOUS-sats vid %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Syntaxfel i ASYNCHRONOUS-sats vid %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "MODULE PROCEDURE-deklaration vid %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE vid %C måste vara i ett generiskt modulgränssnitt"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "Den inbyggda proceduren vid %L kan inte vara en MODULE PROCEDURE"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Tvetydig symbol i TYPE-definition vid %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Symbolen %qs vid %C har inte definierats tidigare"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "%qs i EXTENDS-uttryck vid %C är inte en härledd typ"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "%qs kan inte utökas vid %C för att den är BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qs kan inte utökas vid %C eftersom det är en SEQUENCE-typ"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Härledd typ vid %C kan endast vara PRIVATE i specifikationsdelen av en modul"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Härledd typ vid %C kan endast vara PUBLIC i specifikationsdelen av en modul"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "ABSTRACT typ vid %C"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Misslyckades att skapa en post av typen ”%s” vid %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Typdefinitionen av %qs vid %C definierades redan vid %L"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "Skräp efter MAP-sats vid %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Skräp efter UNION-sats vid %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%s vid %C är en DEC-utökning, aktivera den med %<-fdec-structure%>"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Postnamn förväntades i icke nästad postdeklaration vid %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Skräp efter icke nästad STRUCTURE-sats vid %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Postnamnet %qs vid %C får inte vara samma som en inbyggd typ"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr ":: förväntades i TYPE-definition vid %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "Manglad härledd typdefinition vid %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Typnamnet %qs vid %C kan inte vara samma som en inbyggd typ"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Härlett typnamn %qs vid %C har redan en grundtyp %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Härlett typnamn %qs vid %C har redan en grundtyp"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Attrappargumentet %qs vid %L får inte vara en härledd typ vid %C"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "Härledd typdefinition %qs vid %C har redan definierats"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Skräp efter PARAMETERIZED TYPE-deklaration vid %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Cray-utpekad vid %C kan inte vara förmodat formad vektor"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "ENUM och ENUMERATOR vid %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Uppräkningstypen överskrider C:s heltalstyp vid %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L är inte initierad med ett heltalsuttryck"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "ENUM-definitionssats förväntades före %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Syntaxfel i ENUMERATOR-definition vid %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Dubblerad åtkomstspecifikation vid %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Bindningsattribut anger redan passing, otillåten NOPASS vid %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Bindningsattribut anger redan passing, otillåten PASS vid %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Dubblerat POINTER-attribut vid %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Dubblerad NON_OVERRIDABLE vid %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "Dubblerad DEFERRED vid %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Åtkomstspecificerare förväntades vid %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Bindningsattribut förväntades vid %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE och DEFERRED kan inte båda finnas vid %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "POINTER-attribut krävs för procedurpekarkomponenten vid %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Gränssnittsnamn förväntades efter %<(%> vid %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "%<)%> förväntades vid %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Gränssnitt måste anges för DEFERRED bindning vid %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDURE(interface) vid %C skulle vara deklarerat DEFERRED"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Bindningsnamn förväntades vid %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "PROCEDURE-lista vid %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%<=> mål%> är ogiltigt för DEFERRED-bindning vid %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "%<::%> behövs i PROCEDURE-bindning med explicit mål vid %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Bindningsmål förväntades efter %<=>%> vid %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "Typen %qs som innehåller en DEFERRED-bindning vid %C är inte ABSTRACT"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Det finns redan en procedur med bindningsnamnet %qs för den härledda typen %qs vid %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "%<::%> förväntades vid %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Generiskt namn eller operatorbeskrivare förväntades vid %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Felformad GENERIC-sats vid %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "%<=>%> förväntades vid %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr "Åtkomstspecifikationen vid %L är inte i en modul"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr "Det generiska specifikationsnamnet %qs vid %C krockar med namnet på en enhet som deklareras vid %L som inte är en procedur"
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Det finns redan en icke-generisk procedur med namnet %qs vid %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "Åtkomstspecifikation vid %L står i konflikt med den som redan har angivits till %qs"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "Åtkomstspecifikation vid %L upprepar den som redan har angivits till %qs"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr "Den generiska specifikationen i den generiska satsen vid %C har en typ från deklarationen vid %L"
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "Användaroperatorn vid %L måste ha samma åtkomstspecifikation som den redan definierade användaroperatorn %qs"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr "Användaroperatorn vid %L upprepar åtkomstspecifikationen för en redan definierad användaroperator %qs"
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr "Ett specifikt procedurnamn förväntades vid %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr "Namnet %qs på den specifika proceduren vid %C står i konflikt med det för den generiska specifikationen"
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%qs är redan definierat som en specifik procedur för den generiska %qs vid %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "Skräp efter GENERIC-sats vid %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "GENERIC vid %C måste vara inuti en härledd typs CONTAINS"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Det finns redan en icke-generisk procedur med bindningsnamnet %qs för den härledda typen %qs vid %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "Bindning vid %C måste ha samma åtkomst som den redan definierade bindningen %qs"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Specifikt bindningsnamn förväntades vid %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%qs är redan definierat som en specifik bindning för den generiska %qs vid %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Skräp efter GENERIC-bindning vid %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "FINAL-deklaration vid %C måste vara inuti en härledd typs CONTAINS-sektion"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "Härledd typdeklaration med FINAL vid %C måste vara med i specifikationsdelen av en MODULE"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "Tom FINAL vid %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Modulprocedurnamn förväntades vid %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "%<,%> förväntades vid %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Okänt procedurnamn %qs vid %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "%qs vid %C är redan definierad som FINAL procedur"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Okänt attribut i !GCC$ ATTRIBUTES-sats vid %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Syntaxfel i !GCC$ ATTRIBUTES-sats vid %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr "Direktivet %<GCC unroll%> kräver en icke-negativ heltalskonstant mindre än eller lika med %u vid %C"
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Syntaxfel i direktivet !GCC$ UNROLL vid %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Syntaxfel i direktivet !GCC$ IVDEP vid %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Syntaxfel i direktivet !GCC$ VECTOR vid %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "Syntaxfel i direktivet !GCC$ NOVECTOR vid %C"
@@ -76788,408 +76943,408 @@ msgstr "RE-part_ref vid %C"
 msgid "IM part_ref at %C"
 msgstr "IM-part_ref vid %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "argument till elementär funktion vid %C följer inte standarden"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "Numeriska eller CHARACTER-operander krävs i uttrycket vid %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Konkateneringsoperatorn i uttrycket vid %L måste ha två CHARACTER-operander"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Konkateneringsoperatorn vid %L måste konkatenera strängar av samma sort"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ".NOT.-operatorn i uttrycket vid %L måste ha en LOGICAL-operand"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "LOGICAL-operander krävs i uttryck vid %L"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "Endast inbyggda operatorer kan användas i uttryck vid %L"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "Numeriska operander krävs i uttryck vid %L"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Ogiltigt initieringsuttryck för ALLOCATABLE-komponent %qs i postkonstrueraren vid %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Teckenlängdsvariabel %qs med antagen eller fördröjd längd i konstant uttryck vid %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "transformerande inbyggd %qs vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Beräkning av ett initieringsuttryck utanför standarden vid %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "Funktionen %qs i initieringsuttrycket vid %L måste vara en inbyggd funktion"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "Inbyggd funktion %qs vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "PARAMETER %qs används vid %L före dess definition är komplett"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "Vektor %qs med antagen storlek vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Vektor %qs med antagen form vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Vektor %qs med antagen form vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "Fördröjd vektor %qs vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Vektor %qs vid %L är en variabel, som inte reduceras till ett konstant uttryck"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "Vektor %qs med antagen ordning vid %L är inte tillåten i ett initieringsuttryck"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Parameter %qs vid %L har inte deklarerats eller är en variabel, som inte reduceras till ett konstant uttryck"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "check_init_expr(): Okänd uttryckstyp"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Specifikationsfunktionen %qs vid %L kan inte vara en satsfunktion"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Specifikationsfunktionen %qs vid %L kan inte vara en intern funktion"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Specifikationsfunktionen %qs vid %L måste vara PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Specifikationsfunktionen %qs vid %L får inte vara RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Attrappvariabeln %qs är inte tillåten i uttrycket vid %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Attrappargumentet %qs vid %L får inte vara OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Attrappargumentet %qs vid %L får inte vara INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Variabeln %qs kan inte förekomma i uttrycket vid %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "check_restricted(): Okänd uttryckstyp"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Uttryck vid %L måste vara av INTEGER-typ, hittade %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "Funktionen %qs vid %L måste vara PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Uttryck vid %L måste vara skalärt"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr "optype_msgid-spill: %d"
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Inkompatibla ordningar i %s (%d och %d) vid %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Olika form för %s vid %L på dimension %d (%d och %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "Typparametrar som inte stämmer %qs(%d/%d) %s vid %L/%L"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "Tilldelning till en LEN- eller KIND-part_ref vid %L tillåts inte"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs vid %L är inte ett VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Otillåten tilldelning till extern procedur vid %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Inkompatibla ordningar %d och %d i tilldelning vid %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Variabeltypen är OKÄND i tilldelning vid %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL finns på högersidan i tilldelning vid %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "POINTER-värd funktion förekommer på högersidan av tilldelning vid %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr "litteral BOZ-konstant nära %L kan inte tilldelas till en %qs-variabel"
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "Tilldelningen till en KIND- eller LEN-komponent i en parametriserad typ vid %L tillåts inte"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Inkompatibla typer i DATA-sats vid %L, försökte med konvertering av %s till %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Pekartilldelningsmålet är inte en POINTER vid %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "%qs i pekartilldelningen vid %L kan inte vara ett l-värde eftersom det är en procedur"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Begränsningsspecifikation för %qs förväntades vid %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Begränsningsspecifikation för %qs i pekartilldelning vid %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "Steg får inte finnas vid %L"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Ordningsommappning kräver en lista av specifikationer %<undre-gräns : övre-gräns%> vid %L"
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "En specifikation som lista av %<undre-gräns :%> eller lista av %<undre-gräns : övre-gräns%> förväntades vid %L"
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Pekarobjektet vid %L kan inte ha ett co-index"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Ogiltig procedurpekartilldelning vid %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Funktionsresultatet %qs är ogiltigt i proc-mål i procedurpekartilldelning vid %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Abstrakt gränssnitt %qs är ogiltigt i procedurpekartilldelning vid %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Satsfunktion %qs är ogiltigt i procedurpekartilldelning vid %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Intern procedur %qs är ogiltigt i procedurpekartilldelning vid %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Inbyggd %qs vid %L är ogiltigt i procedurpekartilldelning"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Den ej inbyggda elementära proceduren %qs är ogiltig i procedurpekartilldelning vid %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "Det stämmer inte i procedurpekartilldelningen vid %L: anropskonventionen stämmer inte"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Gränssnitten stämmer inte överens i procedurpekartilldelning vid %L: %qs är inte en subrutin"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Explicit gränssnitt krävs för komponenten %qs vid %L: %s"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Explicit gränssnitt krävs för %qs vid %L: %s"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Gränssnitten stämmer inte överens i procedurpekartilldelning vid %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr "Procedurpekarmålet %qs vid %L måste vara antingen en inbyggd, värd, värd- eller användningsassocierad, refererad eller ha attributet EXTERNAL"
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Pekartilldelningsmålet får inte vara en konstant vid %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr "Datapekarobjekt vid %L måste vara obegränsat polymorft, eller av en typ med attributet BIND eller SEQUENCE, för att vara kompatibel med ett obegränsat polymorft mål"
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Olika typer i pekartilldelning vid %L, försökte med tilldelning av %s till %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Olika sorters typparametrar i pekartilldelning vid %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Olika ordning i pekartilldelning vid %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "Målet för översättning av ordningen är mindre än storleken på pekaren (%ld < %ld) vid %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr "Målet med antagen ordning vid %L är en experimentell funktion i F202y. Använd flaggan -std=f202y för att aktivera"
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "Målet för översättning av målet måste ha ordning 1 eller vara enkelt sammanhängande vid %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Målet för översättning av ordning är inte av ordning 1 vid %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
-msgstr "Datamålet vid %L är ett objekt med antagen ordning så datapekarobjektet %s måste en gränsomavbildningslista (lista med nedregräns:övregräns för varje dimension)"
+msgstr "Datamålet vid %L är ett objekt med antagen ordning så datapekarobjektet %s måste ha en gränsomavbildningslista (lista med nedregräns:övregräns för varje dimension)"
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "Datamålet med antagen ordning vid %L måste vara sammanhängande"
@@ -77197,197 +77352,198 @@ msgstr "Datamålet med antagen ordning vid %L måste vara sammanhängande"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "Datamålet vid %L får inte ha co-index"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "Måluttryck i pekartilldelning vid %L måste leverera ett pekarresultat"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr "Nollstor vektor detekterad vid %L där en entitet med attributet TARGET förväntades"
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "Målet för pekartilldelningen i initieraruttrycket har inte attributet TARGET vid %L"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Varje index till målspecifikationen vid %L måste vara ett konstant uttryck"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr "Delsträngens start- och slutpunkter i målspecifikationen vid %L måste vara konstanta uttryck"
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Pekartilldelningsmål är vare sig TARGET eller POINTER vid %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Felaktigt mål i pekartilldelning i PURE-procedur vid %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Pekartilldelning med vektorindexering på högersidan vid %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Pekartilldelningsmålet har attributet PROTECTED vid %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr "Tilldelning till sammanhängande pekare från icke sammanhängande mål vid %L"
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "Pekare vid %L i pekartilldelning kan överleva pekarmålet"
 
-#: fortran/expr.cc:4987
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125348
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr "Komponenten %qs vid %L av ​​härledd typ %qs har parametriserade typ- eller vektorlängdsparametrar, vilket inte är kompatibelt med en standardinitierare"
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "Pekarinitieringsmål vid %L får inte vara ALLOCATABLE"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "Målet för pekarinitieringen vid %L måste ha attributet TARGET"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Pekarinitieringsmål vid %L måste ha attributet SAVE"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "Procedurpekarinitieringsmål vid %L får inte vara en procedurpekare"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Intern procedur %qs är ogiltigt i procedurpekarinitiering vid %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Attrapproceduren %qs är ogiltig i procedurpekarinitiering vid %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr "generate_isocbinding_initializer(): felaktig iso_c_binding-typ, %<c_ptr%> eller %<c_funptr%> förväntades"
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008: Pekarfunktioner i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Icke variabelt uttryck i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "Namngiven konstant %qs i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%qs i variabeldefinitionssammanhang (%s) vid %L är inte en variabel"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Icke-POINTER i pekarassociationssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "Typen är oåtkomlig i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "%qs-parameterfråga för %qs i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "Attrappargument %qs med INTENT(IN) i pekarassociationssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "Attrappargument %qs med INTENT(IN) i variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Variabeln %qs är PROTECTED och kan inte förekomma i ett pekarassociationssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "Variabeln %qs är PROTECTED och kan inte förekomma i ett variabeldefinitionssammanhang (%s) vid %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Variabeln %qs kan inte förekomma i ett variabeldefinitionssammanhang (%s) vid %L i en PURE-procedur"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "%qs vid %L som är associerad med vektorindexerat mål kan inte användas i ett variabeldefinitionssammanhang (%s)"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "%qs vid %L som är associerad med uttryck kan inte användas i ett variabeldefinitionssammanhang (%s)"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "%qs vid %L som är associerad med ett pekarfunktionsmål används i ett variabeldefinitionssammanhang (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Associationsnamn %qs kan inte förekomma i ett variabeldefinitionssammanhang (%s) vid %L eftersom dess mål vid %L inte heller kan"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "Element med samma värde vid %L och %L i vektorindex i ett variabeldefinitionssammanhang (%s)"
@@ -77408,7 +77564,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr "Otillåtet id i copy_walk_reduction_arg"
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -77469,42 +77625,42 @@ msgstr "Variabeln %qs vid %L satt till odefinierad inuti en slinga som börjar v
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "Variabeln %qs vid %L ej definierbar inuti slingan som börjar vid %L är argument INTENT(INOUT) till subrutin %qs"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "Vektorreferens vid %L är utanför gränsen (%ld < %ld) i slingan som börjar vid %L"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "Vektorreferens vid %L är utanför gränsen (%ld > %ld) i slingan som börjar vid %L"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "Variabeln %qs vid %L satt till odefinierad inuti slingan som börjar vid %L är argument INTENT(OUT) till funktionen %qs"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "Variabeln %qs vid %L ej definierbar inuti slingan som börjar vid %L är argument INTENT(INOUT) till funktionen %qs"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr "Kod för omallokering av den allokerbara vektorn vid %L kommer läggas till"
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr "Skalärisering med DIMEN_RANGE är oimplementerat"
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr "Utväxlande slingor vid %L"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "%s mellan %L och %L"
@@ -77629,12 +77785,12 @@ msgstr "Första argumentet till definierad tilldelning vid %L måste vara INTENT
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Andra argumentet av definierad tilldelning vid %L måste vara INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Första argumentet till operatorgränssnitt vid %L måste vara INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Andra argumentet till operatorgränssnitt vid %L måste vara INTENT(IN)"
@@ -77783,7 +77939,7 @@ msgstr "Det stämmer inte mellan en subrutin och funktion vid %L"
 #: fortran/interface.cc:2591
 #, gcc-internal-format
 msgid "Type mismatch at %L passing global function %qs declared at %L (%s/%s)"
-msgstr "Typen stämmer vid %L när den globala funktionen %qs skickas, som är deklarerad vid %L (%s/%s)"
+msgstr "Typen stämmer inte vid %L när den globala funktionen %qs skickas, som är deklarerad vid %L (%s/%s)"
 
 #: fortran/interface.cc:2644
 #, gcc-internal-format
@@ -77928,7 +78084,7 @@ msgstr "Oväntad alternativ returspecificerare i subrutinanrop vid %L"
 #: fortran/interface.cc:3499
 #, gcc-internal-format
 msgid "Intrinsic %<NULL()%> without %<MOLD%> argument at %L passed to assumed-rank dummy %qs"
-msgstr "Inbyggd %<NULL()%> utan argumentet %<MOLD%> vid %L skickad til attrappen %qs med antagen ordning"
+msgstr "Inbyggd %<NULL()%> utan argumentet %<MOLD%> vid %L skickad till attrappen %qs med antagen ordning"
 
 #: fortran/interface.cc:3512
 #, gcc-internal-format
@@ -78060,307 +78216,312 @@ msgstr "Aktuellt argument till %qs skall vara en ALLOCATABLE vid %L"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr "Aktuella argument till %qs vid %L är ett funktionsresultat och attrappargumentet är ALLOCATABLE"
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "Vektorsektion som aktuellt argument med vektorindex vid %L är inte kompatibelt med attributet INTENT(OUT), INTENT(INOUT), VOLATILE eller ASYNCHRONOUS på attrappargumentet %qs"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Aktuellt argument med antagen form vid %L är inte kompatibel med attrappargumentet %qs utan antagen form på grund av attributet VOLATILE"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Vektorsektion som aktuellt argument vid %L är inkompatibelt med attrappargumentet %qs utan antagen form på grund av attributet VOLATILE"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "Pekarvektor som aktuellt argument vid %L kräver ett attrappargument %qs med antagen form eller pekarvektor på grund av attributet VOLATILE"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "ISO_C_BINDING-finktionens aktuella argument vid %L kräver att attrappargumentet %qs har en matchande typ från ISO_C_BINDING"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Alternativ returspecifikation saknas i subrutinanrop vid %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Aktuellt argument saknas för argument %qs vid %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "compare_actual_expr(): Felaktig komponentkod"
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr "check_some_aliasing(): Listor stämmer inte"
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr "check_some_aliasing(): trasig data"
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Samma aktuella argument associerat med INTENT(%s)-argument %qs och INTENT(%s)-argument %qs vid %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr "check_intents(): Listor stämmer inte"
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Procedurargument vid %L är lokalt i en PURE-procedur och har attributet POINTER"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Co-indexerat aktuellt argument vid %L i en PURE-procedur skickas till ett INTENT(%s)-argument"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Co-indexerat aktuell argument vid %L i en PURE-procedur skickas till ett POINTER-attrappargument"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Co-indexerat polymorft aktuellt argument vid %L skickas ett polymorft attrappargument %qs"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Proceduren %qs anropad vid %L är inte explicit deklarerad; menade du %qs?"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Proceduren %qs anropad vid %L är inte explicit deklarerad"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Procedur %qs anropad med ett implicit gränssnitt vid %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Pekarobjektet %qs vid %L måste ha ett explicit funktionsgränssnitt eller deklareras som vektor"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Det allokerbara objektet %qs vid %L måste ha ett explicit funktionsgränssnitt eller deklareras som vektor"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Allokerbar funktion %qs vid %L måste ha ett explicit funktionsgränssnitt"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Explicit gränssnitt krävs för polymorft argument vid %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Nyckelordsargument kräver explicit gränssnitt för proceduren %qs vid %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Argumentet ”%s” med antagen typ vid %L kräver ett explicit gränssnitt"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Aktuellt argument till LOCK_TYPE eller med LOCK_TYPE-komponent vid %L kräver ett explicit gränssnitt för proceduren %qs"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Aktuellt argument till EVENT_TYPE eller med EVENT_TYPE-komponent vid %L kräver ett explicit gränssnitt för proceduren %qs"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "MOLD-argumentet till NULL krävs vid %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Att skicka ett inbyggt NULL som aktuellt argumentet vid %L kräver ett explicit gränssnitt"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Argumentet med antagen ordning kräver ett explicit gränssnitt vid %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Procedurpekarkomponent %qs anropad med ett implicit gränssnitt vid %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "Nyckelordsargument kräver explicit gränssnitt för procedurpekarkomponent %qs vid %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "MOLD= krävs i NULL()-argument vid %L: Tvetydighet mellan de specifika funktionerna %s och %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "Kan inte hitta symbolen %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Entiteten %qs vid %L finns redan i gränssnittet"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "gfc_add_interface(): Felaktig gränssnittstyp"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "Det går inte att skriva över GENERIC %qs vid %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%qs vid %L åsidosätter en procedurbindning deklarerad NON_OVERRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "%qs vid %L får inte vara DEFERRED eftersom det åsidosätter en ej DEFERRED bindning"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%qs vid %L åsidosätter en PURE-procedur och måste också vara PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%qs vid %L åsidosätter en ELEMENTAL-procedur och måste också vara ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%qs vid %L åsidosätter en icke-ELEMENTAL-procedur och får inte heller vara ELEMENTAL"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%qs vid %L åsidosätter en SUBROUTINE och måste också vara en SUBROUTINE"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%qs vid %L åsidosätter en FUNCTION och måste också vara en FUNCTION"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Resultaten stämmer inte överens för den åsidosättande proceduren %qs vid %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%qs vid %L åsidosätter en PUBLIC-procedur och får inte vara PRIVATE"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "Attrappargument %qs till %qs vid %L skulle ha namnet %qs för att stämma med motsvarande argument i den åsidosatta proceduren"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Argument stämmer inte överens för den åsidosättande proceduren %qs vid %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "%qs vid %L måste ha samma antal formella argument som den åsidosatta proceduren"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%qs vid %L åsidosätter en NOPASS-bindning och måste också vara NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%qs vid %L åsidosätter en bindning med PASS och måste också vara PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "Attrappargument för pass-objekt till %qs vid %L måste vara på samma position som attrappargumentet för pass-objektet i den åsidosatta proceduren"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "DTIO-attrappargument vid %L måste ha typen %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "DTIO-attrappargument vid %L måste ha KIND = %d"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "DTIO-attrappargument vid %L måste vara skalärt"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "DTIO-attrappargument vid %L måste vara en ASSUMED SHAPE ARRAY"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "DTIO-teckenargumentet vid %L måste ha antagen längd"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "DTIO-attrappargument vid %L måste ha INTENT %s"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "Alternativ retur vid %L är inte tillåtet i en DTIO-procedur"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "DTIO-proceduren %qs vid %L måste vara en subrutin"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "För få attrappargument i DTIO-proceduren %qs vid %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "För många attrappargument i DTIO-proceduren %qs vid %L"
@@ -78549,7 +78710,7 @@ msgstr "Konvertering från %s till %s vid %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "Kan inte konvertera %s till %s vid %L"
@@ -79095,7 +79256,7 @@ msgstr "NAMELIST %qs i READ-sats vid %L innehåller symbolen %qs som inte får s
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "NAMELIST-objekt %qs i namnlistan %qs vid %L är polymorf och behöver en definierad input/output-procedur"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "NAMELIST-objektet %qs i namnlistan %qs vid %L med ALLOCATABLE- eller POINTER-komponenter"
@@ -79266,12 +79427,12 @@ msgstr "identifierarspill: %d"
 msgid "check_charlen_present(): length not set"
 msgstr "check_charlen_present(): längden inte satt"
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr "GET_TEAM vid %L behöver USE av den inbyggda modulen ISO_FORTRAN_ENV för att definiera sin resultattyp TEAM_TYPE"
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr "ATTGÖRA: obegränsad polymorf MOLD i inbyggd TRANSFER vid %L"
@@ -79489,7 +79650,7 @@ msgstr "Ett associationsnamn förväntade vid %C"
 #: fortran/match.cc:2006
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad bounds remapping list at %C"
-msgstr "Felaktig litea på gränsavbildningar vid %C"
+msgstr "Felaktig lista på gränsavbildningar vid %C"
 
 #: fortran/match.cc:2012
 #, gcc-internal-format, gfc-internal-format
@@ -79529,7 +79690,7 @@ msgstr "Associationsmålet vid %L får inte vara en BOZ-litteralkonstant"
 #: fortran/match.cc:2131
 #, gcc-internal-format, gfc-internal-format
 msgid "The associate name %s with an assumed rank target at %L must have a bounds remapping list (list of lbound:ubound for each dimension)"
-msgstr "Det associerade namnet %s med ett mål med antagen ordning vid %L måste ha en lista för omavbildning av gränser (lista av nedtregräns:övregräns för varje dimension)"
+msgstr "Det associerade namnet %s med ett mål med antagen ordning vid %L måste ha en lista för omavbildning av gränser (lista av nedregräns:övregräns för varje dimension)"
 
 #: fortran/match.cc:2140
 #, gcc-internal-format, gfc-internal-format
@@ -79620,7 +79781,7 @@ msgstr "”,” eller ”)” förväntades i reduktionslistan vid %C"
 #: fortran/match.cc:3239
 #, gcc-internal-format, gfc-internal-format
 msgid "REDUCE locality spec at %L"
-msgstr "REDUCE-likalitestsspecifikation vid %L"
+msgstr "REDUCE-lokalitetsspecifikation vid %L"
 
 #: fortran/match.cc:3246
 #, gcc-internal-format, gfc-internal-format
@@ -79773,7 +79934,7 @@ msgstr "STOP-koden vid %L måste vara standard tecken-KIND=%d"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "STOP-kod vid %L måste vara standard heltal KIND=%d"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "QUIET-specificerare vid %L måste vara en skalär LOGICAL"
@@ -80239,7 +80400,7 @@ msgstr "EQUIVALENCE-sats vid %C"
 #: fortran/match.cc:6795
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of statement function argument at %L"
-msgstr "Ogiltig användning ett satsfunktionsargument vid %L"
+msgstr "Ogiltig användning av ett satsfunktionsargument vid %L"
 
 #: fortran/match.cc:6862
 #, gcc-internal-format, gfc-internal-format
@@ -80286,92 +80447,92 @@ msgstr "Blocknamnet %qs förväntades av SELECT-konstruktionen vid %C"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "SELECT TYPE vid %C får inte förekomma i denna räckvidd"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "parsningsfel i SELECT TYPE-sats vid %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "Väljare i SELECT TYPE vid %C är inte en namngiven variabel, använd associationsnamn =>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "SELECT RANK-sats vid %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr "Selektorn SELECT RANK vid %C måste vara en variabel med antagen ordning"
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "parsningsfel i SELECT RANK-sats vid %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Oväntad CASE-sats vid %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Syntaxfel i CASE-specifikation vid %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Oväntad TYPE IS-sats vid %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr "Typspecifikationen skall inte specificera en sekvens härledd typ eller en typ med attributet BIND i SELECT TYPE vid %C [F2003:C815]"
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr "Alla LEN-typparametrar i satsen TYPE IS vid %C måste vara ASSUMED"
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Syntaxfel i TYPE IS-specifikation vid %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Syntaxfel i CLASS IS-specifikation vid %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "Oväntad RANK-sats vid %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "SELECT RANK CASE-uttrycket vid %C måste vara en skalär heltalskonstant"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr "Värdet på SELECT RANK CASE-uttrycket vid %C får inte vara mindre än noll eller större än %d"
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "Syntaxfel i RANK-specifikation vid %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "ELSEWHERE-sats vid %C inte innesluten i WHERE-block"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "Etiketten %qs vid %C stämmer inte med WHERE-etikett %qs"
@@ -80435,7 +80596,7 @@ msgstr "gfc_code2string(): Felaktig kod"
 #: fortran/module.cc:245
 #, gcc-internal-format
 msgid "free_pi_tree(): Unresolved fixup"
-msgstr "free_pi_tree(): Ej upplöst upprättning"
+msgstr "free_pi_tree(): Ej uppslagen upprättning"
 
 #: fortran/module.cc:462
 #, gcc-internal-format
@@ -80780,7 +80941,7 @@ msgstr "%<omp_all_memory%> använt med en annan beroendetyp än OUT eller INOUT
 #: fortran/openmp.cc:820
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in OpenMP SINK dependence-type list at %C"
-msgstr "Syntaxfel i OpenMP DEPEND SINK beroendetyplista vid %C"
+msgstr "Syntaxfel i OpenMP SINK beroendetyplista vid %C"
 
 #: fortran/openmp.cc:883
 #, gcc-internal-format, gfc-internal-format
@@ -80840,7 +81001,7 @@ msgstr "Komma förväntades vid %C"
 #: fortran/openmp.cc:1500
 #, gcc-internal-format
 msgid "%<-%> operator at %C for reductions deprecated in OpenMP 5.2"
-msgstr "Operatorn %<-%> vid %C för reduktioner är föråldrade i OpenMP 5.2"
+msgstr "Operatorn %<-%> vid %C för reduktioner fasas ut i OpenMP 5.2"
 
 #: fortran/openmp.cc:1594
 #, gcc-internal-format, gfc-internal-format
@@ -80872,7 +81033,7 @@ msgstr "%<,%> eller %<)%> förväntades vid %C"
 #: fortran/openmp.cc:1722 fortran/openmp.cc:1732
 #, gcc-internal-format
 msgid "%qs directive mentioned multiple times in %s clause in %s directive at %L"
-msgstr "Direktivet %s nämnt flera gånger i en %s-klausul i ett %s-direktiv vid %L"
+msgstr "Direktivet %qs nämnt flera gånger i en %s-klausul i ett %s-direktiv vid %L"
 
 #: fortran/openmp.cc:1740
 #, gcc-internal-format
@@ -80907,12 +81068,12 @@ msgstr "%<{%> förväntades vid %C"
 #: fortran/openmp.cc:1964
 #, gcc-internal-format
 msgid "Duplicated %<fr%> preference-selector-name at %C"
-msgstr "Dubblerad %<fr%>-preferensväljarnamn vid %C"
+msgstr "Dubblerat %<fr%>-preferensväljarnamn vid %C"
 
 #: fortran/openmp.cc:1989 fortran/openmp.cc:2127
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant scalar integer expression or non-empty default-kind character literal at %L"
-msgstr "Ett konstant skalärt heltalsuttryck eller en icke-tom standardsorts teckenliteral vid %L"
+msgstr "Ett konstant skalärt heltalsuttryck eller en icke-tom standardsorts teckenlitteral vid %L"
 
 #: fortran/openmp.cc:2003 fortran/openmp.cc:2140
 #, gcc-internal-format
@@ -80922,7 +81083,7 @@ msgstr "Okänd främmande körtidsidentifierare %qd vid %L"
 #: fortran/openmp.cc:2017 fortran/openmp.cc:2152
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected null character in character literal at %L"
-msgstr "Oväntat null-tecken i teckenliteralen vid %L"
+msgstr "Oväntat null-tecken i teckenlitteralen vid %L"
 
 #: fortran/openmp.cc:2024 fortran/openmp.cc:2159
 #, gcc-internal-format
@@ -80937,17 +81098,17 @@ msgstr "%<)%> förväntades vid %C"
 #: fortran/openmp.cc:2047
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected default-kind character literal at %L"
-msgstr "En standardsorts teckenliteral förväntades vid %L"
+msgstr "En standardsorts teckenlitteral förväntades vid %L"
 
 #: fortran/openmp.cc:2058
 #, gcc-internal-format
 msgid "Character literal at %L must start with %<ompx_%>"
-msgstr "Teckenliteralen vid %L måste börja med %<ompx_%>"
+msgstr "Teckenlitteralen vid %L måste börja med %<ompx_%>"
 
 #: fortran/openmp.cc:2066
 #, gcc-internal-format
 msgid "Unexpected null or %<,%> character in character literal at %L"
-msgstr "Oväntat null eller %<,%>-tecken i teckenliteralen vid %L"
+msgstr "Oväntat null eller %<,%>-tecken i teckenlitteralen vid %L"
 
 #: fortran/openmp.cc:2083
 #, gcc-internal-format
@@ -81207,7 +81368,7 @@ msgstr "FATAL eller WARNING förväntades i SEVERITY-klausul vid %C"
 #: fortran/openmp.cc:4387
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> at %L deprecated since OpenMP 5.2, use %<enter%>"
-msgstr "Klauslen %<to%> med %<declare target%> vid %L är utfasat sedan OpenMP 5.2, använd %<enter%>"
+msgstr "Klausulen %<to%> med %<declare target%> vid %L är utfasat sedan OpenMP 5.2, använd %<enter%>"
 
 #: fortran/openmp.cc:4537
 #, gcc-internal-format, gfc-internal-format
@@ -81262,12 +81423,12 @@ msgstr "Endast formen !$ACC ROUTINE utan en lista är tillåten i gränssnittsbl
 #: fortran/openmp.cc:5002
 #, gcc-internal-format
 msgid "Invalid NAME %qs in !$ACC ROUTINE ( NAME ) at %C"
-msgstr "Felaktigt NAME %qs i !ACC$ ROUTINE ( NAME ) vid %C"
+msgstr "Felaktigt NAMN %qs i !ACC$ ROUTINE ( NAMN ) vid %C"
 
 #: fortran/openmp.cc:5010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C"
-msgstr "Syntaxfel i !ACC$ ROUTINE ( NAME ) vid %C"
+msgstr "Syntaxfel i !ACC$ ROUTINE ( NAMN ) vid %C"
 
 #: fortran/openmp.cc:5017
 #, gcc-internal-format
@@ -81354,7 +81515,7 @@ msgstr "DEPEND-klausulen vid %L av en OMP DEPOBJ-konstruktion skall inte ha bero
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr "DEPEND-klausulen vid %L av OMP DEPOBJ-konstruktionen skall bara ha en ensam lokaliserare"
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "MESSAGE-klausul vid %L kräver ett skalärt CHARACTER-uttryck med standardsort"
@@ -81389,12 +81550,12 @@ msgstr "Lista specificerad tillsammans med minnesordningsklausul i FLUSH-direkti
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Oväntat skräp efter $OMP FLUSH-sats vid %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr "Omdefinition av fördefinierad %s !$OMP DECLARE REDUCTION vid %L"
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr "Omdefinition av fördefinierad !$OMP DECLARE REDUCTION vid %L"
@@ -81472,7 +81633,7 @@ msgstr "Listobjektet %qs vid %L satt med NOHOST specificerat får inte förekomm
 #: fortran/openmp.cc:6333
 #, gcc-internal-format
 msgid "Common block %</%s/%> at %L not appear in the %qs clause as it was previously specified in a GROUPPRIVATE directive"
-msgstr "Common-blocket %</%s/%> vid %L förekommer inte i klausulen %qs eftersom det tidigare tidigare specificerades i ett direktiv GROUPPRIVATE"
+msgstr "Common-blocket %</%s/%> vid %L förekommer inte i klausulen %qs eftersom det tidigare specificerades i ett direktiv GROUPPRIVATE"
 
 #: fortran/openmp.cc:6340
 #, gcc-internal-format
@@ -81507,7 +81668,7 @@ msgstr "Common-blocket %</%s/%> vid %L satt med NOHOST specificerat får inte f
 #: fortran/openmp.cc:6417
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP DECLARE TARGET directive at %L with only DEVICE_TYPE or INDIRECT clauses is ignored"
-msgstr "Direktivet OMP DECLARE TARGET vid %L med endast DEVICE_TYPE- eller INDIRECTklausuler ignoreras"
+msgstr "Direktivet OMP DECLARE TARGET vid %L med endast DEVICE_TYPE- eller INDIRECT-klausuler ignoreras"
 
 #: fortran/openmp.cc:6428
 #, gcc-internal-format, gfc-internal-format
@@ -81544,7 +81705,7 @@ msgstr "selektorn %qs tar inte några egenskaper vid %C"
 #: fortran/openmp.cc:6558
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set at %C"
-msgstr "%<score%> kan inte anges bland egenskaper i %s trait-selector-set vid %C"
+msgstr "%<score%> kan inte anges bland egenskaper i %qs trait-selector-set vid %C"
 
 #: fortran/openmp.cc:6565 fortran/openmp.cc:6697 fortran/openmp.cc:6788
 #: fortran/openmp.cc:6879 fortran/openmp.cc:7074
@@ -81680,7 +81841,7 @@ msgstr "deklarativa direktivvarianter stödjs ej"
 #: fortran/openmp.cc:7228
 #, gcc-internal-format, gfc-internal-format
 msgid "variant directive used in OMP BEGIN METADIRECTIVE at %C must have a corresponding end directive"
-msgstr "variantdirektivet som används i OMP BEGIN METADIRECTIVE vid %C måste ha ett mostsvarande slutdirektiv"
+msgstr "variantdirektivet som används i OMP BEGIN METADIRECTIVE vid %C måste ha ett motsvarande slutdirektiv"
 
 #: fortran/openmp.cc:7262
 #, gcc-internal-format, gfc-internal-format
@@ -81868,7 +82029,7 @@ msgstr "Oväntat skräp efter NOWAIT-klausul vid %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "%s-klausul vid %L kräver ett skalärt INTEGER-uttryck"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "INTEGER-uttryck i %s-klausul vid %L måste vara positivt"
@@ -81888,7 +82049,7 @@ msgstr "Cray-pekarobjekt %qs av härledd typ i %s-klausul vid %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Cray-utpekat objekt %qs av härledd typ i %s-klausul vid %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "POINTER-objekt %qs av polymorf typ i %s-klausul vid %L"
@@ -81918,17 +82079,17 @@ msgstr "Vektor %qs med antagen storlek i %s-klausul vid %L"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "POINTER-objekt %qs i %s-fall vid %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Cray-pekarobjekt %qs i %s-klausul vid %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Cray-utpekadobjekt %qs i %s-klausul vid %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "ALLOCATABLE-objekt %qs i %s-klausul vid %L"
@@ -82048,8 +82209,8 @@ msgstr "ORDERED-klausulparameter är mindre än COLLAPSE vid %L"
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "en ORDER-klausul får inte användas tillsammans med ORDERED vid %L"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "IF-klausul vid %L kräver ett skalärt LOGICAL-uttryck"
@@ -82129,7 +82290,7 @@ msgstr "Objekt %qs är inte en variabel vid %L; parametrar kan inte och behöver
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr "Klausulen för objekt %qs vid %L ignoreras eftersom det är en parameter"
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "Objekt %qs är inte en variabel vid %L"
@@ -82152,7 +82313,7 @@ msgstr "en SCHEDULE-klausul angiven tillsammans med en %<inscan%> REDUCTION-klau
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "Symbolen %qs finns i flera fall vid %L"
@@ -82192,7 +82353,7 @@ msgstr "Symbolen %qs finns i både data- och avbildningsklausuler vid %L"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qs förekommer mer än en gång i %<allocate%> vid %L"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr "%qs angivet i en %<allocate%>-klausul vid %L men inte i en explicit privatiseringsklausul"
@@ -82210,7 +82371,7 @@ msgstr "Oväntad co-vektor %qs i %<allocate%> vid %L"
 #: fortran/openmp.cc:9561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> at %L but not in the associated ALLOCATE statement"
-msgstr "%qs angivet i en %<allocate%> vid %L men inte deN motsvarande ALLOCATE-satsen"
+msgstr "%qs angivet i en %<allocate%> vid %L men inte den motsvarande ALLOCATE-satsen"
 
 #: fortran/openmp.cc:9595
 #, gcc-internal-format
@@ -82230,7 +82391,7 @@ msgstr "Direktivet ALLOCATORS vid %L inuti en målregion måste ange en  ALLOCAT
 #: fortran/openmp.cc:9635
 #, gcc-internal-format
 msgid "ALLOCATE directive at %L inside a target region must specify an ALLOCATOR clause for %qs"
-msgstr "Direktivet ALLOCATE vid %L inuti en målregion moste ange en ALLOCATOR-klausul för %qs"
+msgstr "Direktivet ALLOCATE vid %L inuti en målregion måste ange en ALLOCATOR-klausul för %qs"
 
 #: fortran/openmp.cc:9639
 #, gcc-internal-format, gfc-internal-format
@@ -82320,7 +82481,7 @@ msgstr "Nollskilt intervallsteg förväntades vid %L"
 #: fortran/openmp.cc:9808
 #, gcc-internal-format, gfc-internal-format
 msgid "Dependence-type SINK used together with SOURCE on the same construct at %L"
-msgstr "Beroendetypen SINK använt tillsammans med SOURCE på samma konstruktion vid %L"
+msgstr "Beroendetypen SINK använd tillsammans med SOURCE på samma konstruktion vid %L"
 
 #: fortran/openmp.cc:9818
 #, gcc-internal-format, gfc-internal-format
@@ -82355,7 +82516,7 @@ msgstr "Argumentet %qs till klausulen MAP vid %L får inte vara en enhetslokal v
 #: fortran/openmp.cc:9910
 #, gcc-internal-format
 msgid "%qs clause argument must be ALLOCATABLE or a POINTER at %L"
-msgstr "Argumentet till klausulen %qs måster vara  ALLOCATABLE eller en POINTER vid %L"
+msgstr "Argumentet till klausulen %qs måste vara  ALLOCATABLE eller en POINTER vid %L"
 
 #: fortran/openmp.cc:9922
 #, gcc-internal-format, gfc-internal-format
@@ -82493,7 +82654,7 @@ msgstr "Ledsen, listposten %qs vid %L med allokerbara komponenter stödjs inte 
 #: fortran/openmp.cc:10338
 #, gcc-internal-format
 msgid "Polymorphic list item %qs at %L in %s clause has unspecified behavior and unsupported"
-msgstr "Det polymorfa listelementet %qs vid %L i klausulen %s har i odefinierat beteende och stödjs ej"
+msgstr "Det polymorfa listelementet %qs vid %L i klausulen %s har odefinierat beteende och stödjs ej"
 
 #: fortran/openmp.cc:10370
 #, gcc-internal-format, gfc-internal-format
@@ -82505,598 +82666,608 @@ msgstr "Endast DEFAULT tillåten som reduktionsmodifierare i REDUCTION-klausul v
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr "!$OMP DECLARE REDUCTION %s finns inte för typen %s vid %L"
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr "Ledsen, ALLOCATABLE-objektet %qs i klausulen LINEAR i en konstruktion för arbetsdelningsslinga vid %L stödjs inte ännu"
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr "Ledsen, vektorn %qs i klausulen LINEAR i en konstruktion för arbetsdelningsslinga vid %L stöjs inte ännu"
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr "LINEAR-klausulmodifierare använd på DO- eller SIMD-konstruktion vid %L"
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr "En annan LINEAR-klausulmodifierare än VAL använd på DO- eller SIMD-konstruktion vid %L"
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "LINEAR-variabel %qs måste vara INTEGER vid %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "LINEAR-attrappargument %qs med VALUE-attribut med %s-modifierare vid %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%qs i LINEAR-klausul vid %L kräver ett skalärt heltalsuttryck för linjärsteg"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%qs i LINEAR-klausul vid %L kräver ett konstant heltalsuttryck för linjärsteg eller ett attrappargument angivet i en UNIFORM-klausul"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "%s-klausulvariabeln %qs vid %L är varken en POINTER eller en vektor"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr "NUM_TEAMS lägre gräns vid %L är större den övre gränsen vid %L"
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "Värdet på HINT-klausulen vid %L skall vara ett giltigt konstant hint-uttryck"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "DIST_SCHEDULE-klausulens chunk_size vid %L kräver ett skalärt INTEGER-uttryck"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "en %<GRAINSIZE%>-klausul vid %L får inte användas tillsammans med en %<NUM_TASKS%>-klausul"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "en %<REDUCTION%>-klausul vid %L får inte användas tillsammans med en %<NOGROUP%>-klausul"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "en %<FULL%>-klausul vid %C får inte användas tillsammans med en %<PARTIAL%>-klausul"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Inkompatibel användning av TILE och COLLAPSE vid %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "TARGET DATA måste innehålla åtminstone en MAP-, USE_DEVICE_PTR ELLER USE_DEVICE_ADDR-klausul vid %L"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%s måste innehålla åtminstone en MAP-klausul vid %L"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "SIZES behöver ett konstant uttryck vid %L"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr "%qs vid %L skall vara en skalär av typen integer(kind=omp_event_handle_kind)"
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "Händelsehandtaget vid %L får inte vara ett vektorelement"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "Händelsehandtaget vid %L får inte vara del av en härledd typ eller klass"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "en %<DETACH%>-klausul vid %L får inte användas tillsammans med en %<MERGEABLE%>-klausul"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr "Konstruktionen %<host_data%> vid %L kräver en %<use_device%>-klausul"
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr "IF förväntades vid %L i atomic compare capture"
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr "ELSE förväntades vid %L i atomic compare capture"
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr "%<==%>, %<.EQ.%> eller %<.EQV.%> förväntades i atomärt jämförelseuttryck vid %L"
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr "En skalär inbyggd variabel förväntades vid %L i atomär jämförelse"
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Ett skalärt inbyggt uttryck förväntades vid %L i atomär jämförelse"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC-sats måste sätta en skalär variabel av inbyggd typ vid %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "!$OMP ATOMIC-sats måste tilldela ett uttryck av inbyggd typ vid %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "!$OMP ATOMIC med ALLOCATABLE variabel vid %L"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC READ-sats måste läsa från en skalär variabel av inbyggd typ vid %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "uttr i !$OMP ATOMIC WRITE-tilldelning var = uttr måste vara skalär och får inte referera var vid %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC-fångstsats måste sätta en skalär variabel av inbyggd typ vid %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC-fångstsats behöver en skalär variabel av inbyggd typ vid %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "!$OMP ATOMIC CAPTURE-fångstsats läser från en annan variabel än uppdateringssatsen skriver till vid %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "För !$OMP ATOMIC COMPARE måste den första operanden i jämförelsen vid %L vara variabeln %qs som uppdateringssatsen skriver till vid %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "uttr i !$OMP ATOMIC COMPARE-tilldelning var = uttr måste vara skalär och får inte referera var vid %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr "!$OMP ATOMIC UPDATE vid %L med en FAIL-klausul behöver antingen klausulen COMPARE eller användning av den inbyggda proceduren MIN/MAX"
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "!$OMP ATOMIC-tilldelningsoperator måste vara binärt +, *, -, /, .AND., .OR., .EQV. eller .NEQV. vid %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "!$OMP ATOMIC-tilldelning måste vara var = var op uttr eller var = uttr op var vid %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP ATOMIC var = var op expr är inte matematiskt ekvivalent med var = var op (uttr) vid %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "uttr i !$OMP ATOMIC-tilldelning var = var op uttr måste vara skalär och får inte referera var vid %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "!$OMP ATOMIC-tilldelning av inbyggd IAND, IOR eller IEOR måste ha två argument vid %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "!$OMP ATOMIC-tilldelning av inbyggd måste vara MIN, MAX, IAND, IOR eller IEOR vid %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "!$OMP ATOMIC-inbyggds argument utom ett får inte referera %qs vid %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "!$OMP ATOMIC-inbyggds argument måste vara skalära vid %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Första eller sista !$OMP ATOMIC-inbyggds argument måste vara %qs vid %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "!$OMP ATOMIC-tilldelning måste ha en operator eller inbyggd på högersidan vid %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "oväntat !$OMP ATOMIC-uttryck vid %L"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr "Med INSCAN vid %L, slingkropp med !$OMP SCAN förväntades mellan två strukturerade blocksekvenser"
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr "!$OMP SCAN vid %L med noll körbara satser i föregående strukturerade blocksekvens"
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr "!$OMP SCAN vid %L med noll körbara satser i efterföljande strukturerade blocksekvens"
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr "%s kan inte innehålla en slinga i mellanliggande kod vid %L"
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr "%s kan inte innehålla OpenMP-API-anrop i mellanliggande kod vid %L"
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr "%s kan inte innehålla OpenMP-direktiv i mellanliggande kod vid %L"
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr "en klausul SIZES krävs på konstruktionen !$OMP TILE vid %L"
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%s får inte vara en DO WHILE eller DO utan slingstyrning vid %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr "%s kan inte vara en DO CONCURRENT-slinga vid %L"
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr "Den genererade slingan av konstruktionen UNROLL vid %L utan en klausul PARTIAL har inte kanonisk form"
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr "Konstruktionen UNROLL vid %L med en klausul PARTIAL genererar bara en slinga med kanonisk form men %d slingor behövs"
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr "Konstruktionen TILE vid %L genererar %d slingor med kanonisk form men %d slingor behövs"
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr "Imperfekt nästad slinga vid användning av genererade slingor"
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "%s-iterationsvariabel måste ha typen heltal vid %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "%s-iterationsvariabel får inte vara THREADPRIVATE vid %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "%s-iterationsvariabel finns i en annan klausul än PRIVATE, LASTPRIVATE eller ALLOCATE vid %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "%s-iterationsvariabel finns i en annan klausul än PRIVATE, LASTPRIVATE, ALLOCATE eller LINEAR vid %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "%s-iterationsvariabel använd i mer än en slinga vid %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "iterationsvariabeln %s vid %L binds i mellanliggande kod"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr "%s-slingans startuttryck är inte i kanonisk form vid %L"
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr "%s-slingans startuttryck vid %L använder en variabel bunden i mellanliggande kod"
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "%s-slingans slututtryck är inte i kanonisk form vid %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr "%s-slingans slututtryck vid %L använder variabel begränsning i mellanliggande kod"
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "%s-slingegränser refererar en annan iterationsvariabel vid %L"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr "%s-slingeinkrementet är inte i kanonisk form vid %L"
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr "%s-slingans ökningsuttryck vid %L använder variabel begränsning i mellanliggande kod"
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr "Ickerektangulära slingor från genererade slingor stödjs inte"
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "för få DO-slingor för kollapsad %s (nivå %d) vid %L"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "%s inre slingor måste vara perfekt nästade med klausulen ORDERED vid %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr "%s intre slingor måste vara perfekt nästade med en REDUCTION INSCAN-klausul vid %L"
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "%s inre slingor måste vara perfekt nästade vid %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "argument till %<score%> måste vara ett konstant heltalsuttryck vid %L"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "argumentet till %<score%> måste vara ickenegativt vid %L"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "egenskapen måste vara ett logiskt uttryck vid %L"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "egenskapen måste vara ett heltalsuttryck vid %L"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "egenskapen måste vara ett konstant logiskt uttryck vid %L"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "egenskapen måste vara ett konstant heltalsuttryck vid %L"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr "egenskapen måste vara ett konformt enhetsnummer vid %L"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr "Direktivet %s kan inte anges inuti en %s-region vid %L"
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$ACC LOOP får inte vara en DO WHILE eller DO utan slingstyrning vid %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "!$ACC LOOP kan inte vara en DO CONCURRENT-slinga vid %L"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "!$ACC LOOP-iterationsvariabel måste ha typen heltal vid %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "!$ACC LOOP %s-slingor formar inte en rektangulär iterationsrymd vid %L"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "%s !$ACC LOOP-slingor är inte perfekt nästade vid %L"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "för få DO-slingor för %s !$ACC LOOP vid %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr "Slinga uppdelad i bitar kan inte parallelliseras över gang, worker och vektorer på samma gång vid %L"
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "TILE behöver ett konstant uttryck vid %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "Objektet %qs vid %L ignoreras eftersom parametrar inte behöver kopieras"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "Vektorsektioner: %qs är inte tillåtet i !$ACC DECLARE vid %L"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "NAME %qs refererar inte till en subrutin eller funktion i !ACC$ ROUTINE ( NAME ) vid %L"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "NAME %qs är felaktigt i !ACC$ ROUTINE ( NAME ) vid %L"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "!$OMP TARGET-regionen vid %L med en nästad TEAMS vid %L får inte innehålla någon annan sats, deklaration eller direktiv utanför den ensamma TEAMS-konstruktionen"
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "!$OMP TARGET-regionen vid %L med en nästad TEAMS får inte innehålla någon annan sats, deklaration eller direktiv utanför den ensamma TEAMS-konstruktionen"
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
-msgstr "Direktivet %<OMP DISPATCH%> vid %L måste följas av ett proceduranrop me möjlig tilldelning"
+msgstr "Direktivet %<OMP DISPATCH%> vid %L måste följas av ett proceduranrop med möjlig tilldelning"
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr "Direktivet %<OMP DISPATCH%> vid %L kan inte följas av en procedurpekare"
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr "OMP TARGET UPDATE vid %L behöver åtminstone en TO- eller FROM-klausul"
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr "OMP CRITICAL vid %L med HINT-klausul kräver ett NAME, utom när omp_sync_hint_none används"
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr "Oväntat !$OMP SCAN vid %L utanför slingkonstruktion med %<inscan%> REDUCTION-klausul"
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr "!$OMP DECLARE SIMD skall referera till den inneslutande proceduren %qs vid %L"
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "Ett konstant icke-negativt skalärt heltalsavståndsuttryck förväntades vid %L"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr "För intervallbaserat %<adjust_args%> krävs ett konstant positivt skalärt heltalsuttryck vid %L"
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
-msgstr "Ett attrapparameternamn eller ettt positivt heltal förväntades vid %L"
+msgstr "Ett attrapparameternamn eller ett positivt heltal förväntades vid %L"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "En annan variabel än OMP_PRIV eller OMP_ORIG använd i INITIALIZER-klausul i !$OMP DECLARE REDUCTION vid %L"
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "En annan variabel än OMP_OUT eller OMP_IN använd i kombineraren i !$OMP DECLARE REDUCTION vid %L"
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr "Felaktig operator för !$OMP DECLARE REDUCTION %s vid %L"
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr "CHARACTER-längden i !$OMP DECLARE REDUCTION %s är inte konstant vid %L"
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Subrutinanrop med alternativa returer i kombinerare i !$OMP DECLARE REDUCTION vid %L"
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Subrutinanrop med alternativa returer i INITIALIZER-klausul i !$OMP DECLARE REDUCTION vid %L"
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr "Ett av de aktuella subrutinargumenten i INITIALIZER-klausulen i !$OMP DECLARE REDUCTION måste vara OMP_PRIV vid %L"
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr "INITIALIZER-klausul saknas i !$OMP DECLARE REDUCTION av härledd typ utan standardinitierare vid %L"
@@ -83234,7 +83405,7 @@ msgstr "direktivet %qs vid %L måste antingen ha ett variabelt argument eller, o
 #: fortran/parse.cc:843
 #, gcc-internal-format
 msgid "Structure-component expression at %L in %qs directive not permitted in declarative directive; as directive associated with an ALLOCATE stmt it must be preceded by an executable statement or OpenMP construct"
-msgstr "Strukturkomponentuttrycket vid %L i %qs-direktivet är inte tillåtet i ett deklarativt direktiv; som ett diretiv associerat med en ALLOCATE-sats måste det föregås av en körbar sats eller OpenMP-konstruktion"
+msgstr "Strukturkomponentuttrycket vid %L i %qs-direktivet är inte tillåtet i ett deklarativt direktiv; som ett direktiv associerat med en ALLOCATE-sats måste det föregås av en körbar sats eller OpenMP-konstruktion"
 
 #: fortran/parse.cc:869
 #, gcc-internal-format
@@ -83244,7 +83415,7 @@ msgstr "direktivet %qs vid %L associerat med en ALLOCATE-sats måste föregås a
 #: fortran/parse.cc:1059 fortran/parse.cc:1373
 #, gcc-internal-format, gfc-internal-format
 msgid "OpenMP directive at %C is not pure and thus may not appear in a PURE procedure"
-msgstr "OpenMP-direktivet vid %C är inte rent och får därför inte förekomma i en PURE-procedurer"
+msgstr "OpenMP-direktivet vid %C är inte rent och får därför inte förekomma i en PURE-procedur"
 
 #: fortran/parse.cc:1340
 #, gcc-internal-format, gfc-internal-format
@@ -83474,12 +83645,12 @@ msgstr "Härledd typdefinition vid %C utan komponenter"
 #: fortran/parse.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C must precede structure components"
-msgstr "PRIVATE-sats vid %C måste föregå strukturkomponenter"
+msgstr "PRIVATE-sats vid %C måste föregå postkomponenter"
 
 #: fortran/parse.cc:4044
 #, gcc-internal-format, gfc-internal-format
 msgid "SEQUENCE statement at %C must precede structure components"
-msgstr "SEQUENCE-sats vid %C måste föregå strukturkomponenter"
+msgstr "SEQUENCE-sats vid %C måste föregå postkomponenter"
 
 #: fortran/parse.cc:4050
 #, gcc-internal-format, gfc-internal-format
@@ -83759,62 +83930,62 @@ msgstr "Direktivet %<GCC vector%> ligger inte i början av en slinga vid %C"
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr "Direktivet %<GCC novector%> ligger inte i början av en slinga vid %C"
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Innesluten procedur %qs vid %C är redan tvetydig"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Oväntad %s-sats i CONTAINS-sektion vid %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "CONTAINS-sats utan FUNCTION- eller SUBROUTINE-sats vid %L"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "%s-satsen vid %C får inte förekomma efter körbara satser"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "CONTAINS-sats vid %C är redan i en innesluten programenhet"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Globalt bindningsnamn %qs vid %L används redan som en %s vid %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Globalt namn %qs vid %L används redan som en %s vid %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Globalt bindningsnamn %qs vid %L används redan vid %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Globalt namn %qs vid %L används redan vid %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "Blank BLOCK DATA vid %C står i konflikt med tidigare BLOCK DATA vid %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Oväntad %s-sats i BLOCK DATA vid %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Oväntad %s-sats i MODULE vid %C"
@@ -83822,7 +83993,7 @@ msgstr "Oväntad %s-sats i MODULE vid %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Två huvud-PROGRAM vid %L och %C"
@@ -84279,1080 +84450,1080 @@ msgstr "PARAMETER %qs skall inte förekomma i en DATA-sats vid %C"
 msgid "%qs at %C is not a variable"
 msgstr "%qs vid %C är inte en variabel"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs vid %L har den ABSTRACT:a typen %qs"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "ABSTRACT typ %qs används vid %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "Gränssnitt %qs vid %L, är deklarerat i en senare PROCEDURE-sats"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "Gränssnitt %qs vid %L kan inte vara generiskt"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Gränssnitt %qs vid %L kan inte vara en satsfunktion"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Den inbyggda proceduren %qs är inte tillåten i PROCEDURE-sats vid %L"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "Gränssnitt %qs vid %L måste vara explicit"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROCEDURE %qs vid %L får inte användas som sitt eget gränssnitt"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Alternativ returspecificerare i elementär subrutin %qs vid %L är inte tillåten"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Alternativ returspecificerare i funktionen %qs vid %L är inte tillåten"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Det självrefererande argumentet %qs vid %L är inte tillåtet"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Attrapprocedur %qs av PURE-procedur vid %L måste också vara PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Argumentet %qs till pure-funktion %qs vid %L med attributet VALUE men utan INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "Argumentet %qs till pure-funktion %qs vid %L måste vara INTENT(IN) eller VALUE"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Argument %qs till pure-subrutin %qs vid %L med attributet VALUE men utan INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Argumentet %qs till pure-subrutin %qs vid %L måste ha sitt INTENT angivet eller ha attributet VALUE"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "INTENT(OUT)-argumentet %qs till den rena proceduren %qs vid %L får inte vara polymorf"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Co-vektorattrappargument %qs vid %L till elementär i proceduren"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "%qs-argumentet till elementär procedur vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Argumentet %qs av elementär procedur vid %L får inte ha attributet ALLOCATABLE"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Argumentet %qs av elementär procedur vid %L får inte ha attributet POINTER"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "Attrapprocedur %qs är inte tillåten i elementär procedur %qs vid %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Argumentet %qs till elementär subrutin %qs vid %L måste ha sitt INTENT angivet eller ha attributet VALUE"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Argument %qs till satsfunktionen %qs vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Teckenvärt argument %qs till satsfunktion vid %L måste ha konstant längd"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Innesluten procedur %qs vid %L har samma namn som sin omgivande procedur"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Innesluten funktion %qs vid %L har ingen IMPLICIT-typ"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Resultatet %qs av innesluten funktion %qs vid %L har ingen IMPLICIT-typ"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Teckenvärd modulprocedur %qs vid %L får inte ha antagen längd"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Teckenvärd intern funktion %qs vid %L får inte ha antagen längd"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Funktion %s vid %L har ingångar med vektorspecifikationer som ej stämmer överens"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "Funktion %s vid %L har ingången %s med egenskaper som inte stämmer"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "Funktionen ”%s” vid %L med ingångar som returnerar variabler av olika stränglängder"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "FUNCTION-resultat %s får inte vara en vektor i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "ENTRY-resultat %s får inte vara en vektor i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "FUNCTION-resultat %s får inte vara en POINTER i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "ENTRY-resultat %s får inte vara en POINTER i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "FUNCTION-resultat %s får inte vara ALLOCATABLE i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "ENTRY-resultat %s får inte vara ALLOCATABLE i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "FUNCTION-resultat %s får inte vara av typen %s i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "ENTRY-resultat %s får inte vara av typen %s i FUNCTION %s vid %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Den globala entiteten %qs vid %L får inte förekomma i ett COMMON-block vid %L"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Den globala entiteten %qs vid %L får inte förekomma i ett COMMON-block"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr "COMMON-block vid %L"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "Variabel %qs vid %L är i COMMON men endast i BLOCK DATA är initiering tillåten"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "Initierad variabel %qs vid %L är i en blank COMMON men initiering ir endast tillåten i namngivna common-block"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "%qs vid %L kan inte förekomma i COMMON [F2008:C5100]"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Det automatiska objektet %qs vid %L får inte förekomma i COMMON vid %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "Härledd typvariabel %qs i COMMON vid %L har varken attributet SEQUENCE eller BIND(C)"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "Härledd typvariabel %qs i COMMON vid %L har en slutlig komponent som är allokerbar"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "Härledd typvariabel %qs i COMMON vid %L får inte ha standardinitierare"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr "I Fortran 2003 är COMMON %qs-block vid %L en global identifierare och måste således ha samma bindningsnamn som COMMON-blocket med samma namn vid %L: %s resp %s"
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "COMMON-block %qs vid %L använder samma globala identifierare som en entitet vid %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "Fortran 2008: COMMON-block %qs med bindningsetikett vid %L delar identifierare med en global ej-COMMON-blockentitet vid %L"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "COMMON-block vid %L med bindningsetikett %qs använder samma globala identifierare som entiteten vid %L"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "COMMON-block %qs vid %L används som PARAMETER vid %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "COMMON-blocket %qs vid %L får inte ha attributet EXTERNAL"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "COMMON-block %qs vid %L är också en inbyggd procedur"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "COMMON-block %qs vid %L som också är ett funktionsresultat"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "COMMON-block %qs vid %L som också är en global procedur"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr "KIND-parametern %qs i PDT-konstrueraren vid %C har inget värde"
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Ordningen på elementet i postkonstrueraren vid %L stämmer inte överens med komponentens (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Elementet i postkonstrueraren vid %L, för pekarkomponent %qs, är %s men borde vara %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Olika teckenlängder (%wd/%wd) för pekarkomponenten %qs i konstrueraren vid %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "NULL i postkonstrueraren vid %L används på komponenten %qs, som varken är en POINTER eller en ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Gränssnittet stämmer inte för procedurpekarkomponenten %qs i postkonstruerare vid %L: %s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Felaktig vektorspecifikation av komponenten %qs refererad i postkonstruerare vid %L"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Formen på komponenten %qs i postkonstrueraren vid %L skiljer från formen på den deklarerade komponenten för dimension %d (%ld/%ld)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Elementet i postkonstrueraren vid %L, för pekarkomponent %qs, borde vara en POINTER eller en TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Pekartilldelningsmålet vid %L har en vektorindexering"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Ogiltigt uttryck i postkonstrueraren för pekarkomponent %qs vid %L i PURE-procedur"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Den övre gränsen i sista dimensionen måste vara med i referensen till vektorn %qs med antagen storlek vid %L"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%qs vid %L är tvetydig"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "GENERIC procedur %qs är inte tillåten som aktuellt argument vid %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Typ angiven för inbyggd funktion %qs vid %L ignoreras"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Inbyggd subrutin %qs vid %L får inte ha en typspecificerare"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "%qs deklarerad INTRINSIC vid %L finns inte"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "Den inbyggda %qs deklarerad INTRINSIC vid %L är inte tillgänglig i den aktuella standardinställningen utan i %s.  Använd en lämplig flagga %<-std=*%> eller aktivera %<-fall-intrinsics%> för att använda den."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Icke RECURSIVE procedur %qs från modulen %qs anropar kanske sig själv rekursivt i proceduren %qs. Deklarera den RECURSIVE eller använd %<-frecursive%>"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Icke RECURSIVE procedur %qs vid %L anropar kanske sig själv rekursivt.  Deklarera den RECURSIVE eller använd %<-frecursive%>"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Etikett %d som refereras vid %L är aldrig definierad"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Den härledda typen %qs används som aktuellt argument vid %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Satsfunktionen %qs vid %L får inte vara ett aktuellt argument"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Inbyggd %qs vid %L får inte vara ett aktuellt argument"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Den interna proceduren %qs används som aktuellt argument vid %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL icke INTRINSIC procedur %qs är inte tillåten som aktuellt argument vid %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Det går inte att hitta en angiven INTRINSIC-procedur för referensen %qs vid %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Symbolen %qs vid %L är tvetydig"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Värdesargument vid %L har inte en numerisk typ"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "Värdeargument vid %L får inte vara en vektor eller vektorsektion"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Värdesargument vid %L är inte tillåtet i denna kontext"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Att skicka intern procedur som plats vid %L är inte tillåtet"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL icke INTRINSIC procedur %qs är inte tillåten som aktuellt argument vid %L"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Co-indexerat aktuellt argument vid %L med slutlig pekarkomponent"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "Proceduren %qs vid %L använd som aktuellt argument men har varken ett explicit gränssnitt eller attributet EXTERNAL"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "%qs vid %L är en vektor och OPTIONAL.  Om den inte finns, då kan den inte vara det aktuella argumentet i en ELEMENTAL-procedur om det inte finns ett ej valfritt argument med samma ordning (Fortran 2018, 15.5.2.12)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "Aktuellt argument vid %L för INTENT(%s)-attrapp %qs av ELEMENTAL-subrutin %qs är en skalär, men ett annat aktuellt argument är en vektor"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Returtypen stämmer inte för funktionen %qs vid %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Gränssnitt stämmer inte överens i den globala proceduren %qs vid %L: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
-msgstr "Det finns ingen specifik funktionen för den generiska %qs vid %L"
+msgstr "Det finns ingen specifik funktion för den generiska %qs vid %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Generisk funktion %qs vid %L är inte konsistent med ett specifikt inbyggt gränssnitt"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Funktionen %qs vid %L är INTRINSIC men är inte kompatibel med en inbyggd"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Kan inte slå upp den specifika funktionen %qs vid %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr "Saknad explicit deklaration med attributet EXTERNAL för symbolen %qs vid %L"
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Funktionen %qs vid %L har ingen IMPLICIT-typ; menade du %qs?"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Funktionen %qs vid %L har ingen IMPLICIT-typ"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "Referens till en oren funktion vid %L inuti ett DO CONCURRENT"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "Referens till den orena funktionen %qs vid %L är inuti ett FORALL-%s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "Referens till den orena funktionen %qs vid %L är inuti ett DO CONCURRENT-%s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Referens till den orena funktionen %qs vid %L inuti en PURE-procedur"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "Oväntat skräp efter %qs vid %L"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs vid %L är inte en funktion"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ABSTRACT INTERFACE %qs får inte refereras vid %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr "ABSTRACT INTERFACE %qs vid %L får inte ha ett antaget teckenlängdsresultat (F2008: C418)"
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "Funktionen %qs är deklarerad CHARACTER(*) och får inte användas vid %L eftersom det inte är ett attrappargument"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
-msgstr "Olika argumentlistor i den externa atrappfunktionen %s vid %L och %L"
+msgstr "Olika argumentlistor i den externa attrappfunktionen %s vid %L och %L"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "resolve_function(): felaktig funktionstyp"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr "En litteral BOZ-konstant vid %L får inte förekomma som ett faktiskt argument i en funktionsreferens"
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "Användardefinierad ej ELEMENTAL funktion %qs vid %L är inte tillåten i WORKSHARE-konstruktion"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "ENTRY %qs vid %L får inte anropas rekursivt, eftersom funktionen %qs inte är RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Funktion %qs vid %L får inte anropas rekursivt, eftersom den inte är RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "Att använda funktionen %qs vid %L bör undvikas"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "Attrapproceduren %qs vid %L kräver ett attribut EXTERNAL"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Subrutinanrop vid %L i ett block DO CONCURRENT är inte PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Subrutinanrop till %qs i FORALL-block vid %L är inte PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Subrutinanrop till %qs i DO CONCURRENT-block vid %L är inte PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Subrutinanrop till %qs vid %L är inte PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Det finns ingen specifik subrutinen för den generiska %qs vid %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Generisk subrutin %qs vid %L är inte konsistent med ett inbyggt subrutingränssnitt"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Subrutin %qs vid %L är INTRINSIC men är inte kompatibel med en inbyggd"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Kan inte slå upp den specifika subrutinen %qs vid %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr "F2018: C8102 %qs vid %L är värdassocierat men förekommer inte i en lista IMPORT eller IMPORT, ONLY"
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
-msgstr "F2018: C8102 %qs vid %L är värdassocierat i en räckvidd so har IMPORT, NONE"
+msgstr "F2018: C8102 %qs vid %L är värdassocierat i en räckvidd som har IMPORT, NONE"
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "%qs vid %L har en typ som inte är konsistent med CALL vid %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "ENTRY %qs vid %L är får inte anropas rekursivt, eftersom subrutinen %qs inte är RECURSIVE"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "SUBROUTINE %qs vid %L får inte anropas rekursivt, eftersom den inte är RECURSIVE"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr "Olika argumentlistor i den externa attrappsubrutinen %s vid %L och %L"
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "resolve_subroutine(): felaktig funktionstyp"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "Att använda subrutinen %qs vid %L bör undvikas"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Formerna för operanderna vid %L och %L är inte konforma"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "logical_to_bitwise(): Felaktig inbyggd"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Den orena funktionen %qs vid %L beräknas eventuellt inte"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "Den orena funktionen vid %L beräknas eventuellt inte"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "BOZ-litteralkonstanten vid %L får inte vara en operand till den unära operatorn %qs"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "Negation av ett teckenlöst uttryck vid %L är inte tillåtet "
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr "Operander vid %L och %L kan inte förekomma som operander av den binära operatorn %qs"
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Ogiltigt sammanhang för NULL()-pekare vid %L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, gcc-internal-format
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Operand till unär numerisk operator %qs vid %L är %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, gcc-internal-format
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Operander till binär numerisk operator %qs vid %L är %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Inkonsistenta ordningar för operator vid %L och %L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "Oväntade entiteter av härledd typ i binär inbyggd numerisk operator %qs vid %L"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Operanderna till strängkonkateneringsoperatorn vid %L är %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, gcc-internal-format
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Operanderna till logiska operatorn %qs vid %L är %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Operand till operatorn .not. vid %L är %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "COMPLEX-kvantiteter kan inte jämföras vid %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "BOZ-litteralkonstanten nära %L får inte förekomma som en operand till en relationsoperator"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Inkonsistenta typer för operatorn vid %L och %L: %s och %s"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr "Likhetsjämförelse av %s vid %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr "Olikhetsjämförelse av %s vid %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, gcc-internal-format, gfc-internal-format
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Logiska vid %L måste jämföras med %s istället för %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, gcc-internal-format
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Operanderna till jämförelseoperatorn %qs vid %L är %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "Okänd operator %qs vid %L; menade du %qs?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "Okänd operator %qs vid %L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, gcc-internal-format
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Operanderna till användaroperatorn %qs vid %L är %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, gcc-internal-format
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Operanderna till användaroperatorn %qs vid %L är %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "resolve_operator(): Felaktig inbyggd"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Villkoret i villkorsuttrycket måste vara en skalär logisk vid %L"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "uttrycket vid %L och uttrycket vid %L i villkorsuttrycket måste ha samma deklarerade typ"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "uttrycket vid %L och uttrycket vid %L i villkorsuttrycket måste ha samma sortparameter"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "uttrycket vid %L och uttrycket vid %L i villkorsuttrycket måste ha samma ordning"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
-msgstr "Ledsen, endast heltal, logiska, reella complexa och teckentyper stödjs för närvarande för villkorliga uttryck vid %L"
+msgstr "Ledsen, endast heltal, logiska, reella, komplexa och teckentyper stödjs för närvarande för villkorliga uttryck vid %L"
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr "Ledsen, vektorer stödjs inte för närvarande för villkorsuttryck vid %L"
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Vektorreferens vid %L är utanför gränsen (%ld < %ld) i dimension %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Vektorreferens vid %L är utanför gränsen (%ld < %ld) i co-dimension %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Vektorreferens vid %L är utanför gränsen (%ld > %ld) i dimension %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Vektorreferens vid %L är utanför gränsen (%ld > %ld) i co-dimension %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Otillåtet steg på noll vid %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Undre vektorreferens vid %L är utanför gränsen (%ld < %ld) i dimension %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Undre vektorreferens vid %L är utanför gränsen (%ld > %ld) i dimension %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Övre vektorreferens vid %L är utanför gränsen (%ld < %ld) i dimension %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Övre vektorreferens vid %L är utanför gränsen (%ld > %ld) i dimension %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "check_dimension(): Felaktig vektorreferens"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Högraste övre gränsen av en sektion av vektor med antagen storlek inte angiven vid %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Ordning stämmer inte i vektorreferens vid %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Co-indexordning stämmer inte i vektorreferens vid %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Co-index i co-dimension %d måste vara en skalär vid %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Vektorindex vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Vektorindex vid %L måste ha INTEGER-typ, fann %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "REAL-vektorindex vid %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Dim-argumentet vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Dim-argumentet vid %L måste ha INTEGER-typ"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Felaktig vektorreferens till en icke-vektorentitet vid %L"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr "find_array_spec(): oanvänd as(1)"
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr "find_array_spec(): oanvänd as(2)"
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Vektorindex vid %L är en vektor med ordning %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Argumentet till TEAM_NUMBER vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Argumentet till TEAM_NUMBER vid %L måste vara av INTEGER-typ, hittade %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be scalar"
 msgstr "Argumentet till TEAM vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr "Argumentet till TEAM vid %L måste vara av TEAM_TYPE från den inbyggda modulen ISO_FORTRAN_ENV, hittade %s"
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be scalar"
 msgstr "Argumentet till STAT vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Argumentet till STAT vid %L måste vara av INTEGER-typ, hittade %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT's expression at %L must be a variable"
 msgstr "STATs uttryck vid %L måste vara en variabel"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Startindex för delsträng vid %L måste typen INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Startindex för delsträng vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "Slutindex för delsträng vid %L måste ha typen INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "Slutsträng för delsträng vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "Slutindex för delsträng vid %L är för stort"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "resolve_ref(): Felaktig vektorreferens"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Komponent till den högra av en delreferens med ordning skild från noll får inte ha attributet POINTER vid %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Komponent till den högra av en delreferens med ordning skild från noll får inte ha attributet ALLOCATABLE vid %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Två eller flera delreferenser med ordning skild från noll får inte anges vid %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr "gfc_expression_rank(): Två vektorspecifikationer"
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "Otillåtet co-vektorindex"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK får bara användas som ett aktuellt argument"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "Variabeln %s med antagen typ vid %L får bara användas som ett aktuellt argument"
@@ -85361,12 +85532,12 @@ msgstr "Variabeln %s med antagen typ vid %L får bara användas som ett aktuellt
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Variabel med antagen typ %s vid %L som aktuellt argument till en frågefunktion skall vara det första argumentet"
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "Variabeln %s med antagen ordning vid %L kan bara användas som ett aktuellt argument"
@@ -85375,413 +85546,413 @@ msgstr "Variabeln %s med antagen ordning vid %L kan bara användas som ett aktue
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Variabel med antagen ordning %s vid %L som aktuellt argument till en frågefunktion skall vara det första argumentet"
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK skall inte ha en subobjektreferens"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "Variabeln %s med antagen typ vid %L skall inte ha en subobjektreferens"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "Variabeln %s med antagen ordning vid %L skall inte ha en subobjektreferens"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "Den skalära variabeln %qs har en vektorreferens vid %L"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "Variabel %qs, använd i ett specifikationsuttryck, refereras vid %L före ENTRY-satsen i vilken den är en parameter"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "Variabel %qs används vid %L före ENTRY-satsen i vilken den är en parameter"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Polymorft subobjekt till co-indexerat objekt vid %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Co-indexerat objekt med polymorf allokerbar delkomponent vid %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "Att använda variabeln %qs vid %L bör undvikas"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "Felaktig vektorreferens vid %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr "%qs vid %L är värdassocierad vid %L in i en innesluten procedur med en intern procedur med samma namn"
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "Fel i typbundet anrop vid %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Skickat objekt vid %L måste vara skalär"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "Basobjekt för procedurpekarkomponentanrop vid %L är av ABSTRACT typ %qs"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "Basobjekt för typbundet proceduranrop vid %L är av ABSTRACT typ %qs"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Basobjekt för typbundet NOPASS-proceduranrop vid %L måste vara skalärt"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "Hittade ingen matchande specifik bindning för anropet till GENERIC %qs vid %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%qs vid %L skulle vara en SUBROUTINE"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs vid %L skulle vara en FUNCTION"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "gfc_resolve_expr(): Felaktig uttryckstyp"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s vid %L måste vara en skalär"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s vid %L måste vara ett heltal"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s vid %L måste vara INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "Steguttryck i DO-slinga vid %L får inte vara noll"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "DO-slinga vid %L kommer köras noll gånger"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr "DO-slingan vid %L är odefinierad eftersom den spiller över"
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr "DO-slingan vid %L är odefinierad eftersom den spiller under"
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
-msgstr "Variabeln %qs refererad i samtidighetshuvud (concurrent-header) vid %L får inte förekomma i en lokalitesspecifikation LOCAL vid %L"
+msgstr "Variabeln %qs refererad i samtidighetshuvud (concurrent-header) vid %L får inte förekomma i en lokalitetsspecifikation LOCAL vid %L"
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr "Variabeln %qs vid %L inte angiven i en lokalitetsspecifikation av DO CONCURRENT vid %L men behövs på grund av DEFAULT (NONE)"
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Variabelnamn förväntades i %s lokalitetsspecifikation vid %L"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Variabeln %qs vid %L har redan angivits i en lokalitetsspecifikation"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "Indexvariabeln %qs vid %L kan inte anges i en lokalitetsspecifikation"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "Attributet OPTIONAL är inte tillåtet för %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "En vektor med antagen storlek är inte tillåten till %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "Attributet ALLOCATABLE är inte tillåtet till %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr "Polymorft attrappargument som inte är en pekare är inte tillåtet för %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "En co-vektor är inte tillåten till %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr "en finalize:bar typ är inte tillåten för %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
-msgstr "Typen med en ytterst allokerbar komponent är inte är inte tillåten till %qs i lokalitetsspecifikationen %s vid %L"
+msgstr "Typen med en ytterst allokerbar komponent är inte inte tillåten till %qs i lokalitetsspecifikationen %s vid %L"
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr "Attributet ASYNCHRONOUS är inte tillåtet för %qs i lokalitetsspecifikationen REDUCE vid %L"
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr "Attributet VOLATILE är inte tillåtet för %qs i lokalitetsspecifikationen REDUCE vid %L"
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "En numerisk typ förväntades till %qs i REDUCE vid %L, fick %s"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
-msgstr "En logiskt typ förväntades till %qs i REDUCE vid %L, fick %s"
+msgstr "En logisk typ förväntades till %qs i REDUCE vid %L, fick %s"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr "En INTEGER, REAL eller CHARACTER typ förväntades för %qs i REDUCE med MIN/MAX vid %L, fick %s"
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr "En heltalstyp förväntades för %qs i REDUCE med IAND/IOR/IEOR vid %L, fick %s"
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "Variabeln %qs i lokalitetsspecifikationen vid %L används inte"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "FORALL-indexnamn vid %L måste vara en skalär INTEGER"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "FORALL-slututtryck vid %L måste vara en skalär INTEGER"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "FORALL-slututtryck vid %L måste vara en skalär INTEGER"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "FORALL-steguttryck vid %L måste vara en skalär %s"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "FORALL-steguttryck vid %L får inte vara noll"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "FORALL-index %qs får inte förekomma i triplettspecifikation vid %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Allokeringsobjekt vid %L måste vara ALLOCATABLE eller en POINTER"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Co-indexerat allokerbart objekt vid %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "Allokeringsobjekt vid %L har ordningen %d men uttrycket MOLD= vid %L har ordningen %d"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "Källuttryck vid %L måste vara skalärt eller ha samma ordning som allokeringsobjektet vid %L"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "Källuttryck vid %L och allokeringsobjekt vid %L måste ha samma form"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "Den inbyggda NULL kan inte användas som källuttryck vid %L"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "Typen på entiteten vid %L är typinkompatibel med källuttrycket vid %L"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "Allokeringsobjektet vid %L och källuttrycket vid %L skall ha samma sorts typparameter"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "Källuttrycket vid %L skall varken vara av typen LOCK_TYPE eller ha en LOCK_TYPE-komponent om det allokerbara objektet vid %L är en co-vektor"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "Källuttrycket vid %L skall varken vara av typen EVENT_TYPE eller ha en EVENT_TYPE-komponent om det allokerbara objektet vid %L är en co-vektor"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "Allokering %s av ABSTRACT bastyp vid %L behöver en typspecifikation eller source-uttryck"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
-msgstr "Typparametern i satsen ALLOCATE med typspecifikationen skall vara en asterisk eftersom allokeringsobjektet %qs vid %L är ett attrappargumentparameter med antagen typ"
+msgstr "Typparametern i satsen ALLOCATE med typspecifikationen skall vara en asterisk eftersom allokeringsobjektet %qs vid %L är ett attrappargument med antagen typparameter"
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "Allokerar %s vid %L med typspecifikation kräver samma teckenlängdsparameter som i deklarationen"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "Vektorspecifikation krävs i ALLOCATE-sats vid %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "Vektorspecifikation eller vektorvärt SOURCE=-uttryck krävs i ALLOCATE-sats vid %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Co-vektorspecifikation krävs i ALLOCATE-sats vid %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Felaktig co-vektorspecifikation i ALLOCATE-sats vid %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr "Övre cobound är mindre än den lägre cobound vid %L"
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr "Övre cobound är mindre än lägre cobound av 1 vid %L"
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Felaktig vektorspecifikation i ALLOCATE-sats vid %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "%qs får inte förekomma i vektorspecifikationen vid %L i samma ALLOCATE-sats där den själv allokeras"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "%<*%> förväntades i co-indexspecifikation i ALLOCATE-sats vid %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "Statvariabel vid %L måste vara en INTEGER-variabel"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Statvariabel vid %L skall inte %s:as i samma %s-sats"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "ERRMSG vid %L är oanvändbart utan en STAT-tagg"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "ERRMSG-variabeln vid %L måste vara en skalär standard-CHARACTER-variabel"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "Errmsg-variabel vid %L skall inte %s:as i samma %s-sats"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "Allokeringsobjekt vid %L förekommer också vid %L"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "Allokeringsobjekt vid %L är underobjekt till objekt vid %L"
@@ -85790,314 +85961,314 @@ msgstr "Allokeringsobjekt vid %L är underobjekt till objekt vid %L"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "CASE-etikett vid %L överlappar med CASE-etikett vid %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "uttryck i CASE-sats vid %L måste vara av typ %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Uttryck i CASE-sats vid %L måste ha sort %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Uttryck i CASE-sats vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Valuttryck i beräknad-GOTO-sats vid %L måste vara ett skalärt heltalsuttryck"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Argument till SELECT-sats vid %L kan inte vara %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Argumentet till SELECT-satsen vid %L måste vara ett skalärt uttryck"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Uttryck i CASE-sats vid %L ligger inte i intervallet %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "DEFAULT CASE vid %L får inte följas av ett andra DEFAULT CASE vid %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Logiskt intervall CASE-sats vid %L är inte tillåtet"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "Konstant logiskt värde i CASE-sats upprepas vid %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Intervallspecifikationen vid %L kan aldrig matchas"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Logiskt SELECT CASE-block vid %L har mer än två fall"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
-msgstr "%s kunde inte slås upp till en specifik funktionen vid %L"
+msgstr "%s kunde inte slås upp till en specifik funktion vid %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr "(F202y)Saknad eller ogiltig gräns i ordningsomavbildning ASSOCIATE av associerat namn %s vid %L"
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "Den associerande entiteten %qs vid %L är en procedurpekare"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Den härledda typen %qs får inte användas som en variabel vid %L"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "Den associerande entiteten %qs vid %L är ett procedurnamn"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr "Det associerande selector-uttrycket vid %L ger en procedur"
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "Selektorn vid %L får inte vara NULL()"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "Selektorn vid %L har ingen typ"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Associationsnamn %qs vid %L används som en vektor"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr "CLASS-väljare vid %L behöver en temporär som inte är implementerad ännu"
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Selektorer skall vara polymorfiska i SELECT TYPE-sats vid %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "Selektorn vid %L får inte vara co-indexerad"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "TYPE IS vid %L överlappar med TYPE IS vid %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Härledd typ %qs vid %L måste vara utökningsbar"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Härledd typ %qs vid %L måste vara en utökning av %qs"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Oväntad inbyggd typ %qs vid %L"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "Typspecifikationen vid %L skall ange att varje längdtypparameter är antagen"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Dubbelt CLASS IS-block i SELECT TYPE-sats vid %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr "RANK DEFAULT vid %L upprepas vid %L"
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr "RANK (*) vid %L upprepas vid %L"
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr "RANK (%i) vid %L upprepas vid %L"
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr "RANK (*) vid %L får inte användas med en pekare eller allokerbar selector vid %L"
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Ogiltigt sammanhang för inbyggd NULL () vid %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "DTIO %s-procedur vid %L måste vara rekursiv"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "Dataöverföringselementet vid %L kan inte vara polymorft om det inte behandlas av en definierad input/output-procedur"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "Dataöverföringselementet vid %L kan inte ha POINTER-komponenter om det inte behandlas av en definierad input/output-procedur"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "Dataöverföringselement vid %L får inte ha procedurpekarkomponenter"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "Dataöverföringselementet vid %L kan inte ha ALLOCATABLE-komponenter om det inte behandlas av en definierad input/output-procedur"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "Dataöverföringselement vid %L får inte ha PRIVATE-komponenter"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "Dataöverföringselementet vid %L kan inte ha PRIVATE-komponenter om det inte behandlas av en definierad input/output-procedur"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Dataöverföringselement vid %L får inte vara en full referens till en vektor med antagen storlek"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "Låsvariabel vid %L måste vara en skalär av typen LOCK_TYPE"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "Händelsevariabeln vid %L måste vara en skalär av typen EVENT_TYPE"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "Händelsevariabelargumentet vid %L måste vara en co-vektor eller co-indexerat"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "Händelsevariabelargumentet vid %L måste vara en co-vektor men inte co-indexerat"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "STAT=-argumentet vid %L måste vara en skalär INTEGER-variabel"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "ERRMSG=-variabeln vid %L måste vara en skalär CHARACTER-variabel"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "ACQUIRED_LOCK=-argumentet vid %L måste vara en skalär LOGICAL-variabel"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "UNTIL_COUNT=-argumentet vid %L måste vara ett skalärt INTEGER-uttryck"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr "Argumentet till TEAM vid %L måste vara ett skalärt uttryck av typen TEAM_TYPE från den inbyggda modulen ISO_FORTRAN_ENV"
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "%s-argumentet vid %L måste vara en skalär %s-variabel av åtminstone sort %d"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Argumentet %s vid %L måste vara en skalär %s av åtminstone sort %d"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Bildmängdsargument vid %L måste vara ett skalärt eller INTEGER-uttryck av ordning 1"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Bildmängdsargument vid %L måste vara mellan 1 och num_images()"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Sats vid %L är inte en giltig grenmålssats för grensatsen vid %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Gren vid %L kan orsaka en oändlig slinga"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "GOTO-sats vid %L lämnar CRITICAL-konstruktion för etikett vid %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "GOTO-sats vid %L lämnar DO CONCURRENT-konstruktion för etikett vid %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "GOTO-sats vid %L lämnar CHANGE TEAM-konstruktion för etikett vid %L"
@@ -86105,212 +86276,212 @@ msgstr "GOTO-sats vid %L lämnar CHANGE TEAM-konstruktion för etikett vid %L"
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Etiketten vid %L är inte i samma block som GOTO-satsen vid %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "WHERE-mask vid %L har inkonsistent form"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "WHERE-tilldelningsmål vid %L har inkonsistent form"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Ej ELEMENTAL användardefinierad tilldelning i WHERE vid %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Ej stödd sats inuti WHERE vid %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Tilldelning till en FORALL-indexvariabel vid %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "FORALL med index %qs används inte på vänster sida av en tilldelning vid %L och kan därför orsaka multipla tilldelningar till detta objekt"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "FORALL-konstruktion vid %L"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "FORALL-indexnamn vid %L måste vara en skalär variabel av heltalstyp"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "En yttre FORALL-konstruktion har redan ett index med detta namn %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, gcc-internal-format
 msgid "Expected shadow variable name to start with _"
 msgstr "Skuggvariabelnamn förväntades börja med _"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "WHERE/ELSEWHERE-klausul vid %L kräver en LOGICAL-vektor"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "gfc_resolve_blocks(): Felaktig blocktyp"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "Variabeln i den ordinära tilldelningen vid %L är en procedurpekarkomponent"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot assign %s to %s at %L"
 msgstr "Kan inte tilldela %s till %s vid %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "CHARACTER-uttryck kommer att huggas av i tilldelning (%wd/%wd) vid %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Co-indexerat uttryck vid %L är tilldelat till en härledd typvariabel med en POINTER-komponent i en PURE-procedur"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr "I ett rent underprogram skall inte ett INTENT(IN) attrappargument användas som uttrycket vid %L av en inbyggd tilldelningssats i vilken variabeln är av an härledd typ om den härledda typen har en pekarkomponent på någon nivå av komponentvalet."
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Tilldelning till en co-indexerad variabel vid %L i en PURE-procedur"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "Tilldelning till en polymorf co-vektor vid %L är inte tillåtet"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Tilldelning till en allokerbar polymorf variabel vid %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "Tilldelning till en allokerbar polymorf variabel vid %L kräver %<-frealloc-lhs%>"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "Ej allokerbar variabel får inte vara polymorf i inbyggd tilldelning vid %L - kontrollera att det finns en matchande specifik subrutin för operatorn %<=%>"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "Co-indexerad variabel får inte ha en allokerbar yttersta komponent i tilldelningen vid %L"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr "ATT GÖRA: typbegränsad definierad tilldelning vid %L inte gjord för att multipla delvektorreferenser skulle uppträda i intermediära uttryck."
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "Procedurpekartilldelning vid %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "Funktionsresultatet på vänstersidan av tilldelningen vid %L måste ha attributet pointer."
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "ASSIGNED GOTO-sats vid %L kräver en skalär INTEGER-variabel"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Variabeln %qs har inte tilldelats någon måletikett vid %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Alternativ RETURN-sats vid %L kräver en SCALAR-INTEGER-returspecificerare"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Inbyggd tilldelning förväntades i OMP WORKSHARE vid %L"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "ASSIGN-sats vid %L kräver en skalär standard-INTEGER-variabel"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "Ogiltig NULL vid %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Aritmetisk IF-sats vid %L kräver ett skalärt REAL- eller INTEGER-uttryck"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "gfc_resolve_code(): Inget uttryck i DO WHILE"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Avslutsvillkor i DO WHILE-slinga vid %L måste vara ett skalärt LOGICAL-uttryck"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "FORALL-maskklausul vid %L kräver ett skalärt LOGICAL-uttryck"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_resolve_code(): Felaktig satskod"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Att använda parametern %qs deklarerad vid %L bör undvikas"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Variabeln %qs med bindningsetiketten %qs vid %L använder samma globala identifierare som en entitet vid %L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "Variabeln %qs från modulen %qs med bindningsetikett %qs vid %L använder samma globala identifierare som entiteten vid %L från modulen %qs"
@@ -86318,1056 +86489,1056 @@ msgstr "Variabeln %qs från modulen %qs med bindningsetikett %qs vid %L använde
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Proceduren %qs med bindningsetiketten %qs vid %L använder samma globala identifierare som entiteten vid %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "Stränglängden vid %L är för stor"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Den allokerbara vektorn %qs vid %L måste ha en fördröjd form eller antagen ordning"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Skalärt objekt %qs vid %L får inte vara ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Vektorpekaren %qs vid %L måste ha en fördröjd form eller antagen ordning"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Vektor %qs vid %L kan inte ha en fördröjd form"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "Typen %qs på CLASS-variabeln %qs vid %L är inte utvidgningsbar"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "CLASS-variabel %qs vid %L måste vara en attrapp, allokerbar eller pekare"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Typen %qs kan inte vara värdassocierad vid %L för att den blockeras av ett inkompatibelt objekt med samma namn deklarerat vid %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Implicerad SAVE för modulvariabeln %qs vid %L, behövs på grund av standardinitieringar"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Enheten %qs vid %L har en fördröjd typparameter och kräver antingen attributet POINTER eller ALLOCATABLE"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "Det automatiska objektet %qs vid %L får inte ha attributet SAVE"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Modul- eller huvudprogramvektorn %qs vid %L måste ha konstant form"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "Entitet med antagen teckenlängd vid %L måste vara ett attrappargument eller en PARAMETER"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "%qs vid %L måste ha konstant teckenlängd i detta sammanhang"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "COMMON-variabeln %qs vid %L måste ha konstant teckenlängd"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Allokerbar %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Extern %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Attrapp-%qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Inbyggd %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Funktionsresultat %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Automatisk vektor %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s vid %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Teckenvärd satsfunktion %qs vid %L måste ha konstant längd"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "%qs är av en PRIVATE-typ och kan inte vara ett attrappargument till %qs, som är PUBLIC vid %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Proceduren %qs i PUBLIC-gränssnittet %qs vid %L tar attrappargument för %qs som är PRIVATE"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Funktion %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Externt objekt %qs vid %L kan inte ha en initierare"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "ELEMENTAL-funktion %qs vid %L måste ha ett skalärt resultat"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "Satsfunktionen %qs vid %L får inte ha attributet pointer eller allocatable"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*)-funktion %qs vid %L kan inte ha vektorvärde"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "CHARACTER(*)-funktion %qs vid %L kan inte ha pekarvärde"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*)-funktion %qs vid %L kan inte vara pure"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "CHARACTER(*)-funktion %qs vid %L kan inte vara rekursiv"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "CHARACTER(*)-funktionen %qs vid %L"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "Procedurpekaren %qs vid %L skall inte vara elementär"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Attrapprocedur %qs vid %L skall inte vara elementär"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "Funktionens resultatvariabel %qs vid %L för den elementära funktionen %qs skall inte ha ett attribut ALLOCATABLE eller POINTER"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr "Resultatvariabeln %qs i den rena funktionen vid %L är polymorft allokerbar"
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Resultatvariabeln %qs i den rena funktionen vid %L har en polymorft allokerbar komponent %qs"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "PROCEDURE-attribut i konflikt med SAVE-attribut i %qs vid %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "PROCEDURE-attribut i konflikt med INTENT-attribut i %qs vid %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "PROCEDURE-attribut i konflikt med RESULT-attribut i %qs vid %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "EXTERNAL-attribut i konflikt med FUNCTION-attribut i %qs vid %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "Procedurpekarresultat %qs vid %L saknar pekarattributet"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "ELEMENTAL-attribut stämmer inte mellan MODULE PROCEDURE vid %L och dess gränssnitt i %s"
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "PURE-attribut stämmer inte mellan MODULE PROCEDURE vid %L och dess gränssnitt i %s"
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "RECURSIVE-attribut stämmer inte mellan MODULE PROCEDURE vid %L och dess gränssnitt i %s"
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr "%s mellan MODULE PROCEDURE-deklarationen i MODULE %qs och deklarationen vid %L i (SUB)MODULE %qs"
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Gränssnittet för %qs vid %L måste vara explicit"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "FINAL-procedur %qs vid %L är inte en SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "FINAL-procedur vid %L måste ha precis ett argument"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Argument till FINAL-procedur vid %L måste ha typen %qs"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr "FINAL-procedur vid %L med argument med antagen ordning måste vara den enda avslutaren med samma sort/typ (F2018: C790)"
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "Argument till FINAL-procedur vid %L får inte vara en POINTER"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "Argument till FINAL-procedur vid %L får inte vara ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "Argument till FINAL-procedur vid %L får inte vara OPTIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "Argument till FINAL-procedur vid %L får inte vara INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Ickeskalär FINAL-procedur vid %L skulle ha argument med antagen form"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "FINAL-procedur %qs deklarerad vid %L har samma ordning (%d) som %qs"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Endast vektor-FINAL-procedurer deklarerade för den härledda typen %qs definierade vid %L, föreslår även en skalär om inte en avslutare med antagen ordning har deklarerats"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "%qs och %qs kan inte blandad FUNCTION/SUBROUTINE för GENERIC %qs vid %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "%qs och %qs för GENERIC %qs vid %L är tvetydiga"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "Odefinierad specifik bindning %qs som mål för GENERIC %qs vid %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "GENERIC %qs vid %L måste ha som mål en specifik bindning, %qs är också GENERIC"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "GENERIC %qs vid %L kan inte åsidosätta en specifik bindning med samma namn"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Typbindningsoperator vid %L kan inte vara NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "%qs måste vara en modulprocedur eller en extern procedur med ett explicit gränssnitt vid %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Proceduren %qs med PASS(%s) vid %L har inget argument %qs"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Procedur %qs med PASS vid %L måste ha åtminstone ett argument"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Ickepolymorfa attrappargument för pass-objekt till %qs vid %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Argument %qs till %qs med PASS(%s) vid %L måste ha den härledda typen %qs"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Argument %qs till %qs med PASS(%s) vid %L måste ha den parametriskt härledda typen %qs"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr "Alla parametrar av typen LEN i det skickade attrappargumentet %qs till %qs vid %L måste vara ASSUMED"
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Skickat objekt-attrappargument till %qs vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Skickat objekt-attrappargument till %qs vid %L får inte vara ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Skickat objekt-attrappargument till %qs vid %L får inte vara POINTER"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Procedur %qs vid %L har samma namn som en komponent i %qs"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Proceduren %qs vid %L har samma namn som den ärvd komponent i %qs"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "Härledd typ %qs deklarerad vid %L måste vara ABSTRACT för att %qs är DEFERRED och inte åsidosatt"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Co-vektorkomponent %qs vid %L måste vara allokerbar med fördröjd form"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Komponenten %qs vid %L av TYPE(C_PTR) eller TYPE(C_FUNPTR) får inte vara en co-vektor"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "Komponenten %qs vid %L med co-vektorkomponent skall skalär som inte är en pekare eller allokerbar"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "Component %qs vid %L har attributet CONTIGUOUS men är inte en vektorpekare"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Komponenten %qs med typen BIND(C) vid %L måste ha längden ett"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Procedurpekarkomponent %qs med PASS(%s) vid %L har inget argument %qs"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Procedurpekarkomponent %qs med PASS vid %L måste ha åtminstone ett argument"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Argument %qs till %qs med PASS(%s) vid %L måste ha den härledda typen %qs"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Argument %qs till %qs med PASS(%s) vid %L måste vara skalärt"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Argumentet %qs till %qs med PASS(%s) vid %L får inte ha attributet POINTER"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "Argumentet %qs till %qs med PASS(%s) vid %L får inte vara ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Komponent %qs i %qs vid %L har samma namn som en ärvd typbunden procedur"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Teckenlängd på komponent %qs behöver vara ett konstant specifikationsuttryck vid %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Teckenlängdsuttrycket för komponenten %qs vid %L måste vara av typen INTEGER, hittade %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "Teckenkomponent %qs av %qs vid %L med fördröjd längd måste vara en POINTER eller ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "komponenten %qs är en PRIVATE-typ och kan inte vara en komponent i %qs, som är PUBLIC vid %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Polymorf komponent %s vid %L i SEQUENCE- eller BIND(C)-typ %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Komponent %s av SEQUENCE-typ deklarerad vid %L har inte attributet SEQUENCE"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Initierare som står i konflikt i unionen vid %L och %L"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "Eftersom utvidgningen av %qs vid %L har en co-vektorkomponent, skall föräldratypen %qs också ha en"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Ej utvidgningsbar härledd typ %qs vid %L får inte vara ABSTRACT"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr "Den parametriserade typen %qs har inte någon komponent som motsvarar parametern %qs vid %L"
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Det generiska namnet %qs på funktionen %qs vid %L är samma namn som den härledda typen vid %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Härledd typ %qs vid %L har inte deklarerats"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr "Misslyckades att bygga PDT-klasskomponenten vid %L"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Vektor %qs med antagen storlek i namnlistan %qs vid %L är inte tillåtet"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "NAMELIST-vektorobjektet %qs med antagen form i namnlistan %qs vid %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "NAMELIST-vektorobjektet %qs med icke-konstant form in namnlistan %qs vid %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "NAMELIST-vektorobjektet %qs med icke-konstant längd i namnlistan %qs vid %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST-objekt %qs deklarerades PRIVATE och kan inte vara medlem av PUBLIC-namnlista %qs vid %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "NAMELIST-objekt %qs har användningsassociativa PRIVATE-komponenter och kan inte vara medlem av namnlistan %qs vid %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "NAMELIST-objekt %qs har PRIVATE-komponenter och kan inte vara medlem av PUBLIC-namnlista %qs vid %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "PROCEDURE-attribut i konflikt med NAMELIST-attribut i %qs vid %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Parametervektor %qs vid %L kan inte ha automatisk eller fördröjd form"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Implicit typad PARAMETER %qs vid %L matchar inte en senare IMPLICIT-typ"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Inkompatibel härledd typ i PARAMETER vid %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "CLASS-variabeln %qs vid %L får inte ha attributet PARAMETER"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "Ett konstant uttryck förväntades nära %L"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Enheten %qs vid %L har en fördröjd LEN-parameter %qs och kräver antingen attributet POINTER eller ALLOCATABLE"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr "AUTOMATIC-objektet %qs vid %L får inte ha attributet SAVE eller vara en variabel deklarerad i huvudprogrammet, en modul eller en submodul(F08/C513)"
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr "Objektet %qs vid %L med ASSUMED typparametrar måste vara en attrapp eller en SELECT TYPE-selektor(F08/4.2)"
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr "Ledsen, allocatable/pointer-komponenter i co-vektor av polymorf (CLASS)-typ vid %L stödjs inte"
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr "%<omp_all_memory%>, deklarerat vid %L, får endast användas i OpenMP-klausulen DEPEND"
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "Attributet PROTECTED står i konflikt med attributet EXTERNAL vid %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "Attributet PROCEDURE står i konflikt med attributet PROTECTED vid %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "%qs vid %L har attributet CONTIGUOUS, men är inte en vektorpekare eller en vektor med antagen form eller antagen ordning"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "Felaktig specifikation för vektor med antagen storlek vid %L"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Vektor med antagen storlek vid %L måste vara ett attrappargument"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Vektor med antagen form vid %L måste vara ett attrappargument"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Vektor med antagen ordning vid %L måste vara ett attrappargument"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr "Vektor med antagen ordning vid %L kan inte ha attributet VALUE eller CODIMENSION"
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Symbol vid %L är inte en DUMMY-variabel"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "%qs vid %L kan inte ha attributet VALUE eftersom det inte är ett attrappargument"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Teckenvärd attrappvariabel %qs vid %L med attributet VALUE måste ha konstant längd"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "C-interoperativ teckenattrappvariabel %qs vid %L med attributet VALUE måste ha längd ett"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Den härledda typen %qs vid %L har typen %qs, som inte har definierats"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK skall vara ett attrappargument"
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK skall ha typen TYPE(*) eller en numerisk inbyggd typ"
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK får inte ha attributet ALLOCATABLE, CODIMENSION, POINTER eller VALUE"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK får inte ha attributet INTENT(OUT)"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "Variabeln %s vid %L med attributet NO_ARG_CHECK skall antingen vara en skalär eller en vektor med förmodad storlek"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "Den antagna typen på variabeln %s vid %L är bara tillåten för attrappvariabler"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Variabeln ”%s” med antagen typ vid %L får inte ha attributet ALLOCATABLE, CODIMENSION, POINTER eller VALUE"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "Variabeln ”%s” med antagen typ vid %L får inte ha attributet INTENT(OUT)"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "Variabeln %s med antagen typ vid %L får inte vara en vektor med explicit form"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "Variabel %qs vid %L kan inte vara BIND(C) eftersom den varken är ett COMMON-block eller deklarerad med räckvidd modulnivå"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "BIND(C)-variabeln %qs vid %L måste ha längden ett"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "PUBLIC %s %qs vid %L har PRIVATE härledd typ %qs"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "Variabeln %s vid %L av typen LOCK_TYPE eller med en delkomponent av typen LOCK_TYPE måste vara en co-vektor"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "Variabeln %s vid %L av typen EVENT_TYPE eller med en delkomponent av typen EVENT_TYPE måste vara en co-vektor"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "INTENT(OUT)-attrappargumentet %qs vid %L har ASSUMED SIZE och kan därför inte ha en standardinitierare"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Attrappargumentet %qs vid %L av LOCK_TYPE får inte vara INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Attrappargumentet %qs vid %L av EVENT_TYPE får inte vara INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Funktionsresultat %qs vid %L skall inte vara en co-vektor eller ha en co-vektorkomponent"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Variabeln %qs vid %L av TYPE(C_PTR) eller TYPE(C_FUNPTR) får inte vara en co-vektor"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "Variabeln %qs vid %L med co-vektorkomponent skall vara en skalär som inte är en pekare eller allokerbar och inte en co-vektor"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "Variabeln %qs vid %L är en co-vektor och är inte ALLOCATABLE, SAVE eller ett attrappargument"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "Co-vektorvariabeln %qs vid %L skall inte ha co-dimensioner med fördröjd form utan allokerbarhet"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Allokerbar co-vektorvariabel %qs vid %L måste ha en fördröjd form"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "Variabeln %qs vid %L är INTENT(OUT) och kan alltså inte vara en allokerbara co-vektor eller har co-vektorkomponenter"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Co-attrappvariabeln %qs vid %L är inte tillåten i BIND(C)-proceduren %qs"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "LOGICAL-attrappargumentet %qs vid %L med icke-C_Bool-sort i BIND(C)-proceduren %qs"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "LOGICAL-resultatvariabeln %qs vid %L med icke-C_Bool-sort i BIND(C)-proceduren %qs"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Namnlistan %qs får inte vara ett argument till en subrutin eller funktion vid %L"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Trådprivat vid %L är inte SAVE:ad"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "OpenMP groupprivate-variabeln %qs vid %L måste ha attributet SAVE"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "!$OMP GROUPPRIVATE-variabeln %qs vid %L får inte ha en initierare"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr "!$OMP DECLARE TARGET-variabeln %qs vid %L är inte SAVE:ad"
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "Definierbar entitet förväntades nära %L"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "BLOCK DATA-element %qs vid %L måste vara i COMMON"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "DATA-vektor %qs vid %L måste anges i en tidigare deklaration"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "DATA-elementet %qs vid %L kan inte ha ett co-index"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "DATA-element %qs vid %L är en pekare och måste då vara en fullständig vektor"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr "DATA-objektet nära %L har pekarattributet och det motsvarande DATA-värdet är inte ett giltigt initialt-data-mål"
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "DATA-elementet %qs vid %L får inte ha attributet ALLOCATABLE"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Ickekonstant vektorsektion vid %L i DATA-sats"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "DATA-sats vid %L har fler variabler än värden"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Ickekonstant teckenlängd vid %L i DATA-sats"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "början av implicerad do-slinga vid %L kan inte förenklas till ett konstant värde"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "slutet av implicerad do-slinga vid %L kan inte förenklas till ett konstant värde"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "steget i implicerad do-slinga vid %L kan inte förenklas till ett konstant värde"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "steget i implicerad do-slinga vid %L skall inte vara noll"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "DATA-sats vid %L har fler värden än variabler"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Etiketten %d vid %L är definierad men inte använd"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Etiketten %d vid %L är definierad men kan inte användas"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Härledd typvariabel %qs vid %L måste ha attributet SEQUENCE för att vara ett EQUIVALENCE-objekt"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Härledd typvariabel %qs vid %L kan inte ha ALLOCATABLE-komponenter för att vara ett EQUIVALENCE-objekt"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Härledd typvariabel %qs vid %L med standardinitiering kan inte vara i EQUIVALENCE med en variabel i COMMON"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Härledd typvariabel %qs vid %L med pekarkomponent(er) kan inte vara ett EQUIVALENCE-objekt"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Syntaxfel i EQUIVALENCE-sats vid %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Antingen alla eller inget av objekten i EQUIVALENCE-mängden vid %L kan ha attributet PROTECTED"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "COMMON-blockmedlem %qs vid %L kan inte vara ett EQUIVALENCE-objekt i den rena proceduren %qs"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Namngiven konstant %qs vid %L kan inte vara ett EQUIVALENCE-objekt"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr "Sekvensen %s med blandade komponenter i EQUIVALENCE-satsen vid %L med olika typobjekt"
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr "Icke-standardtypobjekt eller sekvens %s i EQUIVALENCE-satsen vid %L med objekt av en annan typ"
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr "Icke-CHARACTER-objektet %qs i standard-CHARACTER EQUIVALENCE-satsen vid %L"
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Ett icke-numeriskt objektet %qs i satsen NUMERIC EQUIVALENCE vid %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Vektor %qs vid %L med icke-konstanta gränser kan inte vara ett EQUIVALENCE-objekt"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Postkomponent %qs vid %L kan inte vara ett EQUIVALENCE-objekt"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Delsträng vid %L har längden noll"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Självreferens i uttrycket för teckenlängd för %qs vid %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "PUBLIC-funktionen %qs vid %L har PRIVATE typ %qs"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY %qs vid %L har ingen IMPLICIT-typ"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Användaroperatorprocedur %qs vid %L måste vara en FUNCTION"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Användaroperatorprocedur %qs vid %L får inte ha antagen teckenlängd"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Användaroperatorprocedur %qs vid %L måste ha åtminstone ett argument"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Första argumentet till operatorgränssnitt vid %L får inte vara frivilligt"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Andra argumentet till operatorgränssnitt vid %L får inte vara valfritt"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Operatorgränssnitt vid %L måste ha, högst, två argument"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "Innesluten procedur %qs vid %L i en PURE-procedur måste också vara PURE"
@@ -87387,97 +87558,97 @@ msgstr "Inkluderingskatalogen %qs finns inte"
 msgid "%qs is not a directory"
 msgstr "%qs är inte en katalog"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$ACC vid %C inleder en kommentarrad eftersom det varken följs av en blank eller en fortsättningsrad"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP vid %C inleder en kommentarrad eftersom det varken följs av en blank eller en fortsättningsrad"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr "Ignorerar leverantörsutvidgningens vaktpost %<!$omx%> vid %C"
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Rad avhuggen vid %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Gränsen på %d fortsättningar överskrids i sats vid %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr "Felaktig OpenACC-fortsättning vid %C: !$ACC förväntades, fick !$OMP"
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr "Felaktig OpenMP-fortsättning vid %C: !$OMP förväntades, fick !$ACC"
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "%<&%> saknas i fortsatt teckenkonstant vid %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Ej konformt tabulatortecken vid %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "Felaktigt tecken 0x%s vid %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "%<&%> är inte tillåtet ensamt på rad %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Ej konformt tabulatortecken i kolumn %d på rad %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "gått ifrån men inte till filen %qs"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "Ogiltigt preprocessordirektiv"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr "Filen %qs inkluderas rekursivt"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "Kan inte öppna filen %qs"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "Kan inte öppna den inkluderade filen %qs"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "Kan inte öppna den förinkluderade filen %qs"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "Den inkluderade filen %qs är inte en normal fil"
@@ -87642,218 +87813,218 @@ msgstr "Om första argumentet till ATAN2PI vid %L är noll får inte andra argum
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim(): Felaktig typ"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "i gfc_simplify_exp(): Felaktig typ"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor(): Felaktig sort"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Argument till IACHAR vid %L måste ha längden ett"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Argument till IACHAR-funktion vid %L är utanför sitt intervall 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "Summan av andra och tredje argumenten till IBITS överskrider bitstorleken vid %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr "IBITS: Felaktig bit"
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Argument till ICHAR vid %L måste ha längden ett"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Andra argumentet till %s är negativt vid %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "Magnituden på andra argumentet till %s överskrider bitstorleken vid %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "Magnituden på andra argumentet till ISHFTC överskrider BIT_SIZE av första argumentet vid %C"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "Absolutvärdet av SHIFT måste vara mindre än eller lika med SIZE vid %C"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "DIM-argument vid %L är utanför gränsen"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "Argument till LOG vid %L får inte vara mindre än eller lika med noll"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "Komplext argument till LOG vid %L får inte vara noll"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "gfc_simplify_log: felaktig typ"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "Argument till LOG10 vid %L får inte vara mindre än eller lika med noll"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr "simplify_min_max(): Felaktig typ i argumentlistan"
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "Argument %qs till MOD vid %L får inte vara noll"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_simplify_mod(): Felaktiga argument"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Argument %qs till MODULO vid %L får inte vara noll"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr "gfc_simplify_modulo(): felaktiga argument"
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Resultatet av NEAREST är NaN vid %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "Argument NCOPIES till inbyggd REPEAT är negativt vid %L"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "Argumentet NCOPIES till inbyggd REPEAT är för stort vid %L"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr "Beräkningen av en sträng längre än 2**28 vid %L fördröjd till körtillfället, förvänta dig fel"
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr "SHAPE-vektorn för den inbyggda RESHAPE vid %L har ett negativt värde %d som dimension %d"
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr "Former av ORDER vid %L och SHAPE vid %L är olika"
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr "Storlekar av ORDER vid %L och SHAPE vid %L är olika"
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr "Element med ett värde på %d i ORDER vid %L måste ligga i intervallet [1, …, %d] för den inbyggda RESHAPE nära %L"
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr "ORDER vid %L är inte en permutation av storleken av SHAPE vid %L"
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Omformad vektor är för stor vid %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Resultat av SCALE spiller över sin sort vid %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "DIM-argumentet (%d) till inbyggd SIZE vid %L är utanför intervallet (1:%d)"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Felaktig typ i gfc_simplify_sign"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "i gfc_simplify_sin(): Felaktig typ"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr "Misslyckades att bestämma längden på en konstant vektor."
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "Antalet element (%d) i vektorkonstrueraren vid %L kräver en ökning av den tillåtna övre gränsen %d.  Se flaggan %<-fmax-array-constructor%>."
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Förenkling av SPREAD vid %C är inte implementerat ännu"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Argument till SQRT vid %L har ett negativt värde"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "ogiltigt argument till SQRT vid %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "Utanför gränserna i IMAGE_INDEX vid %L för dimension %d, SUB har %ld och COARRAY nedre gräns är %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "Utanför gränserna i IMAGE_INDEX vid %L för dimension %d, SUB har %ld och COARRAY övre gräns är %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "Tecknet %qs i sträng vid %L kan inte konverteras till tecken av sort %d"
@@ -88059,7 +88230,7 @@ msgstr "Proceduren ”%s” vid %L är redan deklarerad som %s-procedur"
 #: fortran/symbol.cc:1898
 #, gcc-internal-format
 msgid "F2008: A pointer function assignment is ambiguous if it is the first executable statement after the specification block.  Please add any other kind of executable statement before it"
-msgstr "F2008: En tilldelning av funktionspekare är tvetydig om det är dn första exekverbara satsen efter specifikationsblocket.  Lägg någon annan sorts exekverbar sats före den."
+msgstr "F2008: En tilldelning av funktionspekare är tvetydig om det är den första exekverbara satsen efter specifikationsblocket.  Lägg någon annan sorts exekverbar sats före den."
 
 #: fortran/symbol.cc:1935
 #, gcc-internal-format, gfc-internal-format
@@ -88191,75 +88362,75 @@ msgstr "Delad DO-avslutningsetikett %d vid %C"
 msgid "Labeled DO statement at %L"
 msgstr "Etiketterad DO-sats vid %L"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Namnet %qs vid %C är en tvetydig referens till %qs från modulen %qs"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Namnet %qs vid %C är en tvetydig referens till %qs från den aktuella programenheten"
 
 # Vad är "host associated"?
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Symbolen %qs vid %C har redan blivit host-associerad"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr "verify_bind_c_derived_type(): Den angivna symbolen är oväntat NULL"
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Härledd typ %qs deklarerad vid %L måste ha attributet BIND för att vara ett C-interoperativ"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Den härledda typen %qs med attributet BIND(C) vid %L har inga komponenter"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "Härledd typ %qs med attributet BIND(C) vid %L är tom, och kan vara otillgängliga av C-följeslagarprocessorn"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponent %qs vid %L får inte ha attributet POINTER eftersom det är en medlem av den BIND(C)-härledda typen %qs vid %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "Procedurpekarkomponenten %qs vid %L kan inte vara en medlem av den BIND(C)-härledda typen %qs vid %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Komponent %qs vid %L får inte ha attributet ALLOCATABLE eftersom det är en medlem av den BIND(C)-härledda typen %qs vid %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "Komponent %qs i härledd typ %qs vid %L får inte vara C-interoperativ, trots att den härledda typen %qs är BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "Komponent %qs i härledd typ %qs vid %L får inte vara C-interoperativ"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Härledd typ %qs vid %L kan inte ha attributet SEQUENCE för att den är BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "Symbolen %qs används före den har fått sin typ vid %L"
@@ -88289,29 +88460,34 @@ msgstr "Överlappande olika initierare i EQUIVALENCE vid %L"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Överlappande olika initierare i EQUIVALENCE vid %C"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
-msgstr "Postkonstrueraren vid %L har avslutats. Denna funktion togs bart av f08/0011. Använd -std=f2018 eller -std=gnu för att eliminera avslutningen."
+msgstr "Postkonstrueraren vid %L har avslutats. Denna funktion togs bort av f08/0011. Använd -std=f2018 eller -std=gnu för att eliminera avslutningen."
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr "Kontroll av gränser för elementindex vid %L kommer orsaka två anrop av %qs, vilken inte är declarerad PURE och inte är implicit ren."
 
+#: fortran/trans-array.cc:7109
+#, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "Vektorinitialiseraren vid %L reduceras inte till ett konstant uttryck"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "Antalet element i vektorkonstrueraren vid %L kräver en ökning av den tillåtna övre gränsen %d.  Se flaggan %<-fmax-array-constructor%>"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Skapar vektortemporär vid %L för argument %qs"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "felaktig uttryckstyp under genomlöpning (%d)"
@@ -88413,113 +88589,113 @@ msgstr "Tilldelning annat värde än 0 eller 1 till LOGICAL har odefinierat resu
 msgid "non-constant initialization expression at %L"
 msgstr "ej konstant initieringsuttryck vid %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr "Vektorn %qs vid %L är större än gränsen satt med %<-fmax-stack-var-size=%>, flyttad från stacken till statisk lagring.  Detta gör proceduren osäker när den anropas rekursivt, eller samtidigt från flera trådar.  Överväg att öka gränsen %<-fmax-stack-var-size=%> (eller använd %<-frecursive%>, som implicerad obegränsad %<-fmax-stack-var-size=%> – eller ändra koden till att använda en ALLOCATABLE vektor. Om variabeln aldrig används av flera samtidigt kan denna varning ignoreras och variabeln skulle också kunna deklareras med attributet SAVE."
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr "Ledsen, OMP GROUPPRIVATE är inte implementerat, använt av %qs deklarerad vid %L"
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr "Ledsen, OMP DECLARE TARGET med en klausul LOCAL är inte implementerat, använt av %qs deklarerad vid %L"
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%s vid %L har ingen standardtyp"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "inbyggd variabel som inte är en procedur"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "Returvärdet för funktionen %qs vid %L är inte satt"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "Fördröjd typparameter stödjs inte ännu"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "bakändedeklaration för modulvariabel %qs finns redan"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Oanvänd PRIVATE modulvariabel %qs deklarerad vid %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "Symbolen %qs vid %L har attributet WEAK men är ett attrappargument"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "Symbolen %qs vid %L har attributet WEAK men är en lokal variabel"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Attrappargument %qs vid %L deklarerades INTENT(OUT) men sattes inte"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "Attrappargument med härledd typ %qs vid %L deklarerades INTENT(OUT) men sattes inte och har inte en standardinitierare"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Oanvänt attrappargument %qs vid %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Oanvänd modulvariabel %qs som uttryckligen har importerats vid %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Oanvänd variabel %qs deklarerad vid %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Oanvänd parameter %qs deklarerad vid %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Oanvänd parameter %qs som uttryckligen har importerats vid %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Returvärdet %qs för funktionen %qs deklarerad vid %L är inte satt"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr "Ledsen, !$ACC DECLARE vid %L är inte tillåtet i BLOCK-konstruktion"
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Teckenlöst är inte implementerat ännu"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr "Symbolen %qs vid %L är deklarerad i en programenhet BLOCK DATA men är inte i ett COMMON-block"
@@ -88549,12 +88725,12 @@ msgstr "Ledsen, co-indexerad åtkomst till en obegränsat polymorf komponent vid
 msgid "Unknown intrinsic op"
 msgstr "Okänd inbyggd op"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Okänd argumentlistefunktion vid %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr "Om ommappning av gränser anges vid %L skall pekarmålet inte vara NULL"
@@ -88570,12 +88746,12 @@ msgstr "Inbyggd funktion %qs (%d) känns inte igen"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "%<dim%>-argumentet till inbyggd %s vid %L är inte ett giltigt dimensionsindex"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "Ledsen, händelsekomponenten hos härledd typ vid %L stödjs inte ännu"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "Händelsevariabeln vid %L får inte vara co-indexerad"
@@ -88600,182 +88776,182 @@ msgstr "Ledsen, polymorfa vektorer stödjs inte ännu för firstprivate"
 msgid "implicit mapping of assumed size array %qD"
 msgstr "implicit avbildning av vektorn %qD med antagen storlek"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr "Avbildning av den obegränsade polymorfa listposten %qD är odefinierat beteende och stödjs ej"
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr "Avbildningen av den polymorfa listposten %qD är odefinierat beteende"
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, gcc-internal-format
 msgid "optional class parameter"
 msgstr "valfri klassparameter"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "ohanterad uttryckstyp"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr "ohanterat uttryck"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr "klausulen %<uses_allocators%> med egenskaper och minnesutrymmen"
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr "%<!$OMP %s%> vid %L kräver %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr "Alla filer som kan avallokera en sådan variabel måste kompileras med %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr "Detta inkluderar explicit DEALLOCATE, omallokering eller inbyggd tilldelning, INTENT(OUT) för allokerbara attrappargument och omallokering av allokerbara komponenter allokerade med en OpenMP-allokerare"
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr "icke-rektangulär slinga nästar med ett icke-konstant steg till %qs"
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr "Använd här"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Felaktig satskod"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "Basnamnet för %<declare variant%> måste anges vid %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Basnamnet vid %L stämmer inte med namnet på den aktuella proceduren"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "Basnamnet vid %L får inte vara ett ingångsnamn"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "Basnamnet vid %L får inte vara ett generiskt namn"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "Basnamnet vid %L får inte vara en procedurpekare"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "Basproceduren vid %L måste ha ett explicit gränssnitt"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, gcc-internal-format
 msgid "Cannot find symbol %qs at %L"
 msgstr "Kan inte hitta symbolen %qs vid %L"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "varianten %qs vid %L är varken en funktion eller subrutin"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "varianten %qs vid %L är samma som basfunktionen"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "varianten %qs och basen %qs vid %L har inkompatibla typer: %s"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr "klausulen %<append_args%> implicerar att %qs har %d attrappargument av heltalstyp med sorten %<omp_interop_kind%>"
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr "%qs vid %L måste vara en icke-pekare-, oallokerbart skalärt heltalsattrapparument av sorten %<omp_interop_kind%> eftersom det används i klausulen %<append_args%> vid %L"
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr "%qs vid %L med attributet OPTIONAL stödjs inte när det används i klausulen %<append_args%> vid %L"
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr "%qs vid %L har %d men behöver %d attrappargument av sorten %<omp_interop_kind%> eftersom den används i klausulen %<append_args%> vid %L"
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr "klausulen %qs kan endast anges om väljaren %<dispatch%> i konstruktionsväljarmängden förekommer i klausulen %<match%> vid %L"
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "Ett positivt argumentindex förväntades vid %L"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Argumentindexet vid %L överskrider antalet argument %d"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr "Det övre argumentindexet är mindre än det lägre vid %L"
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Listposten %qs vid %L, deklarerad vid %L, är inte ett attrappargument"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Argumentet %qs vid %L till listposten i %<need_device_ptr%> vid %L måste vara en skalär av TYPE(C_PTR)"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr "Överväg att använda %<need_device_addr%> istället"
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Argumentet %qs vid %L till listposten i %<need_device_addr%> vid %L får inte ha attributet VALUE"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "%qs vid %L anges mer än en gång"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr "%<need_device_addr%> stödjs inte ännu"
@@ -88809,12 +88985,12 @@ msgstr "Ledsen, specificeraren %s vid %L för vektorn %qs med antagen storlek st
 #: fortran/trans-stmt.cc:5353
 #, gcc-internal-format
 msgid "Sorry, LOCAL specifier at %L for %qs of derived type with default initializer is not yet supported"
-msgstr "Ledsen, specificeraren LOCAL vid %L för %qs av härledd typp med standardinitierare stödjs inte ännu"
+msgstr "Ledsen, specificeraren LOCAL vid %L för %qs av härledd typ med standardinitierare stödjs inte ännu"
 
 #: fortran/trans-types.cc:619
 #, gcc-internal-format
 msgid "%<-fconvert=r16_ieee%> or %<-fconvert=r16_ibm%> not supported on this architecture"
-msgstr "%<-fconverter=r16_ieee%> eller %<-fconvert=r16_ibm%> stödjs inte på denna arkitektur"
+msgstr "%<-fconvert=r16_ieee%> eller %<-fconvert=r16_ibm%> stödjs inte på denna arkitektur"
 
 #: fortran/trans-types.cc:632
 #, gcc-internal-format
@@ -89112,7 +89288,7 @@ msgstr "stäng: %s"
 msgid "two or more sections for %s"
 msgstr "två eller flera sektioner för %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr "min partitionsstorlek kan inte vara större än max partitionsstorlek"
@@ -89292,7 +89468,7 @@ msgstr "spill i implicit konstantkonvertering"
 #: m2/gm2-gcc/m2decl.cc:122
 #, gcc-internal-format
 msgid "storage size of %qD has not been resolved"
-msgstr "lagringsstorlek på %qD har inte lösts upp"
+msgstr "lagringsstorlek på %qD har inte slagits upp"
 
 #: m2/gm2-gcc/m2decl.cc:125
 #, gcc-internal-format
@@ -89323,22 +89499,22 @@ msgstr "argumentet till CAP är inte en konstant eller variabel av typen CHAR"
 #: m2/gm2-gcc/m2expr.cc:3692
 #, gcc-internal-format
 msgid "constant literal %qs exceeds internal ZTYPE range"
-msgstr "den konstanta literalen %qs överskrider det interna intervallet för ZTYPE"
+msgstr "den konstanta litteralen %qs överskrider det interna intervallet för ZTYPE"
 
 #: m2/gm2-gcc/m2expr.cc:3612
 #, gcc-internal-format
 msgid "constant literal %qs contains %qc, expected 0 or 1"
-msgstr "den konstanta literalen %qs innehåller %qc, 0 eller 1 förväntades"
+msgstr "den konstanta litteralen %qs innehåller %qc, 0 eller 1 förväntades"
 
 #: m2/gm2-gcc/m2expr.cc:3627 m2/gm2-gcc/m2expr.cc:3639
 #, gcc-internal-format
 msgid "constant literal %qs contains %qc, expected %qs"
-msgstr "den konstanta literalen %qs innehåller %qc, %qs förväntades"
+msgstr "den konstanta litteralen %qs innehåller %qc, %qs förväntades"
 
 #: m2/gm2-gcc/m2expr.cc:3658
 #, gcc-internal-format
 msgid "constant literal %qs contains %qc, expected %qs or %qs"
-msgstr "dem konstanta literalen %qs innehåller %qc, %qs eller %qs förväntades"
+msgstr "den konstanta litteralen %qs innehåller %qc, %qs eller %qs förväntades"
 
 #: m2/gm2-gcc/m2expr.cc:3724
 #, gcc-internal-format
@@ -89436,32 +89612,32 @@ msgstr "vektortyper måste initieras"
 msgid "array element value must be the same type as its declaration"
 msgstr "vektorelementsvärden måste vara av samma typ som dess deklaration"
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr "lägsta gränsen för delintervallet har spillt över"
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr "högsta gränsen för delintervallet har spillt över"
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "begärd minnesjustering är inte en konstant"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "begärd minnesjustering är inte en potens av 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "begärd minnesjustering är för stor"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "minnesjusteringen får inte anges för %qD"
@@ -90190,7 +90366,7 @@ msgstr "omimplementation av klassen %qE"
 #: objc/objc-act.cc:7068
 #, gcc-internal-format
 msgid "conflicting super class name %qE"
-msgstr "motstridande superklassnamn %qE"
+msgstr "motstridigt superklassnamn %qE"
 
 #: objc/objc-act.cc:7071
 #, gcc-internal-format
--- a/src/gcc/po/tr.po
+++ b/src/gcc/po/tr.po
@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 5.2.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2015-09-11 20:22+0300\n"
 "Last-Translator: Nilgün Belma Bugüner <nilgun@fide.org>\n"
 "Language-Team: Turkish <gnu-tr-u12a@lists.sourceforge.net>\n"
@@ -1403,12 +1403,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr ""
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers"
 msgid "Initialize ptx registers."
@@ -2338,14 +2338,14 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, fuzzy, no-c-format
 #| msgid "Use propolice as a stack protection method"
 msgid "Use given stack-protector guard."
 msgstr "Yığıt koruma yöntemi olarak propolice kullanılır"
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 #| msgid "invalid option for -mfloat-gprs: '%s'"
@@ -2855,7 +2855,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Hedef işlemci kıymetli baytın başta olduğu yapılandırmaya sahip kabul edilir"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 #| msgid "Assume target CPU is configured as little endian"
 msgid "Assume target CPU is configured as little endian."
@@ -2940,7 +2940,7 @@ msgstr "İşlev önbilgisi/sonbilgisi için altyordamlar kullanılır"
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 #| msgid "Specify the register allocation order"
@@ -2980,7 +2980,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 #| msgid "Omit the frame pointer in leaf functions"
 msgid "Omit the frame pointer in leaf functions."
@@ -3095,7 +3095,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -3142,7 +3142,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5712,7 +5712,7 @@ msgstr "MMX ve SSE2 yerleşik işlevleri ve kod üretimi desteklenir"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -6107,7 +6107,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "gettr komutu için varsayılacak maliyet"
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -6453,219 +6453,224 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "The register used to access the thread pointer:"
 msgstr "Evre göstericisine nasıl erişileceği belirtilir"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "Specify the thread pointer register."
 msgstr "Evre göstericisine nasıl erişileceği belirtilir"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 #| msgid "Specify bit size of immediate TLS offsets"
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Dolaysız TLS konumlarının bit genişliği belirtilir"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule given CPU"
 msgid "Use features of architecture ARCH."
 msgstr "Belirtilen işlemcinin özelliklerini ve zamanlamasını kullanır"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "Use features of and schedule code for given CPU"
 msgid "Use features of and optimize for CPU."
 msgstr "Verilen işlemcinin özellikleri ve zamanlama kodu kullanılır"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "Generate code that conforms to the given ABI"
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Verilen ABI'ye uyumlu kod üretilir"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate code for big-endian"
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Kıymetli baytın başta olduğu kod üretilir"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "type is deprecated"
 msgid "This option is deprecated."
@@ -12561,7 +12566,7 @@ msgstr "Ağaçlarda döngü vektörleştirimi etkin olur"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -20192,93 +20197,93 @@ msgstr "ISO 1998 C++ standardına uyulur"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "argument must be passed by copying"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 #| msgid "caller edge count is negative"
 msgid "callee returns twice"
 msgstr "çağrıcı ayrıt sayısı negatif"
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has initializer but incomplete type"
 msgid "volatile function type"
 msgstr "%qD değişkeni ilklendiricili ama içi boş türde"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "unexpected node"
 msgid "nested function"
 msgstr "umulmadık düğüm"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "redefinition of parameter %q+D"
 msgid "inconsistent number of popped arguments"
 msgstr "%q+D parametresinin yeniden tanımlanması"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s split_block'u desteklemez."
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "variable size arguments"
 msgstr "tür argümanı geçersiz"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "Pass arguments on the stack"
 msgid "hidden string length argument passed on stack"
 msgstr "Yığıttaki argümanlar aktarılır"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "gimplification failed"
 msgid "tail call production failed"
@@ -20405,12 +20410,12 @@ msgstr "'%%l' terimi bir yafta değil"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "gerçel sayı sabit yanlış kullanılmış"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -21870,13 +21875,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "bu o komuttur:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "Disable indexed addressing"
 msgid "unable to reload address in "
 msgstr "İndisli adresleme kapatılır"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "aşağıdakiler için yeniden yüklemeler üretilemiyor:"
 
@@ -22134,7 +22139,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC yaklaşımları: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonim>"
@@ -22529,11 +22534,11 @@ msgstr "terim, kod `%c' için geçersiz"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand for '%%%c'"
@@ -22541,9 +22546,9 @@ msgstr "terim, kod `%c' için geçersiz"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid insn:"
 msgid "invalid vector constant"
@@ -22595,83 +22600,83 @@ msgstr "terim kodu `%c' geçersiz"
 msgid "invalid address mode"
 msgstr "adres geçersiz"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "%<__fpreg%> türünden dönüşüm geçersiz"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "%qT'ye %qT'den dönüşüm geçersiz"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 msgid "preincrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 msgid "predecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "pointers are not permitted as case values"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "case değeri olarak göstericiler kullanılamaz"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "%<this%> may not be used in this context"
 msgid "negation operation not permitted on svbool_t"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 #| msgid "stack limits not supported on this target"
 msgid "subscript operation not supported on svbool_t"
 msgstr "bu hedefte yığıt sınırları desteklenmiyor"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands to binary %s"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "iki terimli %s için terimler geçersiz"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -22688,13 +22693,13 @@ msgid "invalid %%r value"
 msgstr "%%r değeri geçersiz"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "%%R değeri geçersiz"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "%%N değeri geçersiz"
@@ -22709,7 +22714,7 @@ msgstr "%%P değeri geçersiz"
 msgid "invalid %%h value"
 msgstr "%%h değeri geçersiz"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "%%L değeri geçersiz"
@@ -22724,7 +22729,7 @@ msgstr "%%m değeri geçersiz"
 msgid "invalid %%M value"
 msgstr "%%M değeri geçersiz"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "%%U değeri geçersiz"
@@ -23098,7 +23103,7 @@ msgstr "beklenmeyen terim"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -23347,150 +23352,150 @@ msgstr "geçersiz komut:"
 msgid "Expected register or constant integer."
 msgstr "birikeç bir tamsayı sabit değil"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "terim olarak UNSPEC geçersiz"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "%<restrict%> kullanımı geçersiz"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid use of asm flag output"
 msgstr "asm çıktısı %d içinde geçersiz sol değer"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code 'O'"
 msgstr "terim, kod `%c' için geçersiz"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code 'z'"
 msgstr "terim, kod `%c' için geçersiz"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "terim, kod `%c' için geçersiz"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand for code '%c'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "terim, kod `%c' için geçersiz"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "terim ne bir sabit ne de bir koşul kodu, geçersiz terim kodu 'c'"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "terim kodu `%c' geçersiz"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "kısıtlar terim için geçersiz"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "invalid conditional operand"
 msgid "invalid vector immediate"
 msgstr "koşullu terim geçersiz"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "bilinmeyen komut kipi"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "%<__fpreg%> türünden dönüşüm geçersiz"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "%<__fpreg%> türünden dönüşüm geçersiz"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "%<__fpreg%> türüne dönüşüm geçersiz"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "%qT'ye %qT'den dönüşüm geçersiz"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -23575,9 +23580,9 @@ msgstr "'%s' geçerli bir sınıf ismi değil"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, fuzzy, c-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of '%%%c'"
@@ -23647,7 +23652,7 @@ msgid "insn contains an invalid address !"
 msgstr "adres geçersiz"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "adres geçersiz"
 
@@ -23725,7 +23730,7 @@ msgstr "işlev bildirimi geçersiz"
 msgid "invalid %%H value"
 msgstr "%%H değeri geçersiz"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "%%d değeri geçersiz"
@@ -23784,34 +23789,34 @@ msgstr "desteklenmeyen birleşim: %s"
 msgid "unsupported memory expression:"
 msgstr "desteklenmeyen birleşim: %s"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%P operand"
 msgid "invalid vector operand"
 msgstr "%%P terimi geçersiz"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "'b' değiştirici için terim geçersiz"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -23882,7 +23887,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "%%H değeri geçersiz"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "%%D değeri geçersiz"
@@ -23923,7 +23928,7 @@ msgstr "%%J kodu geçersiz"
 msgid "invalid %%k value"
 msgstr "%%k değeri geçersiz"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "%%K değeri geçersiz"
@@ -23954,18 +23959,18 @@ msgstr "%%T değeri geçersiz"
 msgid "invalid %%u value"
 msgstr "%%u değeri geçersiz"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "%%v değeri geçersiz"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%H value"
 msgid "invalid %%V value"
 msgstr "%%H değeri geçersiz"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "%%x değeri geçersiz"
@@ -24205,28 +24210,28 @@ msgstr "geçersiz %%s terimi"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "gerçel sayı sabit geçerli bir anlık terim değil"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "`B' terimi sabit değil"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "`B' terimi çoklu bit kümesi içeriyor"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "`o' terimi sabit değil"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "`B' terimi sabit değil"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: kod bilinmiyor"
@@ -24290,24 +24295,24 @@ msgstr ""
 msgid "Unable to load DLL."
 msgstr "%qs öykünümü mümkün değil"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "hatalı test"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "mask geçersiz"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "%%t/%%b değeri geçersiz"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "adreste yazmaç yok"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "adres mesafesi bir sabit değil"
 
@@ -24341,7 +24346,7 @@ msgstr "<anonim>"
 msgid "aka"
 msgstr ""
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 #, fuzzy
 #| msgid "<anonymous>"
 msgid "({anonymous})"
@@ -24368,8 +24373,8 @@ msgstr "<anonim>"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "%<;%> umuluyordu"
@@ -24398,7 +24403,7 @@ msgstr "%<,%> veya %<;%> umuluyordu"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<)%>"
@@ -24407,7 +24412,7 @@ msgstr "%<{%> umuluyordu"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<]%>"
@@ -24430,14 +24435,14 @@ msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<(%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<[%>"
@@ -24447,7 +24452,7 @@ msgstr "%<{%> umuluyordu"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -24464,14 +24469,14 @@ msgstr "%<{%> umuluyordu"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<:%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<while%>"
@@ -24482,7 +24487,7 @@ msgstr "%<{%> umuluyordu"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<,%>"
@@ -24495,20 +24500,20 @@ msgid "expected %<.%>"
 msgstr "%<{%> umuluyordu"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@end%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<>%>"
 msgstr "%<{%> umuluyordu"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<,%> or %<)%>"
@@ -24519,14 +24524,14 @@ msgstr "%<,%> veya %<;%> umuluyordu"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "%<=%> umuluyordu"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<)%> or %<,%>"
@@ -24534,36 +24539,36 @@ msgstr "%<,%> veya %<;%> umuluyordu"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<}%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<else%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<}%>"
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "%<,%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 #, fuzzy
 #| msgid "<anonymous>"
 msgid "(anonymous)"
 msgstr "<anonim>"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<<%>"
@@ -24594,7 +24599,7 @@ msgstr "1. aday:"
 msgid "  after user-defined conversion:"
 msgstr "DB komutunun kullanımı etkin olur"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 #, fuzzy
 #| msgid "candidate 1:"
 msgid "candidate is:"
@@ -24718,7 +24723,7 @@ msgstr "şablon parametresi %q+#D"
 msgid "<statement>"
 msgstr "deyim umuluyordu"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown src"
 msgid "<unknown>"
@@ -24748,325 +24753,367 @@ msgstr ""
 msgid "*this"
 msgstr ""
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr ""
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 #, fuzzy
 #| msgid "Bad operator"
 msgid "<unknown operator>"
 msgstr "Hatalı işleç"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr ""
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "birikeç bir tamsayı sabit değil"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "increment of read-only variable %qD"
 msgid "reflect_constant failed"
 msgstr "salt-okunur değişken %qD için eksiltme"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "birikeç bir tamsayı sabit değil"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "%qD cannot have default arguments"
 msgid "reflection does not have template arguments"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "called object %qE is not a function"
 msgid "reflection does not represent a function or function type"
 msgstr "çağrılan nesne %qE bir işlev değil"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "format string argument not a string type"
 msgid "operators argument is not a valid operator"
 msgstr "biçim dizgesinin argümanı bir dizge türü değil"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "kardeş bildirimi bir sınıf veya işlevi isimlendirmiyor"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 #| msgid "called object %qE is not a function"
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "çağrılan nesne %qE bir işlev değil"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 #| msgid "non-static declaration of %q+D follows static declaration"
 msgid "non-constant offset for offset_of"
 msgstr "%q+D statik olmayan bildirim statik bildirimi izliyor"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "içi boş ture gösterici ilişkilendirme"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment"
 msgid "reflection not suitable for alignment_of"
 msgstr "Yazılabilir veri hizalaması ayarlanmaz"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "assignment of read-only location"
 msgid "alignment_of on function type"
 msgstr "salt-okunur konuma atama"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 msgid "reflection with incomplete type in alignment_of"
 msgstr "%2$qT tamamlanmamış türüne %1$qs uygulanması geçersiz"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "içi boş ture gösterici ilişkilendirme"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr ""
+
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "gimplification failed"
 msgid "reflect_function failed"
 msgstr "gimpleme başarısız"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr ""
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "Unexpected end of module"
 msgid "unexpected value of value member"
 msgstr "Beklenmeyen modül sonu"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "expression in new-declarator must have integral or enumeration type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "new bildirimli ifade bütünleyici ya da numaralama türünde olmalı"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 #| msgid "Expected integer string"
 msgid "reflection represents non-integral or bool type"
 msgstr "Tamsayı dizgesi umuluyordu"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qs attribute"
 msgid "invalid argument to can_substitute"
 msgstr "%qs özniteliğinin argümanı geçersiz"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "creating pointer to member reference type %qT"
 msgid "type is not object or reference type"
 msgstr "%qT üye referans türünde gösterici oluşturulması"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "name is not a valid identifier"
 msgstr "%<%T::%D%> geçerli bir bildirici değil"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "%q+D için yazmaç ismi belirtilmemiş"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 #, fuzzy
 #| msgid "bit-field %q+#D with non-integral type"
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "bit-alanı %q+#D tümleyen türde değil"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %q+D"
 msgid "both alignment and bit_width specified"
 msgstr "hizalama, %q+D için belirtilmiş olmayabilir"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width"
 msgid "bit_width 0 with specified name"
 msgstr "alan uzunluğu"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "sağa kaydırma sayısı negatif"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a power of 2"
 msgid "alignment is not power of two"
 msgstr "istenen hizalama 2 nin kuvveti değil"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "caller edge count is negative"
 msgid "alignment is negative"
 msgstr "çağrıcı ayrıt sayısı negatif"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "assignment (not initialization) in declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "bildirim içinde atama (ilklendirme değil)"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "%qE does not have class type"
+msgid "reflection does not have non-array object type"
+msgstr "%qE sınıf türüne sahip değil"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "cast to union type from type not present in union"
+msgid "current scope does not represent a function"
+msgstr "union içinde mevcut olmayan türden union türe dönüşüm"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "kardeş bildirimi bir sınıf veya işlevi isimlendirmiyor"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qE"
 msgid "incomplete parent class"
 msgstr "%qE sınıfının gerçekleniminin içi boş"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qT is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qT bir sınıf ya da isim alanı değil"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "return type is an incomplete type"
 msgid "not a complete class type"
 msgstr "dönüş türü, bir içi boş tür"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "template parameters cannot be friends"
 msgid "value cannot be extracted"
@@ -25126,54 +25173,54 @@ msgstr ""
 msgid "source type is not polymorphic"
 msgstr ""
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "adaylar:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "tek terimli eksiye yanlış türde argüman"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "tek terimli artıya yanlış türde argüman"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "bit-tümler için yanlış türde argüman"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "abs'a yanlış türde argüman"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "mantıksal çarpım için yanlış türde argüman"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 #| msgid "wrong type argument to unary plus"
 msgid "in argument to unary !"
 msgstr "tek terimli artıya yanlış türde argüman"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr ""
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr ""
 
@@ -25193,76 +25240,76 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "%L'deki satır kırpıldı"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, fuzzy, c-format
 #| msgid "different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "'%s' ve '%s' argümanları 'dot_product' yerleşiği için (%L'de) farklı biçimde"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, fuzzy, c-format
 #| msgid "different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "'%s' ve '%s' argümanları 'dot_product' yerleşiği için (%L'de) farklı biçimde"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, fuzzy, c-format
 #| msgid "different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "'%s' ve '%s' argümanları 'dot_product' yerleşiği için (%L'de) farklı biçimde"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "%qD is not a template"
 msgid "NULL() is not interoperable"
 msgstr "%qD bir şablon değil"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid insn:"
 msgid "BOZ literal constant"
 msgstr "geçersiz komut:"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "invalid expression as operand"
 msgid "Expression is polymorphic"
 msgstr "terim olarak ifade geçersiz"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "expression statement has incomplete type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "ifade deyimi boş tür içeriyor"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "expected statement"
 msgid "Procedure unexpected as argument"
 msgstr "deyim umuluyordu"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 #| msgid "Illegal character in BOZ constant at %C"
 msgid "Type shall have a character length of 1"
 msgstr "%C'de BOZ sabitinde kuraldışı karakter"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "türler tam uyumlu değil"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 #| msgid "Assumed size array '%s' in namelist '%s'at %C is not allowed."
 msgid "Assumed-size arrays are not interoperable"
@@ -25334,7 +25381,7 @@ msgstr ""
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 #| msgid "Array assignment"
 msgid "array assignment"
@@ -25345,17 +25392,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -25539,11 +25586,11 @@ msgstr "blok IF"
 msgid "implied END DO"
 msgstr "örtük END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "atama"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "gösterici ataması"
 
@@ -25551,167 +25598,167 @@ msgstr "gösterici ataması"
 msgid "simple IF"
 msgstr "basit IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 #, fuzzy
 #| msgid "elemental subroutine"
 msgid "elemental procedure"
 msgstr "öğesel altyordam"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "allocatable argument"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 #| msgid "no arguments"
 msgid "asynchronous argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 #| msgid "no arguments"
 msgid "optional argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "pointer assignment"
 msgid "pointer argument"
 msgstr "gösterici ataması"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 #| msgid "no arguments"
 msgid "target argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "value argument"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-shape argument"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 #| msgid "no arguments"
 msgid "assumed-rank argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 #| msgid "no arguments"
 msgid "coarray argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "parametrized derived type argument"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "argüman yok"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 #| msgid "invalid type argument"
 msgid "assumed-type argument"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr ""
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 #, fuzzy
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "result with non-constant character length"
 msgstr "'%s' %L'de bu bağlam için sabit karakter uzunluklu olmalı"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr ""
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr ""
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 #| msgid "Perform variable tracking"
 msgid "iterator variable"
 msgstr "Değişken izleme uygulanır"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 #, fuzzy
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "Start expression in DO loop"
 msgstr "%L'de Do döngüsündeki adım ifadesi sıfır olamaz"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 #| msgid "invalid expression as operand"
 msgid "End expression in DO loop"
 msgstr "terim olarak ifade geçersiz"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 #, fuzzy
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "Step expression in DO loop"
 msgstr "%L'de Do döngüsündeki adım ifadesi sıfır olamaz"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 #, fuzzy
 #| msgid "DEALLOCATE "
 msgid "DEALLOCATE object"
 msgstr "YERAÇ "
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 #, fuzzy
 #| msgid "ALLOCATE "
 msgid "ALLOCATE object"
 msgstr "AYIR "
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr ""
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr ""
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr ""
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr ""
 
@@ -25720,31 +25767,31 @@ msgstr ""
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr ""
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -25810,27 +25857,27 @@ msgstr "%L'de SQRT'nin argümanı negatif değer içeriyor"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -25942,7 +25989,7 @@ msgid "expected boolean type"
 msgstr "İfade türü umuluyordu"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 #| msgid "Expected integer"
 msgid "expected integer"
@@ -26024,7 +26071,7 @@ msgstr "argüman yok"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments for format"
 msgid "too many arguments"
@@ -26517,7 +26564,7 @@ msgstr "VxWorks için profilci desteği"
 msgid "target OS does not support unaligned accesses"
 msgstr "hedef işlemci beraber çalışmayı desteklemiyor"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 #| msgid "profiling is still experimental for this target"
 msgid "profiling is not yet implemented for this architecture"
@@ -26784,13 +26831,13 @@ msgstr "'-%s' seçeneği bilinmiyor"
 msgid "Global declarative %s for %s"
 msgstr "%q+#D genel bildirimi"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -26972,13 +27019,13 @@ msgstr "%qs önerilmiyor"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %qs"
 msgid "unknown autovec preference %qs"
 msgstr "parametre %qs kullanılmamış"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -27469,8 +27516,8 @@ msgstr "%s özniteliği ile %s özniteliği %L'de çelişiyor"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "previous declaration here"
@@ -27490,7 +27537,7 @@ msgstr "%qs öznitelik yönergesi yoksayıldı"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%qs öznitelik yönergesi yoksayıldı"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments specified for %qE attribute"
@@ -27502,7 +27549,7 @@ msgstr "%qs özniteliği için belirtilen argüman sayısı yanlış"
 msgid "expected %i or more, found %i"
 msgstr "Beklenmeyen modül sonu"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %i, found %i"
@@ -27589,12 +27636,12 @@ msgstr "tür öznitelikleri sadece tür tanımlarında uygulanabilir"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -27716,140 +27763,140 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "ayrıt %s->%s için karşılığı olan çağrı deyimi yok"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "location is after end of function"
 msgstr "%qT dizisi oluşturulması"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr ""
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "cannot open profile file %s"
 msgstr "İçerilmiş '%s' dosyası açılamıyor"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "%qT türündeki argüman %qT ile eşleşmiyor"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "can't create repository information file %qs"
 msgid "cannot read summary information from %s"
 msgstr "depo bilgisi %qs dosyasında oluşturulamıyor"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize %qT from %qT"
 msgid "cannot read string table from %s"
 msgstr "%qT türü %qT türünden ilklendirilemez"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read function profile from %s"
 msgstr "sınıf %s için dosya bulunamıyor"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot find file for class %s"
 msgid "cannot read module profile from %s"
@@ -27861,7 +27908,7 @@ msgstr "sınıf %s için dosya bulunamıyor"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "göreli konum sabit dizgenin sınırlarının dışında"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qE declared here"
@@ -27976,7 +28023,7 @@ msgstr "sabit argüman %qs için aralık dışında"
 msgid "illegal argument 0 to %qs"
 msgstr "\"%s\" için argüman eksik"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -28059,12 +28106,12 @@ msgstr "%H%D için son argüman 0 .. 3 arasında bir tamsayı sabit değil"
 msgid "cannot tail-call: %s"
 msgstr "[%s bulunamıyor]"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "işlev çağrısı küme değeri içeriyor"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 #| msgid "Pass arguments on the stack"
 msgid "passing too large argument on stack"
@@ -28758,140 +28805,140 @@ msgstr "temel bloklar ardışık numaralı değil"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "komut zinciri (%d) içindeki bb notlarının sayısı != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 #| msgid "caller edge count is negative"
 msgid "caller edge count invalid"
 msgstr "çağrıcı ayrıt sayısı negatif"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "missing direct call for speculation %i"
 msgstr "'%s' işlevinde argüman listesi eksik (%C'de)"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Create console application"
 msgid "missing ref for speculation %i"
 msgstr "Konsol uygulaması oluşturulur"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "ayrıt %s->%s için yardımcı alan belirtilmiş"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline clone count is not compatible"
 msgstr "ilklendirici öğe bir sabit değil"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "tp_first_run must be non-negative"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 #| msgid "Assume symbols might be invalid"
 msgid "local symbols must be defined"
 msgstr "Tüm simgelerin geçersiz olabileceği varsayılır"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "%D renamed after being referenced in assembly"
 msgid "inline clone is referenced by assembly"
 msgstr "makina dilinde referanslandıktan sonra %D yeniden isimlendirilmiş."
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with a value, in function returning 'void'"
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "'void' dönüşlu işlevde değer içeren `return' deyimi"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid ""
 #| "\n"
@@ -28901,221 +28948,221 @@ msgstr ""
 "\n"
 "Hedefe özel seçenekler:\n"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "aux field set for edge %s->%s"
 msgid "aux field set for indirect edge from %s"
 msgstr "ayrıt %s->%s için yardımcı alan belirtilmiş"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "edge count is not compatible with function count"
 msgstr "-march=%s seçilen ABI ile uyumsuz"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "-march=%s seçilen ABI ile uyumsuz"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "inlined_to göstericisi yanlış"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "çok sayıda satıriçi çağrısı"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "Inlined_to göstericisi satıriçi olmayan çağrıcılar için belirtilmiş"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "caller edge count does not match BB count"
 msgstr "gelen ayrıt sayısı PHI argüman sayısı ile uyuşmuyor"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "incoming edge count does not match number of PHI arguments"
 msgid "indirect call count does not match BB count"
 msgstr "gelen ayrıt sayısı PHI argüman sayısı ile uyuşmuyor"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, fuzzy, gcc-internal-format
 #| msgid "inlined_to pointer is set but no predecesors found"
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "inlined_to göstericisi var ama bir öncül yok"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "Inlined_to göstericisi kendini gösteriyor"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr ""
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr ""
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr ""
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr ""
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "paylaşımlı call_stmt:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "yanlış bildirimin köşeleri:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "çağrı deyimi için çağrı çizgesi ayrıtı eksik"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "reference to dead statement"
 msgstr "deyim umuluyordu"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "ayrıt %s->%s için karşılığı olan çağrı deyimi yok"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "ayrıt %s->%s için karşılığı olan çağrı deyimi yok"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "origin points to a different parent"
 msgstr "göstericiden farklı tamsayı türlere dönüşüm"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node başarısız"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to '-%s' is missing"
 msgid "%s: section %s.%d is missing"
@@ -29964,17 +30011,17 @@ msgstr "%Jyerel nesnelerin toplam boyutu çok büyük"
 msgid "impossible constraint in %<asm%>"
 msgstr "%<asm%> içindeki kısıt imnkansız"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "değişken %q+D %<longjmp%> ya da %<vfork%> tarafından taşırılmış olabilir"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "argüman %q+D `%<longjmp%> ya da %<vfork%> tarafından taşırılmış olabilir"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "işlev bir küme ile dönüyor"
@@ -30738,7 +30785,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "%Jesnek dizi yapının son üyesi değil"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -30780,7 +30827,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 #| msgid "label %q+D defined but not used"
 msgid "%qD defined here"
@@ -30804,24 +30851,24 @@ msgstr "PRINT_OPERAND boş gösterici"
 msgid "function may return address of local variable"
 msgstr "işlev yerel değişkenin adresi ile dönüyor"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "işlev yerel değişkenin adresi ile dönüyor"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -31723,7 +31770,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "returned from %qD"
@@ -31803,229 +31850,229 @@ msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "%qs ile belirtilmiş sınıf ismi yok"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of %qs"
 msgid "invalid memory model %qs for %qD"
 msgstr "%qs için tür argümanı geçersiz"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of %qs"
 msgid "invalid memory model %wi for %qD"
 msgstr "%qs için tür argümanı geçersiz"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "invalid argument of %qs attribute"
 msgid "valid models are %e"
 msgstr "%qs özniteliğinin argümanı geçersiz"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument of %qs"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "%qs için tür argümanı geçersiz"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Statement function at %L is recursive"
 msgid "argument %i value %s is negative"
 msgstr "%L'deki deyim işlevi iç içe"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "referencing argument %u of type %qT"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared with attribute noinline"
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "%q+D işlevinin yeniden bildirimi inline öznitelikli değil"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "%qE özniteliği için vektör türü geçersiz"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "in a call to function %qD"
 msgstr "işlev olmayan %qD ye çağrı"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "in a call with type %qT"
 msgstr "  %qD çağrısında"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "assigned here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "pointer %qE may be used after %qD"
 msgstr "%s den %s e dönüşüm yapılamaz (%L'de)"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "pointer %qE used after %qD"
 msgstr "%s den %s e dönüşüm yapılamaz (%L'de)"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "hizalama, %q+D için belirtilmiş olmayabilir"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %q+D"
 msgid "pointer used after %qD"
 msgstr "parametre %q+D kullanılmamış"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD here"
 msgstr "  %qD çağrısında"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "gösterici kipi olarak %qs geçersiz"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "%qD üyesine gösterici varsayılıyor"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "gösterici kipi olarak %qs geçersiz"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qD declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "bilinmeyen yazmaç ismi: %s"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "unnamed temporary defined here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 #| msgid "implicit declaration of function %qE"
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "%qE işlevinin örtük bildirimi"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  %qD çağrısında"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -32878,371 +32925,371 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "%<::%> kullanımı geçersiz"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 #| msgid "initializer specified for non-virtual method %q+D"
 msgid "contains additional virtual method %qD"
 msgstr "sanal olmayan yöntem %q+D için ilklendirici belirtilmiş"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in initialization"
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "ilklendirmede uyumsuz türler"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "%Jönceden burada tanımlı"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "%Jönceden burada tanımlı"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "a different type is defined in another translation unit"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in initialization"
 msgid "the incompatible type defined in another translation unit"
 msgstr "ilklendirmede uyumsuz türler"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "type name %qs should match type name %qs"
 msgstr "%qT türü %qT türünden türetilmemiş"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in return"
 msgid "the incompatible type is defined here"
 msgstr "dönüş değerinde uyumsuz türler"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "array types have different bounds"
 msgstr "?: için terimler farklı türde"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "return value type mismatch"
 msgstr "alan ilklendirici türü uyumsuzluğu"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Type/rank mismatch in argument '%s' at %L"
 msgid "type mismatch in parameter %i"
 msgstr "Argüman '%s' için tür/sira uyumsuzluğu (%L'de)"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "types have different parameter counts"
 msgstr "?: için terimler farklı türde"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "%Jönceden burada tanımlı"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "type %qT should match type %qT"
 msgstr "%qT türü %qT türünden türetilmemiş"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "has different parameters in another translation unit"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "fields have different layout in another translation unit"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "memory layout mismatch"
 msgstr "alan ilklendirici türü uyumsuzluğu"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "the extra base is defined here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 msgstr[1] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "%Jönceden burada tanımlı"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -33263,7 +33310,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "invalid jump function in LTO stream"
@@ -33511,12 +33558,12 @@ msgstr "%qs parametresinin azami değeri %u'dur."
 msgid "unable to find a register to spill"
 msgstr "%qs sınıfı içinde dökülecek bir yazmaç bulunamadı"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "bir %<asm%> içindeki terim terim kısıtı tutarsız"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Set number of queued insns that can be prematurely scheduled"
 msgid "maximum number of generated reload insns per insn achieved (%d)"
@@ -33912,7 +33959,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -35395,25 +35442,25 @@ msgstr "örtük olarak çekilmiş yazmaçlar yığıtın tepesinde gruplanmalı"
 msgid "output operand %d must use %<&%> constraint"
 msgstr "çıktı terimi %d %<&%> kısıtını kullanmalı"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data: [%u] Boş zincir için next_regno hatalı (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data: regno zinciri içinde döngü (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data: [%u] oldest_regno hatalı (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -36433,190 +36480,190 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr "Döngü eniyilemeleri uygulanır"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "ADDR_EXPR değişirken sabit yeniden hesaplanmadı"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "ADDR_EXPR değişirken yan etkiler yeniden hesaplanmadı"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "adres alındı, ama ADDRESSABLE biti etkin değil"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs:"
 msgid "non-scalar %qs"
 msgstr "%qs işlevinde:"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid position or size operand to %qs"
 msgstr "kısıtlar terim için geçersiz"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qs has non-integer type"
 msgid "%qs of non-mode-precision operand"
 msgstr "%qs dizisinin boyutu tamsayı tür değil"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "type mismatch in %qs reference"
 msgstr "%L'de dizi başvurusunda sıra uyumsuz (%d/%d)"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "conversion of register to a different size in %qs"
 msgstr "göstericiden farklı tamsayı türlere dönüşüm"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "%%R için terim geçersiz"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "Type/rank mismatch in argument '%s' at %L"
 msgid "type mismatch in %qs"
 msgstr "Argüman '%s' için tür/sira uyumsuzluğu (%L'de)"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%f operand"
 msgid "invalid %qs offset operator"
 msgstr "geçersiz %%f terimi"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid address operand in %qs"
 msgstr "%%R için terim geçersiz"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid offset operand in %qs"
 msgstr "%%R için terim geçersiz"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "%qD kullanımı geçersiz"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "basit IF"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "doğrudan değer gereken yerde yapı türünde değer kullanılmış"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "invalid expression for min lvalue"
 msgstr "terim olarak ifade geçersiz"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "invalid function in gimple call"
 msgstr "işlev bildirimi geçersiz"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 #| msgid "function not inlinable"
 msgid "non-function in gimple call"
 msgstr "işlev satıriçine alınabilir değil"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 #| msgid "invalid storage class for function %qs"
 msgid "invalid pure const state for function"
 msgstr "%qs işlevi için geçersiz saklama sınıfı"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PC in line number table"
 msgid "invalid LHS in gimple call"
 msgstr "satır numarası tablosunda geçersiz program sayacı (PC)"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion in gimple call"
 msgstr "%<__fpreg%> türüne dönüşüm geçersiz"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PC in line number table"
 msgid "invalid static chain in gimple call"
 msgstr "satır numarası tablosunda geçersiz program sayacı (PC)"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -36627,679 +36674,679 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_next_arg%> argümansız çağrılmış"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to builtin function"
 msgid "invalid argument to gimple call"
 msgstr "yerleşik işleve aktarılan argüman geçersiz"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operands in gimple comparison"
 msgstr "komuttaki terim geçersiz"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, fuzzy, gcc-internal-format
 #| msgid "function returning a function"
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "bir işlev döndüren işlev"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for %q+#D"
 msgid "invalid vector comparison resulting type"
 msgstr "%q+#D için ortak değişen dönüş türü geçersiz"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operand in unary operation"
 msgstr "komuttaki terim geçersiz"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "invalid vector types in nop conversion"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "invalid types in nop conversion"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "invalid types in address space conversion"
 msgstr "terim olarak ifade geçersiz"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid types in fixed-point conversion"
 msgstr "komuttaki terim geçersiz"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid types in conversion to floating-point"
 msgstr "%<__fpreg%> türüne dönüşüm geçersiz"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid types in conversion to integer"
 msgstr "%<__fpreg%> türüne dönüşüm geçersiz"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in %qs expression"
 msgstr "koşullu ifadede tür uyumsuzluğu"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid types for %qs"
 msgstr "%q+D için soyut tür geçersiz"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid type for %qs"
 msgstr "%q+D için soyut tür geçersiz"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, fuzzy, gcc-internal-format
 #| msgid "Elemental binary operation"
 msgid "non-register as LHS of binary operation"
 msgstr "Öğesel ikilik işlem"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operands to binary %s"
 msgid "invalid operands in binary operation"
 msgstr "iki terimli %s için terimler geçersiz"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid non-vector operands to %qs"
 msgstr "%%R için terim geçersiz"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "gösterici kipi olarak %qs geçersiz"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "vector type expected in %qs"
 msgstr "ifade umuluyordu"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in conditional expression"
 msgid "type mismatch in binary expression"
 msgstr "koşullu ifadede tür uyumsuzluğu"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operands in ternary operation"
 msgstr "komuttaki terim geçersiz"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "vector types expected in %qs"
 msgstr "ifade umuluyordu"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "vectors with different element number found in %qs"
 msgstr "?: için terimler farklı türde"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rotate insn"
 msgid "invalid mask type in %qs"
 msgstr "geçersiz döngü komutu"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "not allowed type combination in %qs"
 msgstr "desteklenmeyen birleşim: %s"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid position or size in %qs"
 msgstr "gösterici kipi olarak %qs geçersiz"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qs has non-integer type"
 msgid "%qs into non-mode-precision operand"
 msgstr "%qs dizisinin boyutu tamsayı tür değil"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for %qs"
 msgid "insertion out of range in %qs"
 msgstr "sabit argüman %qs için aralık dışında"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qs not at element boundary"
 msgstr "%q+D bir işlev değil,"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "non-trivial conversion in %qs"
 msgstr "atamanın sol tarafı geçersiz"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "atamanın sol tarafı geçersiz"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "%qs LHS in clobber statement"
 msgstr "deyim umuluyordu"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "%%R için terim geçersiz"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid IACC argument"
 msgid "invalid %qs size argument in load"
 msgstr "IACC argümanı geçersiz"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid indirect memory address"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "geçersiz dolaylı bellek adresi"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "Elemental binary operation"
 msgid "non-register as LHS with vector constructor"
 msgstr "Öğesel ikilik işlem"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr ""
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "incorrect number of vector %qs elements"
 msgstr "%qE işlevi için çok az argüman belirtildi"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 #| msgid "PHI def is not a GIMPLE value"
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "PHI tanımı bir GIMPLE değeri değil"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "non-vector %qs with elements"
 msgstr "?: için terimler farklı türde"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "data member %qD cannot be a member template"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "veri üyesi %qD bir üye şablon olamaz"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand in the instruction"
 msgid "invalid operand in return statement"
 msgstr "komuttaki terim geçersiz"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "invalid conversion in return statement"
 msgstr "asm deyiminde geçersiz sol taraf"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "goto destination is neither a label nor a pointer"
 msgstr "indisli değer ne dizi ne de bir gösterici"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%s code"
 msgid "invalid operand to switch statement"
 msgstr "%%s kodu için terim geçersiz"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "Generate code for huge switch statements"
 msgid "non-integral type switch statement"
 msgstr "huge switch deyimleri için kod üretilir"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "%<default%> label not within a switch statement"
 msgid "invalid default case label in switch statement"
 msgstr "%<default%> etiketi bir switch deyimi içinde değil"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr ""
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "invalid case label in switch statement"
 msgstr "case etiketi bir switch deyimi içinde değil"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "invalid case range in switch statement"
 msgstr "asm deyiminde geçersiz sol taraf"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type precision mismatch in switch statement"
 msgstr "case etiketi bir switch deyimi içinde değil"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "type mismatch for case label in switch statement"
 msgstr "case etiketi bir switch deyimi içinde değil"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 #| msgid "case label not within a switch statement"
 msgid "case labels not sorted in switch statement"
 msgstr "case etiketi bir switch deyimi içinde değil"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "label context is not the current function declaration"
 msgstr "işlev bildiriminde (türleri belirtmeksizin) parametre isimleri"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, fuzzy, gcc-internal-format
 #| msgid "format string has invalid operand number"
 msgid "incorrect setting of landing pad number"
 msgstr "biçim dizgesi geçersiz sayıda terim içeriyor"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%p code"
 msgid "invalid comparison code in gimple cond"
 msgstr "%%p kodu için terim geçersiz"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in increment"
 msgid "invalid labels in gimple cond"
 msgstr "arttırmada geçersiz sol taraf"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid address"
 msgid "invalid %<PHI%> result"
 msgstr "adres geçersiz"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "missing %<PHI%> def"
 msgstr "tanım eksik"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid IACC argument"
 msgid "invalid %<PHI%> argument"
 msgstr "IACC argümanı geçersiz"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "atamada uyumsuz türler"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_stmts failed"
 msgid "%<verify_gimple%> failed"
 msgstr "verify_stmts başarısız"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "implicit declaration of function %qE"
 msgid "local declaration from a different function"
 msgstr "%qE işlevinin örtük bildirimi"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "bb_for_stmt (phi) is set to a wrong basic block"
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "bb_for_stmt (phi) yanlış temel bloka atanmış"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, fuzzy, gcc-internal-format
 #| msgid "from this location"
 msgid "PHI node with location"
 msgstr "buradan"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "Ağaç düğümlerinin paylaşımı yanlış"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, fuzzy, gcc-internal-format
 #| msgid "bb_for_stmt (stmt) is set to a wrong basic block"
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "bb_for_stmt (stmt) yanlış temel bloka atanmış"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "deyim yakalama için imli, ama olmuyor."
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "Deyim blokun ortasında yakalama için imlenmiş"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, fuzzy, gcc-internal-format
 #| msgid "verify_stmts failed"
 msgid "verify_gimple failed"
 msgstr "verify_stmts başarısız"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY_BLOCK has a statement list associated with it"
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK onunla ilişkili bir deyim listesi içeriyor"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, fuzzy, gcc-internal-format
 #| msgid "EXIT_BLOCK has a statement list associated with it"
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK onunla ilişkili bir deyim listesi içeriyor"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "bb %d deki çıkışa düşüş"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "ilklendiricinin sonunda fazladan parantezli grup"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "ilklendiricinin sonunda fazladan parantezli grup"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "exit block count is not compatible with entry block count"
 msgstr "-march=%s seçilen ABI ile uyumsuz"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing initializer"
 msgid "count of bb %d not initialized"
 msgstr "ilklendirici yok"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-march=%s seçilen ABI ile uyumsuz"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 #| msgid "Label '%s' at %C doesn't match IF label '%s'"
 msgid "label %qD to block does not match in bb %d"
 msgstr "Yafta '%s' IF yaftası '%s' ile eşleşmiyor (%C'de)"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "label %qD has incorrect context in bb %d"
 msgstr "%qD alanı içi boş türde"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "%d. temel blokun ortasında denetim akışı"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "control flow in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "%d. temel blokun ortasında denetim akışı"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "bb %d içinde bir denetim deyimi sonrası düşen kenar"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "fallthru edge after a control statement in bb %d"
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "bb %d içinde bir denetim deyimi sonrası düşen kenar"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "bb %d sonunda çıkan ayrıt bayrağı sayısı yanlış"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "bb %d sonunda açıkça goto"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "dönüş ayrıtı bb %d içindeki çıkışı göstermiyor"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, fuzzy, gcc-internal-format
 #| msgid "found default case not at end of case vector"
 msgid "found default case not at the start of case vector"
 msgstr "default case, case vektörünün sonunda değil"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 #| msgid "case labels not sorted:"
 msgid "case labels not sorted: "
 msgstr "sırasız case etiketleri:"
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "fazladan çıkan ayrıt %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "ayrıt %i->%i eksik"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<noreturn%> function does return"
 msgid "%<noreturn%> function does return"
 msgstr "%H%<noreturn%> işlev değer döndürüyor"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, fuzzy, gcc-internal-format
 #| msgid "%Hcontrol reaches end of non-void function"
 msgid "control reaches end of non-void function"
 msgstr "%Hdenetim void olmayan işlevin sonunu aşıyor"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "%H%qD dönüş değeri yoksayılıyor, warn_unused_result özniteliği ile bildirilmiş"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of function declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -37495,13 +37542,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "%qE özniteliği için vektör türü geçersiz"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -38041,7 +38088,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -38479,12 +38526,12 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
@@ -38492,19 +38539,19 @@ msgstr ""
 msgid "previous declaration of %qD"
 msgstr "%q+D bildiriminin önceki bildirimi"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with previous using declaration %q#D"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D önceki using bildirimi %q#D ile çelişiyor"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "%q#D conflicts with previous using declaration %q#D"
 msgid "%qD conflicts for version %qB"
 msgstr "%q#D önceki using bildirimi %q#D ile çelişiyor"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%q#D conflicts with previous using declaration %q#D"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -38590,7 +38637,7 @@ msgstr "bss bölümüne sıfır ilklendirmeli veri yerleştirilir"
 msgid "no initializers are allowed in section %qs"
 msgstr "üye %qs için ilk değer geçersiz"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "%q+D için yazmaç ismi belirtilmemiş"
@@ -38751,7 +38798,7 @@ msgstr "weakref %q+D eninde sonunda kendini hedefliyor"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "üye işlev %qD static ilintilemeli olarak bildirilemez"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "alias definitions not supported in this configuration"
@@ -38798,62 +38845,62 @@ msgstr "Paketlenmiş yığıt yerleşimi kullanılır"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "%d. şablon argümanı geçersiz"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "%d. şablon argümanı geçersiz"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "%qE attribute argument has type %qT"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "%qs öznitelik argümanı bir tamsayı sabit değil"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "%qs öznitelik argümanı bir tamsayı sabit değil"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "öntanımlı argümanlara sadece işlev parametresi olarak izin verilir"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "öntanımlı argümanlara sadece işlev parametresi olarak izin verilir"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "öntanımlı argümanlara sadece işlev parametresi olarak izin verilir"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -38870,13 +38917,13 @@ msgstr "%qE özniteliği sadece değişkin işlevlere uygulanır"
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "%qE özniteliği veri türlerinde yoksayılır"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
@@ -39111,13 +39158,13 @@ msgstr "%qs kipi sembolik sabit türler için kullanılamaz"
 msgid "mode %qs applied to inappropriate type"
 msgstr "%qs kipi ilgisiz türe uygulanmış"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attributes are not supported for this target"
 msgid "section attributes are not supported for this target"
 msgstr "%Jbölüm öznitelikleri bu hedef için desteklenmiyor"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "bölüm özniteliğine %q+D için izin verilmez"
@@ -39128,19 +39175,19 @@ msgstr "bölüm özniteliğine %q+D için izin verilmez"
 msgid "section attribute argument not a string constant"
 msgstr "%qs öznitelik argümanı bir dizge sabit değil"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "section attribute cannot be specified for local variables"
 msgstr "%Jbölüm özniteliği yerel değişkenler için belirtilmiş olamaz"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "%q+D bölümü önceki bildirimle çelişiyor"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be overloaded"
 msgid "section of %q+D cannot be overridden"
@@ -39241,7 +39288,7 @@ msgstr "cleanup argümanı bir betimleyici değil"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "%q+D veri alanı önceki bildirimle çelişiyor"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "inline function %q+D declared weak"
@@ -39296,13 +39343,13 @@ msgstr "%qs özniteliği sadece değişkenlere uygulanır"
 msgid "%qE attribute is only applicable on functions"
 msgstr "%qs özniteliği sadece işlevlere uygulanır"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "%qs özniteliği sadece işlevlere uygulanır"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -39314,12 +39361,12 @@ msgstr "%qs özniteliği sadece değişkenlere uygulanır"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "%qs öznitelik argümanı bir dizge sabit değil"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -39424,25 +39471,25 @@ msgstr "%qE özniteliği sınıf türleri dışında yoksayılır"
 msgid "visibility argument not a string"
 msgstr "visibility argümanı bir dizge değil"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "%qE özniteliği veri türlerinde yoksayılır"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "%qs öznitelik argümanı bir dizge sabit değil"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD redeclared with different visibility"
 msgstr "%qD farklı erişimle tekrar bildirilmiş"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -39460,7 +39507,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applies only to functions"
@@ -39540,7 +39587,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -39629,7 +39676,7 @@ msgstr "assert: %s %s ile uyumlu atanıyor"
 msgid "%qE argument is not a function"
 msgstr "cleanup argümanı bir işlev değil"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "deprecated message is not a string"
@@ -39702,7 +39749,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "%qE özniteliği veri türlerinde yoksayılır"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qE attribute requires a string argument"
@@ -39876,16 +39923,16 @@ msgid "requested position is less than zero"
 msgstr "istenen konum sıfırdan küçük"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "empty string in attribute %<target%>"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%qE attribute argument not a string constant"
@@ -40183,7 +40230,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "atamayı sarmalayan parantezler muhtemelen doğruluk değeri olarak kullanılmış"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "%<restrict%> kullanımı geçersiz"
@@ -40367,8 +40414,8 @@ msgstr "değişken argümanları bir gözcüyü doldurmak için yetersiz"
 msgid "missing sentinel in function call"
 msgstr "işlev çağrısında gözcü eksik"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -41467,7 +41514,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr "geleneksel C dizge sabitlerin birleştirilmesine izin vermez"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -41524,7 +41571,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, fuzzy, gcc-internal-format
 #| msgid "invalid vector type for attribute %qE"
 msgid "invalid type for iteration variable %qE"
@@ -41542,18 +41589,18 @@ msgstr "%qE özniteliği için vektör türü geçersiz"
 msgid "%qE is not initialized"
 msgstr "ilklendirici yok"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conditional operand"
 msgid "invalid controlling predicate"
 msgstr "koşullu terim geçersiz"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 #| msgid "assignment suppression"
 msgid "missing increment expression"
@@ -41564,7 +41611,7 @@ msgstr "atama engelleme"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 #| msgid "invalid truth-value expression"
 msgid "invalid increment expression"
@@ -41667,19 +41714,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is not a function argument"
 msgstr "%qD bir işlev şablonu değil"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qs has invalid type"
 msgid "bit-field %qE in %qs clause"
@@ -41691,8 +41738,8 @@ msgstr "%qs bit alanı geçersiz tür içeriyor"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qD bir şablon türü bildirmiyor"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "%<_Atomic%> %qE in %qs clause"
@@ -42273,7 +42320,7 @@ msgstr "%<#pragma align%> için hizalama geçersiz - yoksayıldı"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "%<#pragma pack%> bozuk - yoksayıldı"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, fuzzy, gcc-internal-format
 #| msgid "junk at end of #pragma %s"
 msgid "junk at end of %<#pragma %s%>"
@@ -42350,8 +42397,8 @@ msgstr "%<#pragma%> burada kullanılamaz"
 msgid "wrong type argument to %s"
 msgstr "abs'a yanlış türde argüman"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -42890,19 +42937,19 @@ msgstr "%qs işlevi için argümanlar çok az"
 msgid "function %qD used as %<asm%> output"
 msgstr "salt-okunur konum %<asm%> çıktısı olarak kullanılmış"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, fuzzy, gcc-internal-format
 #| msgid "assignment of read-only location"
 msgid "assignment of read-only location %qE"
 msgstr "salt-okunur konuma atama"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, fuzzy, gcc-internal-format
 #| msgid "increment of read-only location"
 msgid "increment of read-only location %qE"
 msgstr "salt-okunur konuma eksiltim"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, fuzzy, gcc-internal-format
 #| msgid "decrement of read-only location"
 msgid "decrement of read-only location %qE"
@@ -43204,7 +43251,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume
 msgstr[0] "%2$qE işlevinin %1$d. argümanına aktarım gösterici hedef türündeki niteleyicileri iptal ediyor"
 msgstr[1] "%2$qE işlevinin %1$d. argümanına aktarım gösterici hedef türündeki niteleyicileri iptal ediyor"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -44217,7 +44264,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -44893,7 +44940,7 @@ msgstr "belirgin Nesnel-C türündeki %2$qE işlevinin %1$d. argümanının akta
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of %q+D"
 msgid "duplicate definition of %qs"
@@ -44947,7 +44994,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "%qT türü bilinen bir boyuta sahip değil"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -45006,7 +45053,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -45111,19 +45158,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec argümanı prototipsiz işleve aktarıldı"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -45171,198 +45218,198 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "%qs özniteliği yoksayıldı"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on %<__fpreg%>"
 msgid "invalid format for %<sve_width%>"
 msgstr "%<__fpreg%> üzerinde geçersiz işlem"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%H value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "%%H değeri geçersiz"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid floating point option: -mfpu=%s"
 msgid "tuning string missing in option (%s)"
 msgstr "geçersiz gerçel değer seçeneği: -mfpu=%s"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown spec function '%s'"
 msgid "unknown tuning option (%s)"
 msgstr "bilinmeyen '%s' spec işlevi"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs geçerli bir çıktı dosyası değil"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "streaming functions require the ISA extension %qs"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "%<__builtin_frame_address%>'e aktarılan argüman geçersiz"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "%<__builtin_frame_address%>'e aktarılan argüman geçersiz"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march= switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "-mcpu=%s ile -march= seçenekleri çelişiyor"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "does not support multilib"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "multilib desteklenmiyor"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%qs önerilmiyor"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %s not supported in PIC mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "PIC kipinde %s kod modeli desteklenmiyor"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 #| msgid "missing %<(%> after %<#pragma pack%> - ignored"
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "%<#pragma pack%> sonrasında %<(%> eksik - yoksayıldı"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
@@ -45370,24 +45417,24 @@ msgstr "%<#pragma pack%> sonrasında %<(%> eksik - yoksayıldı"
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "%<#pragma init%> bozuk"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -45396,211 +45443,211 @@ msgstr ""
 msgid "attribute %<target%> argument not a string"
 msgstr "alias argümanı bir dizge değil"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 #| msgid "alias argument not a string"
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "alias argümanı bir dizge değil"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 #| msgid "alias argument not a string"
 msgid "attribute %<target_version%> has multiple values"
 msgstr "alias argümanı bir dizge değil"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "alias argument not a string"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "alias argümanı bir dizge değil"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "missing %<(%> after %<#pragma pack%> - ignored"
 msgid "missing value in %<target_version%> attribute"
 msgstr "%<#pragma pack%> sonrasında %<(%> eksik - yoksayıldı"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "yığıt sınırlama ifadesi desteklenmiyor"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_eh_return not supported on this target"
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "__builtin_eh_return bu hedefte desteklenmiyor"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported simdlen %wd"
 msgstr "desteklenmeyen birleşim: %s"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "$ tarzı biçimde kullanılmamış argümanlar"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "unsupported return type %qT for simd"
 msgstr "$ tarzı biçimde kullanılmamış argümanlar"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "$ tarzı biçimde kullanılmamış argümanlar"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 #| msgid "unused arguments in $-style format"
 msgid "unsupported argument type %qT for simd"
 msgstr "$ tarzı biçimde kullanılmamış argümanlar"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "-shared seçeneği VAX ELF için şu an desteklenmiyor."
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "type attributes are honored only at type definition"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "tür öznitelikleri sadece tür tanımlarında uygulanabilir"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "label %q+D defined but not used"
 msgid "%q+D defined here"
 msgstr "%q+D yaftası tanımlı ama kullanılmamış"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 #| msgid "%Hfirst argument of %D must be a pointer, second integer constant"
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "%H%D için ilk argüman bir gösterici, ikinci argüman sabit olmalıdır"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı farklı genişlikte değer aktarılması"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "%L'deki ATANH argümanı -1 .. 1 aralığının içinde kalmalı"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı farklı genişlikte değer aktarılması"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı farklı genişlikte değer aktarılması"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı farklı genişlikte değer aktarılması"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 #| msgid "invalid argument of %qs attribute"
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
@@ -45810,12 +45857,12 @@ msgstr "%qs özniteliğinin argümanı \"ilink1\" ya da \"ilink2\" değildir"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
@@ -45966,24 +46013,24 @@ msgid "argument of %qE attribute ignored"
 msgstr "%qE özniteliği yoksayıldı"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "%qE attribute only applies to variables"
 msgstr "%qs özniteliği sadece değişkenlere uygulanır"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown %<asm%> flag output %qs"
 msgstr "%qs makine kipi bilinmiyor"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid type for %<asm%> flag output"
@@ -46575,13 +46622,13 @@ msgstr "-pipe desteklenmiyor"
 msgid "%<-fPIE%> is not supported"
 msgstr "-pipe desteklenmiyor"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 #| msgid "-G and -static are mutually exclusive"
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-G ve -static birlikte kullanılamaz"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%qs function cannot have arguments"
@@ -46592,7 +46639,7 @@ msgstr "%qD öntanımlı argümanlara sahip olamaz"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 #| msgid "Function does not return a value"
 msgid "%qs function cannot return a value"
@@ -46962,7 +47009,7 @@ msgstr ""
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to builtin function"
 msgid "invalid argument to built-in function"
@@ -47314,7 +47361,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -47501,196 +47548,196 @@ msgstr "%qs argümanı 2 bitlik işaretsiz bir sabit olmalı"
 msgid "parameter to builtin not valid: %s"
 msgstr "-ffpe-trap seçeneğinin argümanı geçersiz: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt Service Routines cannot be coded in Thumb mode"
 msgid "interrupt service routine cannot be called directly"
 msgstr "sistem kesmesi Servis İşlemleri Thumb kipinde kodlanamaz"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 2-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 #| msgid "shift must be an immediate"
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "shift bir anlık değer olmalı"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the third argument must be an 8-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be an 1-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 3-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be a 4-bit unsigned literal"
 msgid "the last argument must be a 4-bit immediate"
 msgstr "3. argüman 4 bitlik bir işaretsiz sabit olmalı"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 1-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid floating point option: -mfpu=%s"
 msgid "'%s' needs isa option %s"
 msgstr "geçersiz gerçel değer seçeneği: -mfpu=%s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 5-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be an 8-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the third argument must be comparison constant"
 msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect insn:"
 msgid "incorrect comparison mode"
 msgstr "yanlış komut:"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect sharing of tree nodes"
 msgid "incorrect rounding operand"
 msgstr "Ağaç düğümlerinin paylaşımı yanlış"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 #| msgid "argument 3 must be a 4-bit unsigned literal"
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "3. argüman 4 bitlik bir işaretsiz sabit olmalı"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the fourth argument must be one of enum %qs"
 msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "seçici 0..%wi aralığında bir tamsayı sabit olmalı"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%> için 2. argüman geçersiz; sıfır kullanılıyor"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid IACC argument"
 msgid "invalid third argument"
 msgstr "IACC argümanı geçersiz"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%> için 3. argüman geçersiz; sıfır kullanılıyor"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%> için 3. argüman geçersiz; sıfır kullanılıyor"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "tls_model argument not a string"
 msgid "second argument must be a const"
 msgstr "tls_model argümanı bir dizge değil"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the last argument must be a 32-bit immediate"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 #| msgid "mask must be an immediate"
 msgid "last argument must be an immediate"
 msgstr "mask bir anlık değer olmalı"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr ""
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -48131,8 +48178,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -48403,7 +48450,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -48431,13 +48478,13 @@ msgstr "SSE etkin değilken SSE yazmaç argümanı"
 msgid "x87 register return with x87 disabled"
 msgstr "SSE etkin değilken SSE yazmaç dönüşü"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, fuzzy, gcc-internal-format
 #| msgid "Calling %qD with attribute sseregparm without SSE/SSE2 enabled"
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "SSE/SSE2 etkin değilken sseregparm öznitelikli %qD çağrısı"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -48447,42 +48494,42 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "assert: %s %s ile uyumlu atanıyor"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 #| msgid "-march=%s is not compatible with the selected ABI"
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "-march=%s seçilen ABI ile uyumsuz"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "bu hedefte yığıt sınırları desteklenmiyor"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 #| msgid "global destructors not supported on this target"
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "bu hedefte global yıkıcılar desteklenmiyor"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "%s is not supported by this configuration"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%s bu yapılandırma ile desteklenmiyor"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -48490,96 +48537,96 @@ msgstr "ISO C90 esnek dizi üyelerini desteklemez"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "ISO C90 esnek dizi üyelerini desteklemez"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported operand size for extended register"
 msgid "unsupported size for integer register"
 msgstr "ek yazmaç için desteklenmeyen terim boyutu"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "ek yazmaçların yüksek yarıları yok"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "ek yazmaç için desteklenmeyen terim boyutu"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand for code '%c'"
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "terim, kod `%c' için geçersiz"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "yüksek yazmaçları çekmeye elverişli düşük yazmaç yok"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 #| msgid "no class name specified with %qs"
 msgid "unknown architecture specific memory model"
 msgstr "%qs ile belirtilmiş sınıf ismi yok"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -48637,7 +48684,7 @@ msgstr "gp_offset (%ld) veya end_offset (%ld) sıfırdan küçük."
 msgid "argument %qd is not a constant"
 msgstr "%qd argümanı bir sabit değil"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -48649,7 +48696,7 @@ msgstr "PRINT_OPERAND_ADDRESS, boş gösterici"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: '%c' noktalaması bilinmiyor"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -48816,49 +48863,49 @@ msgstr ""
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "alias argümanı bir dizge değil"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "bu platformda %qE özniteliği desteklenmiyor"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "%qs is not supported in target attribute"
@@ -49682,7 +49729,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 #| msgid "bad builtin fcode"
 msgid "bad builtin code"
@@ -49940,87 +49987,87 @@ msgstr "%s: veri dosyası açılamıyor\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "komut satırı seçeneği %qs bu yapılandırmada desteklenmiyor"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 #| msgid "weak declaration of %q+D not supported"
 msgid "not generating patch area, nops not supported"
 msgstr "%q+D zayıf bildirimi desteklenmiyor"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute requires a void return type"
 msgstr "%qE özniteliği veri türlerinde yoksayılır"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "__BELOW100__ özniteliğine özdevinimli saklatım sınıfında izin verilmez"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "tls_model argument not a string"
 msgid "complement argument must be constant"
 msgstr "tls_model argümanı bir dizge değil"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "%Jtakma ad tanımlamaları bu yapılandırmada desteklenmiyor"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "%Jalias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -50269,355 +50316,355 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "%qT türü bilinen bir boyuta sahip değil"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "%qT türü bilinen bir boyuta sahip değil"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "fields cannot have RVV type %qT"
 msgstr "%qD alanı içi boş türde"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "function returns an aggregate"
 msgid "array elements cannot have RVV type %qT"
 msgstr "işlev bir küme ile dönüyor"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "soyut %qT türünde bir nesne tahsis edilemez"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "soyut %qT türünde bir nesne tahsis edilemez"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "%qT türü %qT türüne dönüştürülemiyor"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "capture by copy of RVV type %qT"
 msgstr "%s içi boş %qT türüne bir gösterici olamaz"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is disallowed in Java %<throw%> or %<catch%>"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "tür %qT Java %<throw%> veya %<catch%> içinde kullanılmaz"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized wide sub-instruction"
 msgid "unrecognized RVV builtin"
 msgstr "geniş alt komut anlaşılamadı"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to %<%D(%A)%>"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "%<%D(%A)%> çağrısı ile eşleşen bir işlev yok"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown value %qs of -mmacosx-version-min"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "-mmacosx-version-min için %qs değeri bilinmiyor"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "AltiVec argümanı prototipsiz işleve aktarıldı"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 #| msgid "Use the Cray Pointer extension"
 msgid "%s %qT requires the V ISA extension"
 msgstr "Cray Göstericisi eklentisi kullanılır"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %q+D declared as non-function"
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not \"ilink1\" or \"ilink2\""
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "%qs özniteliğinin argümanı \"ilink1\" ya da \"ilink2\" değildir"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE özniteliği sınıf türleri dışında yoksayılır"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qs requires an integer constant"
 msgstr "%qs özniteliği bir tamsayı sabit argüman gerektirir"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support interworking"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "hedef işlemci beraber çalışmayı desteklemiyor"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "%2$s bit kipinde %1$qs kod modeli desteklenmiyor"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 karmaşık türleri desteklemez"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d is not between %d and 12"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d, %d ile 12 arasında değil"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid class name"
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs geçerli bir sınıf ismi değil"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs geçerli bir çıktı dosyası değil"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "invalid argument of %qs attribute"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -51720,23 +51767,23 @@ msgstr "yerel değişkenin bellek gereksinimi kapasiteyi aşıyor."
 msgid "%<function_profiler%> support"
 msgstr "function_profiler destegi"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "kesme işlevinde va_start kullanılamaz"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "%lu girdilik switch deyimi çok büyük"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "%<__BELOW100__%> özniteliği sadece değişkenlere uygulanır"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -51988,34 +52035,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D tanımlanmış ama kullanılmamış"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "mantıksal yazmaçlar kayan nokta seçeneği için gerekli"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "-f%s seçeneği CONST16 komutları ile desteklenmiyor"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC gerekli ama  CONST16 komutları ile desteklenmiyor"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "sadece ilklendirilmemiş değişkenler .bss bölümüne yerleştirilebilir"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -52112,7 +52159,7 @@ msgstr "%qE özniteliği isimli argümanları olan prototipler gerektirir"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "%qE özniteliği sadece değişkin işlevlere uygulanır"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
@@ -52207,8 +52254,8 @@ msgstr "%q+D bir işlev değil,"
 msgid "could not get size of source file"
 msgstr "belirtim dosyası %s bulunamadı\n"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "void değer yoksayılması gerekirken yoksayılmadı"
@@ -52729,7 +52776,7 @@ msgstr "deyim ifadesine jump"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%H%qEyanlış etiket çeşidi olarak tanımlı"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute applied to %qD with void return type"
@@ -52894,7 +52941,7 @@ msgstr "ISO C90, parametre dizisi bildirimlerinde `%<static%> veya tür niteleyi
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 %<[*]%> dizi bildirimlerini desteklemez"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -52905,7 +52952,7 @@ msgstr "bu kapsamda %<this%> kullanılamaz"
 msgid "%q+D is usually a function"
 msgstr "%q+D çoğu kez bir işlevdir"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 #| msgid "no previous declaration for %q+D"
 msgid "no previous declaration for %qD"
@@ -52989,7 +53036,7 @@ msgstr "oynak alanlı nesne yazmaça konulamaz"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "ilklendirilmemiş sabit %qD"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -53211,7 +53258,7 @@ msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 msgid "storage class specified for unnamed parameter"
 msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "veri türü ismi için saklama sınıfı belirtildi"
@@ -53412,7 +53459,7 @@ msgstr "%qs dizi ile dönen işlev olarak bildirilmiş"
 msgid "function definition has qualified void return type"
 msgstr "işlev tanımı nitelikli void dönüş türü içeriyor"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "tür niteleyicileri işlev dönüş türünde yok sayıldı"
@@ -53557,7 +53604,7 @@ msgstr "ISO C 'const' ya da 'volatile' işlev türlerini yasaklar"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "veri üyesi değişken olarak değiştirilmiş %qT türünde olamayabilir"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "void bildirimli değişken ya da alan %qE"
@@ -53789,7 +53836,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr "ilklendiricide bilinmeyen %qE alanı belirtilmiş"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "bildirim hiçbir şey bildirmiyor"
@@ -53856,7 +53903,7 @@ msgstr "yapı hiç isimli üye içermiyor"
 msgid "struct has no members"
 msgstr "yapı hiç üye içermiyor"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "%Jflexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -53928,7 +53975,7 @@ msgstr "%<enum %E%> yeniden bildirilmiş"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -53990,7 +54037,7 @@ msgstr "ISO C sembolik sabit grubunun değerlerini %<int%> kapsamında sınırla
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C sembolik sabit grubunun değerlerini %<int%> kapsamında sınırlar"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %q+D given attribute noinline"
 msgid "inline function %qD given attribute %qs"
@@ -54159,12 +54206,12 @@ msgstr "%qD argümanı yerleşik prototiple eslesmiyor"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "%qD argümanı prototiple uyumsuz"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "void olmayan dönüşlü işlevde `return' deyimi yok"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD is initialized"
 msgid "parameter %qD set but not used"
@@ -54256,7 +54303,7 @@ msgstr "%<__thread%> %<register%> ile kullanılmış"
 msgid "two or more data types in declaration specifiers"
 msgstr "bildirim belirteçleri içinde iki veya daha fazla veri türü"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> GCC için çok uzun"
@@ -54371,7 +54418,7 @@ msgstr "ISO C90 karmaşık türleri desteklemez"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C karmaşık tamsayı türleri desteklemez"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 #| msgid "stack limits not supported on this target"
 msgid "%<_Float%d%s%> is not supported on this target"
@@ -54549,12 +54596,12 @@ msgstr "Sabit satır uzunluğu en az yedi olmalıdır"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ %<long long%> desteklemez"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -54620,39 +54667,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "-frepo, -c ile kullanilmalı"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "sola kaydırma sayısı negatif"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "sola kaydırma sayısı negatif"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "sağa kaydırma sayısı negatif"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "sola kaydırma sayısı tür genişliğinden büyük ya da eşit"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "sağa kaydırma sayısı tür genişliğinden büyük ya da eşit"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "sola kaydırma sayısı tür genişliğinden büyük ya da eşit"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -54674,7 +54721,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr "%J  diğer tür burada"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected end of line"
@@ -54686,7 +54733,7 @@ msgstr "Beklenmeyen modül sonu"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C boş kaynak dosyalarına izin vermez"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -54736,8 +54783,8 @@ msgid "unknown type name %qE"
 msgstr "bilinmeyen yazmaç ismi: %s"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "bildirim belirteçleri umuluyordu"
@@ -54776,7 +54823,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "betimleyici veya %<(%> umuluyordu"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "prefix attributes are ignored for methods"
@@ -54794,13 +54841,13 @@ msgstr "tür öznitelikleri sadece tür tanımlarında uygulanabilir"
 msgid "unexpected attribute"
 msgstr "Öznitelik bit ismi umuluyordu"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "bölüm özniteliğine %q+D için izin verilmez"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -54849,7 +54896,7 @@ msgstr "dosya etki alanı boş bildiriminde %<auto%>"
 msgid "%qs may only be used with a single declarator"
 msgstr "-mn, -mh veya -ms olmaksızın kullanılmış"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
@@ -54886,7 +54933,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "birleşik yapı şeffaf olamaz"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "dizge sabiti umuluyordu"
@@ -54921,7 +54968,7 @@ msgstr "bütünleyen ifade %qE bir sabit değil"
 msgid "static assertion failed: %E"
 msgstr "CRIS-port olumlaması başarısız: "
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 #| msgid "CRIS-port assertion failed: "
 msgid "static assertion failed"
@@ -54981,8 +55028,8 @@ msgstr "%qs kipi sembolik sabit türler için kullanılamaz"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "betimleyici umuluyordu"
@@ -55015,12 +55062,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "%q#D önceki using bildirimi %q#D ile çelişiyor"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "sembolik sabitler listesinin sonunda virgul"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -55104,25 +55151,25 @@ msgstr "bildirim belirteçleri veya %<...%> umuluyordu"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected OpenMP directive name"
 msgstr "sınıf ismi umuluyordu"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires prototypes with named arguments"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%qE özniteliği isimli argümanları olan prototipler gerektirir"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute does not apply to types"
 msgid "%qE attribute does not take any arguments"
@@ -55134,7 +55181,7 @@ msgstr "%qs özniteliği veri türlerine uygulanmaz"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 %<[*]%> dizi bildirimlerini desteklemez"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -55166,17 +55213,17 @@ msgstr "ISO C90 ilklendirici olarak alt nesnelerin belirtilmesine izin vermez."
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "%<=%> olmaksızın tasarlanmış ilklendirici kullanımı artık geçersiz"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -55186,44 +55233,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qs attribute does not take any arguments"
@@ -55257,7 +55304,7 @@ msgstr "%HISO C90 kod ve bildirimlerin karışmasına izin vermez"
 msgid "expected %<}%> before %<else%>"
 msgstr "%<,%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr ""
@@ -55272,7 +55319,7 @@ msgstr "bileşik ifadenin sonunda yafta kullanımı"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "deyim umuluyordu"
@@ -55309,31 +55356,31 @@ msgstr "ISO C karmaşık tamsayı türleri desteklemez"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected declaration"
 msgstr "boş bildirim"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, fuzzy, gcc-internal-format
 #| msgid "%Hempty body in an if-statement"
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "%Hif deyiminin gövdesi boş"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, fuzzy, gcc-internal-format
 #| msgid "%Hempty body in an else-statement"
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "%Helse gövdesi boş"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, fuzzy, gcc-internal-format
 #| msgid "%Hsuggest explicit braces to avoid ambiguous %<else%>"
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "%Hanlamca belirsiz %<else%>den kaçınmak için kaşlı ayraçlar önerilir"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -55354,12 +55401,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr "komuttaki yazmaç geçersiz"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -55376,8 +55423,8 @@ msgstr "işlev çağrısında gözcü eksik"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -55402,12 +55449,12 @@ msgstr "ISO C ?: üç terimlisinin orta teriminin atlanmasına izin vermez"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "first %<sizeof%> operand was declared here"
@@ -55606,7 +55653,7 @@ msgstr "ISO C90 %<[*]%> dizi bildirimlerini desteklemez"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "ifade umuluyordu"
@@ -55621,13 +55668,13 @@ msgstr "ifade içinde parantezli gruplamalara sadece bir işlevin içinde izin v
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C ifadelerde parantezli gruplamalara izin vermez"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "%<va_start%>'in ikinci parametresi isimli son argüman değil"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -55792,7 +55839,7 @@ msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
@@ -55840,7 +55887,7 @@ msgstr "%qs işlevine kayan noktalı olmayan argüman"
 msgid "rotate count is negative"
 msgstr "%s döngü sayısı negatif"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -55954,7 +56001,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -55997,12 +56044,12 @@ msgstr "bildirim belirteçleri umuluyordu"
 msgid "no type or storage class may be specified here,"
 msgstr "%qs için saklatım sınıfı belirtilmiş"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr ""
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -56014,61 +56061,61 @@ msgstr "Code özniteliği eksik"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "Hatalı işleç"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr ""
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 #| msgid "misplaced %<@%D%> Objective-C++ construct"
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "yanlış yere konmuş %<@%D%> Nesnel-C++ oluşumu"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected %qE selector name"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC memregs must precede any function decls"
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "#pragma GCC memregs bir işlev bildirimi ile öncelenmeli"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr ""
@@ -56079,13 +56126,13 @@ msgstr ""
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "#pragma GCC memregs bir işlev bildirimi ile öncelenmeli"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 #| msgid "%s statement expected at %L"
 msgid "for, while or do statement expected"
 msgstr "%s deyimi %L'de umuluyordu"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, fuzzy, gcc-internal-format
 #| msgid "malformed #pragma GCC pch_preprocess, ignored"
 msgid "%<#pragma GCC pch_preprocess%> must be first"
@@ -56096,11 +56143,11 @@ msgstr "#pragma GCC pch_preprocess bozuk, yoksayıldı"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %qs clauses"
@@ -56118,67 +56165,67 @@ msgstr "%L'deki ifade değişmez olmalı"
 msgid "%qD is not a variable"
 msgstr "%qD bir şablon değil"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is not a pointer variable"
 msgstr "%qD bir şablon değil"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "collapse argument needs positive constant integer expression"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<none%> or %<present%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "%<=%>, %<,%>, %<;%>, %<asm%> veya %<__attribute__%> umuluyordu"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected constant logical expression"
 msgstr "ifade umuluyordu"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<data%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<if%> clauses"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<if%> clauses without modifier"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -56203,25 +56250,25 @@ msgstr ""
 msgid "%<num_tasks%> value must be positive"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC memregs must precede any function decls"
 msgid "%<grainsize%> value must be positive"
 msgstr "#pragma GCC memregs bir işlev bildirimi ile öncelenmeli"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "%<priority%> value must be non-negative"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "ifade umuluyordu"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr ""
@@ -56232,110 +56279,110 @@ msgstr ""
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "%qs expression must be integral"
 msgstr "%L'deki ifade değişmez olmalı"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "%qs value must be positive"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments for format"
 msgid "too many %<static%> arguments"
 msgstr "biçim için argüman sayısı çok fazla"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 #| msgid "Expected attribute bit name"
 msgid "unexpected argument"
 msgstr "Öznitelik bit ismi umuluyordu"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%qs öznitelik argümanı bir tamsayı sabit değil"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<self%> clauses"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<concurrent%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "ordered argument needs positive constant integer expression"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr ""
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "chunk size value must be positive"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_double operand"
 msgid "invalid schedule kind"
@@ -56346,40 +56393,40 @@ msgstr "const_double terim geçersiz"
 msgid "%<num_teams%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr ""
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "%qs yinelenmiş"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
@@ -56396,23 +56443,23 @@ msgstr "%<,%> veya %<;%> umuluyordu"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple linear modifiers"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple %<step%> modifiers"
@@ -56423,7 +56470,7 @@ msgstr "cv-niteleyici yinelenmiş"
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -56438,348 +56485,348 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "assert: %s %s ile uyumlu atanıyor"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%d operand"
 msgid "invalid depend kind"
 msgstr "geçersiz %%d terimi"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid doacross kind"
 msgstr "mask geçersiz"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected %<fallback%> modifier"
 msgstr "Beklenmeyen modül sonu"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "missing operand"
 msgid "illegal comma"
 msgstr "terim eksik"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<always%> modifiers"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<close%> modifiers"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<iterator%> modifiers"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<mapper%> modifiers"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "betimleyici veya %<(%> umuluyordu"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<present%> modifiers"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid map kind"
 msgstr "mask geçersiz"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_double operand"
 msgid "invalid dist_schedule kind"
 msgstr "const_double terim geçersiz"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rotate insn"
 msgid "invalid proc_bind kind"
 msgstr "geçersiz döngü komutu"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "%<asm%> de geniş dizge sabit"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "%qs makine kipi bilinmiyor"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected string literal or constant integer expression"
 msgstr "ifade umuluyordu"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown foreign runtime identifier %qwd"
 msgstr "%qs makine kipi bilinmiyor"
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "dizge sabiti umuluyordu"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<restrict%>"
 msgid "duplicate %<target%> modifier"
 msgstr "%<restrict%> yinelenmiş"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected an OpenACC clause"
 msgstr "sınıf ismi umuluyordu"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "%qs is not valid for %qs"
 msgstr "%qs geçerli bir çıktı dosyası değil"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "%qs must be the first clause of %qs"
 msgstr "%qT %qT'nin alt sınıfı değil"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected an OpenMP clause"
 msgstr "sınıf ismi umuluyordu"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a global declaration"
 msgid "array section in %<#pragma acc declare%>"
 msgstr "%qD bildirimi bir global bildirimi gölgeliyor"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is a variably modified type"
 msgid "invalid OpenACC clause at file scope"
 msgstr "%qT değişkene göre değişen türde"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<extern%> variable %q+D in %<for%> loop initial declaration"
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "%<for%> döngüsünün ilk bildiriminde %<extern%> değişken %q+D bildirimi"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of member %q+D in static member function"
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "statik üye işlevde üye %q+D kullanımı geçersiz"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "dizge sabiti umuluyordu"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -56796,7 +56843,7 @@ msgstr "%qD bildirilmemişti"
 msgid "expected function name"
 msgstr "umulmadık düğüm"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a function"
@@ -56808,25 +56855,25 @@ msgstr "%qD bir üye şablon işlevi değil"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "bir işlev tanımıda özniteliklere izin verilmez"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "bir işlev tanımıda özniteliklere izin verilmez"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC memregs must precede any function decls"
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "#pragma GCC memregs bir işlev bildirimi ile öncelenmeli"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC memregs must precede any function decls"
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "#pragma GCC memregs bir işlev bildirimi ile öncelenmeli"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -56853,7 +56900,7 @@ msgstr ""
 msgid "modified here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
@@ -56889,122 +56936,122 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many atomic clauses"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many memory order clauses"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "assert: %s %s ile uyumlu atanıyor"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qs clause requires %qs clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "%C'deki işlev bildiriminden sonra umulmayan döküntü"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "malformed %<#pragma align%>"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "%<#pragma align%> bozuk"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "unexpected %<else%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "malformed %<#pragma align%>"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "%<#pragma align%> bozuk"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 #| msgid "malformed %<#pragma align%>"
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "%<#pragma align%> bozuk"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operation on %<__fpreg%>"
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "%<__fpreg%> üzerinde geçersiz işlem"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr ""
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "%<depobj%> expression is not lvalue expression"
@@ -57016,30 +57063,30 @@ msgstr "bütünleyen ifade %qE bir sabit değil"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "%<=%>, %<,%>, %<;%>, %<asm%> veya %<__attribute__%> umuluyordu"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "%<=%>, %<,%>, %<;%>, %<asm%> veya %<__attribute__%> umuluyordu"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -57050,34 +57097,34 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "Beklenmeyen modül sonu"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<}%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "%<,%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<}%>"
 msgid "expected %<#pragma omp scan%>"
 msgstr "%<,%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr ""
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 #| msgid "%s statement expected at %L"
 msgid "for statement expected"
@@ -57086,72 +57133,72 @@ msgstr "%s deyimi %L'de umuluyordu"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "%s statement expected at %L"
 msgid "loop nest expected"
 msgstr "%s deyimi %L'de umuluyordu"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected iteration declaration or initialization"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough type information"
 msgid "not enough nested loops"
 msgstr "tür bilgisi yetersiz"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<for%> after %qs"
@@ -57163,7 +57210,7 @@ msgstr "%<,%> veya %<;%> umuluyordu"
 msgid "expected a function name"
 msgstr "umulmadık düğüm"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected node"
 msgid "expected target-function call"
@@ -57175,48 +57222,48 @@ msgstr "umulmadık düğüm"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<point%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -57233,65 +57280,65 @@ msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected trait selector name"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "%qs makine kipi bilinmiyor"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr ""
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> sadece bir sınıf içinde belirtilebilir"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<score%> argument must be constant integer expression"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "%<score%> argument must be non-negative"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "dizge sabiti umuluyordu"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "property must be integer expression"
 msgstr "ifade umuluyordu"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "%<large%> kod modeli henüz desteklenmiyor"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected context selector set name"
@@ -57303,30 +57350,30 @@ msgstr "bildirim veya deyim umuluyordu"
 msgid "variant %qD is not a function"
 msgstr "%q+D bir işlev değil,"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs declared as a function"
 msgid "variant %qD is the same as base function"
 msgstr "%qs alanı bir işlev olarak bildirilmiş"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %<match%> clauses"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 #| msgid "Array specification at %C has more than %d dimensions"
 msgid "%qD is specified more than once"
@@ -57338,7 +57385,7 @@ msgstr "%C'deki dizi belirtimi %d boyuttan fazlasına sahip"
 msgid "%qD is not of pointer type"
 msgstr "%qD bir şablon değil"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -57350,19 +57397,19 @@ msgstr "%<,%> veya %<;%> umuluyordu"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs geçerli bir çıktı dosyası değil"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<interop%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<match%> clause"
@@ -57384,12 +57431,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "yerleşik işlev `%q+D işlev olarak bildirilmemiş"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "%J  original definition appeared here"
 msgid "%<append_args%> specified here"
@@ -57400,7 +57447,7 @@ msgstr "%J  ozgun tanımı burada görüldü"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %q+D has incomplete type"
 msgid "variant %qD and base %qD have incompatible types"
@@ -57412,7 +57459,7 @@ msgstr "%q+D parametresi tamamlanmamış türde"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
@@ -57430,89 +57477,89 @@ msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 msgid "no declaration of base function %qs"
 msgstr "%qE işlevinin örtük bildirimi"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared %<register%>"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "%<register%> bildirimli işlev tanımı"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<match%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%s özniteliği ile %s özniteliği %L'de çelişiyor"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<declare%> or %<assumes%>"
@@ -57541,13 +57588,13 @@ msgstr "%qD bildirimi bir global bildirimi gölgeliyor"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "unexpected clause"
 msgstr "sınıf ismi umuluyordu"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "missing open paren"
 msgid "missing %<map%> clause"
@@ -57612,33 +57659,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "%<=%>, %<,%>, %<;%>, %<asm%> veya %<__attribute__%> umuluyordu"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -57654,172 +57701,172 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "%<restrict%> kullanımı geçersiz"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<sizes%>"
 msgstr "%<{%> umuluyordu"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%qs öznitelik argümanı bir tamsayı sabit değil"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %qs or %qs"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr ""
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr ""
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr ""
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "Expected name"
 msgid "expected directive name"
 msgstr "Umulmadık isim"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown demangling style '%s'"
 msgid "unknown assumption clause %qs"
 msgstr "cendereleme tarzı %s bilinmiyor"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected assumption clause"
 msgstr "sınıf ismi umuluyordu"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "bilinmeyen yazmaç ismi: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, fuzzy, gcc-internal-format
 #| msgid "%q+F declared %<static%> but never defined"
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%<static%> olarak bildirilen `%q+F hiç tanımlanmamış"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 #| msgid "%Jparameter %u has incomplete type"
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%J%u. parametre tamamlanmamış türde"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr ""
@@ -57829,7 +57876,7 @@ msgstr ""
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr ""
@@ -57845,7 +57892,7 @@ msgstr ""
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD bir tamamlanmamış tür içeriyor"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "void ifade kullanımı geçersiz"
@@ -57878,178 +57925,178 @@ msgstr "tamamlanmamış typedef %qD kullanımı geçersiz"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "%qE özniteliği sadece değişkin işlevlere uygulanır"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "işlev türleri  ISO C'de tam uyumlu değil"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "türler tam uyumlu değil"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "pointer target types incompatible in C++"
 msgstr "%qT üye türünde gösterici nesne türü %qT ile uyumsuz"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "işlevin dönüş türü %<volatile%> den dolayı uyumsuz"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "esnek dizi üyeli yapı kullanımı geçersiz"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT türü %qE isimli üye içermiyor"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT türü %qE isimli üye içermiyor"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, fuzzy, gcc-internal-format
 #| msgid "protected member %q+#D in anonymous union"
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "anonim union içinde protected üye %q+#D"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "bir struct veya union olmayan şeyin %qE üyesi için istek"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "%<void *%> gösterici ilişkilendirmesi"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "subscripted value is neither array nor pointer"
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "indisli değer ne dizi ne de bir gösterici"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "dizi indisi bir tamsayı değil"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "indisli değer, işleve göstericidir"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "dizi indisi bir tamsayı değil"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C %<register%> dizisi indislemesine izin vermez"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 sol tarafsız dizi indislemesine izin vermez"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD başvuru olarak bildirilmiş ama ilklendirilmemiş"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object %qE is not a function or function pointer"
 msgstr "çağrılan nesne %qE bir işlev değil"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object %qD is not a function or function pointer"
 msgstr "çağrılan nesne %qE bir işlev değil"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 #| msgid "called object %qE is not a function"
 msgid "called object is not a function or function pointer"
@@ -58058,2021 +58105,2021 @@ msgstr "çağrılan nesne %qE bir işlev değil"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "uyumlu olmayan türde işlev çağrısı"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 #| msgid "function definition has qualified void return type"
 msgid "function with qualified void return type called"
 msgstr "işlev tanımı nitelikli void dönüş türü içeriyor"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "%d biçimsel parametre türü tamamlanmayan türde"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı gerçel sayı değil tamsayı aktarılması"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı karmaşık sayı değil tamsayı aktarılması"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı gercel sayı değil karmaşık sayı aktarılması"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı tamsayı değil gercel sayı aktarılması"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı tamsayı değil karmaşık sayı aktarılması"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı karmaşık sayı değil gerçel sayı aktarılması"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı %<double%> değil %<float%> aktarılması"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı karmaşık sayı değil tamsayı aktarılması"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı farklı genişlikte değer aktarılması"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı işaretsiz tamsayı aktarılması"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "%2$qE işlevinin %1$d. argümanına prototipten dolayı işaretli tamsayı aktarılması"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "%qE işlevi için çok fazla argüman belirtildi"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "%qE işlevi için çok fazla argüman belirtildi"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "%qE işlevi için çok fazla argüman belirtildi"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "%qT türünden %qT türüne örtük dönüşüme C++'da izin verilmez"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "%qE işlevi için çok az argüman belirtildi"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "%qE işlevi için çok az argüman belirtildi"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "%qE işlevi için çok az argüman belirtildi"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, fuzzy, gcc-internal-format
 #| msgid "weak declaration of %q+D after first use results in unspecified behavior"
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "%q+D zayıf bildirimi ilk kullanımdan sonra belirsiz davranışla sonuçlanıyor"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "gösterici ile tamsayı arasında karşılaştırma"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "casting %qT to %qT does not dereference pointer"
 msgid "did you mean to dereference the pointer?"
 msgstr "%qT türünden %qT türüne dönüşüm gösterici başvurusunu kaldırmaz"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "zero as null pointer constant"
 msgstr "dizi sınırı bir tamsayı sabit değil"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "comparison between %qT and %qT"
 msgstr "%q#T ile %q#T arasında karşılaştırma"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "çıkartmada %<void *%> türünde gösterici kullanılmış"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "çıkartmada işlev göstericisi kullanılmış"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "%<~%> on a boolean expression"
 msgstr "ifade umuluyordu"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C karmaşık sayıların mantıksal çarpımında %<~%> desteklemez"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "abs'a yanlış türde argüman"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "tek terimli tümleyen için yanlış türde argüman"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "increment of a boolean expression"
 msgstr "ifade umuluyordu"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "decrement of a boolean expression"
 msgstr "ifade umuluyordu"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C karmaşık sayı türlerinde %<++%> ve %<--%> desteklemez"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "arttırımda yanlış türde argüman"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "eksiltmede yanlış türde argüman"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of expression of type %<void%>"
 msgstr "gecicinin adresi alıniyor"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "%qD bit-alanının adresi alınamaz"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "bir sağ taraf ifadesi olan %<this%>'in adresi alınamaz"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "%qD yazmaç değişkeninin adresi istendi"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "%qD yazmaç değişkeninin adresi istendi"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "genel yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "%qD genel yazmaç değişkeninin adresi istenmiş"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "%qD yazmaç değişkeninin adresi istendi"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "koşullu ifadede sol değersiz dizi"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral mismatch in conditional expression: %qT vs %qT"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "koşullu ifade içinde enum uyumsuzluğu: %qT vs %qT"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "%qT türünden %qT türüne örtük dönüşüme C++'da izin verilmez"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C tek taraflı void tür içeren koşullu ifadelere izin vermez"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "koşullu ifadede gösterici türü uyumsuzluğu"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "koşullu ifadede gösterici türü uyumsuzluğu"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "koşullu ifadede gösterici türü uyumsuzluğu"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C %<void *%> ve işlev göstericisi arasında koşullu ifadelere izin vermez"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "koşullu ifadede gösterici türü uyumsuzluğu"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "İfade türü umuluyordu"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "İfade türü umuluyordu"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "koşullu ifadede gösterici/tamsayı tür uyumsuzluğu"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "koşullu ifadede tür uyumsuzluğu"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "%H%qD dönüş değeri yoksayılıyor, warn_unused_result özniteliği ile bildirilmiş"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "%H%qD dönüş değeri yoksayılıyor, warn_unused_result özniteliği ile bildirilmiş"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "%H%qD dönüş değeri yoksayılıyor, warn_unused_result özniteliği ile bildirilmiş"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "%Hignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "%H%qD dönüş değeri yoksayılıyor, warn_unused_result özniteliği ile bildirilmiş"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "in call to %qD, declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "virgüllü ifadenin sol terimi etkisiz"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "right-hand operand of comma expression has no effect"
 msgstr "virgüllü ifadenin sol terimi etkisiz"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 #| msgid "cast adds new qualifiers to function type"
 msgid "cast adds %q#v qualifier to function type"
 msgstr "tür dönüşümü, işlev türüne yeni niteleyiciler ekliyor"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 #| msgid "cast discards qualifiers from pointer target type"
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "tür dönüşümü, gösterici hedef türünden niteleyicileri iptal ediyor"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "tür dönüşümü dizi belirtiyor"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "tür dönüşümü işlev belirtiyor"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C skalar olmayandan aynı türe dönüşüme izin vermez"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 #| msgid "%qT uses local type %qT"
 msgid "useless cast to type %qT"
 msgstr "%qT yerel tür %qT kullanıyor"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C union türe dönüşüme izin vermez"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "union içinde mevcut olmayan türden union türe dönüşüm"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "bir tür dönüşümü olmaksızın ayrı gösterici türlerinin karşılaştırması"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "bir tür dönüşümü olmaksızın ayrı gösterici türlerinin karşılaştırması"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "bir tür dönüşümü olmaksızın ayrı gösterici türlerinin karşılaştırması"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "tür dönüşümü hedef türün gerekli hizalamasını azaltıyor"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "göstericiden farklı tamsayı türlere dönüşüm"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "%qT türündeki işlev çağrısından eşleşmeyen %qT türüne dönüşüm"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "farklı boyuttaki tamsayı türden göstericiye dönüşüm"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C işlev göstericisinin nesne göstericisine dönüştürülmesini yasaklar"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C nesne göstericisinin işlev göstericisine dönüştürülmesini yasaklar"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 #| msgid "can't convert from incomplete type %qT to %qT"
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "içi boş %qT türünden %qT türüne dönüşüm yapılamaz"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 #| msgid "assignment suppression"
 msgid "assignment to expression with array type"
 msgstr "atama engelleme"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(%qs için near ilklendirme)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "parantezli dizge sabitten ilklendirmeli dizi"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "built-in %qD declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "%q+D declared here"
 msgid "%e declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, fuzzy, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımında gösterici hedefleri farklı sign'lıkta"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "expected %qT but argument is of type %qT"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımında gösterici hedefleri farklı sign'lıkta"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımında gösterici hedefleri farklı sign'lıkta"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "implicit conversion from %qT to %qT"
 msgstr "%qT türünden %qT türüne dönüşüm geçersiz"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "%2$qE işlevinin %1$d. argümanına aktarım niteliksiz göstericiyi nitelikli yapıyor"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 #| msgid "assignment makes qualified function pointer from unqualified"
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "atama niteliksiz işlev göstericisini nitelikli yapıyor"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 #| msgid "initialization makes qualified function pointer from unqualified"
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "ilklendirme niteliksiz işlev göstericisini nitelikli yapıyor"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 #| msgid "return makes qualified function pointer from unqualified"
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "dönüş değeri niteliksiz işlev göstericisini nitelikli yapıyor"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "%2$qE işlevinin %1$d. argümanına aktarım gösterici hedef türündeki niteleyicileri iptal ediyor"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 #| msgid "assignment discards qualifiers from pointer target type"
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "atama gösterici hedef türündeki niteleyicileri iptal ediyor"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 #| msgid "initialization discards qualifiers from pointer target type"
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "ilklendirme gösterici hedef türündeki niteleyicileri iptal ediyor"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 #| msgid "return discards qualifiers from pointer target type"
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "dönüş değeri gösterici hedef türündeki niteleyicileri iptal ediyor"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C union türe argüman dönüşümünü yasaklar"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "%qT türünden %qT türüne örtük dönüşüme C++'da izin verilmez"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 #| msgid "cast from pointer to integer of different size"
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "göstericiden farklı tamsayı türlere dönüşüm"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, fuzzy, gcc-internal-format
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "uyumsuz gösterici türünde ilklendirme"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "%2$qE işlevinin %1$d. argümanı bir biçim özniteliği adayı olabilir"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "atamada sol taraf bir biçim özniteliği adayı olabilir"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "ilklendirmede sol taraf bir biçim özniteliği adayı olabilir"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "dönüş türü bir biçim özniteliği adayı olabilir"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C işlev göstericisi ile  %<void *%> arasında %2$qE işlevinin %1$d. argümanının  aktarımına izin vermez"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C de işlev göstericisi ile %<void *%> arasında atama yasaktır"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C de işlev göstericisi ile %<void *%> arasında ilklendirme yasaktır"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C de işlev göstericisi ile %<void *%> arasında return yasaktır"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımında gösterici hedefleri farklı sign'lıkta"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "atama sırasında gösterici hedefleri farklı signed'lıkta"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in initialization differ in signedness"
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "ilklendirmede gösterici hedefleri farklı signed'lıkta"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımında gösterici hedefleri farklı sign'lıkta"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "uyumsuz gösterici türünde atama"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "uyumsuz gösterici türünde ilklendirme"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "uyumsuz gösterici türünde ilklendirme"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "creating pointer to member function of non-class type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "sınıf olmayan %qT türünde üye işlev göstericisi oluşturulması"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "%<return%> with a value, in function returning void"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "void dönüşlü işlevde %<return%> değer içeriyor"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımı sırasında bir tür dönüşümü olmaksızın tamsayıdan gösterici yapılıyor"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes pointer from integer without a cast"
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "atama bir tür dönüşümü olmaksızın tamsayıdan gösterici yapıyor"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes pointer from integer without a cast"
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "ilklendirme bir tür dönüşümü olmaksızın tamsayıdan gösterici yapıyor"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımı sırasında bir tür dönüşümü olmaksızın tamsayıdan gösterici yapılıyor"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımı sırasında bir tür dönüşümü olmaksızın göstericiden tamsayı yapılıyor"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes integer from pointer without a cast"
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "atamada bir tür dönüşümü olmaksızın göstericiden tamsayı yapılıyor"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes integer from pointer without a cast"
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "ilklendirmede bir tür dönüşümü olmaksızın göstericiden tamsayı yapılıyor"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "%2$qE işlevinin %1$d. argümanının aktarımı sırasında bir tür dönüşümü olmaksızın göstericiden tamsayı yapılıyor"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, fuzzy, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "%2$qE işlevinin %1$d. argümanı için tür uyumsuz"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "%qT'nin %qT'ye atanmasında türler uyumsuz"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in initialization"
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "ilklendirmede uyumsuz türler"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "%qT'nin %qT'ye atanmasında türler uyumsuz"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "geleneksel C özdevinimli ortak değer ilklendirmesini reddeder"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, fuzzy, gcc-internal-format
 #| msgid "a template-id may not appear in a using-declaration"
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "using bildiriminde bir şablon kimliği bulunamaz"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer not of integer type"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "ilklendiricideki dizi indisi tamsayı türünde değil"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer not of integer type"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "ilklendiricideki dizi indisi tamsayı türünde değil"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "esnek dizi üyesi ilklendirmesi"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "karakter dizisi için dizge ilklendirici çok uzun"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "karakter dizisi için dizge ilklendirici çok uzun"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "dizge sabitten ilgisiz türde ilklendirilmiş dizi"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "sol değersiz dizi kullanımı geçersiz"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "geçersiz ilklendirici"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "ilklendirici öğe bir sabit değil"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "dizi sabit olmayan dizi ifadesinden ilklendirilmiş"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "initializer element is not a constant expression"
 msgstr "ilklendirici öğe bir sabit değil"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "%qT türünden %qT türüne dönüşüm niteleyicileri iptal ediyor"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "ilkledirici öğe yükleme sırasında hesaplanabilir değil"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "opak vektör türleri ilklendirilemez"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "ilklendiricinin sonunda fazladan parantezli grup"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "skalar ilklendiriciyi kuşatan parantezler"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "iç içe bağlam içinde esnek dizi üyesi ilklendirmesi"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "ilklendiriciyi çevreleyen parantezler yok"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "missing initializer for field %qD of %qT"
 msgstr "uye %qD için ilklendirici eksik"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "skalar ilklendiricide fazladan öğeler"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "dizi olmayan ilklendiricide dizi indisi"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "alan ismi kayıt ya da union ilklendiricisinde kullanılmamış"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "ilklendiricideki dizi indisi tamsayı türünde değil"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer not of integer type"
 msgid "array index in initializer is not an integer constant expression"
 msgstr "ilklendiricideki dizi indisi tamsayı türünde değil"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "ilklendiricide sabit olmayan dizi indisi"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "ilklendiricideki dizi indisi dizi sınırlarının dışında"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "ilklendiricide indis aralığı boş"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "ilklendiricideki dizi indisi aralığı dizi sınırlarını aşıyor"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, fuzzy, gcc-internal-format
 #| msgid "initialized field with side-effects overwritten"
 msgid "initialized field overwritten"
 msgstr "yan etkili ilklendirilmiş alanın üzerine yazıldı"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "yan etkili ilklendirilmiş alanın üzerine yazıldı"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "union ilklendiricide gereğinden fazla öğe"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "struct ilklendiricide gereğinden fazla öğe"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "esnek dizi üyesinin statik olmayan ilklendirmesi"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "union ilklendiricide gereğinden fazla öğe"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "geleneksel C union ilklendirmesini reddeder"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "dizi ilklendiricide gereğinden fazla öğe"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "vektör ilklendiricide gereğinden fazla öğe"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "skalar ilklendiricide gereğinden fazla öğe"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C işlevler dışında fazladan %<;%> kullanımına izin vermez"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in output operand outside of a function"
 msgstr "ISO C işlevler dışında fazladan %<;%> kullanımına izin vermez"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "çıktı terimi %d %<&%> kısıtını kullanmalı"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<-%> modifier used inside of a function"
 msgstr "%<friend%> sadece bir sınıf içinde belirtilebilir"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in input operand outside of a function"
 msgstr "ISO C işlevler dışında fazladan %<;%> kullanımına izin vermez"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD işlev etki alanı dışında tanımlı değil"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C %<goto *expr;%> kullanımına izin vermez"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "%<noreturn%> olarak bildirilmiş işlev %<return%> deyimi içeriyor"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "dönüş değeri void olmayan işlevde %<return%> değer içermiyor"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "void dönüşlü işlevde %<return%> değer içeriyor"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, fuzzy, gcc-internal-format
 #| msgid "%<return%> with a value, in function returning void"
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "void dönüşlü işlevde %<return%> değer içeriyor"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of label"
 msgstr "işlev yerel değişkenin adresi ile dönüyor"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "işlev yerel değişkenin adresi ile dönüyor"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch miktarı bir tamsayı değil"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "ISO C'de %<long%> switch ifadesi %<int%> türüne dönüştürülmez"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "case label is not an integer constant expression"
 msgstr "dizi boyutu bir tümleyen sabit ifadesi değil"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case etiketi bir switch deyimi içinde değil"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "%<default%> etiketi bir switch deyimi içinde değil"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break deyimi switch ya da döngü içinde değil"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "break statement used with OpenMP for loop"
 msgstr "break deyimi switch ya da döngü içinde değil"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue deyimi bir döngü içinde değil"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "deyim etkisiz"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "ifade deyimi boş tür içeriyor"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "comparing vectors with different element types"
 msgstr "?: için terimler farklı türde"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %q#T and %q#T"
 msgid "comparison between types %qT and %qT"
 msgstr "%q#T ile %q#T türleri arasında karşılaştırma"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "== veya != ile karşılaştırma gerçel sayılarda güvenli değil"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 #| msgid "comparison of distinct pointer types lacks a cast"
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "bir tür dönüşümü olmaksızın ayrı gösterici türlerinin karşılaştırması"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C %<void *%> ile işlev göstericisinin karşılaştırılmasına izin vermez"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "bir tür dönüşümü olmaksızın ayrı gösterici türlerinin karşılaştırması"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "gösterici ile tamsayı arasında karşılaştırma"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "tamamlanmış ve içi boş göstericilerin karşılaştırılması"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C işlev göstericilerinin sıralı karşılaştırmalarına izin vermez"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with null pointer"
 msgstr "tamsayı sıfır ile sıralı gösterici karşılaştırması"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "tamsayı sıfır ile sıralı gösterici karşılaştırması"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, fuzzy, gcc-internal-format
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "%qT türünden %qT türüne örtük dönüşüme C++'da izin verilmez"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "doğrudan değer gereken yerde göstericiye dönüştürülemeyen dizi kullanılmış"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "doğrudan değer gereken yerde yapı türünde değer kullanılmış"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "doğrudan değer gereken yerde union türünde değer kullanılmış"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "used vector type where scalar is required"
 msgstr "doğrudan değer gereken yerde yapı türünde değer kullanılmış"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%qE is not a variable in %qs clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "low bound %qE of array section does not have integral type"
 msgstr "array new içindeki boyut bütünleyici türde olmalı"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "length %qE of array section does not have integral type"
 msgstr "array new içindeki boyut bütünleyici türde olmalı"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "expected single pointer in %qs clause"
 msgstr "işlev `%s' (%C'deki) zaten %L'de tanımlı"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 #| msgid "Copy array sections into a contiguous block on procedure entry"
 msgid "zero length array section in %qs clause"
 msgstr "Dizi bölümlerini yordam girdisinde sürekli bir blokun içine kopyalar"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, fuzzy, gcc-internal-format
 #| msgid "Copy array sections into a contiguous block on procedure entry"
 msgid "array section is not contiguous in %qs clause"
 msgstr "Dizi bölümlerini yordam girdisinde sürekli bir blokun içine kopyalar"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qE does not have pointer or array type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "tumleyen, gösterici olmayan NULL yakalanıyor"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "ISO C nitelikli işlev türlerini yasaklar"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %q+D has incomplete type"
 msgid "iterator %qD has const qualified type"
 msgstr "%q+D parametresi tamamlanmamış türde"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %q+#D with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "bit-alanı %q+#D tümleyen türde değil"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand for 'o' modifier"
 msgid "end expression refers to outer iterator %qD"
 msgstr "'o' değiştiricisi için terim geçersiz"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "expresion reference type error at %L"
 msgid "step expression refers to outer iterator %qD"
 msgstr "%L'de ifade başvuru türü hatası"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "Expected integer"
 msgid "expected pointer in %qs clause"
 msgstr "Tamsayı umuluyordu"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr ""
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "vektör silme işlemi için tür ne gösterici ne de dizi"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids qualified function types"
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "ISO C nitelikli işlev türlerini yasaklar"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s'at %C is not allowed."
 msgid "zero sized type %qT in %qs clause"
 msgstr "'%s' tahmini boyutlu dizisine '%s' isim listesinde izin verilmiyor (%C'de)."
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s'at %C is not allowed."
 msgid "variable sized type %qT in %qs clause"
 msgstr "'%s' tahmini boyutlu dizisine '%s' isim listesinde izin verilmiyor (%C'de)."
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr ""
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "user defined reduction not found for %qE"
 msgstr "%qD ile ilişkilendirme belirsiz"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr ""
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "vektör silme işlemi için tür ne gösterici ne de dizi"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qT erişilebilir bir %qT tabanı değil"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "vektör silme işlemi için tür ne gösterici ne de dizi"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "'%s' ismi (%C'de) tanımlı bir işleç olarak kullanılamaz"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "traits array must be initialized with constants"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported map expression %qE"
 msgstr "desteklenmeyen birleşim: %s"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not declare a template type"
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD bir şablon türü bildirmiyor"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qT erişilebilir bir %qT tabanı değil"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD bir işlev şablonu değil"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "base operand of %<->%> is not a pointer"
 msgid "%qs variable is not a pointer"
 msgstr "%<->%> için taban terim bir gösterici değil"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "vektör silme işlemi için tür ne gösterici ne de dizi"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "too many %qs clauses on a task construct"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD %<void%> almalı"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qD shall not be const"
 msgstr "%q+D bir işlev değil,"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "%<va_arg%>'ın ilk argümanının türü %<va_list%> değil"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "%<va_arg%>'ın ilk argümanının türü %<va_list%> değil"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "%<va_arg%>'ın ilk argümanının türü %<va_list%> değil"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -60378,261 +60425,256 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%q+D will be initialized after"
 msgid "%s should not be null"
 msgstr "%q+D sonradan ilklendirilmiş olacak"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD does not declare a template type"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qD bir şablon türü bildirmiyor"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid receiver type %qs"
 msgid "%s: Invalid field type %s:"
 msgstr "alıcı tür %qs geçersiz"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for ACCEPT statement."
 msgstr "%C'deki PROGRAM deyiminin biçimi geçersiz"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for DISPLAY statement."
 msgstr "%C'deki PROGRAM deyiminin biçimi geçersiz"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown %<setop_t%> code %d"
 msgstr "%qs makine kipi bilinmiyor"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT bir sınıf türü olmayan %qT türüne çözümleniyor"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "İsim '%s' %C'de işlev ismidir"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -60641,75 +60683,86 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "türetilmiş tür bildirimi"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown register name: %s"
 msgid "Unknown type %d"
 msgstr "bilinmeyen yazmaç ismi: %s"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "Attempting an assignment of differing types."
 msgstr "atama sırasında gösterici hedefleri farklı signed'lıkta"
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "assert: %s is assign compatible with %s"
+msgid "%s:%d: Must not call here with %s"
+msgstr "assert: %s %s ile uyumlu atanıyor"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -60719,13 +60772,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "cannot initialize %qT from %qT"
 msgid "cannot get %<float%> value from %s"
@@ -60742,65 +60795,65 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr "%s %d çıkış durumu ile döndü"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "%s: key must be field"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "spec '%s' is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "spec '%s' geçersiz"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: regcomp: %s"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -61287,7 +61340,7 @@ msgstr "%2$qT için uygun bir %<%1$s işleci%> yok"
 msgid "%q#D is private within this context"
 msgstr "bu bağlamda"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "declared private here"
@@ -61299,7 +61352,7 @@ msgstr "burada bildirilmiş %q+D"
 msgid "%q#D is protected within this context"
 msgstr "bu bağlamda"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "declared protected here"
@@ -61666,7 +61719,7 @@ msgstr ""
 msgid "constructor delegates to itself"
 msgstr "kurucular virtual olarak bildirilemez"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI"
@@ -61689,7 +61742,7 @@ msgstr "%<%T::%s(%A)%#V%> çağrısı ile eşleşen işlev yok"
 msgid "call to non-function %qD"
 msgstr "işlev olmayan %qD ye çağrı"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr ""
@@ -62356,7 +62409,7 @@ msgstr "%Jbaşka bir boş yapı içinde esnek dizi"
 msgid "next member %q#D declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "%q#T sınıfın yeniden tanımı"
@@ -62366,7 +62419,7 @@ msgstr "%q#T sınıfın yeniden tanımı"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -62508,7 +62561,7 @@ msgstr "işlev %q+#D için soyut dönüş değeri türü geçersiz"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
@@ -62562,7 +62615,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%q+D normalde bir static olmayan işlevdir"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -62600,348 +62653,348 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "%H%qT türündeki olağandışılık yakalanmış olacak"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D bir olağandışılık belirtimi ile bildirilmiş"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D bir olağandışılık belirtimi ile bildirilmiş"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s %s desteği vermiyor"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, gcc-internal-format
 msgid "%qD called with unexpected %qs argument"
 msgstr ""
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to bit-complement"
 msgid "wrong number of arguments to %qs call"
 msgstr "bit-tümler için yanlış türde argüman"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "programs: %s\n"
 msgid "constexpr message: %.*s"
 msgstr "programlar: %s\n"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 #| msgid "%<register%> in file-scope empty declaration"
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "dosya etki alanı boş bildiriminde %<register%>"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%q+E is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "işlev olmayan %qD ye çağrı"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer"
 msgstr "%<void *%> gösterici ilişkilendirmesi"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "the comparison reduces to %qE"
 msgstr "%s %q+#D için argümanlar çok fazla"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to internal function %qE"
 msgstr "işlev olmayan %qD ye çağrı"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 #| msgid "%J  original definition appeared here"
 msgid "originally declared %<const%> here"
 msgstr "%J  ozgun tanımı burada görüldü"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "tür %qT tür %qT için bir taban tür değil"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD may not have been initialized"
 msgid "virtual table pointer is used uninitialized"
 msgstr "değişken %q+D ilklendirilmiş olmayabilir"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an ambiguous base of %qT"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT bir belirsiz %qT tabanıdır"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "üye işlev %qD nesne olmaksızın çağrılamaz"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "kardeş bildirimi bir sınıf veya işlevi isimlendirmiyor"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "`o' terimi sabit değil"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, fuzzy, gcc-internal-format
 #| msgid "-client_name not allowed with -dynamiclib"
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "-client_name ile -dynamiclib birarada olmaz"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "allocation performed here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "-client_name not allowed with -dynamiclib"
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "-client_name ile -dynamiclib birarada olmaz"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr ""
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "%qD bildirimi önceki yereli gölgeliyor"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD called in a constant expression"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D was used with no prototype before its definition"
 msgid "%qD used before its definition"
 msgstr "%q+D tanımlanmadan önce prototipsiz kullanılmış"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, fuzzy, gcc-internal-format
 #| msgid "protocol %qs has circular dependency"
 msgid "call has circular dependency"
 msgstr "protokol %qs döngüsel bağımlılık içeriyor"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "%d lik azami şablon örneklenim derinliği %qD örnekleniminde aşılıyor (azami değeri arttırmak için -ftemplate-depth-NN kullanın)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "reference to %qD is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is negative"
 msgstr "sağa kaydırma sayısı negatif"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "sağa kaydırma sayısı negatif"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "virgüllü ifadenin sol terimi etkisiz"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "shift expression %q+E overflows"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "dizi indisi bir tamsayı değil"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "dizi indisi bir tamsayı değil"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized array element"
 msgstr "uye %qD için ilklendirici eksik"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "%<void *%> gösterici ilişkilendirmesi"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
@@ -62949,599 +63002,599 @@ msgstr "%<void *%> gösterici ilişkilendirmesi"
 msgid "%qE is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized member %qD"
 msgstr "uye %qD için ilklendirici eksik"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "%qD şablon parametresi %qT türündeyse butunleyen ya da sırali türde olmadığından bir butunleyen sabit ifadesinde kullanılmaz"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "global destructors not supported on this target"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "bu hedefte global yıkıcılar desteklenmiyor"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "uye %qD için ilklendirici eksik"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qT object created here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q#D declared here"
 msgstr "burada bildirilmiş %q+D"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "allocated here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 #| msgid "no field %qD found in union being initialized"
 msgid "%qD used in its own initializer"
 msgstr "ilklendirilen union içinde %qD diye bir alan yok"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%q#D is not const"
 msgstr "%q+D bir işlev değil,"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D is private"
 msgid "%q#D is volatile"
 msgstr "%q+#D private'dir"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot appear in a constant-expression"
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD bu etki alanında bildirilmemiş"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 #| msgid "expression in new-declarator must have integral or enumeration type"
 msgid "%qD does not have integral or enumeration type"
 msgstr "new bildirimli ifade bütünleyici ya da numaralama türünde olmalı"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "dizi boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "%d lik azami şablon örneklenim derinliği %qD örnekleniminde aşılıyor (azami değeri arttırmak için -ftemplate-depth-NN kullanın)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline assembly is not a constant expression"
 msgstr "ilklendirici öğe bir sabit değil"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "%qD kullanımı geçersiz"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D bir olağandışılık belirtimi ile bildirilmiş"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "%d lik azami şablon örneklenim derinliği %qD örnekleniminde aşılıyor (azami değeri arttırmak için -ftemplate-depth-NN kullanın)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 #| msgid "enumeral and non-enumeral type in conditional expression"
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "koşullu ifade içinde enum ve enum olmayan türler"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "ilklendirici öğe bir sabit değil"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "%qD şablon parametresi %qT türündeyse butunleyen ya da sırali türde olmadığından bir butunleyen sabit ifadesinde kullanılmaz"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "pointed-to object declared here"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "expression %qE is not a constant expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%<goto%> is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "statement is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unexpected expression %qE of kind %s"
 msgstr "ifade umuluyordu"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "`B' terimi sabit değil"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "contract predicate is false in constant expression"
 msgstr "dizi boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "break deyimi switch ya da döngü içinde değil"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%> sadece bir sınıf içinde belirtilebilir"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "jump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "deyim ifadesine jump"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "%s aşırı yüklü işlevin adresini çözümleyemiyor"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "%qT türündeki bir sağ taraf değerinin %qT türüne dönüşümü geçersiz"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr ""
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "sanal işlevler kardeş işlev olamaz"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr ""
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 #| msgid "%H%qE undeclared here (not in a function)"
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%H%qE burada bildirilmemiş (bir işlev içinde değil)"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 #| msgid "%q+F declared %<static%> but never defined"
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%<static%> olarak bildirilen `%q+F hiç tanımlanmamış"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "division by zero is not a constant expression"
 msgstr "dizi boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "non-constant array initialization"
 msgstr "ilklendiricide sabit olmayan dizi indisi"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected end of file in '%s'"
 msgid "unexpected AST of kind %s"
@@ -63687,417 +63740,417 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has a user-defined constructor"
 msgid "%qT is not nothrow default constructible"
 msgstr "%qs türü bir kullanıcı tanımlı yapıcıya sahip"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid class name"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qs geçerli bir sınıf ismi değil"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has a user-defined constructor"
 msgid "%qT is not trivially default constructible"
 msgstr "%qs türü bir kullanıcı tanımlı yapıcıya sahip"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not trivially copy constructible"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "base class %q#T has a non-virtual destructor"
 msgid "%qT is not trivially destructible"
 msgstr "taban sınıf %q#T bir sanal olmayan yıkıcıya sahip"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not declare a template type"
 msgid "%qT does not have unique object representations, because"
 msgstr "%qD bir şablon türü bildirmiyor"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "base class %q#T has a non-virtual destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "taban sınıf %q#T bir sanal olmayan yıkıcıya sahip"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a template"
 msgid "%qT is not an abstract class"
 msgstr "%q#T bir şablon değil"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an aggregate"
 msgstr "%qT bir şablon değil"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not an array"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not a bounded array"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a template"
 msgid "%qT is not a class"
 msgstr "%q#T bir şablon değil"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qT is not a const type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is normally a non-static function"
 msgid "%qT is not default constructible, because"
 msgstr "%q+D normalde bir static olmayan işlevdir"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not destructible, because"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a template"
 msgid "%qT is not an empty class"
 msgstr "%q#T bir şablon değil"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT bir şablon değil"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a template"
 msgid "%qT is not a final class"
 msgstr "%q#T bir şablon değil"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qT is not a function"
 msgstr "%q+D bir işlev değil,"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not invocable, because"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "assert: %s %s ile uyumlu atanıyor"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qT is not a literal type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD bir üye şablon işlevi değil"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT bir %qT üyesi değil"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT bir %qT üyesi değil"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is normally a non-static function"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%q+D normalde bir static olmayan işlevdir"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT bir nesne göstericisi türü değil"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT erişilebilir bir %qT tabanı değil"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not a POD type"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "base operand of %<->%> is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "%<->%> için taban terim bir gösterici değil"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT bir isim alanı değil"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "%qT bir isim alanı değil"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qT is not a trivial type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is normally a non-static function"
 msgid "%qT is not trivially default constructible, because"
 msgstr "%q+D normalde bir static olmayan işlevdir"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is normally a non-static function"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%q+D normalde bir static olmayan işlevdir"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not trivially copyable"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not trivially destructible, because"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an unbounded array"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qT is not a union"
 msgstr "%q+D bir işlev değil,"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "argument %qd is not a constant"
-msgid "%qT is not consteval-only"
-msgstr "%qd argümanı bir sabit değil"
+#| msgid "%qE does not have class type"
+msgid "%qT is not a structural type"
+msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "%q+#D bildirilemez"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qT is not destructurable"
 msgstr "%qD bir şablon değil"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "%qT türü %qT türünden türetilmemiş"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid insn:"
 msgid "invalid constraints"
 msgstr "geçersiz komut:"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "constructors may not be cv-qualified"
 msgid "constraints not satisfied"
 msgstr "kurucular cv-nitelemeli olmayabilir"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -64131,52 +64184,52 @@ msgstr "asm bildirimi önceki isim değişikliği ile çeliştiğinden yoksayıl
 msgid "previous declaration with fewer contracts here"
 msgstr "%2$qL ilintili önceki %1$q+#D bildirimi"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %q+D declared %<inline%>"
 msgid "parameter declared here"
 msgstr "%<inline%> bildirimli %q+D parametresi"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "%q#D yeniden bildirimi"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "first declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -64255,7 +64308,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "%2$q#T içinde %1$q#T isminde tür yok"
@@ -64338,90 +64391,90 @@ msgstr "yetkin tür %qT, yıkıcı ismi ~%qT ile eslesmiyor"
 msgid "awaitable type %qT is not a structure"
 msgstr "yetkin tür %qT, yıkıcı ismi ~%qT ile eslesmiyor"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%s burada asm içinde kullanılamaz"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "%<noreturn%> olarak bildirilmiş işlev %<return%> deyimi içeriyor"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%> için 3. argüman bir sabit olmalı"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %q+D"
 msgid "no suspend point info for %qD"
 msgstr "%q+D için önceki prototip yok"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "%qE yinelenmiş"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "case değeri olarak göstericiler kullanılamaz"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -64448,79 +64501,85 @@ msgstr "%qD bir şablon işlevi değildir"
 msgid "%qs used outside of constant expressions"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "empty declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "boş bildirim"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of an immediate function %qD"
 msgstr "gecicinin adresi alıniyor"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD, will always evaluate as %<true%>"
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%qD adresi, daima %<true%> olarak değerlendirilecek"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "Constructor can't be %s"
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "Kurucu %s olmayabilir"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "applying attributes to template parameters is not implemented"
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "özniteliklerin şablon parametrelerine uygulanması gerçeklenmedi"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qs attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "%qs özniteliğinin argümanı geçersiz"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in template argument list"
 msgid "use fold expression in the attribute argument instead"
 msgstr "şablon argüman listesinde çözümleme hatası"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is not a type"
 msgstr "%qD bir şablon değil"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qD is not a class type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 #| msgid "expression in new-declarator must have integral or enumeration type"
 msgid "%qD does not have integral type"
 msgstr "new bildirimli ifade bütünleyici ya da numaralama türünde olmalı"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -64573,7 +64632,7 @@ msgstr "%qT türündeki sabit olmayan başvurunun geçici %qT türünden ilklend
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "%qT türünden %qT türüne dönüşüm niteleyicileri iptal ediyor"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "%qT türünden %qT türüne dönüşüm gösterici başvurusunu kaldırmaz"
@@ -65004,7 +65063,7 @@ msgstr "önceki %q+F bildirimindeki farklı olağandışılıkları yakalıyor"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "bir şablon olmayan olarak yeniden %qT bildirimi"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D"
 msgid "previous declaration %qD"
@@ -65259,13 +65318,13 @@ msgstr "öntanımlı argüman %2$q#D bildiriminin %1$d. parametresi için"
 msgid "previous specification in %q#D here"
 msgstr "%q+#D bildirimindeki önceki belirtimden sonra verilmiş"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "previously declared here without exporting"
@@ -65495,7 +65554,7 @@ msgstr "  %q+#D ilklendirmesi atlanıyor"
 msgid "  enters %<template for%> statement"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -65547,600 +65606,600 @@ msgstr "%<%T::%D%> bir tür değil"
 msgid "template parameters do not match template %qD"
 msgstr "şablon parametreleri bu şablonla uyuşmuyor:"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "trampolines not supported"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "trampolines desteklenmiyor"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D invalid; an anonymous union can only have non-static data members"
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q+#D geçersiz; bir anonim union sadece statik olmayan veri üyeleri içerebilir"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "anonim yapı isimli türün içinde değil"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "anonim kümeleme içinde kuruculu üye %q+#D kullanılamaz"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "anonim kümeleme içinde yıkıcılı üye %q+#D kullanılamaz"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "anonim kümeleme içinde kopya atama isleçli üye %q+#D kullanılamaz"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attribute ignored in declaration of %q#T"
 msgstr "%q+#T bildiriminde öznitelik yoksayıldı"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, fuzzy, gcc-internal-format
 #| msgid "attribute for %q+#T must follow the %qs keyword"
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "%q+#T için öznitelik %qs anahtar sözcüğünü izlemeli"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "bir bildirimde birden fazla tür"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "C++ yerleşik türü %qT için yeniden bildirim"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%qs sadece işlevler için belirtilebilir"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "typedef bildiriminde tür ismi eksik"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ anonim yapıları (struct) yasaklar"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "%qs sadece işlevler için belirtilebilir"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%qs sadece işlevler için belirtilebilir"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> sadece bir sınıf içinde belirtilebilir"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> sadece kurucular için belirtilebilir"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "bir saklama sınıfı sadece işlevler ve nesneler için belirtilebilir"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "niteliyiciler sadece işlevler ve nesneler için belirtilebilir"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "niteliyiciler sadece işlevler ve nesneler için belirtilebilir"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "niteliyiciler sadece işlevler ve nesneler için belirtilebilir"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "a storage class can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "bir saklama sınıfı sadece işlevler ve nesneler için belirtilebilir"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 #| msgid "typedef declaration invalid in parameter declaration"
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "typedef bildirimi parametre bildiriminde geçersiz"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "%<register%> in file-scope empty declaration"
 msgid "%qs cannot be used for type declarations"
 msgstr "dosya etki alanı boş bildiriminde %<register%>"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "%q+#T bildiriminde öznitelik yoksayıldı"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "%qE özniteliği sadece sınıf tanımlarına uygulanabilir"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
 msgid "attribute ignored"
 msgstr "%qE özniteliği yoksayıldı"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "%qE özniteliği sadece sınıf tanımlarına uygulanabilir"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %qD is initialized (use __typeof__ instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD ilklendirilmiş (yerine  __typeof__  kullanın)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "%q#D hem %<extern%> olarak bildirilmiş hem de ilklendirilmiş"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D definition is marked dllimport"
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "%q+D işlevinin tanımı dllimport imli"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q#D %qT'nin bir static olmayan üyesi değildir"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member-template declaration of %qD"
 msgstr "%q#D şablon bildirimi"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member template declaration %qD"
 msgid "does not match member template declaration here"
 msgstr "geçersiz üye sablonu bildirimi %qD"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ %<%T::%D%>nin %<%T::%D%> olarak tanımlanmasına izin vermez"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "%qD ilklendirmesi yinelenmiş"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "sınıf dışında %q#D bildirimi bir tanım değildir"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "%q#D değişkeni ilklendirilmiş ama içi boş türde"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "%q#D dizisinin elemanları içi boş türde"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "küme %q#D içi boş türde olup tanımlı olamaz"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD başvuru olarak bildirilmiş ama ilklendirilmemiş"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, fuzzy, gcc-internal-format
 #| msgid "name %qD used in a GNU-style designated initializer for an array"
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "%qD ismi bir dizi için GNU tarzında tasarlanmış bir ilklendiricide kullanılmış"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "%qD ismi bir dizi için GNU tarzında tasarlanmış bir ilklendiricide kullanılmış"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "alelade olmayan ilklendiriciler desteklenmiyor"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "ilklendirici %qD bildiriminin boyutunu saptayamıyor"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "%qD bildiriminde dizi boyutu eksik"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "sıfır boyutlu dizi %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of %q+D isn%'t known"
 msgid "storage size of %qD isn%'t known"
 msgstr "%q+D nin saklama uzunluğu bilinmiyor"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "storage size of %q+D isn%'t constant"
 msgid "storage size of %qD isn%'t constant"
 msgstr "%q+D nin saklama genişligi sabit değil"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "özür: satıriçi işlev static verisi %q+#D'nin kodlaması yanlış (sizi çoklu kopyalara sürükleyecek)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 #| msgid "sorry: semantics of inline function static data %q+#D are wrong (you'll wind up with multiple copies)"
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "özür: satıriçi işlev static verisi %q+#D'nin kodlaması yanlış (sizi çoklu kopyalara sürükleyecek)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 #| msgid "%J  you can work around this by removing the initializer"
 msgid "you can work around this by removing the initializer"
 msgstr "%J  ilklendiriciyi kaldırarak bunun olurunu bulabilirsiniz"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "ilklendirilmemiş sabit %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs has a user-defined constructor"
 msgid "%q#T has no user-provided default constructor"
 msgstr "%qs türü bir kullanıcı tanımlı yapıcıya sahip"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, fuzzy, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "%2$qT türündeki bir vektör için ilklendirici olarak %1$qT türü geçersiz"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "%qT için ilklendirici {} içinde olmalı"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, fuzzy, gcc-internal-format
 #| msgid "name %qD used in a GNU-style designated initializer for an array"
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%qD ismi bir dizi için GNU tarzında tasarlanmış bir ilklendiricide kullanılmış"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "üye %qD için istek belirsiz"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT %qD isminde statik olmayan bir üyeye sahip değil"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD %qT'nin bir üyesi değil"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer for %q#D"
 msgstr "geçersiz ilklendirici"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "%qT için ilklendirici sayısı çok fazla"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "%qT için skalar ilklendiriciyi kuşatan parantezler"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "%qT için skalar ilklendiriciyi kuşatan parantezler"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "%qT için ilklendiriciyi çevreleyen parantezler yok"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "structured binding has incomplete type %qT"
 msgstr "%qD alanı içi boş türde"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 #| msgid "elements of array %q#D have incomplete type"
 msgid "elements of array %q#T have incomplete type"
 msgstr "%q#D dizisinin elemanları içi boş türde"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids compound literals"
 msgid "variable-sized compound literal"
 msgstr "ISO C90 bileşik sabitlere izin vermez"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has incomplete type"
 msgid "%q#D has incomplete type"
 msgstr "%qD içi boş türde"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "scalar object %qD requires one element in initializer"
 msgstr "union ilklendiricide gereğinden fazla öğe"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be initialized by constructor, not by %<{...}%>"
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "%qD bir kurucu ile ilklendirilmeli, %<{...}%> ile değil"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, fuzzy, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "parantezli dizge sabiti %2$qE ile ilklendirilmiş %1$qD dizgesi"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "kuruculu statik üye için ilklendirici geçersiz"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "ISO C++ sabit olmayan statik %qD üyesinin sınıf içi ilklendirmesine izin vermez"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "ISO C++ sabit olmayan statik %qD üyesinin sınıf içi ilklendirmesine izin vermez"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(bir sınıf dışı ilklendirme gerekli)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "%qD doğrudan yazmaç değişkeninin adresi istendi"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD is initialized"
 msgid "reference %qD is initialized with itself"
 msgstr "%qD parametresi ilklendirilmiş"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "could not find variant declaration"
 msgstr "boş bildirimde %<inline%>"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%s %q+#D için argümanlar çok az"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "%<declare variant%> on destructor %qD"
 msgstr "enumerator %q+D yeniden bildirilmiş"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "bildirim içinde atama (ilklendirme değil)"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ tasarlanmış ilkendiricilere izin vermez"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %qs"
 msgid "%<register%> storage class specifier used"
 msgstr "%qs için saklatım sınıfı belirtilmiş"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D has %<extern%> and is initialized"
 msgid "declaration of %q#D has no initializer"
 msgstr "%q#D hem %<extern%> olarak bildirilmiş hem de ilklendirilmiş"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static member function %qD"
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "static olmayan üye işlev %qD kullanımı geçersiz"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -66148,131 +66207,131 @@ msgstr "dönüş türü %q#T bir içi boş türdür"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%<::main%> cannot be deleted"
 msgstr "%q+#D bildirilemez"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "önceki %q#D tür bildirimini gölgeliyor"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%qs sadece işlevler için belirtilebilir"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "%q#D işlevi bir değişken gibi ilklendirilmiş"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decompose address"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "adres çözümlenemez"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "lambda declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at %q+D because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "  %q+D'deki atıl baglantı bir yıkıcıya sahip olduğundan kullanılamaz"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an inaccessible base of %qT"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "%qT, bir erişilemeyen %qT tabanıdır"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT %qT'nin alt sınıfı değil"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing pointer to incomplete type"
 msgid "structured binding refers to incomplete type %qT"
 msgstr "içi boş ture gösterici ilişkilendirme"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "parametre %1$qD bilinmeyen sınırlı %3$qT dizisine %2$s içeriyor"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable-size array %qs"
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 değişken boyutlu %qs dizisini yasaklar"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot decompose variable length vector %qT"
 msgstr "%q#T türüne gösterici bildirilemez"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "dizi boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot decompose union type %qT"
 msgstr "bit alanı %qD işlev türü ile bildirilemez"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "sınıf olmayan %qT türünde üye göstericisi oluşturulması"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "dönüş türü, bir içi boş tür"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "storage class specified for structure field %qs"
 msgid "%u name provided for structured binding"
@@ -66280,1928 +66339,1940 @@ msgid_plural "%u names provided for structured binding"
 msgstr[0] "%qs yapı alan için saklama sınıfı belirtilmiş"
 msgstr[1] "%qs yapı alan için saklama sınıfı belirtilmiş"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "in initialization of structured binding pack %qD"
 msgstr "%qT işlev türüne dönüşüm geçersiz"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "in initialization of structured binding variable %qD"
 msgstr "%qT işlev türüne dönüşüm geçersiz"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static data member %qD"
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "static olmayan veri üyesi %qD kullanımı geçersiz"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 #| msgid "initializer fails to determine size of %qD"
 msgid "initializer fails to determine size of %qT"
 msgstr "ilklendirici %qD bildiriminin boyutunu saptayamıyor"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 #| msgid "array size missing in %qD"
 msgid "array size missing in %qT"
 msgstr "%qD bildiriminde dizi boyutu eksik"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 #| msgid "zero-size array %qD"
 msgid "zero-size array %qT"
 msgstr "sıfır boyutlu dizi %qD"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "yabancı sınıf %qT için yıkıcı, bir üye olamaz"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "yabancı sınıf %qT için kurucu, bir üye olamaz"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD bir %<virtual%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "%2$s bildirimindeki %<const%> ve %<volatile%> işlev belirtecleri %1$qD için geçersiz"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD bir %<virtual%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD nesnesi bir %<inline%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "%2$s bildirimindeki %<const%> ve %<volatile%> işlev belirtecleri %1$qD için geçersiz"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD bir %<virtual%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD nesnesi bir %<inline%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "%2$s bildirimindeki %<const%> ve %<volatile%> işlev belirtecleri %1$qD için geçersiz"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as a %<virtual%> %s"
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD bir %<virtual%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> %s"
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD nesnesi bir %<inline%> %s olarak bildirilmiş"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "%2$s bildirimindeki %<const%> ve %<volatile%> işlev belirtecleri %1$qD için geçersiz"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D bir kardeş olarak bildirilmiş"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D bir olağandışılık belirtimi ile bildirilmiş"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "%qD tanımı %qT bağlamını kapsayan isim alanınında değil"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "statik üye işlev %q#D tür niteleyicilerle bildirilmiş"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "isimli dönüş değerleri artık desteklenmiyor"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD bir şablon işlevi değildir"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "kardeş bildirimi sınıf bildiriminde değil"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "%qD doğrudan özelleştirmesinin kardeş bildirimde tanımı"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "birincil şablon bildiriminde %qD şablon kimliğinin kullanımı geçersiz"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "öntanımlı argümanlara kardeş şablon özelleştirmesi %qD bildiriminde izin verilmez"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "kardeş şablon özelleştirmesi %qD bildiriminde %<inline%> kullanılamaz"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "sınıf dışında %q#D bildirimi bir tanım değildir"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "%<::main%> bir şablon olarak bildirilemez"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "%<::main%> inline olarak bildirilemez"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "%<::main%> static olarak bildirilemez"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "%<::main%> static olarak bildirilemez"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be inline"
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "%<::main%> inline olarak bildirilemez"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "%<::main%> bir şablon olarak bildirilemez"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "explicit object parameter declared here"
 msgstr "void bildirimli değişken ya da alan"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "  declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "işlev olmayan olarak %qD bildirimi"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 #| msgid "template with C linkage"
 msgid "literal operator with C linkage"
 msgstr "C ilintilemeli şablon"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 #| msgid "invalid option argument %qs"
 msgid "%qD has invalid argument list"
 msgstr "seçenek argümanı %qs geçersiz"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-member function"
 msgstr "%qD static olmayan bir üye işlev olmalıdır"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> %<int%> döndürmeli"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "dolaylı bildirimli %qD tanımı"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "definition of implicitly-declared %qD"
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "dolaylı bildirimli %qD tanımı"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "%q#D explicitly defaulted here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, fuzzy, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "sınıf %2$qT içinde bildirilmiş %1$q#D diye bir üye işlev yok"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "%<::main%> bir şablon olarak bildirilemez"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "strong using only meaningful at namespace scope"
 msgid "concept must be defined at namespace scope"
 msgstr "kesin kullanım sadece isimalanı kapsamında anlamlıdır"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "isimli dönüş değerleri artık desteklenmiyor"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "tümleyen olmayan %qT türündeki statik veri üyesinin sınıf içi ilklendirmesi geçersiz"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "tümleyen olmayan %qT türündeki statik veri üyesinin sınıf içi ilklendirmesi geçersiz"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 #| msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "tümleyen olmayan %qT türündeki statik veri üyesinin sınıf içi ilklendirmesi geçersiz"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "tümleyen olmayan %qT türündeki statik veri üyesinin sınıf içi ilklendirmesi geçersiz"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ sabit olmayan statik %qD üyesinin sınıf içi ilklendirmesine izin vermez"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ tümlemeyen %2$qT türündeki %1$qD üye sabitinin ilklendirilmesine izin vermez"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "%qD dizisinin boyutu tümlemeyen %qT türünde"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "dizi boyutu tümlemeyen %qT türünde"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "dizi boyutu bir tümleyen sabit ifadesi değil"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ da sıfır boyutlu %qD dizisi yasaktır"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++'da sıfır boyutlu dizi yasaktır"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids variable-size array %qD"
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ değişken boyutlu %qD dizisine izin vermez"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids variable-size array"
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++  değişken boyutlu diziye izin vermez"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr ""
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr ""
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "dizi boyutunda taşma"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%q+D bir kardeş olarak bildirilmiş"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "%qT üye referans türünde gösterici oluşturulması"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of voids"
 msgid "declaration of %qD as array of void"
 msgstr "void dizisi olarak %qs bildirimi"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of void"
 msgstr "%qT dizisi oluşturulması"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of functions"
 msgstr "işlev dizisi olarak %qs bildirimi"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of functions"
 msgstr "%qT dizisi oluşturulması"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of references"
 msgstr "işlev dizisi olarak %qs bildirimi"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of %qT"
 msgid "creating array of references"
 msgstr "%qT dizisi oluşturulması"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "declaration of %qD as array of function members"
 msgstr "işlev dizisi olarak %qs bildirimi"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qs as array of functions"
 msgid "creating array of function members"
 msgstr "işlev dizisi olarak %qs bildirimi"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "çok boyutlu dizi olarak %qD bildiriminde ilki dışında tüm boyutlar sınırlanmış olmalıdır"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "çok boyutlu dizi bildiriminde ilki dışında tüm boyutlar sınırlanmış olmalıdır"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when a variable is unused"
 msgid "variable-length array of %<auto%>"
 msgstr "Bir değişken kullanılmamışsa uyarır"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "kurucu için dönüş türü belirtimi geçersiz"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "%<operator %T%> bildiriminde niteleyicilere izin verilmez"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "yıkıcı için dönüş türü belirtimi geçersiz"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "%<operator %T%> bildiriminde niteleyicilere izin verilmez"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "%<operator %T%> için dönüş türü belirtilmiş"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "%<operator %T%> bildiriminde niteleyicilere izin verilmez"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "yıkıcı için dönüş türü belirtimi geçersiz"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "%<operator %T%> bildiriminde niteleyicilere izin verilmez"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 #| msgid "too many template parameter lists in declaration of %qD"
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "%qD bildiriminde çok fazla şablon parametresi listeleniyor"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "void bildirimli adsız değişken ya da alan"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "void bildirimli değişken ya da alan"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "genel kapsam dışında bildirilen %qs işlevi için %<inline%> belirteci geçersiz"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "%qE bildirimin başlangıcında değil"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "yıkıcılar cv-nitelemeli olmayabilir"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "signed and unsigned given together for %qs"
 msgid "%e and %e specified together"
 msgstr "%qs için signed ve unsigned birlikte verilmiş"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<::%>"
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "%<::%> kullanımı geçersiz"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of undefined type %<%s %E%>"
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "tanımsız tür %<%s %E%> kullanımı geçersiz"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of undefined type %<%s %E%>"
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "tanımsız tür %<%s %E%> kullanımı geçersiz"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT bir sınıf ya da isim alanı değil"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "işlev olmayan olarak %qD bildirimi"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "üye olmayan olarak %qD bildirimi"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "bildirimci kimliği eksik; yedek sözcük %qD kullanılıyor"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared %<register%>"
 msgid "function definition does not declare parameters"
 msgstr "%<register%> bildirimli işlev tanımı"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "işlev olmayan olarak %qD bildirimi"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "%2$s olarak %1$qD bildirimi"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q+D shadows a parameter"
 msgid "declaration of %qD as parameter"
 msgstr "%q+D bildirimi bir parametreyi gölgeliyor"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "a template-id may not appear in a using-declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "using bildiriminde bir şablon kimliği bulunamaz"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "%qs bildiriminde iki veya daha fazla veri türü"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain %<complex%> meaning %<double complex%>"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C salt %<complex%>i %<double complex%> anlamında desteklemez"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ türsüz %qs bildirimine izin verilmez"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 #| msgid "__builtin_saveregs not supported by this target"
 msgid "%<__int%d%> is not supported by this target"
 msgstr "__builtin_saveregs bu hedef tarafından desteklenmiyor"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support %<long long%>"
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ %<long long%> desteklemez"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %qE"
 msgid "%qs specified with %qT"
 msgstr "%<__thread%> %qE ile kullanılmış"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter %qs"
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qs specified with %<decltype%>"
 msgstr "%<__thread%> %<typedef%> ile kullanılmış"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qs specified with %<typeof%>"
 msgstr "%<__thread%> %<typedef%> ile kullanılmış"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "%qs için complex geçersiz"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "üye %qD, hem virtual hem de static olarak bildirilemez"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "üye %qD, hem virtual hem de static olarak bildirilemez"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "typedef bildirimi parametre bildiriminde geçersiz"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter %qs"
 msgid "storage class specified for template parameter %qs"
 msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "non-member %qs cannot be declared %<mutable%>"
 msgid "a parameter cannot be declared %qs"
 msgstr "üye olmayan %qs, %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "virtual outside class declaration"
 msgid "%<virtual%> outside class declaration"
 msgstr "sanal dış sınıf bildirimi"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "structured binding declaration cannot be %qs"
 msgstr "%q+#T bildiriminde öznitelik yoksayıldı"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "structured binding declaration cannot have type %qT"
 msgstr "%q+#T bildiriminde öznitelik yoksayıldı"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "%qs bildiriminde çok sayıda saklama sınıfı"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "%qs için saklatım sınıfı belirtilmiş"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "iç işlev %qs %<extern%> olarak bildirilmiş"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "%qs için tepe-seviye bildirim %<auto%> belirtiyor"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "%qs işlevinin etki alanı dolaylı olarak auto ve %<__thread%> bildirimli"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "saklatım sınıfı belirteçleri kardeş işlev bildirimlerinde geçersiz"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "%qs bildiriminde çok sayıda saklama sınıfı"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "Umulmadık sol parantez"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "a function type cannot have an explicit object parameter"
 msgstr "işlev sonucu '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "'%s' beyan işlevine bir fiili argüman olarak izin verilmez (%L'de)"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "valid explicit object parameter declared here"
 msgstr "void bildirimli değişken ya da alan"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "requires-clause on return type"
 msgstr "%qE özniteliği veri türlerinde yoksayılır"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "sanal işlevler kardeş işlev olamaz"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<::%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "%<::%> kullanımı geçersiz"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<::%>"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "%<::%> kullanımı geçersiz"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "tür niteleyicileri işlev dönüş türünde yok sayıldı"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "a conversion function cannot have a trailing return type"
 msgstr "sanal işlevler kardeş işlev olamaz"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs işlevle dönen işlev olarak bildirilmiş"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs dizi ile dönen işlev olarak bildirilmiş"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "Logical range in CASE statement at %L is not allowed"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%L'deki CASE deyiminde mantıksal aralığa izin verilmez"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "yıkıcı bir statik üye işlev olamaz"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "kurucu bir statik üye işlev olamaz"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "yıkıcılar cv-nitelemeli olmayabilir"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "kurucular cv-nitelemeli olmayabilir"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "destructors may not be ref-qualified"
 msgstr "yıkıcılar cv-nitelemeli olmayabilir"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "constructors may not be ref-qualified"
 msgstr "yıkıcılar cv-nitelemeli olmayabilir"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "kurucular virtual olarak bildirilemez"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "sanal işlevler kardeş işlev olamaz"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "kardeş bildirimi sınıf bildiriminde değil"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 #| msgid "can't define friend function %qs in a local class definition"
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "yerel sınıf tanımı içinde kardeş işlev %qs tanımlanamaz"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "%smember function %qD cannot have cv-qualifier"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "%süye işlev %qD cv niteleyicisini içeremez"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD static olmayan bir üye işlev olmalıdır"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "yıkıcılar parametre almayabilir"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "%q#T türüne gösterici bildirilemez"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "%q#T türüne başvuru bildirilemez"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "%q#T üyeye gösterici bildirilemez"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "%q#T türüne başvuru bildirilemez"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "bit alanı %qD işlev türü ile bildirilemez"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "şablon kimliği %qD bir bildirici olarak kullanılmış"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "üye işlevler sınıflarının örtük kardeşleridir"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, fuzzy, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "üye %2$qs üzerinde fazladan niteleme %<%1$T::%>"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot define member function %<%T::%s%> within %<%T%>"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "üye işlev %<%T::%s%> %<%T%> içinde tanımlanamaz"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function %<%T::%s%> within %<%T%>"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "uye işlev %<%T::%s%> %<%T%> içinde bildirilemez"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "üye %<%T::%s%> %qT içinde bildirilemez"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 #| msgid "data member %qD cannot be a member template"
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "veri üyesi %qD bir üye şablon olamaz"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "veri üyesi değişken olarak değiştirilmiş %qT türünde olamayabilir"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "parametre değişken olarak değiştirilmiş %qT türünde olamayabilir"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 #| msgid "virtual outside class declaration"
 msgid "%<explicit%> outside class declaration"
 msgstr "sanal dış sınıf bildirimi"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "boş bildirimde %<inline%>"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 #| msgid "only declarations of constructors can be %<explicit%>"
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "sadece kurucuların bildirimleri %<explicit%> olabilir"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "üye olmayan %qs, %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "nesne olmayan üye %qs %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "işlev %qs %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "static %qs %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "sabit %qs %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 #| msgid "function %qs cannot be declared %<mutable%>"
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "işlev %qs %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "typedef may not be a function definition"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "typedef may not be a member function definition"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "boş bildirimde %<inline%>"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %q+D declared %<inline%>"
 msgid "typedef declared %<auto%>"
 msgstr "%<inline%> bildirimli typedef %q+D"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, fuzzy, gcc-internal-format
 #| msgid "%Jtypedef name may not be a nested-name-specifier"
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "%Jtypedef ismi bir iç içe isimli belirteç olmayabilir"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ kapsayan sınıf ile aynı isimde yuvalanmış %qD türüne izin vermez"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "kardeş sınıf bildirimi için %<inline%> belirtilmiş"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "şablon parametreleri kardeş olamazlar"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "friend bildirimi sınıf anahtarı gerektirir, %<friend class %T::%D%> gibi"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "friend bildirimi %<friend %#T%> gibi bir sınıf anahtarı gerektirir"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "sınıf %qT genel bağlamın kardeşi yapılmaya çalışılıyor"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "üye olmayan işlev türünde niteleyiciler geçersiz"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "mutlak bildirimci %qT bildirim olarak kullanılmış"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast to function type %qT"
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "%qT işlev türüne dönüşüm geçersiz"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "parametre bildiriminde %<::%> kullanılamaz"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter %q+D to be of abstract type %qT"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "parametre %q+D soyut %qT türünde bildirilemez"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %q+D declared %<inline%>"
 msgid "parameter declared %<auto%>"
 msgstr "%<inline%> bildirimli %q+D parametresi"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "bir argüman listesi olmaksızın %qE şablon isminin kullanımı geçersiz"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "non-static data member declared with placeholder %qT"
 msgstr "statik üye %qD %<register%> olarak bildirilmiş"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array %qD"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ da sıfır boyutlu %qD dizisi yasaktır"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 esnek dizi üyelerini desteklemez"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "%<::%> kullanımı geçersiz"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of C function %q#D conflicts with"
 msgid "declaration of function %qD in invalid context"
 msgstr "C işlevi %q#D bildirimi"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "işlev %qD bir union içinde virtual olarak bildirilmiş"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be declared virtual, since it is always static"
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD daima static olduğundan sanal olarak bildirilemez"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "yıkıcı %qD için kardeş bildiriminde nitelikli isim umuluyordu"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "%2$qT üyesi olarak %1$qD bildirimi"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "Constructor can't be %s"
 msgid "a destructor cannot be %qs"
 msgstr "Kurucu %s olmayabilir"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 #| msgid "expected qualified name in friend declaration for destructor %qD"
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "yıkıcı %qD için kardeş bildiriminde nitelikli isim umuluyordu"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 #| msgid "Constructor can't be %s"
 msgid "a constructor cannot be %<concept%>"
 msgstr "Kurucu %s olmayabilir"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be a member function"
 msgstr "kurucu bir statik üye işlev olamaz"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "%s açılamıyor"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of implicitly-declared special member function"
 msgid "specialization of variable template %qD declared as function"
 msgstr "örtük bildirimli özel üye işlev özelleştirmesi"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 #| msgid "variable or field declared void"
 msgid "variable template declared here"
 msgstr "void bildirimli değişken ya da alan"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "field %qD has incomplete type %qT"
 msgstr "%qD alanı içi boş türde"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "%qT ismi içi boş türde"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE ne işlev ne de üye işlev; friend olarak bildirilemez"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE ne işlev ne de üye işlev; friend olarak bildirilemez"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+#| msgid "%J%qE attribute applies only to functions"
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "%J%qE özniteliği sadece işlevlere uygulanır"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "%qD doğrudan özelleştirmesinin kardeş bildirimde tanımı"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "static data member %qE declared %qs"
 msgstr "statik üye %qD %<register%> olarak bildirilmiş"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "Yerleşik '%s' %L'de bir ilklendiriciye sahip olamaz"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "static member %qD declared %<register%>"
 msgid "non-static data member %qE declared %qs"
 msgstr "statik üye %qD %<register%> olarak bildirilmiş"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "saklama sınıfı %<auto%> %qs işlevi için geçersiz"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "saklama sınıfı %<register%> %qs işlevi için geçersiz"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "saklama sınıfı %<__thread%> %qs işlevi için geçersiz"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %<__thread%> invalid for function %qs"
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "saklama sınıfı %<__thread%> %qs işlevi için geçersiz"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "%qs sadece işlevler için belirtilebilir"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "bir işlev tanımında bir asm belirtimine izin verilmez"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "%<static%> specified invalid for function %qs declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "genel kapsam dışında bildirilen %qs işlevi için %<static%> belirteci geçersiz"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "genel kapsam dışında bildirilen %qs işlevi için %<inline%> belirteci geçersiz"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "sınıf olmayan sanal işlev %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%qs defined in a non-class scope"
 msgstr "%qE özniteliği sınıf türleri dışında yoksayılır"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qs declared in a non-class scope"
 msgstr "%qD bu etki alanında bildirilmemiş"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "üye işlev %qD static ilintilemeli olarak bildirilemez"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "statik işlev başka bir işlevin içinde bildirilemez"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "bir statik veri üyesi tanımlarken (bildirime zit olarak) %<static%> kullanılamayabilir"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "statik üye %qD %<register%> olarak bildirilmiş"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "üye %q#D harici ilintilemeli olarak doğrudan bildirilemez"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "sınıf dışında %q#D bildirimi bir tanım değildir"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "non-member %qs cannot be declared %<mutable%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "üye olmayan %qs, %<mutable%> olarak bildirilemez"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs ilklendirilmiş ve %<extern%> bildirilmiş"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs hem %<extern%> olarak bildirilmiş hem de ilklendrilmiş"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 #| msgid "default argument %qE uses local variable %qD"
 msgid "default argument %qE uses %qD"
 msgstr "öntanımlı argüman %qE %qD yerel değişkenini kullanıyor"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "öntanımlı argüman %qE %qD yerel değişkenini kullanıyor"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "%<virtual%> kullanımı %q#D şablon bildiriminde geçersiz"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "%<virtual%> kullanımı %q#D şablon bildiriminde geçersiz"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter type %qT"
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "geçersiz parametre türü %qT"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "parametre %qD geçersiz olarak yöntem türünde bildirilmiş"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "parametre %1$qD bilinmeyen sınırlı %3$qT dizisine %2$s içeriyor"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "parametre %1$qD bilinmeyen sınırlı %3$qT dizisine %2$s içeriyor"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "kurucu geçersiz; muhtemelen %<%T (const %T&)%> anlamında kullandınız"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD bir isim alanı içinde bildirilemeyebilir"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD static olarak bildirilemeyebilir"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD static olmayan bir üye işlev olmalıdır"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a member function"
 msgstr "%qD static olmayan bir üye işlev olmalıdır"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD ya bir statik olmayan üye işlev ya da üye olmayan işlev olmalıdır"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD ya bir sınıf argümanına sahip olmalı ya da enum türünde olmalı"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ ?: üç terimlisinin aşırı yüklenmesini yasaklar"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD ya hiç argüman almamalı ya da bir argüman almalı"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD ya bir ya da iki argüman almalı"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "sonek %qD argüman olarak %<int%> almalı"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "sonek %qD ikinci argümanı olarak %<int%> almalı"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD sadece ve sadece iki argüman almalı"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD sadece ve sadece bir argüman almalı"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD sadece ve sadece iki argüman almalı"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "%s%s'ya dönüşüm asla bir tür dönüşüm işleci kullanmayacak"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "%s%s'ya dönüşüm asla bir tür dönüşüm işleci kullanmayacak"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "%s%s'ya dönüşüm asla bir tür dönüşüm işleci kullanmayacak"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "%s%s'ya dönüşüm asla bir tür dönüşüm işleci kullanmayacak"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to %s%s will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "%s%s'ya dönüşüm asla bir tür dönüşüm işleci kullanmayacak"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "kullanıcı tanımlı %qD daima her iki argümanıyla birlikte değerlendirilir"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "önek %qD %qT döndürmeli"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "sonek %qD %qT döndürmeli"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD değeriyle döndürülmeli"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, fuzzy, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "%2$qs sonrası şablon türü %1$qT parametresi kullanımı"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "%2$q+D için şablon özelleştirmesi %1$qD belirsiz"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, fuzzy, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "%2$qs sonrası typedef-ismi %1$qD kullanımı"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D has a previous declaration here"
 msgid "%qD has a previous declaration here"
 msgstr "%q+D için burada önceki bir bildirim var"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT türüne %qs olarak başvuruluyor"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%qT has a previous declaration here"
 msgstr "%q+T için burada önceki bir bildirim var"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT türüne enum olarak başvuruluyor"
@@ -68213,104 +68284,104 @@ msgstr "%qT türüne enum olarak başvuruluyor"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "%<%s %T%> için şablon argüman gerekli"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "%qD ile ilişkilendirme belirsiz"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "class template %qD redeclared as non-template"
 msgstr "şablon olarak şablon olmayan %qD kullanılmış"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD bildirildiği sınıf ile aynı isimde"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT bir şablon değil"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "önceden bildirim olmaksızın enum %q#D kullanımı"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "bir şablon olmayan olarak yeniden %qT bildirimi"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "türetilmiş union %qT geçersiz"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is already defined in the class %qT"
 msgid "%qT defined with multiple direct bases"
 msgstr "%qD zaten sınıf %qT içinde tanımlı"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct or virtual base of %qT"
 msgid "%qT defined with direct virtual base"
 msgstr "%qT türü bir doğrudan ya da dolaylı %qT tabanı değil"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "taban tür %qT bir yapı veya sınıf türü olarak hatalı"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "ardışık tür %qT tanımsız"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "yinelenmiş taban türü %qT geçersiz"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "previous definition here"
 msgstr "%Jönceden burada tanımlı"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarım"
@@ -68319,96 +68390,102 @@ msgstr "%2$qE işlevinin %1$d. argümanına uyumsuz gösterici türünde aktarı
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "%qT için simgesel sabit değerlerinin tamamını hiçbir tümleyen tür temsil edemez"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qE is not an integer constant"
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "%qE için sembolik sabit değeri bir tamsayı sabit değil"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qE is not an integer constant"
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "%qE için sembolik sabit değeri bir tamsayı sabit değil"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C restricts enumerator values to range of %<int%>"
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "ISO C sembolik sabit grubunun değerlerini %<int%> kapsamında sınırlar"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C restricts enumerator values to range of %<int%>"
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "ISO C sembolik sabit grubunun değerlerini %<int%> kapsamında sınırlar"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "%qD'de simgesel sabit değerlerinde taşma"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qE is not an integer constant"
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "%qE için sembolik sabit değeri bir tamsayı sabit değil"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "çok sayıda %q#T tanımı"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "dönüş türü %q#T bir içi boş türdür"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%>, %<*this%> için bir başvuru döndürmeli"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statements in function returning %qT"
 msgstr "void olmayan dönüşlü işlevde `return' deyimi yok"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 #| msgid "function return types not compatible due to %<volatile%>"
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "işlevin dönüş türü %<volatile%> den dolayı uyumsuz"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "void olmayan dönüşlü işlevde `return' deyimi yok"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD zaten %qT sınıfında tanımlı"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "%J%s %<%c%s%>"
 msgid "using %qs"
 msgstr "%J%s %<%c%s%>"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D bildirim öncesi kullanılmış"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -68874,7 +68951,7 @@ msgstr "C işlevi %q#D bildirimi"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    Included at %s:%d\n"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
@@ -68882,7 +68959,7 @@ msgstr ""
 "Sırayla bir altındaki dosyada içerilerek:\n"
 "\t\t%s:%d\n"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    Included at %s:%d\n"
 msgid "    inlined from %qD at %r%s:%d%R"
@@ -68890,362 +68967,362 @@ msgstr ""
 "Sırayla bir altındaki dosyada içerilerek:\n"
 "\t\t%s:%d\n"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "complex invalid for %qs"
 msgid "    inlined from %qD"
 msgstr "%qs için complex geçersiz"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In static member function %qD"
 msgstr "%qs üye işlevinde:"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs:"
 msgid "In copy constructor %qD"
 msgstr "%qs işlevinde:"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs:"
 msgid "In constructor %qD"
 msgstr "%qs işlevinde:"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs:"
 msgid "In destructor %qD"
 msgstr "%qs işlevinde:"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In lambda function"
 msgstr "%qs üye işlevinde:"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs:"
 msgid "In explicit object member function %qD"
 msgstr "%qs üye işlevinde:"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "%qs üye işlevinde"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "%qs işlevinde"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "but %qE is a type"
 msgstr "%qE bir şablon değil"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "but %qE is an expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "but %qE is a variable"
 msgstr "%qD bir şablon değil"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "but %qE is a parameter"
 msgstr "%qs önerilmiyor"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "but %qE is a function"
 msgstr "%q+D bir işlev değil,"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "but %qE is a data member"
 msgstr "%q#T gösterici veri üyeleri içeriyor"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD bir işlev şablonu değil"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "but %qE is a class template"
 msgstr "%qE bir şablon değil"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "but %qE is a variable template"
 msgstr "%qD bir şablon değil"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD bir isim alanıdır"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a namespace-name"
 msgid "but %qE is an enumerator"
 msgstr "%qD bir isim alanı ismi değil"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 #| msgid "explicit instantiation of %q#D"
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%q#D'nin doğrudan örneklenimi"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of %q#D"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%q#D'nin doğrudan örneklenimi"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr ""
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "buradan çağrıldı"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr ""
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr ""
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "required from %q#D\n"
 msgstr "%q+D için sağlanmış"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "recursively required from here\n"
 msgstr "buradan çağrıldı"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 #| msgid "called from here"
 msgid "required from here\n"
 msgstr "buradan çağrıldı"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr ""
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr ""
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "required by the constraints of %q#D\n"
 msgstr "%q+D için sağlanmış"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of %qE"
 msgid "required for the satisfaction of %qE"
 msgstr "%qE'in önceki bildirimi"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c or -S required for Ada"
 msgid "required for constraint satisfaction\n"
 msgstr "Ada için -c ya da -S gerekli"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "argüman yok"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "argüman yok"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "içi boş %qT türü alt isim belirtecinde kullanılmış"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "%<%T::%D%> ile ilişkilendirme belirsiz"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD %qT'nin bir üyesi değil"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD %qT'nin bir üyesi değil"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qD"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD, %qD nin bir üyesi değil"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD, %qD nin bir üyesi değil"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> bildirilmemişti"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> bildirilmemişti"
@@ -69485,7 +69562,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "uye %qD ilklendirilmemiş referanstir"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -69613,7 +69690,7 @@ msgstr "%qT türü bir doğrudan ya da dolaylı %qT tabanı değil"
 msgid "type %qT is not a direct base of %qT"
 msgstr "%qT türü bir doğrudan %qT tabanı değil"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
@@ -69817,45 +69894,45 @@ msgstr "silme işlecinin çağrısında bir sorun saptandı:"
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "sınıf tanımlanırken bildirilmiş olsalar bile, ne yıkıcı ne de sınıfa özel silme işleci çağrılır."
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "ilklendirici erken sonlanıyor"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "delete içindeki dizi boyutu bilinmiyor"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "dönüş türü, bir içi boş tür"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "silme işlecinin çağrısında bir sorun saptandı:"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined."
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "sınıf tanımlanırken bildirilmiş olsalar bile, ne yıkıcı ne de sınıfa özel silme işleci çağrılır."
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "vektör silme işlemi için tür ne gösterici ne de dizi"
@@ -69893,89 +69970,97 @@ msgstr "%s içi boş %qT türüne bir gösterici olamaz"
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<this%> was not captured for this lambda function"
 msgstr "statik üye işlevlerde %<this%> kullanılmaz"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD' nin anlamlandırılmış ismi GCC'nin gelecek sürümünde değişecek"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD' nin anlamlandırılmış ismi GCC'nin gelecek sürümünde değişecek"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "#pragma %s geçersiz"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable artık desteklenmiyor"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%qs için #pragma oluşumu dosya içerildikten sonra görünüyor"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD tanımsız"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD bu etki alanında bildirilmemiş"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD bu etki alanında bildirilmemiş"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "%qD için bir şablon parametresine bağımlı bir argüman yok, o halde bir %qD bildirimi mümkün olmalı."
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(%<-fpermissive%> kullanırsaniz, G++ kodunuzu kabul edecek ama bildirilmemiş isim kullanımına izin vermek artık önerilmiyor)"
@@ -69985,68 +70070,61 @@ msgstr "(%<-fpermissive%> kullanırsaniz, G++ kodunuzu kabul edecek ama bildiril
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "%<?:%> için ortadaki terim olmadığından yorumlanamadı"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "%qD' nin anlamlandırılmış ismi GCC'nin gelecek sürümünde değişecek"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "%qD' nin anlamlandırılmış ismi GCC'nin gelecek sürümünde değişecek"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "%qD' nin anlamlandırılmış ismi GCC'nin gelecek sürümünde değişecek"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "%qD' nin anlamlandırılmış ismi GCC'nin gelecek sürümünde değişecek"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
@@ -70470,7 +70548,7 @@ msgstr "ilintisiz %q+D yeniden bildirimi"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting type for imported declaration %#qD"
@@ -70488,462 +70566,462 @@ msgstr "%q#D bildirimi çelişkili"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "yerleşik işlev %q+D için tür çelişkisi"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for %q+#D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "%q+#D için belirtilen dönüş türü çelişiyor"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "%q+D bildiriminde"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "%qD için öntanımlı argüman yok"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "existing default declared here"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "öntanımlı argüman %2$q#D bildiriminin %1$d. parametresi için"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of %q#D doesn't match"
 msgid "definition of %qD does not match"
 msgstr "%q#D extern bildirim uyumsuz"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "tanım eksik"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 #| msgid "extern declaration of %q#D doesn't match"
 msgid "enumerator %qD does not match ..."
 msgstr "%q#D extern bildirim uyumsuz"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "enumerator %q+D yeniden bildirilmiş"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE %qT türünde değil"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%q#D şablon bildirimi"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%qD farklı erişimle tekrar bildirilmiş"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD bir isim alanı içinde bildirilemeyebilir"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü o bir göstericidir"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü o bir göstericidir"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "increment of read-only location"
 msgid "%qD refers to TU-local function %qD"
 msgstr "salt-okunur konuma eksiltim"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "module %qs declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "  from definition of %q+#D"
 msgid "macro definitions of %qE corrupted"
 msgstr "  %q+#D tanımından"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "inconsistent imported macro definition %qE"
 msgstr "%L ve %L'de işliçler için sıralar uyumsuz"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 #| msgid "%s: can't delete file '%s': %s\n"
 msgid "compiled module file is %qs"
 msgstr "%s: `%s' silinemiyor: %s\n"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiled module is %sversion %s"
 msgstr "collect2 %s sürümü\n"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 %s sürümü\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs not found"
 msgid "module %qs found"
 msgstr "alan %qs yok"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 #| msgid "multiple function type attributes specified"
 msgid "fixed tree mismatch"
 msgstr "çok sayıda işlev türü öznitelik belirtilmiş"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "yığıt sınırlama ifadesi desteklenmiyor"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr ""
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to get process times"
 msgid "failed to read compiled module: %s"
 msgstr "süreç zamanlarını almada başarısızlık"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration %q#D"
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "%q#D yerleşik bildirimiyle çelişiyor"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration %q#D"
 msgid "declaration %qD conflicts with builtin"
 msgstr "%q#D yerleşik bildirimiyle çelişiyor"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "asm declaration ignored due to conflict with previous rename"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "asm bildirimi önceki isim değişikliği ile çeliştiğinden yoksayıldı"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, fuzzy, gcc-internal-format
 #| msgid "using declaration %q+D conflicts with a previous using declaration"
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "%q+D bildirimi kullanımı önceki bildirimlerden biri ile çelişiyor"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with new declaration with %qL linkage"
 msgid "conflicting declaration of %qD in global module"
 msgstr "%qL ilintili yeni bildirim ile çelişiyor"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "previously declared in module %qs"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "previously declared in global module"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %q#D declares a non-template function"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "friend bildirimi %q#D bir şablon olmayan işlev bildiriyor"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "ilintisiz %q+D yeniden bildirimi"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "Creating '%s'\n"
 msgid "reading CMI %qs"
 msgstr "'%s' oluşturuluyor\n"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "yöntem tanımı @implementation bağlamında değil"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "module declared here"
@@ -70956,116 +71034,116 @@ msgstr "burada bildirilmiş %q+D"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "module already declared"
 msgstr "'%s' bileşeni (%C'deki) zaten %L'de bildirilmiş"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "module already imported"
 msgstr "'%s' bileşeni (%C'deki) zaten %L'de bildirilmiş"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 #| msgid "label %q+D defined but not used"
 msgid "module %qs imported here"
 msgstr "%q+D yaftası tanımlı ama kullanılmamış"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown compiled module interface: %s"
 msgstr "bilinmeyen yazmaç ismi: %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing"
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Geleneksel önişlem etkin olur"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter %qs"
 msgid "invalid header name %qs"
 msgstr "geçersiz parametre %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid module name %qs"
 msgstr "gösterici kipi olarak %qs geçersiz"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "%qs yazılırken hata"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr ""
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to get process times"
 msgid "failed to write compiled module: %s"
 msgstr "süreç zamanlarını almada başarısızlık"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown header kind %qs"
@@ -71082,7 +71160,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "%q+D işlevinin yeniden bildirimi inline öznitelikli değil"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
@@ -71133,291 +71211,302 @@ msgstr "%q#D bildirimi bir parametreyi gölgeliyor"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "%2$qT üyesi olarak %1$qD bildirimi"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %q+D but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "%q+D parametresi için bildirim var ama böyle bir parametre yok"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 #| msgid "using declaration %q+D conflicts with a previous using declaration"
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "%q+D bildirimi kullanımı önceki bildirimlerden biri ile çelişiyor"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s(%E) %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q#D declared here with no linkage"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%q#D declared here with internal linkage"
 msgstr "%qD farklı erişimle tekrar bildirilmiş"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%q#D declared here with module linkage"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> yıkıcı isimlendiriyor"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "sınıf bağlamında üye olmayan için using bildirimi"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT bir sınıf ya da isim alanı değil"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "%q#D şablon bildirimi"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "sınıf bağlamında üye olmayan için using bildirimi"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "%qT türü bir doğrudan %qT tabanı değil"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qD not declared"
 msgid "%qD has not been declared in %qD"
 msgstr "%qD bildirilmemiş"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "using-declaration may not name namespace %qD"
 msgstr "%q#D bildirimi çelişkili"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> %qT içinde kurucu isimlendiriyor"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "%qD bildirimi %qD'yi kuşatan isim alanında değil"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "%qD bildiriminde doğrudan niteleme"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD %qD içinde bildirilmeliydi"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 #| msgid "%qD not declared"
 msgid "%qD has not been declared within %qD"
 msgstr "%qD bildirilmemiş"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D bir kardeş olarak bildirilmiş"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute requires an integer constant argument"
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%qs özniteliği bir tamsayı sabit argüman gerektirir"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "%qD öznitelik yönergesi yoksayıldı"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D"
 msgid "  %qE"
 msgstr "  %q+#D"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "statik üye işlevlerde %<this%> kullanılmaz"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "the macro %qs had not yet been defined"
 msgstr "%q+#D bildirilemez"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "it was later defined here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "switch %qs is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "switch %qs artık desteklenmiyor"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "cannot nest more than %d namespaces"
 msgstr "%qD bir isim alanı içinde bildirilemeyebilir"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "'%s' simgesi (%L'de) belirsiz"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "burada isim alanı rumuzu %qD kullanılamaz, %qD varsayılıyor"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "ilintisiz %q+D yeniden bildirimi"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD bir isim alanı içinde bildirilemeyebilir"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "exporting unnamed namespace"
 msgstr "%<{%> umuluyordu"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "inline namespace must be specified at initial definition"
 msgstr "%Jbölüm özniteliği yerel değişkenler için belirtilmiş olamaz"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with previous using declaration %q#D"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%q#D önceki using bildirimi %q#D ile çelişiyor"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%Jprevious definition here"
 msgid "reachable %s definition here"
 msgstr "%Jönceden burada tanımlı"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX, pop_everything () işlevine giriyor\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -71449,7 +71538,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
@@ -71500,7 +71589,7 @@ msgstr "%<::%D%> bildirilmemişti"
 msgid "request for member %qE in non-class type %qT"
 msgstr "sınıf olmayan %2$qT türündeki %1$qD üyesi için istek"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> has not been declared"
 msgid "%<%T::%E%> has not been declared"
@@ -71582,7 +71671,7 @@ msgstr "(belki de %qT bildiriminden sonra bir ; yoktur)"
 msgid "%qE is not a class template"
 msgstr "%qE bir şablon değil"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE bir şablon değil"
@@ -71927,1866 +72016,1877 @@ msgstr ""
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "bu ortam işlevi sadece fr500 üzerinde kullanılabilir"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD bir işlev şablonu değil"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, gcc-internal-format
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr ""
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qT bir sınıf ya da isim alanı değil"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe not supported"
 msgid "fixed-point types not supported in C++"
 msgstr "-pipe desteklenmiyor"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ da kaşlı ayracla gruplanmış ifadelere izin verilmez"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, fuzzy, gcc-internal-format
 #| msgid "statement-expressions are allowed only inside functions"
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "deyim ifadelerine sadece işlevlerin içinde izin verilir"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected primary-expression"
 msgstr "ifade umuluyordu"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 #| msgid "Objective-C declarations may only appear in global scope"
 msgid "a template declaration cannot appear at block scope"
 msgstr "Objective-C bildirimleri sadece genel etki alanında görünebilir"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "local variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "yerel değişken %qD bu kapsamda görünemez"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "yerel değişken %qD bu kapsamda görünemez"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "bu ortam işlevi sadece fr500 üzerinde kullanılabilir"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected id-expression"
 msgstr "ifade umuluyordu"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "%qT bir sınıf ya da isim alanı değil"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "%2$qT üyesi olarak %<~%1$T%> bildirimi"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef ismi %qD yıkıcı bildiricisi olarak kullanılmış"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, fuzzy, gcc-internal-format
 #| msgid "expected specifier-qualifier-list"
 msgid "expected unqualified-id"
 msgstr "belirteç niteleyici listesi umuluyordu"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD bir şablon değil"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%qT bir enum türü olmayan %qT türüne çözümleniyor"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "içi boş %qT türü alt isim belirtecinde kullanılmış"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "içi boş %qT türü alt isim belirtecinde kullanılmış"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "içi boş %qT türü alt isim belirtecinde kullanılmış"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected nested-name-specifier"
 msgstr "bildirim belirteçleri umuluyordu"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in casts"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "%qs özniteliği için belirtilen argüman sayısı yanlış"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to bit-complement"
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "bit-tümler için yanlış türde argüman"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<__builtin_choose_expr%> not a constant"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "%<__builtin_choose_expr%> için ilk argüman bir sabit değil"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "%qs özniteliği için belirtilen argüman sayısı yanlış"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 #| msgid "nested function %qs declared %<extern%>"
 msgid "selected function declared here"
 msgstr "iç işlev %qs %<extern%> olarak bildirilmiş"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ birleşik sabitlere izin vermez"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "%qD kullanımı geçersiz"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 #| msgid "%<%D::%D%> is not a member of %qT"
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%>, %qT'nin bir üyesi değil"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr ""
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "%Jtypedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%Jtypedef ismi bir iç içe isimli belirteç olmayabilir"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new bir referans türe uygulanamaz"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "new bir işlev türe uygulanamaz"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ tasarlanmış ilkendiricilere izin vermez"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %qs expressions"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a new-expression"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "parantezli tür kimliğinden sonra dizi sınırı yasak"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "tür kimliğini sarmalayan parantezleri kaldırmayı deneyin"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected expression-list or type-id"
 msgstr "İfade türü umuluyordu"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a new-type-id"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %qD applied to template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "saklama sınıfı %qD şablon örneklenimine uygulanmış"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "new bildirimli ifade bütünleyici ya da numaralama türünde olmalı"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "eski tarz tür dönüşümü"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, fuzzy, gcc-internal-format
 #| msgid "suggest parentheses around && within ||"
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "|| içindeki && çevresinde parantezler önerilir"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ tasarlanmış ilkendiricilere izin vermez"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of module"
 msgid "expected end of capture-list"
 msgstr "Beklenmeyen modül sonu"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "%<this%> cannot be captured by reference"
 msgstr "%q#T türüne başvuru bildirilemez"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 #| msgid "increment of read-only variable %qD"
 msgid "capture of non-variable %qE"
 msgstr "salt-okunur değişken %qD için eksiltme"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "öntanımlı argüman %2$q#D bildiriminin %1$d. parametresi için"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter %qs"
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for parameter %qs"
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here"
+msgid "%q#E declared here"
+msgstr "burada bildirilmiş %q+D"
+
+#: cp/parser.cc:14379
 #, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 #| msgid "attributes after parenthesized initializer ignored"
 msgid "attributes at the beginning of statement are ignored"
 msgstr "parantezli ilklendiriciden sonraki öznitelikler yoksayıldı"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected labeled-statement"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case etiketi %qE bir switch deyimi içinde değil"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names constructor in %qT"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%D%> %qT içinde kurucu isimlendiriyor"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 #| msgid "Discover pure and const functions"
 msgid "compound-statement in %<constexpr%> function"
 msgstr "Saf ve sabit işlevler keşfedilir"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "%<if consteval%> requires compound statement"
 msgstr "asm deyiminde geçersiz sol taraf"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected selection-statement"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "bir dizi döndüren işlev"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qs declared as a function"
 msgid "condition declares a function"
 msgstr "%qs alanı bir işlev olarak bildirilmiş"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in conditions"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected initializer"
 msgstr "betimleyici umuluyordu"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot be a sub-component"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "%C'deki döngü değişkeni bir alt bileşen olamaz"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 #| msgid "expression statement has incomplete type"
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "ifade deyimi boş tür içeriyor"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected iteration-statement"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr ""
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in vector initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "vektör ilklendiricide gereğinden fazla öğe"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "union cannot be made transparent"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "birleşik yapı şeffaf olamaz"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ hesaplanmış goto'lara izin vermez"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected jump-statement"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "expected module-partition"
 msgstr "boş bildirim"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected module-name"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "yöntem tanımı @interface bağlamında değil"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "sınıf bağlamında üye olmayan için using bildirimi"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "scope opened here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "private module fragment"
 msgstr "argüman yok"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "sınıf bağlamında üye olmayan için using bildirimi"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "%qE may only occur once in an export declaration"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C işlevler dışında fazladan %<;%> kullanımına izin vermez"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C işlevler dışında fazladan %<;%> kullanımına izin vermez"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "extra %<;%> after in-class function definition"
 msgstr "%q+D tanımlandıktan sonra satıriçi bildirilmiş"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "attributes are not permitted in this position"
 msgstr "bu kapsamda %<this%> kullanılamaz"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored"
 msgid "attributes may be inserted here"
 msgstr "%qE özniteliği yoksayıldı"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "şablon olmayan %qT için doğrudan özelleştirme"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "şablon olmayan %q#D'nin doğrudan örneklenimi"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "export-declarations are not permitted here"
 msgstr "case değeri olarak göstericiler kullanılamaz"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr ""
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "karışık bildirimler ve işlev tanımları yasaktır"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a for-range-declaration"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "multiple types in one declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "bir bildirimde birden fazla tür"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "empty declaration"
 msgid "empty structured binding declaration"
 msgstr "boş bildirim"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initial value for member %qs"
 msgid "invalid initializer for structured binding declaration"
 msgstr "üye %qs için ilk değer geçersiz"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "for-range-declaration cannot be %qs"
 msgstr "%C'deki veri bildiriminde sözdizimi hatası"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "saklatım sınıfı belirteçleri parametre bildiriminde geçersiz"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> sadece bir sınıf içinde belirtilebilir"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "  conflict with %q+D"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "  %q+D ile çelişiyor"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr ""
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "pure-specifier on function-definition"
 msgid "%qD invalid in condition"
 msgstr "işlev tanımında pure belirteci"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in lambda"
 msgstr "%q+D %q#T içinde geçersiz"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "pure-specifier on function-definition"
 msgid "type-specifier invalid in lambda"
 msgstr "işlev tanımında pure belirteci"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "sınıf tanımı kardeş olarak bildirilemeyebilir"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in explicit-specifier"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid linkage-specification"
 msgstr "taban sınıf belirtimi geçersiz"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in a conversion-type-id"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<this%> in non-member function"
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "üye olmayan işlevde %<this%> kullanımı geçersiz"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 #| msgid "only constructors take base initializers"
 msgid "only constructors take member initializers"
 msgstr "temel ilklendiricileri sadece kurucular alır"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "cannot expand initializer for member %qD"
 msgstr "uye %qD için ilklendirici eksik"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 #| msgid "static declaration of %q+D follows non-static declaration"
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "%q+D statik bildirimi statik olmayan bildirimi izliyor"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "artık tarih olmuş eski tarz temel sınıf ilklendiricisi"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "%<typename%> anahtar sözcüğüne bu bağlamda izin verilmez (bir nitelikli üye ilklendirici örtük olarak bir tür olduğundan)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected suffix identifier"
 msgstr "betimleyici umuluyordu"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conditional operand"
 msgid "invalid encoding prefix in literal operator"
 msgstr "koşullu terim geçersiz"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected operator"
 msgstr "beklenmeyen terim"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "%<export%> anahtar sözcüğü gerçekleştirilmedi ve yoksayılacak"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "%<export%> anahtar sözcüğü gerçekleştirilmedi ve yoksayılacak"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "invalid constrained type parameter"
 msgstr "yakalama parametresi geçersiz"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "cv-qualified type parameter"
 msgstr "yakalama parametresi geçersiz"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "%<virtual%> kullanımı %q#D şablon bildiriminde geçersiz"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "template parameter packs cannot have default arguments"
 msgstr "şablon parametreleri kardeş olamazlar"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-id"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> bir şablon argüman listesi başlatamaz"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> ile %<[%> aynı şeyi gösterir. %<<%> ile %<::%> arasında boşluk bırakın"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 #| msgid "(if you use -fpermissive G++ will accept your code)"
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(-fpermissive kullanırsanız G++ kodunuzu kabul edecek)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid template-argument-list"
 msgstr "tür argümanı geçersiz"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected %<(%> after template-argument-list"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "şablon argüman listesinde çözümleme hatası"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-name"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "şablon olarak şablon olmayan %qD kullanılmış"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "bir şablon olduğunu belirtmek için %<%T::template %D%> kullanın"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers or %<...%>"
 msgid "expected parameter pack before %<...%>"
 msgstr "bildirim belirteçleri veya %<...%> umuluyordu"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected template-argument"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid non-type template argument"
 msgstr "tür argümanı geçersiz"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "şablon olmayan tür %qT'nin doğrudan örneklenimi"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "şablon olmayan tür %qT'nin doğrudan örneklenimi"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "şablon olmayan tür %qT'nin doğrudan örneklenimi"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "C ilintileme ile şablon özelleştirmesi"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected type specifier"
 msgstr "bildirim belirteçleri umuluyordu"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr ""
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr ""
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "use of %<auto%> in template argument"
 msgstr "%<virtual%> kullanımı %q#D şablon bildiriminde geçersiz"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected template-id for type"
 msgstr "İfade türü umuluyordu"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 #| msgid "Expected name"
 msgid "expected type-name"
 msgstr "Umulmadık isim"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE bir türü isimlendirmiyor"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously defined here"
 msgid "concept defined here"
 msgstr "%q+#D evvelce burada tanımlanmış"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "%qD kullanımı geçersiz"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "declaration %qD does not declare anything"
 msgstr "bildirim hiçbir şey bildirmiyor"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "attributes ignored on uninstantiated type"
 msgstr "%qE özniteliği sınıf türleri dışında yoksayılır"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %qD applied to template instantiation"
 msgid "attributes ignored on template instantiation"
 msgstr "saklama sınıfı %qD şablon örneklenimine uygulanmış"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is an enumeration template"
 msgstr "%qD bir işlev şablonu değil"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 #| msgid "expression in new-declarator must have integral or enumeration type"
 msgid "%qD does not name an enumeration in %qT"
 msgstr "new bildirimli ifade bütünleyici ya da numaralama türünde olmalı"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma%> is not allowed here"
 msgid "unnamed scoped enum is not allowed"
 msgstr "%<#pragma%> burada kullanılamaz"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in enum-base"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<;%> or %<{%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 #| msgid "Enable automatic template instantiation"
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "Özdevinimli şablon örneklenimi etkin olur"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "kardeş bildirimi bir sınıf veya işlevi isimlendirmiyor"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "%3$qD'yi kapsamayan %2$qD etki alanı içinde %1$qD türünde bildirim"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "%3$qD'yi kapsamayan %2$qD etki alanı içinde %1$qD türünde bildirim"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, fuzzy, gcc-internal-format
 #| msgid "extra qualification ignored"
 msgid "extra qualification not allowed"
 msgstr "fazladan niteleme yoksayıldı"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ bir enum'um %s-lenmesine izin vermez"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a namespace-name"
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD bir isim alanı ismi değil"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD bir isim alanı ismi değil"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected namespace-name"
 msgstr "sınıf ismi umuluyordu"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "nested namespace name required"
 msgstr "sınıf ismi umuluyordu"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma%> is not allowed here"
 msgid "a nested namespace definition cannot have attributes"
 msgstr "%<#pragma%> burada kullanılamaz"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "a nested namespace definition cannot be inline"
 msgstr "Bir satıriçi işlev satıriçi olamadığında uyarır"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "namespace %qD entered"
 msgstr "isim alanı %qD'nin ifade olarak kullanımı"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma%> is not allowed here"
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<#pragma%> burada kullanılamaz"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "using bildiriminde bir şablon kimliği bulunamaz"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete typedef %qD"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "tamamlanmamış typedef %qD kullanımı geçersiz"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete typedef %qD"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "tamamlanmamış typedef %qD kullanımı geçersiz"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "opaque-enum-declaration here"
 msgstr "buradaki önceki %q+#D bildirimi ile çelişiyor"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in alias template declarations"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "dizge sabiti umuluyordu"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "%qD işlev etki alanı dışında tanımlı değil"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT bir isim alanı değil"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%qD işlev etki alanı dışında tanımlı değil"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored in declaration of %q+#T"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "%q+#T bildiriminde öznitelik yoksayıldı"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "işlev bildiriminde (türleri belirtmeksizin) parametre isimleri"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 #| msgid "attributes after parenthesized initializer ignored"
 msgid "remove parentheses to default-initialize a variable"
 msgstr "parantezli ilklendiriciden sonraki öznitelikler yoksayıldı"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "işlev bildiriminde (türleri belirtmeksizin) parametre isimleri"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared as inline"
 msgid "add parentheses to declare a variable"
 msgstr "işlev %q+D 'inline' olarak yeniden bildirilmiş"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "cannot handle qualified name for variant function"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "standart uzlaşımlara bu bağlam içinde izin verilmez"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cleanup argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "cleanup argümanı bir betimleyici değil"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of C function %q#D conflicts with"
 msgid "no declaration of base function %qs in this scope"
 msgstr "C işlevi %q#D bildirimi"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "%qD ile ilişkilendirme belirsiz"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "bir işlev tanımıda özniteliklere izin verilmez"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "bir işlev tanımıda özniteliklere izin verilmez"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "%s aşırı yüklü işlevin adresini çözümleyemiyor"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "bir işlev tanımıda özniteliklere izin verilmez"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 #| msgid "%s: function definition not converted\n"
 msgid "a function-definition is not allowed here"
 msgstr "%s: işlev tanımı dönüştürülmedi\n"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "bir işlev tanımında bir asm belirtimine izin verilmez"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "bir işlev tanımıda özniteliklere izin verilmez"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 #| msgid "can't initialize friend function %qs"
 msgid "initializer provided for function"
 msgstr "kardeş işlev %qs ilklendirilemiyor"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "parantezli ilklendiriciden sonraki öznitelikler yoksayıldı"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared as inline"
 msgid "non-function %qD declared as implicit template"
 msgstr "işlev %q+D 'inline' olarak yeniden bildirilmiş"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "dizi sınırı bir tamsayı sabit değil"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "cannot define member of dependent typedef %qT"
 msgstr "%qT üye referans türünde gösterici oluşturulması"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a type"
 msgid "%<%T::%E%> is not a type"
@@ -73796,309 +73896,309 @@ msgstr "%<%T::%D%> bir tür değil"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "invalid declarator"
 msgstr "işlev bildirimi geçersiz"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "kurucunun şablon olarak kullanımı geçersiz"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr ""
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "qualified-id in declaration"
 msgstr "işlev bildirimi geçersiz"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "expected declarator"
 msgstr "bildirim belirteçleri umuluyordu"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD bir isim alanıdır"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "sınıf olmayan %qT türünde üye göstericisi oluşturulması"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected operand"
 msgid "expected ptr-operator"
 msgstr "beklenmeyen terim"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple ref-qualifiers"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate virt-specifier"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "missing template arguments after %qE"
 msgstr "%q#D için öntanımlı argüman %qT türünde"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "%qT not permitted in template argument"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of %qT"
 msgstr "%qD kullanımı geçersiz"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in template arguments"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of %<auto%> in template argument"
 msgstr "%<virtual%> kullanımı %q#D şablon bildiriminde geçersiz"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier"
 msgid "expected type-specifier"
 msgstr "betimleyici umuluyordu"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected %<,%> or %<...%>"
 msgstr "%<:%> veya %<...%> umuluyordu"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in parameter types"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "saklatım sınıfı belirteçleri parametre bildiriminde geçersiz"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 #| msgid "data member %qD cannot be a member template"
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "veri üyesi %qD bir üye şablon olamaz"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "öntanımlı argümanlara sadece işlev parametresi olarak izin verilir"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "template parameter pack cannot have a default argument"
 msgstr "şablon parametreleri kardeş olamazlar"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "parameter pack cannot have a default argument"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "şablon parametreleri kardeş olamazlar"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ tasarlanmış ilkendiricilere izin vermez"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ tasarlanmış ilkendiricilere izin vermez"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ tasarlanmış ilkendiricilere izin vermez"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected class-name"
 msgstr "sınıf ismi umuluyordu"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "expected %<;%> after class definition"
 msgstr "%q+D tanımlandıktan sonra satıriçi bildirilmiş"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "expected %<;%> after struct definition"
 msgstr "%q+D tanımlandıktan sonra satıriçi bildirilmiş"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "expected %<;%> after union definition"
 msgstr "%C'deki işlev bildiriminden sonra umulmayan döküntü"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %qD specifier"
 msgstr "cv-niteleyici yinelenmiş"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<{%> or %<:%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "qualified name does not name a class"
 msgstr "kardeş bildirimi bir sınıf veya işlevi isimlendirmiyor"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "şablonlar dışında %<typename%> kullanımına izin verilmez"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "%qD bildirimindeki sınıf ismi geçersiz"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "%qD doğrudan özelleştirmesinin kardeş bildirimde tanımı"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "bir doğrudan özelleştirme %<template <>%> ile öncelenmeli"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "function template %qD redeclared as a class template"
 msgstr "şablon olarak şablon olmayan %qD kullanılmış"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+#T"
 msgid "previous definition of %q#T"
@@ -74107,296 +74207,296 @@ msgstr "%q+#T türünde önceden tanım"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "expected class-key"
 msgstr "sınıf ismi umuluyordu"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<;%>"
 msgid "expected %<class%> or %<typename%>"
 msgstr "%<,%> veya %<;%> umuluyordu"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, fuzzy, gcc-internal-format
 #| msgid "a class-key must be used when declaring a friend"
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "bir kardeş bildirilirken bir sınıf anahtarı kullanılmalıdır"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "kardeş bildirimi bir sınıf veya işlevi isimlendirmiyor"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "default member initializer for unnamed bit-field"
 msgstr "%<__alignof%> bir bit-alanına uygulanmış"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD has non-integral type %qT"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "%qD dizisinin boyutu tümlemeyen %qT türünde"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "işlev tanımında pure belirteci"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use %<::%> in parameter declaration"
 msgid "stray %<,%> at end of member declaration"
 msgstr "parametre bildiriminde %<::%> kullanılamaz"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use %<::%> in parameter declaration"
 msgid "expected %<;%> at end of member declaration"
 msgstr "parametre bildiriminde %<::%> kullanılamaz"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "attributes on base specifiers are ignored"
 msgstr "%Jbölüm özniteliği yerel değişkenler için belirtilmiş olamaz"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "%<typename%> anahtar sözcüğüne bu bağlamda izin verilmez (taban sınıfı örtük olarak bir türdür)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in an exception-specification"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 #| msgid "Generate code to check exception specifications"
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "Olağan dışılık belirtimlerini sınayacak kod üretilir"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<this%> in non-member function"
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "üye olmayan işlevde %<this%> kullanımı geçersiz"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in exception-declarations"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "boş bildirimde %<inline%>"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "%q.*s biçiminin %<%T%s%> türünde olması umuluyor, ama %d. argüman %qT türünde"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "%s özniteliği ile %s özniteliği %L'de çelişiyor"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected an identifier for the attribute name"
 msgstr "betimleyici veya %<(%> umuluyordu"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "attribute %qs specified multiple times"
 msgstr "%Jbölüm özniteliği yerel değişkenler için belirtilmiş olamaz"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers or %<...%>"
 msgid "expected attribute before %<...%>"
 msgstr "bildirim belirteçleri veya %<...%> umuluyordu"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "bir prototip olmayanda argümansız null olmayan öznitelik"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected conditional-expression"
 msgstr "ifade umuluyordu"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%qs is only available with %qs"
 msgstr "assert: %s %s ile uyumlu atanıyor"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "%qE özniteliği %qE için yoksayıldı"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "%qE özniteliği sınıf türleri dışında yoksayılır"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "expression must be enclosed in parentheses"
 msgstr "%L'deki ifade değişmez olmalı"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "istenen konum bir tamsayı sabit değil"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "istenen hizalama bir sabit değil"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 #| msgid "invalid redeclaration of %q+D"
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "yeniden %q+D bildirimi geçersiz"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "şablon parametresi listesi çok az"
@@ -74405,490 +74505,490 @@ msgstr "şablon parametresi listesi çok az"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "şablon parametresi listesi çok fazla"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "isimli dönüş değerleri artık desteklenmiyor"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, fuzzy, gcc-internal-format
 #| msgid "invalid declaration of member template %q#D in local class"
 msgid "invalid declaration of member template in local class"
 msgstr "yerel sınıf içinde %q#D üye şablonu bildirimi geçersiz"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "C ilintilemeli şablon"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid explicit specialization"
 msgstr "taban sınıf belirtimi geçersiz"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %qs"
 msgid "template declaration of %<typedef%>"
 msgstr "%qs şablon bildirimi"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "bildirim hiçbir şey bildirmiyor"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization in non-namespace scope %qD"
 msgid "explicit template specialization cannot have a storage class"
 msgstr "isim alanı olmayan %qD kapsamında doğrudan özelleştirme"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 #| msgid "%H%<>>%> should be %<> >%> within a nested template argument list"
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%H%<>>%> alt şablon argüman listesinde %<> >%> olmalıydı"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "sahte  %<>>%>, bir şablon argüman listesini sonlandırmak için %<>%> kullanın"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "sahte  %<>>%>, bir şablon argüman listesini sonlandırmak için %<>%> kullanın"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 #| msgid "invalid base-class specification"
 msgid "invalid use of %qD in linkage specification"
 msgstr "taban sınıf belirtimi geçersiz"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "  conflict with %q+D"
 msgid "%qD specifier conflicts with %qs"
 msgstr "  %q+D ile çelişiyor"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> before %<extern%>"
 msgid "%<__thread%> before %qD"
 msgstr "%<extern%> öncesinde %<__thread%>"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%<__thread%> %<typedef%> ile kullanılmış"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not support %<long long%>"
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ %<long long%> desteklemez"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 #| msgid "both %<short%> and %<char%> in declaration specifiers"
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "bildirim belirteçlerinde hem %<short%> hem de %<char%>"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate %qD"
 msgstr "%qE yinelenmiş"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "%qs yinelenmiş"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<new%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<delete%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<return%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<extern%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "expected %<static_assert%>"
 msgstr "deyim umuluyordu"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<decltype%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<operator%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<class%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<template%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<namespace%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<using%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<asm%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<try%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<catch%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<throw%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<auto%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<__label__%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@try%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@synchronized%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<@throw%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr ""
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<co_yield%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<::%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<...%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<*%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<~%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%> or %<...%>"
 msgid "expected %<:%> or %<::%>"
 msgstr "%<:%> veya %<...%> umuluyordu"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<:]%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "%qs yaftası %q#T isimlemesinde kullanılmış"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "%q#T was previously declared here"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "%q#T türüne başvuru bildirilemez"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 #| msgid "expected class name"
 msgid "replace the class-key with %qs"
 msgstr "sınıf ismi umuluyordu"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "label %q+D defined but not used"
 msgid "%qT defined as %qs here"
 msgstr "%q+D yaftası tanımlı ama kullanılmamış"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "%qT first declared as %qs here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD farklı erişimle tekrar bildirilmiş"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, fuzzy, gcc-internal-format
 #| msgid "%<template%> (as a disambiguator) is only allowed within templates"
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "%<template%> (bir belirsizlik giderici olarak) sadece şablonlarda kullanılabilir"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "öntanımlı argüman içinde dosya sonu"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "yanlış yere konmuş %<@%D%> Nesnel-C++ oluşumu"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> bir argüman olarak bir tür belirtmeli"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "Nesnel-C++ seçici ismi geçersiz"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration specifiers"
 msgid "objective-c++ method declaration is expected"
 msgstr "bildirim belirteçleri umuluyordu"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 #| msgid "%Jsection attribute cannot be specified for local variables"
 msgid "method attributes must be specified at the end"
 msgstr "%Jbölüm özniteliği yerel değişkenler için belirtilmiş olamaz"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 #| msgid "illegal reference type specified for instance variable %qs"
 msgid "invalid type for instance variable"
 msgstr "gerçekleme değişkeni %qs için ilişkilendirme türü kuraldışı"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "%<@protocol%> sonrasında betimleyici umuluyordu"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "%qE özniteliği %qE için yoksayıldı"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid type for property"
 msgstr "tür argümanı geçersiz"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown property attribute %qE"
 msgstr "bilinmeyen yazmaç ismi: %s"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected integer expression list"
 msgstr "ifade umuluyordu"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<wait%> expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid reduction-identifier"
 msgstr "geçersiz ilklendirici"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in iterator type"
@@ -74898,190 +74998,190 @@ msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable artık desteklenmiyor"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "iteration variable %qD should not be reduction"
 msgstr "yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma align%> %D bildiriminden önce görünmeli, yoksayılıyor"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is not a C pointer"
 msgstr "%qD bir şablon değil"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "expected %<target%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "geçersiz ilklendirici"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected id-expression (arguments)"
 msgstr "ifade umuluyordu"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in declare reduction type list"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%>, %<;%> or %<}%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "%<,%>, %<;%> veya %<}%> umuluyordu"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD bir üye şablon işlevi değil"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "Initialization at %C is not allowed in a PURE procedure"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "%C'de ilklendirmeye bir PURE işlevinde izin verilmez"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr ""
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr ""
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "malformed #pragma GCC pch_preprocess, ignored"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "#pragma GCC pch_preprocess bozuk, yoksayıldı"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr ""
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma GCC memregs must precede any function decls"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "#pragma GCC memregs bir işlev bildirimi ile öncelenmeli"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "modüller arası eniyilemeler henüz C++ için gerçeklenmedi"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "standart uzlaşımlara bu bağlam içinde izin verilmez"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr ""
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -75600,17 +75700,23 @@ msgstr "sınıf sablonlarının kapsanması doğrudan özelleştirilmez"
 msgid "redeclaration of %qD with different constraints"
 msgstr "bir şablon olmayan olarak yeniden %qT bildirimi"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "storage class specified for parameter %qs"
+msgid "local class in lambda in template parameter list"
+msgstr "%qs parametresi için saklama sınıfı belirtilmiş"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "%qD bildiriminde şablon belirteçleri belirtilmemiş"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "redeclared with %d template parameter"
@@ -75618,7 +75724,7 @@ msgid_plural "redeclared with %d template parameters"
 msgstr[0] "%qD şablon parametreleri olmaksızın kullanılmış"
 msgstr[1] "%qD şablon parametreleri olmaksızın kullanılmış"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+#D here"
 msgid "previous declaration %qD used %d template parameter"
@@ -75626,527 +75732,527 @@ msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "buradaki önceki %q+#D bildirimi ile çelişiyor"
 msgstr[1] "buradaki önceki %q+#D bildirimi ile çelişiyor"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "şablon parametresi %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "burada %q#D olarak yeniden bildirilmiş"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "redeclared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of typedef %q+D"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "typedef %q+D için yeniden tanımlama"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 #| msgid "%J  original definition appeared here"
 msgid "original declaration appeared here"
 msgstr "%J  ozgun tanımı burada görüldü"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %qT as a non-template"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "bir şablon olmayan olarak yeniden %qT bildirimi"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü o bir göstericidir"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qD nesnesi için harici ilintileme yok"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qD nesnesi için harici ilintileme yok"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "(bir üye göstericisi sadece %<&%E%> ile şekillendirilebilir)"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qD %qT'nin bir üyesi değil"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "got %d template parameters for %q#D"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "%d şablon parametresi %q#D için alındı"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %q#T and %q#T"
 msgid "  mismatched types %qT and %qT"
 msgstr "%q#T ile %q#T türleri arasında karşılaştırma"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "şablon argümanı %qE şablon parametre(ler)ini içine alıyor"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "  %qE is not equivalent to %qE"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, fuzzy, gcc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "%L ve %L'de işliçler için sıralar uyumsuz"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "kısmi özelleştirme %qT hiç bir şablon argümanını özelleştirmiyor"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "  member function type %qT is not a valid template argument"
 msgstr "'%s' beyan işlevine bir fiili argüman olarak izin verilmez (%L'de)"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] ""
 msgstr[1] ""
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "%qT türü %qT türüne dönüştürülemiyor"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an ambiguous base of %qT"
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "%qT bir belirsiz %qT tabanıdır"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "  %qT is not derived from %qT"
 msgstr "%qT türü %qT türünden türetilmemiş"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "%s içi boş %qT türüne bir gösterici olamaz"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 #| msgid "argument of type %qT does not match %qT"
 msgid "  template argument %qE does not match %qE"
 msgstr "%qT türündeki argüman %qT ile eşleşmiyor"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is not a lvalue"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil cunku o bir sol taraf terimi değil"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qD nesnesi için harici ilintileme yok"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qD nesnesi için harici ilintileme yok"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "the address of %qD is not a valid template argument"
 msgstr "kısmi özelleştirme %qT hiç bir şablon argümanını özelleştirmiyor"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 #| msgid "partial specialization %qT does not specialize any template arguments"
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "kısmi özelleştirme %qT hiç bir şablon argümanını özelleştirmiyor"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qD nesnesi için harici ilintileme yok"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is not a lvalue"
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil cunku o bir sol taraf terimi değil"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is not a lvalue"
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil cunku o bir sol taraf terimi değil"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü bu bağlamda dizge sabitler kullanılamaz"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "in template argument for type %qT"
 msgstr "%q#D için öntanımlı argüman %qT türünde"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "şablon argümanı %qE şablon parametre(ler)ini içine alıyor"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "cv nitelemesinde çeliştiğinden dolayı %qE %qT türü için geçerli bir şablon argümanı değildir"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is not a lvalue"
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil cunku o bir sol taraf terimi değil"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because it is not a constant pointer"
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü o bir sabit göstericisi değildir"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü o bir göstericidir"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "yerine %qE kullanmayı deneyin"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qT türündedir"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 #| msgid "applying attributes to template parameters is not implemented"
 msgid "ignoring attributes on template argument %qT"
 msgstr "özniteliklerin şablon parametrelerine uygulanması gerçeklenmedi"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "applying attributes to template parameters is not implemented"
 msgid "ignoring attributes in template argument %qE"
 msgstr "özniteliklerin şablon parametrelerine uygulanması gerçeklenmedi"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of destructor %qE as a type"
 msgstr "kurucunun şablon olarak kullanımı geçersiz"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "bir şablon parametresinin bir tür üyesine basvurmak için %<typename %E%> kullanın"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, fuzzy, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "%2$qD için şablon parametre listesindeki %1$d. argümanda tür/değer uyumsuzluğu"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  %qT türünde bir sabit umulurken %qT alındı"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for parameter of type %qT has type %qT"
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "%qT türündeki parametre için öntanımlı argüman %qT türünde"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  bir sınıf sablonu umulurken %qE alındı"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  bir tür umulurken %qE alındı"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  bir tür umulurken %qT alındı"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  bir sınıf sablonu umulurken %qT alındı"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a template of type %qD, got %qD"
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  %qD türünde bir şablon umulurken %qD alındı"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "%2$qD için şablon parametre listesindeki %1$d. argümanda tür/değer uyumsuzluğu"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "  expected %qD but got %qD"
 msgstr "  bir tür umulurken %qE alındı"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument %qE to %qT"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "şablon argümanı %qE %qT'ye dönüştürülemedi"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "%d. şablon argümanı geçersiz"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "yanlış sayıda şablon argümanı (%d yerine %d olmalıydı)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "yanlış sayıda şablon argümanı (%d yerine %d olmalıydı)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "%q+D için sağlanmış"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "öntanımlı argüman %2$q#D bildiriminin %1$d. parametresi için"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%q#D is not a function template"
 msgstr "%qD bir işlev şablonu değil"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "şablon olarak şablon olmayan tür %qT kullanılmış"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "%q+D şablon bildirimi için"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "template constraint failure for %qD"
 msgstr "%q#T için sınıf şablonu örneklenimi belirsiz"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "use of invalid variable template %qE"
 msgstr "%qD bir şablon değil"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating %qD"
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "%d lik azami şablon örneklenim derinliği %qD örnekleniminde aşılıyor (azami değeri arttırmak için -ftemplate-depth-NN kullanın)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "score argument must be constant integer expression"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "score argument must be non-negative"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "property must be constant integer expression or string literal"
 msgstr "seçici 0..%wi aralığında bir tamsayı sabit olmalı"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "property must be constant integer expression"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "instantiating erroneous template"
 msgstr "şablon olmayan %q#D'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "%J  original definition appeared here"
 msgid "first error appeared here"
 msgstr "%J  ozgun tanımı burada görüldü"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 #| msgid "%Jflexible array member in union"
 msgid "flexible array member %qD in union"
 msgstr "%Junion içinde esnek dizi üye"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE bildirimin başlangıcında değil"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find 'nm'"
 msgid "cannot index an empty pack"
 msgstr "'nm' bulunamıyor"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for %q#D"
 msgid "  when instantiating default argument for call to %qD"
 msgstr "%q#D için öntanımlı argümanın yeniden tanımı"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "sınıf olmayan %qT türünde üye işlev göstericisi oluşturulması"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type argument"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -76165,131 +76271,131 @@ msgstr "tür argümanı geçersiz"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD has initializer but incomplete type"
 msgid "variable %qD has function type"
 msgstr "%qD değişkeni ilklendiricili ama içi boş türde"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "geçersiz parametre türü %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "%q+D bildiriminde"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "bir dizi döndüren işlev"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "bir işlev döndüren işlev"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qE is not usable in a splice type"
 msgstr "%qT erişilebilir bir %qT tabanı değil"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qT erişilebilir bir %qT tabanı değil"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "void'e referans oluşturuluyor"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forming pointer to reference type %qT"
 msgstr "%s %qT referans türünde şekilleniyor"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forming reference to reference type %qT"
 msgstr "%s %qT referans türünde şekilleniyor"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "%2$qT işlev türüne ekli %1$qV niteleyicileri yoksayılıyor"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "%2$qT işlev türüne ekli %1$qV niteleyicileri yoksayılıyor"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "sınıf olmayan %qT türünde üye göstericisi oluşturulması"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "%qT üye referans türünde gösterici oluşturulması"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "void türünde üyeye gösterici oluşturulması"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "%qT dizisi oluşturulması"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "%q+D dizisi tek elemanlı kabul edildi"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT ne bir class, ne struct, ne de union türünde"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT bir enum türü olmayan %qT türüne çözümleniyor"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT bir sınıf türü olmayan %qT türüne çözümleniyor"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT bir enum türü olmayan %qT türüne çözümleniyor"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration or statement"
 msgid "expected a reflection of a type template"
 msgstr "bildirim veya deyim umuluyordu"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "şablonda %qs kullanımı"
@@ -76297,225 +76403,225 @@ msgstr "şablonda %qs kullanımı"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "%2$qT üyesi olarak %<~%1$T%> bildirimi"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 #| msgid "qualified type %qT does not match destructor name ~%qT"
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "yetkin tür %qT, yıkıcı ismi ~%qT ile eslesmiyor"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "%qE bağımlı ismi bir tür olarak çözümlenmedi ama örneklenim onun bir tür olmasını istiyor"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "eğer bu bir tür anlamındaysa %<typename %E%> deyin"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "ilklendirici öğe bir sabit değil"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of void expression"
 msgid "invalid use of pack expansion expression"
 msgstr "void ifade kullanımı geçersiz"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, fuzzy, gcc-internal-format
 #| msgid "%<...%> as arguments.)"
 msgid "use %<...%> to expand argument pack"
 msgstr "%<...%> kabul edeceği varsayılacak.)"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr ""
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a type"
 msgid "use %<%T::%D%> instead"
 msgstr "%<%T::%D%> bir tür değil"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after its definition"
 msgid "%qD declared here, later in the translation unit"
 msgstr "%q+D tanımlandıktan sonra satıriçi bildirilmiş"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<__builtin_choose_expr%> not a constant"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "%<__builtin_choose_expr%> için ilk argüman bir sabit değil"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qs attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "%qs özniteliği için belirtilen argüman sayısı yanlış"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT bir sınıf ya da isim alanı değil"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD ne bir sınıf ne de isim alanı"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "geçersiz alan %qD kullanımı"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is/uses anonymous type"
 msgid "%qT is/uses unnamed type"
 msgstr "%qT anonim türdür/tür kullanır"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "template argument for %qD uses local type %qT"
 msgstr "%q#D için öntanımlı argüman %qT türünde"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT değişkene göre değişen türde"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  %qD örneklenmeye çalışılıyor"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#T"
 msgstr "%q#T için sınıf şablonu örneklenimi belirsiz"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#D"
 msgstr "%q#T için sınıf şablonu örneklenimi belirsiz"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %+#D"
 msgid "%s %#qS"
 msgstr "%s %+#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "şablon olmayan %q#D'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%qD is not a static data member of a class template"
 msgstr "%q#D %qT'nin bir static olmayan üyesi değildir"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "%qD için eşleşen bir şablon yok"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template type %qT"
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "şablon olmayan tür %qT'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "%q#D'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "yinelenmiş doğrudan %q#D örneklenimi"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids the use of %<extern%> on explicit instantiations"
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ doğrudan örneklenimlerde %<extern%> kullanımına izin vermez"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "saklama sınıfı %qD şablon örneklenimine uygulanmış"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiation of non-class template %qD"
 msgstr "şablon olmayan %q#D'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "şablon olmayan tür %qT'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "şablon tanımından önce %q#T'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ doğrudan örneklenimlerde %qE kullanımına izin vermez"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "yinelenmiş doğrudan %q#T örneklenimi"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "ilk kullanımdan sonra %D'nin açıkça özelleştirilmesi"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -76528,175 +76634,175 @@ msgstr "bir işlev tanımında bir asm belirtimine izin verilmez"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "bir tanımlama olmadan %qD'nin doğrudan örneklenimi"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth-NN to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "%d lik azami şablon örneklenim derinliği %q+D örnekleniminde aşılıyor (azami değeri arttırmak için -ftemplate-depth-NN kullanın)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template constant parameter"
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T bir şablon sabiti parametresi için geçerli bir tür değildir"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid catch parameter"
 msgid "invalid template non-type parameter"
 msgstr "yakalama parametresi geçersiz"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a valid type for a template constant parameter"
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T bir şablon sabiti parametresi için geçerli bir tür değildir"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "şablonlar dışında %<typename%> kullanımına izin verilmez"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "union cannot be made transparent"
 msgid "a concept cannot be constrained"
 msgstr "birleşik yapı şeffaf olamaz"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT bir isim alanı değil"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "şablon parametre listesi içinde %q#T tanımı"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "%qD şablon parametreleri olmaksızın kullanılmış"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "use #include instead"
 msgid "use %qD directly instead"
 msgstr "yerine #include kullanın"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "%qE %qT türü için geçerli bir şablon argümanı değil çünkü %qD nesnesi için harici ilintileme yok"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "class template argument deduction failed:"
 msgstr "%d. şablon argümanı geçersiz"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "işlev satıriçine alınma sırasında görmezden gelinir"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D previously declared here"
 msgid "explicit deduction guide declared here"
 msgstr "%q+#D evvelce burada bildirilmiş"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for %q+#D"
 msgid "unable to deduce lambda return type from %qE"
 msgstr "%q+#D için ortak değişen dönüş türü geçersiz"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, fuzzy, gcc-internal-format
 #| msgid "unable to emulate %qs"
 msgid "unable to deduce %qT from %qE"
 msgstr "%qs öykünümü mümkün değil"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "komut kendi kısıtlarını gözönüne almıyor:"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "komut kendi kısıtlarını gözönüne almıyor:"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -76704,385 +76810,446 @@ msgstr "komut kendi kısıtlarını gözönüne almıyor:"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new bir referans türe uygulanamaz"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new bir işlev türe uygulanamaz"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 #| msgid "invalid default argument for a template template parameter"
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "bir şablonun şablon parametresi için öntanımlı argüman geçersiz"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "new bir işlev türe uygulanamaz"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new bir işlev türe uygulanamaz"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new bir işlev türe uygulanamaz"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "%2$qE işlevinin %1$d. argümanı için tür uyumsuz"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qT bir isim alanı değil"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not open dump file %qs: %s"
 msgid "couldn%'t look up %qs"
 msgstr "döküm dosyası %qs açılamadı: %s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  bir tür umulurken %qE alındı"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT bir nesne göstericisi türü değil"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT must be a function type"
 msgstr "%qD bir işlev şablonu değil"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "deyim umuluyordu"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "bit alanı %qD işlev türü ile bildirilemez"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "%J  original definition appeared here"
 msgid "%<consteval%> block defined here"
 msgstr "%J  ozgun tanımı burada görüldü"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "invalid %<access_context%> argument"
 msgstr "tür argümanı geçersiz"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<{%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "%<{%> umuluyordu"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk in formal argument list at %C"
 msgid "unexpected argument to %qs"
 msgstr "%C'deki biçimsel argüman listesinde umulmadık döküntü"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "%2$qE işlevinin %1$d. argümanı için tür uyumsuz"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "%q+#D için belirtilen dönüş türü çelişiyor"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "conflicting return type specified for %q+#D"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "%q+#D için belirtilen dönüş türü çelişiyor"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function '%s'"
 msgid "unknown metafunction %qD"
 msgstr "bilinmeyen '%s' spec işlevi"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "splice argument must be an expression of type %qs"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "%qE cannot be used as a function"
+msgid "cannot splice a null reflection"
+msgstr "%qE bir işlev olarak kullanilamaz"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "parametre bildiriminde %<::%> kullanılamaz"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "add %<constexpr%>"
 msgstr "%qD bu etki alanında bildirilmemiş"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr "standart uzlaşımlara bu bağlam içinde izin verilmez"
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared %<auto%>"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "%<auto%> bildirimli işlev tanımı"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected a reflection of an expression"
 msgstr "ifade umuluyordu"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "şablonlar dışında %<typename%> kullanımına izin verilmez"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "isim alanı %qD'nin ifade olarak kullanımı"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "üye %q#D harici ilintilemeli olarak doğrudan bildirilemez"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "Enforce class member access control semantics"
+msgid "invalid class member access of type template %qE"
+msgstr "Sınıf üyesi erişim denetimi kurallarına uyulur"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can't use '%s' as a %s register"
+msgid "cannot use %qE to access a class member"
+msgstr "'%s' bir %s yazmacı olarak kullanılamıyor"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "iceren işlevden %<auto%> kullanımı"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD bir işlev şablonu değil"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -77445,646 +77612,646 @@ msgstr "nitelikli tür %qT tanımı geçersiz"
 msgid "invalid base-class specification"
 msgstr "taban sınıf belirtimi geçersiz"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 #| msgid "protected member %q+#D in anonymous union"
 msgid "cannot capture member %qD of anonymous union"
 msgstr "anonim union içinde protected üye %q+#D"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is not captured"
 msgstr "%qD bir şablon değil"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> variable from containing function"
 msgid "use of local variable with automatic storage from containing function"
 msgstr "iceren işlevden %<auto%> kullanımı"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "iceren işlevden parametre kullanımı"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "use of parameter from containing function"
 msgid "use of parameter outside function body"
 msgstr "iceren işlevden parametre kullanımı"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type argument"
 msgid "missing template arguments"
 msgstr "tür argümanı geçersiz"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "%qD şablon parametresi %qT türündeyse butunleyen ya da sırali türde olmadığından bir butunleyen sabit ifadesinde kullanılmaz"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "sınıf sablonu %qT'nin ifade olarak kullanımı"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "uye %qD için istek çoklu miras kafesi içinde belirsiz"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD bir sabit ifadesinde bulunamaz"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "%qE türü bilinmiyor"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an enumeration type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "dizi boyutu tümlemeyen %qT türünde"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "pack index is not an integral constant"
 msgstr "dizi sınırı bir tamsayı sabit değil"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qs is negative"
 msgid "pack index %qE is negative"
 msgstr "%qs dizisinin boyutu negatif"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "saklatım sınıfı belirteçleri parametre bildiriminde geçersiz"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static member function %qD"
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "static olmayan üye işlev %qD kullanımı geçersiz"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static member function %qD"
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "static olmayan üye işlev %qD kullanımı geçersiz"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of non-static member function %qD"
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "static olmayan üye işlev %qD kullanımı geçersiz"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "trampolines not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "trampolines desteklenmiyor"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "user defined reduction lookup is ambiguous"
 msgstr "%qD ile ilişkilendirme belirsiz"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %+#D"
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "vektör silme işlemi için tür ne gösterici ne de dizi"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<restrict%>"
 msgid "%qE has const type for %<reduction%>"
 msgstr "%<restrict%> kullanımı geçersiz"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "ifade umuluyordu"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qT erişilebilir bir %qT tabanı değil"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<gang%> static expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "%<gang%> static value must be positive"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<gang%> num expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<vector%> length expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<worker%> num expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "%<gang%> num value must be positive"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 #| msgid "stack size must be an exact power of 2"
 msgid "%<vector%> length value must be positive"
 msgstr "yığıt boyutu ikinin üstel katlarında olmalı"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr ""
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD bir işlev şablonu değil"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is not a valid class name"
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "'%s' geçerli bir sınıf ismi değil"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "'%s' ismi (%C'de) tanımlı bir işleç olarak kullanılamaz"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "weak declaration of %q+D not supported"
 msgid "variable length traits arrays are not supported"
 msgstr "%q+D zayıf bildirimi desteklenmiyor"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD değişken sayıda argümana sahip olmamalı"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "template %qE in clause %qs"
 msgstr "girdi dosyası sayısı çok fazla"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<grainsize%> expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<priority%> expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<hint%> expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "%<filter%> expression must be integral"
 msgstr "%C'deki STAT ifadesi bir değişken olmalıdır"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "bir içi boş tür göstericisi üzerinde aritmetik"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "%<tree%> is not defined as a pointer type"
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tree%> bir gösterici türü olarak tanımlı değil"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "bütünleyen ifade %qE bir sabit değil"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "CRIS-port assertion failed: "
 msgid "static assertion failed: %.*s"
 msgstr "CRIS-port olumlaması başarısız: "
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, fuzzy, gcc-internal-format
 #| msgid "non-static declaration of %q+D follows static declaration"
 msgid "non-constant condition for static assertion"
 msgstr "%q+D statik olmayan bildirim statik bildirimi izliyor"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot resolve address of overloaded function"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%s aşırı yüklü işlevin adresini çözümleyemiyor"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qE sınıf türüne sahip değil"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_next_arg%> argümansız çağrılmış"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_next_arg%> argümansız çağrılmış"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 must be a 5-bit signed literal"
 msgid "%qs argument %qT is a reference"
 msgstr "1. argüman 5 bitlik bir işaretli sabit olmalı"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a template"
 msgid "%qD is not a class or alias template"
 msgstr "%qE bir şablon değil"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "virgüllü ifadenin sol terimi etkisiz"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "şablon argümanı %qE şablon parametre(ler)ini içine alıyor"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_prefetch%> must be a constant"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -78093,387 +78260,387 @@ msgstr "%<__builtin_prefetch%> için 2. argüman bir sabit olmalı"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "new bir işlev türe uygulanamaz"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV niteleyicileri %qT'ye uygulanamaz"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid " declared here"
 msgstr "burada bildirilmiş %q+D"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a floating-point type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT %qT tabanında değil"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T gösterici veri üyeleri içeriyor"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "padding occurs between %qD and %qD"
 msgstr "%q#T ile %q#T arasında karşılaştırma"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs bir gcov veri dosyası değil"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class %q#T has a non-virtual destructor"
 msgid "base class %qT is not public"
 msgstr "taban sınıf %q#T bir sanal olmayan yıkıcıya sahip"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is not public"
 msgstr "%qD bir şablon değil"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template"
 msgid "%qD is mutable"
 msgstr "%qD bir şablon değil"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has an incomplete type"
 msgid "%qD has a non-structural type"
 msgstr "%qD bir tamamlanmamış tür içeriyor"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to function types"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "%qs özniteliği sadece işlev türlerine uygulanır"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "%qs öznitelik argümanı bir dizge sabit değil"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "%qE özniteliği sadece sınıf tanımlarına uygulanabilir"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "%qE özniteliği sadece sınıf tanımlarına uygulanabilir"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "%qE özniteliği sadece sınıf tanımlarına uygulanabilir"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires prototypes with named arguments"
 msgid "%qE attribute takes no arguments"
 msgstr "%qE özniteliği isimli argümanları olan prototipler gerektirir"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "%qs özniteliği sadece işlevlere uygulanır"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "işlev bildirimi geçersiz"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT bir şablon türü değil"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> bir bit-alanına uygulanmış"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "expression in new-declarator must have integral or enumeration type"
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "new bildirimli ifade bütünleyici ya da numaralama türünde olmalı"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%qE on unnamed bit-field"
 msgstr "%<__alignof%> bir bit-alanına uygulanmış"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %q+D but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "%q+D parametresi için bildirim var ama böyle bir parametre yok"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "istenen init_priority bir tamsayı sabit değil"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "%qE özniteliği sadece sınıf türünde nesnelerin dosya bağlamı tanımlarında kullanılabilir"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "istenen init_priority aralık dışında"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "istenen init_priority iç kullanim için ayrilmiştir"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "%2$s olarak %1$qD bildirimi"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires prototypes with named arguments"
 msgid "the %qE attribute requires arguments"
 msgstr "%qE özniteliği isimli argümanları olan prototipler gerektirir"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "%qs özniteliğinin argümanı bir dizge sabiti değil"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 #| msgid "argument of %qs attribute is not a string constant"
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "%qs özniteliğinin argümanı bir dizge sabiti değil"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%T::%D%> geçerli bir bildirici değil"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%T::%D%> geçerli bir bildirici değil"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on non-class types"
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "%qE özniteliği sınıf türleri dışında yoksayılır"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "%qE özniteliği sadece sınıf tanımlarına uygulanabilir"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %qD applied to template instantiation"
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "saklama sınıfı %qD şablon örneklenimine uygulanmış"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 #| msgid "storage class %qD applied to template instantiation"
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "saklama sınıfı %qD şablon örneklenimine uygulanmış"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%J%qE özniteliği sadece işlevlere uygulanır"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 #| msgid "%J%qE attribute applies only to functions"
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "%J%qE özniteliği sadece işlevlere uygulanır"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute argument not an integer constant"
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "%qs öznitelik argümanı bir tamsayı sabit değil"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "%qs özniteliği sadece değişkenlere uygulanır"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "annotation on unnamed bit-field"
 msgstr "%<__alignof%> bir bit-alanına uygulanmış"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q+D shadows a parameter"
 msgid "annotation on void parameter"
 msgstr "%q+D bildirimi bir parametreyi gölgeliyor"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "işlev dizge türü ile dönmüyor"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "lang_* denetimi: %2$s dosyasının %3$d. satırındaki %1$s içinde başarısız"
@@ -78699,895 +78866,901 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT türü %qE isimli üye içermiyor"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%>, %qT'nin bir üyesi değil"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD %qT'nin bir üyesi değil"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD bir üye şablon işlevi değil"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT bir nesne göstericisi türü değil"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of array indexing on pointer to member"
 msgstr "uye göstericisinde %qs kullanımı geçersiz"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "uye göstericisinde %qs kullanımı geçersiz"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qs on pointer to member"
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "uye göstericisinde %qs kullanımı geçersiz"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "dizi başvurusunda altindis yok"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "%<register%> olarak bildirilmiş dizi indislemesi"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "indisli değer ne dizi ne de bir gösterici"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "%qE kullanimında nesne eksik"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "Generate default single-precision SH4 code"
 msgid "no default version in scope"
 msgstr "Öntanımlı tek duyarlıklı SH4 kodu üretilir"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ program içinden %<::main%> çağrısına izin vermez"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, fuzzy, gcc-internal-format
 #| msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>"
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "%<%E (...)%> içinde üye gösterici işlevi çağrısı için %<.*%> veya %<->*%> kullanılmalı"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qD cannot be used as a function"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "expression cannot be used as a function"
 msgstr "%qE bir işlev olarak kullanilamaz"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "too many arguments to constructor %q#D"
 msgstr "%s %q+#D için argümanlar çok fazla"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "too few arguments to constructor %q#D"
 msgstr "%s %q+#D için argümanlar çok az"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qs"
 msgid "too many arguments to member function %q#D"
 msgstr "%qs işlevi için argümanlar çok fazla"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qs"
 msgid "too few arguments to member function %q#D"
 msgstr "%qs işlevi için argümanlar çok az"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qs"
 msgid "too many arguments to function %q#D"
 msgstr "%qs işlevi için argümanlar çok fazla"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qs"
 msgid "too few arguments to function %q#D"
 msgstr "%qs işlevi için argümanlar çok az"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %s %q+#D"
 msgid "too many arguments to method %q#D"
 msgstr "%s %q+#D için argümanlar çok fazla"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to %s %q+#D"
 msgid "too few arguments to method %q#D"
 msgstr "%s %q+#D için argümanlar çok az"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "işlev için çok fazla argüman belirtildi"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "işlev için çok az argüman belirtildi"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "%P parametresi %qD içinde tamamlanmamış %qT türünde"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "parametre %P tamamlanmamış %qT türünde"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD, will always evaluate as %<true%>"
 msgid "the address %qE will never be NULL"
 msgstr "%qD adresi, daima %<true%> olarak değerlendirilecek"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD, will always evaluate as %<true%>"
 msgid "the address of %qD will never be NULL"
 msgstr "%qD adresi, daima %<true%> olarak değerlendirilecek"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD, will always evaluate as %<true%>"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "%qD adresi, daima %<true%> olarak değerlendirilecek"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD, will always evaluate as %<true%>"
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "%qD adresi, daima %<true%> olarak değerlendirilecek"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "?: için terimler farklı türde"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types %qT and %qT lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "bir tür dönüşümü olmaksızın %s (belirgin gösterici türleri %qT ve %qT arasında)"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between types %q#T and %q#T"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "%q#T ile %q#T türleri arasında karşılaştırma"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "%s between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "bir tür dönüşümü olmaksızın %s (belirgin gösterici türleri %qT ve %qT arasında)"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "Do not use hardware floating point"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "Donanım kayan nokta aritmetiği kullanılmaz"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "%qT türündeki işlev çağrısından eşleşmeyen %qT türüne dönüşüm"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "%qT'nin %qT'ye atanmasında türler uyumsuz"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "aşırı yüklü işlevden %qT türüne dönüşüm yapildigi varsayılıyor"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "aritmetik içinde NULL kullanımı"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ da gösterici ile tamsayı arasında karşılaştırmaya izin verilmez"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "%2$q#T içinde %1$q#T isminde tür yok"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "tamsayı sıfır ile sıralı gösterici karşılaştırması"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "gerçel sayı olmayan argümanlar arasında düzenlenmemiş karşılaştırma"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 #| msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "%qT türünden %qT türüne örtük dönüşüme C++'da izin verilmez"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "%qT ve %qT türündeki terimler iki terimli `%qO' için geçersiz"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ bir çıkarma içinde %<void *%> türde gösterici kullanımına izin vermez"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ bir çıkartma işlemi içindeki bir işlev göstericisi kullanımına izin vermez"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ bir çıkartma işlemi içinde bir yöntem göstericisi kullanımına izin vermez"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "gösterici aritmetiginde tamamlanmamış ture gösterici kullanımı geçersiz"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of constructor %qD"
 msgstr "gecicinin adresi alıniyor"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of destructor %qD"
 msgstr "gecicinin adresi alıniyor"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "%qE kullanımı üye işleve gösterici biçiminde geçersiz"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  bir nitelemeli kimlik gerekli"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, fuzzy, gcc-internal-format
 #| msgid "parenthesis around %qE cannot be used to form a pointer-to-member-function"
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "parantez icene alınmis %qE üye işleve gösterici biçiminde kullanilamaz"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ üye işleve bir gösterici şekillendirecek bir niteliksiz ya da parantezli statik olmayan üye işlevin adresinin alınmasına izin vermez.  %<&%T::%D%> denebilir."
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 #| msgid "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%>"
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ üye işleve bir gösterici şekillendirecek bir niteliksiz ya da parantezli statik olmayan üye işlevin adresinin alınmasına izin vermez.  %<&%T::%D%> denebilir."
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ üye işleve bir gösterici şekillendirecek bir sınır üye işlevin adresinin alınmasına izin vermez.  %<&%T::%D%> denebilir"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ üye işleve bir gösterici şekillendirecek bir sınır üye işlevin adresinin alınmasına izin vermez.  %<&%T::%D%> denebilir"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(bir üye göstericisi sadece %<&%E%> ile şekillendirilebilir)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "gecicinin adresi alıniyor"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ %<::main%> işlevinin adresinin alınmasına izin vermez"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "referans üye %qD için gösterici oluşturulamaz"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field %qD"
 msgid "attempt to take address of bit-field"
 msgstr "%qD bit-alanının adresi alınamaz"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "gecicinin adresi alıniyor"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ bir enum'um %s-lenmesine izin vermez"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing an enum"
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ bir enum'um %s-lenmesine izin vermez"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "%s içi boş %qT türüne bir gösterici olamaz"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 #| msgid "cannot %s a pointer to incomplete type %qT"
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "%s içi boş %qT türüne bir gösterici olamaz"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing a pointer of type %qT"
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ bir göstericinin %s işlemine %qT türündeyse izin vermez"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids %sing a pointer of type %qT"
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ bir göstericinin %s işlemine %qT türündeyse izin vermez"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "bir sağ taraf ifadesi olan %<this%>'in adresi alınamaz"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr " %qD için adres istegi (%<register%> olarak bildirilmiş olan)"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 #| msgid "initializer for %qT must be brace-enclosed"
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "%qT için ilklendirici {} içinde olmalı"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in initializer"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "expression list treated as compound expression in functional cast"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "%qT türünden %qT türüne dönüşüm niteleyicileri iptal ediyor"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%qT türünden %qT türüne static_cast geçersiz"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%qT türünden %qT türüne static_cast geçersiz"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 #| msgid "%qT uses local type %qT"
 msgid "useless cast to type %q#T"
 msgstr "%qT yerel tür %qT kullanıyor"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "tür niteleyicileri işlev dönüş türünde yok sayıldı"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "%qT türünden %qT türüne static_cast geçersiz"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "class type %qT is incomplete"
 msgstr "dönüş türü %q#T bir içi boş türdür"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "%qT'den %qT'ye dönüşüm"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "%qT türündeki bir sağ taraf değerinin %qT türüne dönüşümü geçersiz"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "%qT'den %qT'ye tür dönüşümü hassasiyet kaybi oluşturuyor"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 #| msgid "%s between distinct pointer-to-member types %qT and %qT lacks a cast"
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "bir tür dönüşümü olmaksızın %s (belirgin üye göstericisi türleri %qT ve %qT arasında)"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "%qT türünden %qT türüne dönüşüm hedef türün hizalama gereksinimini arttiriyor"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ işlev ve nesne göstericileri arasında dönüşüme izin vermez"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "%qT türünden %qT türüne const_cast geçersiz"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "ne bir gösterici türü ne de bir veri üyesine gösterici türü olan %qT ile const_cast kullanımı geçersiz"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "bir gösterici ya da bir işlev türüne referans olan %qT türü ile const_cast kullanımı geçersiz"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "%qT türündeki bir sağ taraf değerinden %qT türüne const_cast geçersiz"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "%qT türünden %qT türüne const_cast geçersiz"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ %qT dizi türüne dönüşüme izin vermez"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "%qT işlev türüne dönüşüm geçersiz"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "%qE ifadesi %qT türünden %qT türüne dönüştürülemez"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  %<%Q(%#T, %#T)%> nin gelisiminde"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "nonconstant array index in initializer"
 msgid "assigning to an array from an initializer list"
 msgstr "ilklendiricide sabit olmayan dizi indisi"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "%qT'nin %qT'ye atanmasında türler uyumsuz"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 #| msgid "bad array initializer"
 msgid "array used as initializer"
 msgstr "dizi ilklendirici hatalı"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in assignment"
 msgid "invalid array assignment"
 msgstr "atamanın sol tarafı geçersiz"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   üye işleve gösterici dönüşümünde"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "sanal taban %qT üzerinden üye göstericisine dönüşüm"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   üyeye gösterici dönüşümünde"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "%qT'ye %qT'den dönüşüm geçersiz"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "%4$qD işlevinin %3$qP. argümanı için %1$qT türü %2$qT türüne dönüştürülemez"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in return"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "%2$qE işlevinin %1$d. argümanı bir biçim özniteliği adayı olabilir"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 #| msgid "return type might be a candidate for a format attribute"
 msgid "parameter might be a candidate for a format attribute"
 msgstr "dönüş türü bir biçim özniteliği adayı olabilir"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 #| msgid "argument of function call might be a candidate for a format attribute"
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "işlev çağrısı argümanı bir biçim özniteliği için aday olabilir"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 #| msgid "argument of function call might be a candidate for a format attribute"
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "işlev çağrısı argümanı bir biçim özniteliği için aday olabilir"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 #| msgid "assignment left-hand side might be a candidate for a format attribute"
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "atamada sol taraf bir biçim özniteliği adayı olabilir"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "%2$q+D işlevinin %1$P. argümanına aktarımda"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "geçiciye başvuru dönüyor"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "geçiciye başvuru dönüyor"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable %q+D returned"
 msgid "reference to local variable %qD returned"
 msgstr "yerel değişken %q+D'ye referans donduruldu"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of label %qD returned"
 msgstr "yerel değişken %q+D adresi donduruldu"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of local variable %qD returned"
 msgstr "yerel değişken %q+D adresi donduruldu"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "redundant move in return statement"
 msgstr "asm deyiminde geçersiz sol taraf"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qT to %qT in %s"
 msgid "redundant move in initialization"
 msgstr "%qT %qT'ye %s içinde dönüştürülemez"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "bir yıkıcıdan değer donuyor"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "bir kurucunun bir işlev deneme blokunun bir tutamagından dondurulemez"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "kurucudan bir değer dondurulemez"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "%qT donduren işlevde değer içermeyen return"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer"
 msgid "returning initializer list"
 msgstr "ilklendirici yok"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "new türleri bir dönüş türünde tanımlanamayabilir"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "%L ve %L'de işliçler için sıralar uyumsuz"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with no value, in function returning %qT"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "%qT donduren işlevde değer içermeyen return"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%>', %<throw()%> olarak bildirilmedikce (ya da -fcheck-new etkinken) NULL donmemeli"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for %q+#D"
 msgid "not eliding copy on return from %qD"
 msgstr "%q+#D için ortak değişen dönüş türü geçersiz"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s value"
 msgid "using rvalue as lvalue"
@@ -80041,19 +80214,19 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown machine mode %qs"
 msgid "unknown attribute %qs"
 msgstr "%qs makine kipi bilinmiyor"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after being called"
 msgid "%q+D declared weak after being used"
 msgstr "%q+D çağrıdan sonra satıriçi bildirilmiş"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -80082,47 +80255,47 @@ msgstr "uye %qD için ilklendirici eksik"
 msgid "the address of %qD will never be %<null%>"
 msgstr "%qD adresi, daima %<true%> olarak değerlendirilecek"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "%q#T türüne gösterici bildirilemez"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "İşlev isimleri nesne kodunda saklanır"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qE ne işlev ne de üye işlev; friend olarak bildirilemez"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "forming %s to reference type %qT"
 msgid "forward reference to frame of %qs"
@@ -80211,36 +80384,36 @@ msgstr ""
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "%qs özniteliğinin argümanı geçersiz"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "%s yazmak için açılamıyor: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "`%s' çıktı dosyasının açılması: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "%s yazmak için açılamıyor: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "%s bağımlılık dosyasının açılması: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -80347,7 +80520,7 @@ msgstr "%qs makine kipi bilinmiyor"
 msgid "%qs is not an associative array"
 msgstr "%qD bir şablon değil"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -80364,25 +80537,25 @@ msgstr "%q+D normalde bir static olmayan işlevdir"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs geçerli bir çıktı dosyası değil"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "recursive reference %qs"
 msgstr "%q#T türüne başvuru bildirilemez"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "sabit ifadesinde taşma"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "%qs is not an expression"
 msgstr "%s bir sabit ifadesinde görünemez"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot appear in a constant-expression"
 msgid "type %qs is not an expression"
@@ -80483,18 +80656,18 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "typeid, -fno-rtti ile kullanilamaz"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -80840,8 +81013,8 @@ msgstr "%C'deki dizi başvurusu %d boyuttan fazlasını içeremez"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -81141,7 +81314,7 @@ msgstr ""
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "`%s' argümanı `%s' yerleşiği için  %L'de bir sabit olmalı"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad kind for logical constant at %C"
 msgid "Invalid use of BOZ literal constant at %L"
@@ -81231,7 +81404,7 @@ msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) REAL veya COMPLEX olmal
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) INTEGER veya PROCEDURE olmalı"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -81396,7 +81569,7 @@ msgstr "%C'deki ENTRY deyimi bir içerilmiş altyordamın içinde görünemez"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "`%s' ve '%s' argümanları `%s' yerleşiği için  (%L'de) aynı türde olmalı"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different type kinds at %L"
@@ -81414,7 +81587,7 @@ msgstr "%L'deki NULL gösterici '%s' yerleşik işlevinin fiili argümanı olama
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir POINTER olmalı"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
@@ -81575,8 +81748,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -81680,9 +81853,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "%C'deki ENTRY deyimi bir içerilmiş altyordamın içinde görünemez"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs intrinsic with KIND argument at %L"
@@ -81700,13 +81873,13 @@ msgstr "`dim' argümanı `%s' yerleşiği için  (%L'de) geçerli bir boyut indi
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "`%s' argümanı `%s' yerleşiği için  %L'de bir değişmez olmalı"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) sayısal ya da LOGICAL olmalı"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
@@ -81817,684 +81990,684 @@ msgstr "`%s' argümanı `%s' yerleşiği için  %L'de bir sabit olmalı"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "yerleşik `%s' için  (%L'de) en az iki argüman olmalı"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "`%s' yerleşiği için (%L'de) argümanlar eksik"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "`%s' yerleşiği için (%L'de) argümanlar eksik"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "`%s' yerleşiği için (%L'de) argümanlar eksik"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Different type kinds at %L"
 msgid "Different character kinds at %L"
 msgstr "Ek: %L'de farklı tür çeşitleri"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "`a%d' argümanı `%s' yerleşiği için  (%L'de) %s(%d) olmalı"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "`a1' argümanı `%s' yerleşiği için  (%L'de) INTEGER ya da REAL olmalı"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 #| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "`a1' argümanı `%s' yerleşiği için  (%L'de) INTEGER ya da REAL olmalı"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 #| msgid "different shape on dimension 1 for arguments '%s' and '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "'matmul' yerleşiği için 1. boyuttaki '%s' ve '%s' argümanları (%L'de) farklı biçimde"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 #| msgid "different shape on dimension 2 for argument '%s' and dimension 1 for argument '%s' at %L for intrinsic matmul"
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "'matmul' yerleşiği için 2. boyutta '%s' ve 1. boyutta '%s' argümanları (%L'de) farklı biçimde"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2"
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) 1. veya 2. sırada olmalı"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) türetilmemiş bir türde olmalı"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) INTEGER veya REAL olmalı"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir POINTER olmalı"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Complex argument of LOG at %L cannot be zero"
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "%L'de LOG'un karmaşık argümanı sıfır olamaz"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "`%s' ve '%s' argümanları `%s' yerleşiği için  (%L'de) aynı türde olmalı"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "`%s' ve '%s' argümanları `%s' yerleşiği için  (%L'de) aynı türde olmalı"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L may not be zero"
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "%L'de NEAREST'ın ikinci argümanı sıfır olmayabilir"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) ALLOCATABLE olmalı"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of type REAL or COMPLEX"
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) REAL ya da COMPLEX türünde olmalı"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'"
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) `%s' çeşidinde ve aynı türde olmalı"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir sözde değişken olmalı"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir OPTIONAL sözde değişken olmalı"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a variable"
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir değişken olmalı"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %d. çeşitte olmalı"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to %qs must be a 2-bit unsigned literal"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "%qs argümanı 2 bitlik işaretsiz bir sabit olmalı"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a logical array"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir mantıksal dizi olmalı"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "%L'de 'reshape' yerleşiğinin 'shape' argümanı sabit boyutlu bir dizi olmalı"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "%L'de 'reshape' yerleşiğinin 'shape' argümanı d elemandan fazlasını içeriyor"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "`a%d' argümanı `%s' yerleşiği için  (%L'de) %s(%d) olmalı"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %d. sırada olmalı"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of '%s' intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "`dim' argümanı `%s' yerleşiği için  (%L'de) geçerli bir boyut indisi değil"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of '%s' intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "`dim' argümanı `%s' yerleşiği için  (%L'de) geçerli bir boyut indisi değil"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a numeric type"
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) sayısal bir tür olmalı"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "%s özniteliği ile %s özniteliği %L'de çelişiyor"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "%L'de 'shape' yerleşiğinin 'source' argümanı tahmini boyutlu bir dizi olmalı"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "`%s' argümanı `%s' yerleşiği için  %L'de bir değişmez olmalı"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)"
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) INTENT(IN) olamaz"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "%L'de 'shape' yerleşiğinin 'source' argümanı tahmini boyutlu bir dizi olmalı"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) türetilmemiş bir türde olmalı"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must be a FUNCTION"
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Yerleşik işleç arayüzü '%s' %L'de bir FUNCTION olmalı"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "%C'deki bileşen POINTER özniteliğinde olmalı"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "`%s' yerleşiği için (%L'de) argümanlar eksik"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %d. sıradan önce olmalı"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "'dim' argument of '%s' intrinsic at %L is not a valid dimension index"
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "`dim' argümanı `%s' yerleşiği için  (%L'de) geçerli bir boyut indisi değil"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a variable"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir değişken olmalı"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "`%s' için fiili argüman bir gösterici olmalı (%L'de)"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "%s için argümanlar %L'de çok fazla"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "%s için argümanlar %L'de çok fazla"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be the same kind as '%s'"
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s ile aynı çeşit olmalı"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "`%s' ve '%s' argümanları `%s' yerleşiği için  (%L'de) aynı türde olmalı"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "%L'deki ATANH argümanı -1 .. 1 aralığının içinde kalmalı"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %s olmalı"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "%s için argümanlar %L'de çok fazla"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "yanlış sayıda şablon argümanı (%d yerine %d olmalıydı)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %d. çeşitte olmalı"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %d. çeşitte olmalı"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) INTEGER veya LOGICAL olmalı"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -82567,12 +82740,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "%C'deki ilklendirme bir gösterici değişkeni için değil"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "%L'deki altdizge başlangıç indisi birden küçük olmalıdır"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L must be scalar"
 msgid "Substring end index at %L exceeds the string length"
@@ -82628,2278 +82801,2278 @@ msgstr "Değişken '%s' %C'de bir ilklendirici ile zaten bir DATA deyiminde gör
 msgid "Simplification error"
 msgstr "gimpleme başarısız"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 #| msgid "Host associated variable '%s' may not be in the DATA statement at %C."
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Konak ilişkili değişken '%s' %C'de DATA deyiminin içinde olmamalı."
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 #| msgid "Extension: initialization of common block variable '%s' in DATA statement at %C"
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Ek: bildik blok değişkeni '%s'in %C'de DATA deyiminde ilklendirilmesi"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C"
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Sembol '%s' %C'deki DATA deyiminde bir PARAMETER olmalı"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "asm deyiminde geçersiz sol taraf"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "Sözde '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "%C'de ilklendirmeye bir PURE işlevinde izin verilmez"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "%C'deki ENTRY deyimi bir INTERFACE bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid lvalue in asm statement"
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "asm deyiminde geçersiz sol taraf"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "%C'de DATA deyimi için bir PURE işlevinde izin verilmez"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Empty old style initializer list at %C"
 msgstr "Genişletme: %C'de eski tarz ilklendirme"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array component of structure at %C must have an explicit shape"
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Yapının dizi bileşeni %C'de dolaysız durumda olmalı"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "skalar ilklendiricide fazladan öğeler"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "Repeat spec must be an integer at %C"
 msgstr "seçici 0..%wi aralığında bir tamsayı sabit olmalı"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Expected data constant after repeat spec at %C"
 msgstr "%C'de diğer return yaftası umuluyordu"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "End of scalar initializer expected at %C"
 msgstr "%C'deki ilklendirme ifadesinin değişmez olması umuluyordu"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "dizi ilklendiricide gereğinden fazla öğe"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "dizi ilklendiricide gereğinden fazla öğe"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in argument list at %C"
 msgid "Syntax error in old style initializer list at %C"
 msgstr "%C'deki argüman listesinde söz dizimi hatası"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "%C'deki INTENT belirtimi hatalı"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "%2$qs sonrası şablon türü %1$qT parametresi kullanımı"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal character in BOZ constant at %C"
 msgid "Old-style character length at %C"
 msgstr "%C'de BOZ sabitinde kuraldışı karakter"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "%C'deki karakter uzunluğu belirtiminde sözdizimi hatası"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "işlev `%s' (%C'deki) zaten %L'de tanımlı"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "işlev `%s' (%C'deki) zaten %L'de tanımlı"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Genel isim '%s' (%L'de), zaten %s (%L'de) olarak kullanılıyor"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "işlev '%s' (%C'deki) bir dolaysız arayüze sahip ve %L'de bildirilmiş özniteliklere sahip olmamalı"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de bir EQUIVALENCE nesnesi olarak SEQUENCE özniteliğine sahip olmalı"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "%L'deki sözde yordama ELEMENTAL yordamında izin verilmez"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Ayrılabilir '%s' dizisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Anahtar kelime argümanı '%s' (%L'de) yordam içinde değil"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "`%s' için fiili argüman bir gösterici olmalı (%L'de)"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Tahmini boyutlu dizi bir sözde argüman olmalı"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L already has basic type of %s"
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "'%s' simgesi %L'de zaten temel %s türünde"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Element in %s array constructor at %L is %s"
 msgid "CHARACTER length must be a constant at %L"
 msgstr "%s dizi kurucudaki öğe (%L'deki) %s"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "`%s' ve '%s' argümanları `%s' yerleşiği için  (%L'de) aynı türde olmalı"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 #| msgid "Initializer not allowed for PARAMETER '%s' at %C"
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "PARAMETER `%s' için %C'de ilklendirme yapılamaz"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "%L'deki PARAMETER bir ilklendirici kaybediyor"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C with an initializer already appears in a DATA statement"
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Değişken '%s' %C'de bir ilklendirici ile zaten bir DATA deyiminde görünüyor"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize multi-dimensional array with initializer"
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "çok boyutlu diziler ilklendiricilerle ilklendirilemez"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "%L'de dizi başvurusunda sıra uyumsuz (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot initialize multi-dimensional array with initializer"
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "çok boyutlu diziler ilklendiricilerle ilklendirilemez"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Bad shape of initializer at %L"
 msgstr "işlev `%s' (%C'deki) zaten %L'de tanımlı"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "%q#T türüne gösterici bildirilemez"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "%C'deki veri bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "İşlev '%s' (%L'de) bir INTRINSIC ama bir yerleşik ile uyumlu değil"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "%C'deki bileşen POINTER özniteliğinde olmalı"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "'%s' dizi göstericisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Yapının dizi bileşeni %C'de dolaysız ya da ertelenmiş durumda olmalı"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "Component %qs at %C already declared at %L"
 msgstr "'%s' bileşeni (%C'deki) zaten %L'de bildirilmiş"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Yapının gösterici dizisi bileşeni %C'de ertelenmiş durumda olmalı"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer array component of structure at %C must have a deferred shape"
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Yapının gösterici dizisi bileşeni %C'de ertelenmiş durumda olmalı"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Yapının dizi bileşeni %C'de dolaysız durumda olmalı"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "Üç nokta imli bir parametre listesi bir boş parametre isim listesi bildirimi ile eşleşemez"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "NULL() ilklendirme %C'de belirsiz"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NULL() initialization at %C is ambiguous"
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "NULL() ilklendirme %C'de belirsiz"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "%C'deki gösterici ilklendirmesi bir PURE yordamında olamaz"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Error in pointer initialization at %C"
 msgstr "Genişletme: %C'de eski tarz ilklendirme"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "non-NULL pointer initialization at %C"
 msgstr "Genişletme: %C'de eski tarz ilklendirme"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, fuzzy, gcc-internal-format
 #| msgid "%s statement not allowed in PURE procedure at %C"
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "PURE yordamda %s deyimine izin verilmez (%C'de)"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is not a member of the '%s' structure"
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "'%s' (%C'deki) '%s' yapısının bir üyesi değil"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%qD öntanımlı argümanlara sahip olamaz"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Bad character '%c' in OPERATOR name at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "OPERATOR isminde '%c' karakteri geçersiz (%C'de)"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de gösterici değerli olamaz"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be of INTEGER type"
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "%L'de dizi indisi INTEGER türünde olmalıdır"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Sözde '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C."
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Cray göstericileri için dizi belirtimi %C'de yinelenmiş"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set pointee array spec."
 msgstr "bir gösterici türüne dönüştürülemez"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Old-style initialization at %C"
 msgstr "Genişletme: %C'de eski tarz ilklendirme"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid initialization of reference of type %qT from expression of type %qT"
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "%qT türündeki başvurunun %qT türündeki ifadeden ilklendirilmesi geçersiz"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Genişletme: %C'de eski tarz ilklendirme"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "%C'deki ilklendirme bir gösterici değişkeni için değil"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "%C'deki gösterici ilklendirmesi bir '=>' gerektirir, '=' değil"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "%C'de bir ilklendirme ifadesi umuluyordu"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "%C'deki değişken ilklendirmesi bir PURE yordamında olamaz"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "%C'deki değişken ilklendirmesi bir PURE yordamında olamaz"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "%C'deki değişken ilklendirmesi bir PURE yordamında olamaz"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The derived type '%s' at %L is of type '%s', which has not been defined."
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Türetilmiş '%s' türü (%L'de) tanımlanmamış olan '%s' türündedir."
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Harici '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Eski tarz tür bildirimi %s*%d %C'de desteklenmiyor"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "%s*%d %C'de standartdısı tür bildirimi"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing right paren at %C"
 msgid "Missing right parenthesis at %C"
 msgstr "%C'de sağ parantez eksik"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "%C'de ilklendirme ifadesi umuluyordu"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "%C'deki ilklendirme ifadesinin değişmez olması umuluyordu"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "%d. çeşit, %s türü için (%C'de) desteklenmiyor"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing right paren at %C"
 msgid "Missing right parenthesis or comma at %C"
 msgstr "%C'de sağ parantez eksik"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Kind %d not supported for type %s at %C"
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "%d. çeşit, %s türü için (%C'de) desteklenmiyor"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "%C'deki CHARACTER bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "identifier expected after %<@protocol%>"
 msgid "Structure name expected after RECORD at %C"
 msgstr "%<@protocol%> sonrasında betimleyici umuluyordu"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "%<va_start%>'in ikinci parametresi isimli son argüman değil"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "%L'deki ifade INTEGER türünde olmalı"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "%L'deki ifade INTEGER türünde olmalı"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "Bir sabit ifadesine indirgenmeyen '%s' parametresi %L'de ya bildirilmemiş ya da değişken değil"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type argument"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: BYTE type at %C"
 msgid "BYTE type at %C"
 msgstr "Genişletme: %C'de BYTE türü"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "%C'de hedef makinede desteklenmeyen BYTE türü kullanılmış"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type definition at %C has no components"
 msgid "Assumed type at %C is not allowed for components"
 msgstr "%C'deki türetilmiş tür tanımının hiç bileşeni yok"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type argument"
 msgid "Malformed type-spec at %C"
 msgstr "tür argümanı geçersiz"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C is ambiguous"
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Tür ismi '%s' %C'de belirsiz"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected CASE statement at %C"
 msgid "CLASS statement at %C"
 msgstr "%C'de umulmadık CASE deyimi"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "%C'de IMPLICIT NONE deyimi yinelenmiş"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate IMPLICIT NONE statement at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "%C'de IMPLICIT NONE deyimi yinelenmiş"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "%C'deki IMPLICIT içinde karakter aralığı eksik"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "%C'deki IMPLICIT deyiminde harfler alfabetik sırada olmalı"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE statement at %C follows blanket SAVE statement"
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "%C'deki SAVE deyiminden önce bir kapsamlı SAVE deyimi var"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "%C'deki ENTRY deyimi bir INTERFACE bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "%C'deki ENTRY deyimi bir INTERFACE bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "IMPORT statement at %C"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "import-name %qs at %C is in the local scope"
 msgstr "İsim '%s' %C'de işlev ismidir"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in %s statement at %C"
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "%s deyiminde sözdizimi hatası (%C'de)"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting list of named entities at %C"
 msgstr "%s deyimi umuluyordu (%C'de)"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing dimension specification at %C"
 msgid "Missing codimension specification at %C"
 msgstr "%C'de boyut belirtimi eksik"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "%C'de boyut belirtimi eksik"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "%s özniteliği %L'de yinelenmiş"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir POINTER olmalı"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir POINTER olmalı"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s attribute at %L is not allowed outside of a MODULE"
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%s özniteliği ('%L'de) bir MODULE dışında kullanılamaz"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "%L'deki öznitelik bir TYPE tanımında kullanılamaz"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s attribute at %L"
 msgid "PROTECTED attribute at %C"
 msgstr "%s özniteliği %L'de yinelenmiş"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Line truncated at %C"
 msgid "VALUE attribute at %C"
 msgstr "%C'deki satır kırpıldı"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de dizi değerli olamaz"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Belirtim işlevi '%s' (%L'de) bir deyim işlevi olamaz"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing generic specification in USE statement at %C"
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "%C'deki USE deyiminde soysal belirtim eksik"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "missing number"
 msgid "Missing symbol"
 msgstr "sayı eksik"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "BIND(C) statement at %C"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "%C'deki bileşen POINTER özniteliğinde olmalı"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition."
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "%C'deki türetilmiş tür evvelce tanımlanmış olmamalıydı, bu durumda bir türetilmiş tür tanımı içinde görünemez"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "%C'deki veri bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "%C'deki veri bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "procedure name = %s"
 msgid "MODULE prefix at %C"
 msgstr "yordam ismi = %s"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "%C'deki MODULE PROCEDURE bir soysal modül arayüzü olmalı"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "procedure name = %s"
 msgid "IMPURE procedure at %C"
 msgstr "yordam ismi = %s"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "template argument required for %<%s %T%>"
 msgid "A type parameter list is required at %C"
 msgstr "%<%s %T%> için şablon argüman gerekli"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Alternate-return argument at %C"
 msgstr "%C'de diğer return yaftası umuluyordu"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "template argument required for %<%s %T%>"
 msgid "A parameter name is required at %C"
 msgstr "%<%s %T%> için şablon argüman gerekli"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "İsim '%s' %C'de işlev ismidir"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "%C'deki dizi bildiriminde farklı bir boyut umuluyordu"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "%C'deki biçimsel argüman listesinde umulmadık döküntü"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate %s specification at %C"
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "%s belirtimi %C'de yinelenmiş"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Sembol '%s' %C'deki biçimsel argüman listesinde yinelenmiş"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "%C'deki RESULT değişkeninin ismi işlev isminden farklı olmalı"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "%C'deki işlev bildiriminden sonra umulmayan döküntü"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "%L'deki SAVE özniteliği bir PURE yordamında belirtilemez"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L already has basic type of %s"
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "'%s' simgesi %L'de zaten temel %s türünde"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected structure component name at %C"
 msgid "Procedure pointer component at %C"
 msgstr "%C'de yapı bileşeni ismi umuluyordu"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in structure constructor at %C"
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "%C'deki yapı kurucuda söz dizimi hatası"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "%C'deki MODULE PROCEDURE bir soysal modül arayüzü olmalı"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "PROCEDURE statement at %C"
 msgstr "Atıl: %C'deki PAUSE deyimi"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "%C'deki işlev tanımında biçimsel argüman listesi umuluyordu"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "ENTRY statement at %C"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "%C'deki ENTRY deyimi bir PROGRAM içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "%C'deki ENTRY deyimi bir MODULE içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "%C'deki ENTRY deyimi bir MODULE içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "%C'deki ENTRY deyimi bir BLOCK DATA içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "%C'deki ENTRY deyimi bir INTERFACE bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "%C'deki ENTRY deyimi bir SELECT bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "%C'deki ENTRY deyimi bir DERIVED TYPE bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "%C'deki ENTRY deyimi bir IF-THEN bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "%C'deki ENTRY deyimi bir DO bloku içinde görünemez"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "%C'deki ENTRY deyimi bir SELECT bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "%C'deki ENTRY deyimi bir FORALL bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "%C'deki ENTRY deyimi bir WHERE bloku içindeymiş gibi görünmüyor"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "%C'deki ENTRY deyimi bir içerilmiş altyordamın içinde görünemez"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected ENTRY statement at %C"
 msgstr "%C'de beklenmeyen END deyimi"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "%C'deki ENTRY deyimi bir içerilmiş işlevde görünemez"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "%C'deki ENTRY deyimi bir içerilmiş işlevde görünemez"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing alternate return spec in subroutine call at %L"
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "%L'deki altyordam çağrısında diğer return belirtimi eksik"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "%C'deki CASE belirtiminde sözdizimi hatası"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing format label at %C"
 msgid "Missing closing paren for binding label at %C"
 msgstr "%C'de biçim yaftası eksik"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function name '%s' not allowed at %C"
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "'%s' işlev ismi olarak %C'de kullanılamaz"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "%C'de beklenmeyen END deyimi"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s statement at %C cannot follow %s statement at %L"
 msgid "END statement instead of %s statement at %L"
 msgstr "%s deyimi (%C'deki), %s deyimini (%L'deki) izlemiyor"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "%s deyimi %L'de umuluyordu"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting %s statement at %L"
 msgstr "%s deyimi umuluyordu (%C'de)"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "'%s' için %s deyiminde (%C'de) blok ismi umuluyordu"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 #| msgid "Expected label '%s' for %s statement at %C"
 msgid "Expected label %qs for %s statement at %C"
 msgstr "'%s' etiketi umuluyordu (%s deyiminde, %C'de)"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "DIMENSION deyiminde %L'de dizi belirtimi eksik"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing array specification at %L in DIMENSION statement"
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "DIMENSION deyiminde %L'de dizi belirtimi eksik"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Dizi belirtimi %L'de ertelenmiş olmalı"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "%C'deki değişken listesinde umulmadık karakter"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<(%> at %C"
 msgstr "%C'de '(' umuluyordu"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "%C'de değişken ismi umuluyordu"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C must be an integer."
 msgid "Cray pointer at %C must be an integer"
 msgstr "%C'deki Cray göstericisi bir tamsayı olmalı."
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes."
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "%C'deki Cray göstericisi %d baytlık hassasiyete sahip ancak bellek adresi %d bayt gerektiriyor"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "%C'de \",\" umuluyordu"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
 msgstr "bir gösterici türüne dönüştürülemez"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C."
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Cray göstericileri için dizi belirtimi %C'de yinelenmiş"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "%C'de \")\" umuluyordu"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" or end of statement at %C"
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "%C'de \",\" veya deyim sonu umuluyordu"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer declaration at %C requires -fcray-pointer flag."
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "%C'deki Cray göstericisi bildirimi -fcray-pointer seçeneğini gerektiriyor"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "CONTIGUOUS statement at %C"
 msgstr "Atıl: %C'deki PAUSE deyimi"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "%s işlecinin erişim belirtimi %C'de zaten belirtilmişti"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ".%s. işlecinin erişim belirtimi %C'de zaten belirtilmişti"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "PROTECTED statement at %C"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "%C'de DATA deyimi için bir PURE işlevinde izin verilmez"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "%C'de DATA deyimi için bir PURE işlevinde izin verilmez"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "%C'de PARAMETER deyiminde değişken ismi umuluyordu"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "%C'deki PARAMETER deyiminde = işareti umuluyordu"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "%C'deki PARAMETER deyiminde ifade umuluyordu"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initializer not allowed for COMMON variable '%s' at %C"
 msgid "Initializing already initialized variable at %C"
 msgstr "COMMON değişkeni `%s' için %C'de ilklendirme yapılamaz"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "%C'deki PARAMETER deyiminde umulmayan karakterler"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "%C'deki READ deyiminde değişken umuluyordu"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "%C'deki READ deyiminde değişken umuluyordu"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "%C'deki kapsamlı SAVE deyiminden önce bir SAVE deyimi var"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "%C'deki SAVE deyiminden önce bir kapsamlı SAVE deyimi var"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "VALUE statement at %C"
 msgstr "Atıl: %C'deki PAUSE deyimi"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in VALUE statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate PRIVATE statement at %C"
 msgid "VOLATILE statement at %C"
 msgstr "%C'de PRIVATE deyimi yinelenmiş"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Obsolete: PAUSE statement at %C"
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Atıl: %C'deki PAUSE deyimi"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "%C'deki veri bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "%C'deki MODULE PROCEDURE bir soysal modül arayüzü olmalı"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected :: in TYPE definition at %C"
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "%C'deki TYPE tanımında :: umuluyordu"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C has already been host associated"
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "'%s' simgesi (%C'deki) zaten konakla ilişkiliymiş"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be thread-local because it has non-POD type %qT"
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qD evreye yerel olamaz çünkü POD olmayan %qT türünde"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type at %C can only be PRIVATE within a MODULE"
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "%C'deki türetilmiş tür sadece bir MODULE içinde PRIVATE olabilir"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type at %C can only be PUBLIC within a MODULE"
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "%C'deki türetilmiş tür sadece bir MODULE içinde PUBLIC olabilir"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr ""
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr ""
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "'%s' için türetilmiş tür tanımı %C'de zaten tanımlı"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate PRIVATE statement at %C"
 msgid "Junk after MAP statement at %C"
 msgstr "%C'de PRIVATE deyimi yinelenmiş"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate PRIVATE statement at %C"
 msgid "Junk after UNION statement at %C"
 msgstr "%C'de PRIVATE deyimi yinelenmiş"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %C is not a member of the '%s' structure"
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "'%s' (%C'deki) '%s' yapısının bir üyesi değil"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "%C'deki işlev bildiriminden sonra umulmayan döküntü"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate PRIVATE statement at %C"
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "%C'de PRIVATE deyimi yinelenmiş"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Tür ismi '%s' (%C'de) bir yerleşik türle aynı olamaz"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "%C'deki TYPE tanımında :: umuluyordu"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Derived type definition at %C has no components"
 msgid "Mangled derived type definition at %C"
 msgstr "%C'deki türetilmiş tür tanımının hiç bileşeni yok"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Tür ismi '%s' (%C'de) bir yerleşik türle aynı olamaz"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Türetilmiş tür ismi '%s' %C'de zaten temel  %s türünde"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Türetilmiş tür ismi '%s' %C'de zaten temel  %s türünde"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Sözde argüman '%s' (%L'de) OPTIONAL olamaz"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type definition of '%s' at %C has already been defined"
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "'%s' için türetilmiş tür tanımı %C'de zaten tanımlı"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "%C'deki CHARACTER bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "%C'deki Cray göstericileri tahmini biçimli dizi olamaz"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "New in Fortran 2003: ENUM AND ENUMERATOR at %C"
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "Fortran 2003'te yeni: %C'de ENUM AND ENUMERATOR"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Sayısal sabitler %C'de C tamsayı türünü aşıyor"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "bir tamsayı ifadesi ile ilklendirilmemiş ENUMERATOR %L"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "%C öncesinde ENUM tanım deyimi umuluyordu"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "%C'deki ENUMERATOR tanımında sözdizimi hatası"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s specification at %C"
 msgid "Duplicate access-specifier at %C"
 msgstr "%s belirtimi %C'de yinelenmiş"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s attribute at %L"
 msgid "Duplicate POINTER attribute at %C"
 msgstr "%s özniteliği %L'de yinelenmiş"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected VARIABLE at %C"
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "%C'de VARIABLE umuluyordu"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate SEQUENCE statement at %C"
 msgid "Duplicate DEFERRED at %C"
 msgstr "%C'de SEQUENCE deyimi yinelenmiş"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a nameless interface at %C"
 msgid "Expected access-specifier at %C"
 msgstr "%C'de isimsiz bir arayüz umuluyordu"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected binding attribute at %C"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 #| msgid "identifier expected after %<@protocol%>"
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "%<@protocol%> sonrasında betimleyici umuluyordu"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "%<)%> expected at %C"
 msgstr "%C'de '(' umuluyordu"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected binding name at %C"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr ""
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<::%> at %C"
 msgstr "%C'de '(' umuluyordu"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected array subscript at %C"
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "%C'de dizi indisi umuluyordu"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Malformed GENERIC statement at %C"
 msgstr "%C'deki PROGRAM deyiminin biçimi geçersiz"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<=>%> at %C"
 msgstr "%C'de '(' umuluyordu"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Range specification at %L can never be matched"
 msgid "The access specification at %L not in a module"
 msgstr "%L'deki aralık belirtimi asla eşleşmeyebilir"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "procedure name = %s"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "yordam ismi = %s"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "%s işlecinin erişim belirtimi %C'de zaten belirtilmişti"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "%s işlecinin erişim belirtimi %C'de zaten belirtilmişti"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected structure component name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "%C'de yapı bileşeni ismi umuluyordu"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific subroutine '%s' at %L"
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "Özel altyordam '%s' %L'de çözümlenemiyor"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "%C'deki PROGRAM deyiminin biçimi geçersiz"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected terminating name at %C"
 msgid "Expected specific binding name at %C"
 msgstr "%C'de sonlandıran isim umuluyordu"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected VARIABLE at %C"
 msgid "Empty FINAL at %C"
 msgstr "%C'de VARIABLE umuluyordu"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected structure component name at %C"
 msgid "Expected module procedure name at %C"
 msgstr "%C'de yapı bileşeni ismi umuluyordu"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" at %C"
 msgid "Expected %<,%> at %C"
 msgstr "%C'de \",\" umuluyordu"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 #| msgid "procedure name = %s"
 msgid "Unknown procedure name %qs at %C"
 msgstr "yordam ismi = %s"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 #| msgid "%s procedure at %L is already declared as %s procedure"
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "%s yordamı %L'de zaten %s yordamı olarak bildirilmiş"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "RESULT attribute required in ENTRY statement at %C"
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "%C'deki ENTRY deyimi bir RESULT özniteliği gerektirir"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "%C'deki FORALL yineleyicisinde sözdizimi hatası"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "%C'deki CHARACTER bildiriminde sözdizimi hatası"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in ENUMERATOR definition at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -85055,457 +85228,457 @@ msgstr "yordam ismi = %s"
 msgid "IM part_ref at %C"
 msgstr "yordam ismi = %s"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "%L'deki ifade içinde sayısal terimler ya da CHARACTER terimleri gerekiyor"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "%L'deki ifade içindeki ardarda ekleme işleçleri iki CHARACTER terimine sahip olmalıdır"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "%L'deki ardarda ekleme işleci aynı cins dizgeleri eklemeli"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "%L'deki ifade içindeki .NOT. işleci bir LOGICAL terime sahip olmalıdır"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "%L'deki ifadede LOGICAL terimler gerekiyor"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "%L'deki ifadede sadece yerleşik işleçler kullanılabilir"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "%L'deki ifade içinde sayısal terimler gerekiyor"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 #| msgid "Too few components in structure constructor at %C"
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "%C'deki yapı kurucuda çok az bileşen"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 #| msgid "The F95 does not permit the assumed character length variable '%s' in constant expression at %L."
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "F95, '%s' varsayılan karakter uzunluğu değişkenine %L'deki sabit ifadesi içinde izin vermez"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Evaluation of nonstandard initialization expression at %L"
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Ek: %L'de standartdışı ilklendirme ifadesinin değerlenimi"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' in initialization expression at %L must be an intrinsic function"
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "'%s' işlevi (%L'deki ilklendirme ifadesindeki) bir yerleşik işlev olmalı"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Bir sabit ifadesine indirgenmeyen '%s' parametresi %L'de ya bildirilmemiş ya da değişken değil"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 #| msgid "KIND parameter of %s at %L must be an initialization expression"
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "%s'in KIND parametresi %L'de bir ilklendirme ifadesi olmalıdır"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Bir sabit ifadesine indirgenmeyen '%s' parametresi %L'de ya bildirilmemiş ya da değişken değil"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_init_expr(): Unknown expression type"
 msgstr "İfade türü umuluyordu"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Belirtim işlevi '%s' (%L'de) bir deyim işlevi olamaz"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be an internal function"
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Belirtim işlevi '%s' (%L'de) dahili bir işlev olamaz"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Belirtim işlevi '%s' (%L'de) PURE olmalı"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be RECURSIVE"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Belirtim işlevi '%s' (%L'de) RECURSIVE olamaz"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Değişken '%s' (%L'de) ifade içinde görünemez"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Sözde argüman '%s' (%L'de) OPTIONAL olamaz"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Sözde argüman '%s' (%L'de) INTENT(OUT) olamaz"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Değişken '%s' (%L'de) ifade içinde görünemez"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_restricted(): Unknown expression type"
 msgstr "İfade türü umuluyordu"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "%L'deki ifade INTEGER türünde olmalı"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Function %qs at %L must be PURE"
 msgstr "Belirtim işlevi '%s' (%L'de) PURE olmalı"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "%L'deki ifade değişmez olmalı"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s at %L"
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "%s (%L'de) içindeki sıra uyumsuz"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "different shape for %s at %L on dimension %d (%d/%d)"
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "%s için %L'de %d. boyutta biçim farklı (%d/%d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "%2$qs sonrası şablon türü %1$qT parametresi kullanımı"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L is not a VALUE"
 msgid "%qs at %L is not a VALUE"
 msgstr "'%s' %L'de bir VALUE değil"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "%L'de sıfır adım uzunluğu kuraldışı"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "%d ve %d sıraları uyumsuz (%L'deki atamada)"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "%L'deki atamada değişken UNKNOWN türünde"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL %L'deki atamanın sağ tarafında görünüyor"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "POINTER valued function appears on right-hand side of assignment at %L"
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "POINTER değerli işlev %L'deki atamanın sağ tarafında görünüyor"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible types in assignment at %L, %s to %s"
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "%L'deki atamada uyumsuz türler, %s den %s'e"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "%L'deki gösterici atamasının hedefi bir POINTER değil"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "'%s' (%L'deki gösterici atamasındaki) bir yordam olduğundan bir sol taraf değeri olamaz"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate %s specification at %C"
 msgid "Expected bounds specification for %qs at %L"
 msgstr "%s belirtimi %C'de yinelenmiş"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "stack size must not be greater than 64k"
 msgid "Stride must not be present at %L"
 msgstr "yığıt boyutu 64k'dan büyük olmamalıdır"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Harici nesne '%s'  %L'de bir ilklendiriciye sahip olamayabilir"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' requires argument list at %C"
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "'%s' deyim işlevi %C'de argüman listesi gerektiriyor"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not included in the selected standard"
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "%L'deki yerleşik '%s' seçilmiş standartta bulunmuyor"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "%L'deki gösterici atamasında farklı karakter uzunlukları"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate interface declaration for class %qs"
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "%qs sınıfı için birden fazla arabirim bildirimi"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate interface declaration for class %qs"
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "%qs sınıfı için birden fazla arabirim bildirimi"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "%L'deki gösterici atamasında farklı karakter uzunlukları"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "%L'deki gösterici atamasının hedefi bir POINTER değil"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "%L'deki gösterici atamasında farklı sıralamalar"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "%L'deki gösterici atamasının hedefi bir POINTER değil"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "The assumed rank data-target at %L must be contiguous"
@@ -85514,210 +85687,210 @@ msgstr "`%s' argümanı (%L'de) tek uzunluk olmalı"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data target at %L shall not have a coindex"
 msgstr "%L'deki veri aktarım elemanının POINTER bileşenleri olamaz"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "%L'de hesaplanmış GOTO deyimindeki seçim ifadesi bir değişmez tamsayı ifadesi olmalıdır"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "%C'deki bileşen POINTER özniteliğinde olmalı"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "%L'deki gösterici atamasının hedefi ne TARGET ne de POINTER"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "%L'deki PURE yordamdaki gösterici atamasında hedef berbat"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "%L'de sağ tarafta vektör indisli gösterici ataması"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "%L'deki gösterici atamasının hedefi bir POINTER değil"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "%C'deki gösterici ilklendirmesi bir '=>' gerektirir, '=' değil"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "%C'deki bileşen POINTER özniteliğinde olmalı"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Nesne '%s' (%L'de), %s SAVE özniteliğine sahip olmalı"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Değişken '%s' (%L'de) ifade içinde görünemez"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "Değişken '%s' (%L'de) ifade içinde görünemez"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Değişken '%s' (%L'de) ifade içinde görünemez"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -85740,7 +85913,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "creating array of %qT"
@@ -85808,46 +85981,46 @@ msgstr "'%s' değişkeni (%C'deki), %L'de başlayan döngünün içinde yeniden
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "'%s' değişkeni (%C'deki), %L'de başlayan döngünün içinde yeniden tanımlanamaz"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "'%s' değişkeni (%C'deki), %L'de başlayan döngünün içinde yeniden tanımlanamaz"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "'%s' değişkeni (%C'deki), %L'de başlayan döngünün içinde yeniden tanımlanamaz"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %q#T and %q#T"
 msgid "%s between %L and %L"
@@ -85985,12 +86158,12 @@ msgstr "%L'de tanımlanmış atamanın ilk argümanı INTENT(IN) veya INTENT(INO
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "%L'de tanımlanmış atamanın ikinci argümanı INTENT(IN) olmalıdır"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "%L'deki işleç arayüzünün ilk argümanı INTENT(IN) olmalıdır"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "%L'deki işleç arayüzünün ikinci argümanı INTENT(IN) olmalıdır"
@@ -86457,337 +86630,342 @@ msgstr "`%s' için fiili argüman bir gösterici olmalı (%L'de)"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "%L'deki altyordam çağrısında diğer return belirtimi eksik"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 #| msgid "Missing actual argument for argument '%s' at %L"
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Argüman '%s' için fiili argüman eksik (%L'de)"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, fuzzy, gcc-internal-format
 #| msgid "Same actual argument associated with INTENT(%s) argument '%s' and INTENT(%s) argument '%s' at %L"
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "INTENT(%s) ile '%s' argümanı ve INTENT(%s) ile '%s' argümanı aynı fiili argüman ile ilişkilendirilmiş"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "%L'deki yordam argümanı bir PURE yordamına yerel olup POINTER özniteliğine sahiptir"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "%L'deki yordam argümanı bir PURE yordamına yerel olup bir INTENT(%s) argümanına aktarılmıştır"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "%L'deki yordam argümanı bir PURE yordamına yerel olup bir INTENT(%s) argümanına aktarılmıştır"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Yordam '%s' bir örtük arayüz ile çağrılmış (%L'de)"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Yordam '%s' bir örtük arayüz ile çağrılmış (%L'de)"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Yordam '%s' bir örtük arayüz ile çağrılmış (%L'de)"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Ayrılabilir '%s' dizisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "duplicate interface declaration for class %qs"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "%qs sınıfı için birden fazla arabirim bildirimi"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Anahtar kelime argümanı '%s' (%L'de) yordam içinde değil"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "'%s' simgesi %L'de zaten bir aleni arayüze sahip"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Anahtar kelime argümanı '%s' (%L'de) yordam içinde değil"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing arguments to %s intrinsic at %L"
 msgid "MOLD argument to NULL required at %L"
 msgstr "`%s' yerleşiği için (%L'de) argümanlar eksik"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "'%s' simgesi %L'de zaten bir aleni arayüze sahip"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Yordam '%s' bir örtük arayüz ile çağrılmış (%L'de)"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Yordam '%s' bir örtük arayüz ile çağrılmış (%L'de)"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D aliased to undefined symbol %qs"
 msgid "Unable to find symbol %qs"
 msgstr "%q+D tanımsız %qs simgesine rumuzlu"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 #| msgid "Entity '%s' at %C is already present in the interface"
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "'%s' öğesi (%C'de) zaten arayüzde mevcut"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "%s den %s e dönüşüm yapılamaz (%L'de)"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "Bir PURE yordamında içerilmiş '%s' yordamının kendisi de PURE olmalı"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "Bir PURE yordamında içerilmiş '%s' yordamının kendisi de PURE olmalı"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "%L'de boyut argümanı INTEGER türünde olmalı"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "`%s' argümanı (%L'de) tek uzunluk olmalı"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Karakter değerli iç işlev '%s' tahmini uzunlukta olmamalı (%L'de)"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "Sözde argüman '%s' (%L'de) INTENT(OUT) olamaz"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "%C'de DATA deyimi için bir PURE işlevinde izin verilmez"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "'%s' yordamı (%s içinde, %L'de) be işlev ne de altyordam"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "`%s' çağrısındaki argümanlar çok fazla (%L'de)"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -87000,7 +87178,7 @@ msgstr "%s den %s e dönüşüm (%L'de)"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -87626,7 +87804,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -87812,12 +87990,12 @@ msgstr "Tamsayı üstten taşması"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -88383,7 +88561,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "%C'deki Cray göstericisi bir tamsayı olmalı."
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -88947,102 +89125,102 @@ msgstr "'%s' için %s deyiminde (%C'de) blok ismi umuluyordu"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "%C'deki ENTRY deyimi bir DO bloku içinde görünemez"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Empty IMPLICIT statement at %C"
 msgid "SELECT RANK statement at %C"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "%C'deki SAVE deyiminde sözdizimi hatası"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "%C'de umulmadık CASE deyimi"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in CASE specification at %C"
 msgstr "%C'deki CASE belirtiminde sözdizimi hatası"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "%C'de beklenmeyen END deyimi"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "%C'deki CASE belirtiminde sözdizimi hatası"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "%C'deki CASE belirtiminde sözdizimi hatası"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "%C'de beklenmeyen END deyimi"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "%L'deki FORALL adım ifadesi bir değişmez %s olmalıdır"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE-specification at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "%C'deki CASE belirtiminde sözdizimi hatası"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "%C'deki ELSEWHERE deyimi WHERE bloku içinde değil"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 #| msgid "Label '%s' at %C doesn't match WHERE label '%s'"
 msgid "Label %qs at %C doesn't match WHERE label %qs"
@@ -90125,7 +90303,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
@@ -90163,12 +90341,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "%C'deki ELSE deyiminden sonra umulmadık döküntü"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -90689,7 +90867,7 @@ msgstr "%C'deki ELSE deyiminden sonra umulmadık döküntü"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "%L'deki IF deyimi bir sabit LOGICAL ifadesi gerektirir"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be of type %s"
 msgid "INTEGER expression of %s clause at %L must be positive"
@@ -90713,7 +90891,7 @@ msgstr "%L'deki PURE yordamında hatalı gösterici nesnesi"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "%L'deki PURE yordamında hatalı gösterici nesnesi"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -90746,19 +90924,19 @@ msgstr "%3$s:%4$d: %2$s içinde alttan taşmalı %1$s sanal dizisi"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 #| msgid "Bad pointer object in PURE procedure at %L"
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "%L'deki PURE yordamında hatalı gösterici nesnesi"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 #| msgid "Bad pointer object in PURE procedure at %L"
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "%L'deki PURE yordamında hatalı gösterici nesnesi"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -90884,8 +91062,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "%L'deki IF deyimi bir sabit LOGICAL ifadesi gerektirir"
@@ -90973,7 +91151,7 @@ msgstr "%L'deki simge bir DUMMY değişken değil"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol at %L is not a DUMMY variable"
 msgid "Object %qs is not a variable at %L"
@@ -90997,7 +91175,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -91039,7 +91217,7 @@ msgstr ""
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "'%s' argümanı '%s' çağrısında (%L'de) iki kere görünüyor"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -91374,623 +91552,633 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be INTEGER or REAL"
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "%s' (%L'de) bir INTEGER veya REAL olmalıdır"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, fuzzy, gcc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "`%s' için fiili argüman bir gösterici olmalı (%L'de)"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 #| msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%L'deki IF deyimi bir sabit LOGICAL ifadesi gerektirir"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, fuzzy, gcc-internal-format
 #| msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%L'deki IF deyimi bir sabit LOGICAL ifadesi gerektirir"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "%qD dizisinin boyutu bir tümleyen sabit ifadesi değil"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ELSE IF clause at %L requires a scalar LOGICAL expression"
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "%L'deki ELSE IF deyimi bir değişmez LOGICAL ifadesi gerektirir"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s at %L"
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "%s (%L'de) içindeki sıra uyumsuz"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOGICAL operands are required in expression at %L"
 msgid "SIZES requires constant expression at %L"
 msgstr "%L'deki ifadede LOGICAL terimler gerekiyor"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr ""
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr ""
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "%C'deki ilklendirme ifadesinin değişmez olması umuluyordu"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after ELSE IF statement at %C"
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "%C'deki ELSE IF deyiminden sonra umulmadık dotuntu"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s or %s"
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "%s etiketi (%L'de) ya %s ya da %s türünde olmalıdır"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s or %s"
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "%s etiketi (%L'de) ya %s ya da %s türünde olmalıdır"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "yazmaç değişkeni %qD iç işlevde kullanılmış"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid storage class for function %qs"
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "%qs işlevi için geçersiz saklama sınıfı"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s or %s"
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "%s etiketi (%L'de) ya %s ya da %s türünde olmalıdır"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between signed and unsigned integer expressions"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of IBCLR exceeds bit size at %L"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%L'de IBCLR'nin ikinci argümanı bit boyutunu aşıyor"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "property must be a logical expression at %L"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected expression"
 msgid "property must be an integer expression at %L"
 msgstr "ifade umuluyordu"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOGICAL operands are required in expression at %L"
 msgid "property must be a constant logical expression at %L"
 msgstr "%L'deki ifadede LOGICAL terimler gerekiyor"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s expression list treated as compound expression"
 msgid "property must be a constant integer expression at %L"
 msgstr "%s ifade listesi bilesik ifade olarak ele alıniyor"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOGICAL operands are required in expression at %L"
 msgid "TILE requires constant expression at %L"
 msgstr "%L'deki ifadede LOGICAL terimler gerekiyor"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in COMPLEX constant at %C"
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "%C'deki COMPLEX sabit içinde sözdizimi hatası"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in COMPLEX constant at %C"
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "%C'deki COMPLEX sabit içinde sözdizimi hatası"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected an initialization expression at %C"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "%C'de bir ilklendirme ifadesi umuluyordu"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -92708,69 +92896,69 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 #| msgid "Contained procedure '%s' at %C is already ambiguous"
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "İçerilmiş yordam '%s' zaten belirsiz (%C'de)"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "CONTAINS bölümünde umulmadık %s deyimi (%C'de)"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s statement at %C cannot follow %s statement at %L"
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "%s deyimi (%C'deki), %s deyimini (%L'deki) izlemiyor"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORMAT statement at %L does not have a statement label"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "%L'deki FORMAT deyimi bir deyim yaftası içermiyor"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "%C'deki CONTAINS bölümü zaken içerilmiş bir program birimidir"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Genel isim '%s' (%L'de), zaten %s (%L'de) olarak kullanılıyor"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Genel isim '%s' (%L'de), zaten %s (%L'de) olarak kullanılıyor"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Genel isim '%s' (%L'de), zaten %s (%L'de) olarak kullanılıyor"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Genel isim '%s' (%L'de), zaten %s (%L'de) olarak kullanılıyor"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "%C'deki boş BLOCK DATA %L'deki önceki BLOCK DATA ile çelişiyor"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "BLOCK DATA içinde umulmadık %s deyimi (%C'de)"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "MODULE içinde umulmadık %s deyimi (%C'de)"
@@ -92778,7 +92966,7 @@ msgstr "MODULE içinde umulmadık %s deyimi (%C'de)"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "%L ve %C'de iki ana PROGRAM"
@@ -93282,136 +93470,136 @@ msgstr "Sembol '%s' %C'deki DATA deyiminde bir PARAMETER olmalı"
 msgid "%qs at %C is not a variable"
 msgstr "%L'deki simge bir DUMMY değişken değil"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%s etiketi (%L'de) %s türünde olmalı"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr ""
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Interface %qs at %L may not be generic"
 msgstr "%L'deki yineleyici adımı sıfır olamaz"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Belirtim işlevi '%s' (%L'de) bir deyim işlevi olamaz"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "%C'deki MODULE PROCEDURE bir soysal modül arayüzü olmalı"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in elemental subroutine '%s' at %L is not allowed"
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "'%s' öğesel altyordamında diğer return belirtecine %L'de izin verilmiyor"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in function '%s' at %L is not allowed"
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "'%s' işlevinde diğer return belirtecine %L'de izin verilmiyor"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in elemental subroutine '%s' at %L is not allowed"
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "'%s' öğesel altyordamında diğer return belirtecine %L'de izin verilmiyor"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "PURE yordamının '%s' sözde yordamı da ayrıca PURE olmalı"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "'%s' ('%s' pure işlevinin) argümanı INTENT(IN) olmalıdır (%L'de) INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN)"
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "'%s' ('%s' pure işlevinin) argümanı INTENT(IN) olmalıdır (%L'de) INTENT(IN)"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified"
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "'%s' ('%s' pure altyordamının) argümanında INTENT belirtilmiş olmalıdır (%L'de)"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified"
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "'%s' ('%s' pure altyordamının) argümanında INTENT belirtilmiş olmalıdır (%L'de)"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "Öğesel yordamın '%s' argümanı değişmez olmalı (%L'de)"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 #| msgid "Keyword argument '%s' at %L is not in the procedure"
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Anahtar kelime argümanı '%s' (%L'de) yordam içinde değil"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Öğesel yordamın '%s' argümanı değişmez olmalı (%L'de)"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Öğesel yordamın '%s' argümanı POINTER özniteliğine sahip olamaz (%L'de)"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Öğesel yordamın '%s' argümanı POINTER özniteliğine sahip olamaz (%L'de)"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "%L'deki sözde yordama ELEMENTAL yordamında izin verilmez"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
@@ -93419,1085 +93607,1085 @@ msgstr "Öğesel yordamın '%s' argümanı POINTER özniteliğine sahip olamaz (
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Deyim işlevinin '%s' argümanı değişmez olmalı (%L'de)"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued argument '%s' of statement function at %L must has constant length"
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Deyim işlevinin karakter değerli '%s' argümanı sabit uzunlukta olmalı (%L'de)"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "İsim '%s' %C'de işlev ismidir"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 #| msgid "Contained function '%s' at %L has no IMPLICIT type"
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "İçerilmiş işlev '%s' hiç IMPLICIT tür içermiyor (%L'de)"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 #| msgid "Contained function '%s' at %L has no IMPLICIT type"
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "İçerilmiş işlev '%s' hiç IMPLICIT tür içermiyor (%L'de)"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Karakter değerli iç işlev '%s' tahmini uzunlukta olmamalı (%L'de)"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued internal function '%s' at %L must not be assumed length"
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Karakter değerli iç işlev '%s' tahmini uzunlukta olmamalı (%L'de)"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "çeliskili gerçekleme değişkeni özelliği"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "inconsistent instance variable specification"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "çeliskili gerçekleme değişkeni özelliği"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "FUNCTION sonucu %s FUNCTION %s içinde bir dizi olamaz (%L'de)"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "ENTRY sonucu %s FUNCTION %s içinde bir dizi olamaz (%L'de)"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "FUNCTION sonucu %s FUNCTION %s içinde bir POINTER olamaz (%L'de)"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "ENTRY sonucu %s FUNCTION %s içinde bir POINTER olamaz (%L'de)"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "FUNCTION sonucu %s FUNCTION %s içinde bir POINTER olamaz (%L'de)"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "ENTRY sonucu %s FUNCTION %s içinde bir POINTER olamaz (%L'de)"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "FUNCTION sonucu %s, %s türünde olamaz (FUNCTION %s içinde, %L'de)"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "ENTFY sonucu %s, %s türünde olamaz (FUNCTION %s içinde, %L'de)"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "'%s' simgesi (%C'deki) zaten bir COMMON blokundadır"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "'%s' simgesi (%C'deki) zaten bir COMMON blokundadır"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Özdevinimli dizi '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "%C'de COMMON içindeki türetilmiş tür değişkeni SEQUENCE özniteliğine sahip değildir"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "%C'de COMMON içindeki türetilmiş tür değişkeni SEQUENCE özniteliğine sahip değildir"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable in COMMON at %C does not have the SEQUENCE attribute"
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "%C'de COMMON içindeki türetilmiş tür değişkeni SEQUENCE özniteliğine sahip değildir"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 #| msgid "Named COMMON block '%s' at %L shall be of the same size"
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "İsimli COMMON blok '%s' %L'de aynı boyutta olmalı"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, fuzzy, gcc-internal-format
 #| msgid "Named COMMON block '%s' at %L shall be of the same size"
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "İsimli COMMON blok '%s' %L'de aynı boyutta olmalı"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 #| msgid "Named COMMON block '%s' at %L shall be of the same size"
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "İsimli COMMON blok '%s' %L'de aynı boyutta olmalı"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 #| msgid "Generic subroutine '%s' at %L is not an intrinsic subroutine"
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "Soysal işlev '%s' (%L'de) bir yerleşik altyordam değil"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "%L'de türetilmiş tür kurucusundaki öğe, gösterici bileşeni '%s' için %s'tir fakat %s olmalıydı"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "Different character lengths in pointer assignment at %L"
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "%L'deki gösterici atamasında farklı karakter uzunlukları"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %C"
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "%C'deki yapı kurucuda çok fazla bileşen"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 #| msgid "Too many components in structure constructor at %C"
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "%C'deki yapı kurucuda çok fazla bileşen"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "%L'de türetilmiş tür kurucusundaki öğe, gösterici bileşeni '%s' için %s'tir fakat %s olmalıydı"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "%L'de türetilmiş tür kurucusundaki öğe, gösterici bileşeni '%s' için %s'tir fakat %s olmalıydı"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "%L'de sağ tarafta vektör indisli gösterici ataması"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 #| msgid "The element in the derived type constructor at %L, for pointer component '%s', is %s but should be %s"
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "%L'de türetilmiş tür kurucusundaki öğe, gösterici bileşeni '%s' için %s'tir fakat %s olmalıydı"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, fuzzy, gcc-internal-format
 #| msgid "The upper bound in the last dimension must appear in the reference to the assumed size array '%s' at %L."
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Son boyuttaki üst sınır tahmini boyutlu '%s' dizisine başvuru içinde görünmelidir (%L'de)."
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "%qs at %L is ambiguous"
 msgstr "'%s' simgesi (%L'de) belirsiz"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 #| msgid "Alternate return specifier in function '%s' at %L is not allowed"
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "'%s' işlevinde diğer return belirtecine %L'de izin verilmiyor"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Yerleşik '%s' %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic at %L does not exist"
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "%L'deki yerleşik mevcut değil"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Yafta %d (%L'de başvurulu) hiç tanımlanmamış"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "'%s' beyan işlevine bir fiili argüman olarak izin verilmez (%L'de)"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "'%s' beyan işlevine bir fiili argüman olarak izin verilmez (%L'de)"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure '%s' is not allowed as an actual argument at %L"
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "'%s' iç yordamına %L'de bir fiili argüman olarak izin verilmez."
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL INTRINSIC olmayan '%s' yordamına %L'de bir fiili argüman olarak izin verilmez"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "'%s' simgesi (%L'de) belirsiz"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of INT at %L is not a valid type"
 msgid "By-value argument at %L is not of numeric type"
 msgstr "%L'de INT'in argümanı geçerli bir tür değil"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "standart uzlaşımlara bu bağlam içinde izin verilmez"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL INTRINSIC olmayan '%s' yordamına %L'de bir fiili argüman olarak izin verilmez"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "%2$qs sayacı okunurken %1$qs işlevi için kapsanma çelişkisi"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 #| msgid "Type/rank mismatch in argument '%s' at %L"
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Argüman '%s' için tür/sira uyumsuzluğu (%L'de)"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "'%s' özel işlevi (%L'de) çözümlenemiyor"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 #| msgid "Generic function '%s' at %L is not consistent with a specific intrinsic interface"
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Soysal işlev '%s' (%L'de) belirli bir yerleşik arayüz ile uyumlu değil"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "İşlev '%s' (%L'de) bir INTRINSIC ama bir yerleşik ile uyumlu değil"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "'%s' özel işlevi (%L'de) çözümlenemiyor"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "'%s' işlevi (%L'de) hiç IMPLICIT tür içermiyor"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "'%s' işlevi (%L'de) hiç IMPLICIT tür içermiyor"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function reference to '%s' at %L is inside a FORALL block"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "'%s' için işlev başvurusu %L'de bir FORALL blokunun içindedir"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 #| msgid "Function reference to '%s' at %L is inside a FORALL block"
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "'%s' için işlev başvurusu %L'de bir FORALL blokunun içindedir"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot write to internal file unit '%s' at %C inside a PURE procedure"
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "PURE yordamının içinde dahili dosya birimi '%s' yazılamıyor (%C'de)"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected junk after ELSE statement at %C"
 msgid "Unexpected junk after %qs at %L"
 msgstr "%C'deki ELSE deyiminden sonra umulmadık döküntü"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "%qs at %L is not a function"
 msgstr "%q+D bir işlev değil,"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "'%s' işlevi CHARACTER(*) bildirimli olup, bir sözde argüman olmadığından %L'de kullanılamaz"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "'%s' işlevinde argüman listesi eksik (%C'de)"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function at %L is recursive"
 msgid "Using function %qs at %L is deprecated"
 msgstr "%L'deki deyim işlevi iç içe"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "PURE yordamının '%s' sözde yordamı da ayrıca PURE olmalı"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "'%s' (%L'de bir FORALL blokunun içindeki) için altyordam başvurusu PURE değil"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "'%s' (%L'de bir FORALL blokunun içindeki) için altyordam başvurusu PURE değil"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "'%s' (%L'de bir FORALL blokunun içindeki) için altyordam başvurusu PURE değil"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine call to '%s' at %L is not PURE"
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "'%s' (%L'de) için altyordam başvurusu PURE değil"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific subroutine '%s' at %L"
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Özel altyordam '%s' %L'de çözümlenemiyor"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "Generic subroutine '%s' at %L is not consistent with an intrinsic subroutine interface"
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Soysal işlev '%s' (%L'de) bir yerleşik altyordam arayüzü ile uyumlu değil"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 #| msgid "Subroutine '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Altyordam '%s' (%L'de) bir INTRINSIC ama bir yerleşik ile uyumlu değil"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to resolve the specific subroutine '%s' at %L"
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Özel altyordam '%s' %L'de çözümlenemiyor"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "'%s' (%L'deki) %L'deki CALL ile uyumlu olmayan bir türe sahip"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr ""
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "Yerleşik '%s' %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "%L ve %L'de terimlerin biçimleri benzer değil"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de gösterici değerli olamaz"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "Impure function at %L might not be evaluated"
 msgstr "Bir satıriçi işlev satıriçi olamadığında uyarır"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "unsigned ifade >=0 karşılaştırması daima doğrudur"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "%s için %L'deki çeşit geçersiz"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator '%s' at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "%%L'deki tek terimli sayısal '%s' işlecinin terimi %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "%%L'deki iki terimli sayısal '%s' işlecinin terimleri %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "%L ve %L'de işliçler için sıralar uyumsuz"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "%%L'deki dizge ekleme işlecinin terimleri %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator '%s' at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "%%L'deki mantıksal '%s' işlecinin terimleri %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .NOT. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "%%L'deki .NOT. işlecinin terimi %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "%L'de COMPLEX nicelikler karşılaştırılamıyor"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %L and %L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "%L ve %L'de işliçler için sıralar uyumsuz"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "%s için %L'deki çeşit geçersiz"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "%s için %L'deki çeşit geçersiz"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "%%L'deki mantıksallar %s ile karşılaştırılmalı %s ile değil"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "%%L'deki '%s' karşılaştırma işlecinin terimleri %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "unknown operator '%s' in %%:version-compare"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "%%:version-compare içindeki '%s' işleci bilinmiyor"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "unknown operator '%s' in %%:version-compare"
 msgid "Unknown operator %qs at %L"
 msgstr "%%:version-compare içindeki '%s' işleci bilinmiyor"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator '%s' at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "%%L'deki '%s' kullanıcı işlecinin terimi %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator '%s' at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "%%L'deki '%s' kullanıcı işlecinin terimleri %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "%L'deki FORALL adım ifadesi bir değişmez %s olmalıdır"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "`%s' ve '%s' argümanları `%s' yerleşiği için  (%L'de) aynı türde olmalı"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "%L'de sıfır adım uzunluğu kuraldışı"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array reference at %L is out of bounds"
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "%L'deki dizi başvurusu sınırların dışında"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "dizi başvurusunda altindis yok"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Tahmini boyutlu dizi bölümünün en sağ üst sınırı %L'de belirtilmemiş"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "%L'de dizi başvurusunda sıra uyumsuz (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "%L'de dizi başvurusunda sıra uyumsuz (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "%L'deki FORALL adım ifadesi bir değişmez %s olmalıdır"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "%L'de dizi indisi değişmez olmalıdır"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be of INTEGER type"
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "%L'de dizi indisi INTEGER türünde olmalıdır"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: REAL array index at %L"
 msgid "REAL array index at %L"
 msgstr "Ek: %L'de REAL dizi indisi"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "%L'de boyut argümanı INTEGER türünde olmalı"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "%C'de dizi başvurusunun yapılışı geçersiz"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "%L'deki dizi indisi %d. mertebeden bir dizidir"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "%L'deki ifade INTEGER türünde olmalı"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "%L'deki ifade INTEGER türünde olmalı"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "%L'deki ifade değişmez olmalı"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "%L'deki altdizge başlangıç indisi INTEGER türünde olmalıdır"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "%L'deki altdizge başlangıç indisi bir değişmez olmalıdır"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "%L'deki altdizge son indisi INTEGER türünde olmalıdır"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "%L'deki altdizge son indisi bir değişmez olmalıdır"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L must be scalar"
 msgid "Substring end index at %L is too large"
 msgstr "%L'deki altdizge son indisi bir değişmez olmalıdır"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "resolve_ref(): Bad array reference"
 msgstr "%L'de hatalı dizi başvurusu"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Sıfırdan farklı bir mertebeden bir parça başvurusunun sağ bileşeni %L'de POINTER özniteliğinde olmamalıdır"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Sıfırdan farklı bir mertebeden bir parça başvurusunun sağ bileşeni %L'de POINTER özniteliğinde olmamalıdır"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "%L'de sıfırdan farklı bir mertebeden iki veya daha fazla parça başvurusu belirtilmemelidir"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 #| msgid "missing operand"
 msgid "Illegal coarray index"
 msgstr "terim eksik"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
@@ -94507,12 +94695,12 @@ msgstr "Tahmini boyutlu dizi bir sözde argüman olmalı"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
@@ -94522,440 +94710,440 @@ msgstr "Tahmini boyutlu dizi bir sözde argüman olmalı"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "%L'de hatalı dizi başvurusu"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared private"
 msgid "Using variable %qs at %L is deprecated"
 msgstr "gerçeklenim değişkeni %qs private olarak bildirilmiş"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "%L'de hatalı dizi başvurusu"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Extension: Old-style initialization at %C"
 msgid "Error in typebound call at %L"
 msgstr "Genişletme: %C'de eski tarz ilklendirme"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be scalar"
 msgid "Passed-object at %L must be scalar"
 msgstr "%s' etiketi (%L'de) bir değişmez olmalı"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Öğesel yordamın '%s' argümanı değişmez olmalı (%L'de)"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be INTEGER"
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%s' (%L'de) bir INTEGER olmalıdır"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "İfade türü umuluyordu"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "%s at %L must be integer"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s' (%L'de) bir INTEGER olmalıdır"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "%L'de Do döngüsündeki adım ifadesi sıfır olamaz"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "%C'de değişken ismi umuluyordu"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "'%s' değişkeni (%L'de) bir biçim yaftası atamamış"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "%L'deki SAVE özniteliği bir PURE yordamında belirtilemez"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s'at %C is not allowed."
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "'%s' tahmini boyutlu dizisine '%s' isim listesinde izin verilmiyor (%C'de)."
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "-m%s not supported in this configuration"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "-m%s bu yapılandırmada desteklenmiyor"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected %s statement at %C"
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Umulmadık %s deyimi (%C'de)"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "'%s' için %s deyiminde (%C'de) blok ismi umuluyordu"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "label %q+D defined but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "%q+D yaftası tanımlı ama kullanılmamış"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "%L'de FORALL indis ismi bir değişmez INTEGER olmalıdır"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "%L'de FORALL başlatma ifadesi bir değişmez INTEGER olmalıdır"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "%L'de FORALL son ifadesi bir değişmez INTEGER olmalıdır"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "%L'deki FORALL adım ifadesi bir değişmez %s olmalıdır"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "%L'deki FORALL adım ifadesi sıfır olamaz"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "Değişken '%s' (%L'de) ifade içinde görünemez"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in ALLOCATE statement at %L must be ALLOCATABLE or a POINTER"
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "%L'de ALLOCATE deyimindeki ifade ya bir POINTER ya da ALLOCATABLE olmalı"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "%L'deki ifadede sadece yerleşik işleçler kullanılabilir"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "%L'deki ALLOCATE deyimde dizi belirtimi gerekli "
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "%L'deki ALLOCATE deyimde dizi belirtimi gerekli "
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "%L'deki ALLOCATE deyimde dizi belirtimi gerekli "
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array specification in ALLOCATE statement at %L"
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "%L'deki ALLOCATE deyimde dizi belirtimi hatalı"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "%L'deki ALLOCATE deyimde dizi belirtimi hatalı"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array specification in ALLOCATE statement at %L"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "%L'deki ALLOCATE deyimde dizi belirtimi hatalı"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "%L'deki ASSIGN deyimi bir sabit öntanımlı INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "%L'deki yafta %L'deki GOTO deyimiyle aynı blokta değil"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "%L'deki ASSIGN deyimi bir sabit öntanımlı INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -94964,329 +95152,329 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "%L'deki CASE etiketi ile %L'deki CASE etiketi birbirinin üzerine taşıyor"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "%L'de CASE deyimindeki ifade %s türünde olmalı"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be kind %d"
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "%L'de CASE deyimindeki ifade %d. çeşit olmalı"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "%L'de CASE deyimindeki ifade bir değişmez olmalı"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "%L'de hesaplanmış GOTO deyimindeki seçim ifadesi bir değişmez tamsayı ifadesi olmalıdır"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "%L'deki SELECT deyiminin argümanı %s olamaz"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression in CASE statement at %L must be of type %s"
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "%L'de CASE deyimindeki ifade %s türünde olmalı"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "%L'deki DEFAULT CASE deyiminden sonra %L'de ikinci bir DEFAULT CASE olamaz"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "%L'deki CASE deyiminde mantıksal aralığa izin verilmez"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logical range in CASE statement at %L is not allowed"
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "%L'deki CASE deyiminde mantıksal aralığa izin verilmez"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "%L'deki aralık belirtimi asla eşleşmeyebilir"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "%L'deki mantıksal SELECT CASE blokunun ikiden fazla case'i var"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function '%s' at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "'%s' özel işlevi (%L'de) çözümlenemiyor"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not included in the selected standard"
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "%L'deki yerleşik '%s' seçilmiş standartta bulunmuyor"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "'%s' ismi (%C'de) tanımlı bir işleç olarak kullanılamaz"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L is not included in the selected standard"
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "%L'deki yerleşik '%s' seçilmiş standartta bulunmuyor"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Selector at %L cannot be NULL()"
 msgstr "%L'deki yineleyici adımı sıfır olamaz"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Selector at %L has no type"
 msgstr "'%s' işlevi (%L'de) hiç IMPLICIT tür içermiyor"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "%L'deki EQUIVALENCE deyiminde söz dizimi hatası"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CASE label at %L overlaps with CASE label at %L"
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "%L'deki CASE etiketi ile %L'deki CASE etiketi birbirinin üzerine taşıyor"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %C is being used before it is defined"
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Türetilmiş '%s' türü (%C'deki) tanımından önce kullanılıyor"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type name '%s' at %C already has a basic type of %s"
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Türetilmiş tür ismi '%s' %C'de zaten temel  %s türünde"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected %s statement at %C"
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Umulmadık %s deyimi (%C'de)"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "%s için %L'deki çeşit geçersiz"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array index at %L must be scalar"
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "%L'de dizi indisi değişmez olmalıdır"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "%L'deki veri aktarım elemanının POINTER bileşenleri olamaz"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "%L'deki veri aktarım elemanının POINTER bileşenleri olamaz"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have PRIVATE components"
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "%L'deki veri aktarım elemanının PRIVATE bileşenleri olamaz"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "%L'deki veri aktarım elemanının PRIVATE bileşenleri olamaz"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "%L'deki veri aktarım elemanının POINTER bileşenleri olamaz"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "%L'deki veri aktarım elemanı tahmini boyutlu bir diziye bir tam başvuru olamaz"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "%L'de FORALL indis ismi bir değişmez INTEGER olmalıdır"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "%L'de FORALL indis ismi bir değişmez INTEGER olmalıdır"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "`%s' için fiili argüman bir gösterici olmalı (%L'de)"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument for '%s' must be a pointer at %L"
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "`%s' için fiili argüman bir gösterici olmalı (%L'de)"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "%L'deki ASSIGN deyimi bir sabit öntanımlı INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "%L'deki ASSIGN deyimi bir sabit öntanımlı INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "%L'deki ASSIGN deyimi bir sabit öntanımlı INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s or %s"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "%s etiketi (%L'de) ya %s ya da %s türünde olmalıdır"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "%L'deki SELECT deyiminin argümanı bir sabit ifadesi olmalı"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ACOS at %L must be between -1 and 1"
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "%L'deki ACOS argümanı -1 .. 1 arasında olmalı"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "%L'deki deyim %L'deki dallanma deyimi için geçerli bir dallanma hedef deyimi değildir"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Branch at %L causes an infinite loop"
 msgid "Branch at %L may result in an infinite loop"
@@ -95294,17 +95482,17 @@ msgstr "%L'deki dallanma bir sonsuz döngüye sebep oluyor"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -95312,225 +95500,225 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "%L'deki yafta %L'deki GOTO deyimiyle aynı blokta değil"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "%L'deki WHERE maskesi uyumsuz biçimde"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "%L'deki WHERE atama hedefi uyumsuz biçimde"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "%L'deki WHERE içinde desteklenmeyen deyim"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "%L'de bir FORALL indis değişkenine atama"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, fuzzy, gcc-internal-format
 #| msgid "The FORALL with index '%s' cause more than one assignment to this object at %L"
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "'%s' indisli FORALL %L'de bu nesneye birden fazla atamaya sebep oluyor"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Constructor can't be %s"
 msgid "FORALL construct at %L"
 msgstr "Kurucu %s olmayabilir"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "%L'de FORALL indis ismi bir değişmez INTEGER olmalıdır"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Bir dış FORALL oluşumu zaten bu isimde bir indise sahip (%L'de)"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "%C'de değişken ismi umuluyordu"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "%L'deki WHERE/ELSEWHERE deyimi bir değişmez LOGICAL dizisi gerektirir"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "%L'deki veri aktarım elemanının POINTER bileşenleri olamaz"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "%s den %s e dönüşüm yapılamaz (%L'de)"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Right side of assignment at %L is a derived type containing a POINTER in a PURE procedure"
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "%L'deki atamanın sağ tarafı bir PURE yordamda bir POINTER içeren türetilmiş bir türdür"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "%L'de bir FORALL indis değişkenine atama"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "%L'de bir FORALL indis değişkenine atama"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different types in pointer assignment at %L"
 msgid "Pointer procedure assignment at %L"
 msgstr "%L'deki gösterici atamasında farklı türler"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "%L'de hesaplanmış GOTO deyimindeki seçim ifadesi bir değişmez tamsayı ifadesi olmalıdır"
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "%L'deki ASSIGNED GOTO deyimi bir INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' has not been assigned a target label at %L"
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "'%s' değişkenine %L'de bir hedef etiketi atanmış olmamalıydı"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Alternate RETURN statement at %L requires an INTEGER return specifier"
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Diğer RETURN deyimi %L'de bir INTEGER dönüş belirteci gerektirir"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "%C'deki CASE'de ilklendime ifadesi umuluyordu"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "%L'deki ASSIGN deyimi bir sabit öntanımlı INTEGER değişken gerektirir"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "%s için %L'deki çeşit geçersiz"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Arithmetic IF statement at %L requires a numeric expression"
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "%L'deki aritmetik IF deyimi bir sayısal ifade gerektirir"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "%L'deki DO WHILE döngüsünün çıkış koşulu bir sabit LOGICAL ifadesi olmalıdır"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL mask clause at %L requires a LOGICAL expression"
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "%L'deki FORALL maske deyimi bir LOGICAL ifadesi gerektirir"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_trans_code(): Hatalı deyim kodu"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD declared void"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "parametre %qD void olarak bildirilmiş"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, fuzzy, gcc-internal-format
 #| msgid "Named COMMON block '%s' at %L shall be of the same size"
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
@@ -95538,7 +95726,7 @@ msgstr "İsimli COMMON blok '%s' %L'de aynı boyutta olmalı"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, fuzzy, gcc-internal-format
 #| msgid "Named COMMON block '%s' at %L shall be of the same size"
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
@@ -95547,69 +95735,69 @@ msgstr "İsimli COMMON blok '%s' %L'de aynı boyutta olmalı"
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, fuzzy, gcc-internal-format
 #| msgid "Named COMMON block '%s' at %L shall be of the same size"
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "İsimli COMMON blok '%s' %L'de aynı boyutta olmalı"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "size of array %qs is too large"
 msgid "String length at %L is too large"
 msgstr "%qs dizisinin boyutu çok büyük"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Ayrılabilir '%s' dizisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 #| msgid "Scalar object '%s' at %L may not be ALLOCATABLE"
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "'%s' sabit nesnesi %L'de ALLOCATABLE olmayabilir"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "'%s' dizi göstericisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L cannot have a deferred shape"
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "'%s' dizisi %L'de ertelenmiş bir biçimde olamaz"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, fuzzy, gcc-internal-format
 #| msgid "Possible frontend bug: Deferred array size without pointer or allocatable attribute."
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Olası önyüz hatası: gösterici veya tahsis edilebilir öznitelik olmaksızın ertelenmiş dizi boyutu"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -95617,1091 +95805,1091 @@ msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "The module or main program array '%s' at %L must have constant shape"
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Modül veya ana program dizisi '%s' %L'de sabit biçimde olmalı"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "%L'deki tahmini karakter uzunluklu öğe ya bir sözde argüman ya da bir PARAMETER olmalı"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "%qs at %L must have constant character length in this context"
 msgstr "'%s' %L'de bu bağlam için sabit karakter uzunluklu olmalı"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "'%s' %L'de bu bağlam için sabit karakter uzunluklu olmalı"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Ayrılabilir '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Harici '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Sözde '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Yerleşik '%s' %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "işlev sonucu '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Özdevinimli dizi '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "in %s, at %s:%d"
 msgid "%s at %L"
 msgstr "%s işlevinde (%s dosyasının %d. satırı)"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued statement function '%s' at %L must have constant length"
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Karakter değerli deyim işlevi '%s'  %L'de sabit uzunlukta olmalı"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' is of a PRIVATE type and cannot be a dummy argument of '%s', which is PUBLIC at %L"
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "'%s' bir PRIVATE türündedir ve '%s' (%L'de PUBLIC tanımlı) için bir sözde argüman olamaz"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "işlev sonucu '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Harici nesne '%s'  %L'de bir ilklendiriciye sahip olamayabilir"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "%s' (%L'de) bir değişmez olmalıdır"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "'%s' beyan işlevine bir fiili argüman olarak izin verilmez (%L'de)"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de dizi değerli olamaz"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de gösterici değerli olamaz"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de katıksız olamaz"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be recursive"
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de iç içe olamaz"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "CHARACTER(*) işlevi '%s'  %L'de katıksız olamaz"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "PURE yordamının '%s' sözde yordamı da ayrıca PURE olmalı"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute in '%s' at %L"
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "%s özniteliği ile %s özniteliği '%s' içinde %L'de çelişiyor"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "%L'deki yineleyici adımı sıfır olamaz"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "Kullanıcı işleci yordamı '%s' (%L'de) için en azından bir argüman bulunmalı"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "%L'de ICHAR'ın argümanı bir uzunlukta olmalı"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir POINTER olmalı"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) ALLOCATABLE olmalı"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must not be OPTIONAL"
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) OPTIONAL olmamalı"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "%L'deki işleç arayüzünün ilk argümanı INTENT(IN) olmalıdır"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Kullanıcı işleci yordamı '%s' (%L'de) için en azından bir argüman bulunmalı"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "%L'deki yineleyici adımı sıfır olamaz"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "Yordam '%s' bir örtük arayüz ile çağrılmış (%L'de)"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Kullanıcı işleci yordamı '%s' (%L'de) için en azından bir argüman bulunmalı"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) türetilmemiş bir türde olmalı"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) türetilmemiş bir türde olmalı"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "`%s' argümanı `%s' yerleşiği için  %L'de bir değişmez olmalı"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) ALLOCATABLE olmalı"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) bir POINTER olmalı"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 #| msgid "Array pointer '%s' at %L must have a deferred shape"
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "'%s' dizi göstericisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "%L'de ICHAR'ın argümanı bir uzunlukta olmalı"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 #| msgid "User operator procedure '%s' at %L must have at least one argument"
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Kullanıcı işleci yordamı '%s' (%L'de) için en azından bir argüman bulunmalı"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) türetilmemiş bir türde olmalı"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "%L'de boyut argümanı değişmez olmalı"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Öğesel yordamın '%s' argümanı POINTER özniteliğine sahip olamaz (%L'de)"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) ALLOCATABLE olmalı"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' of '%s' at %L must have constant array bounds."
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "'%s' ('%s'in bileşeni) %L'de sabit dizi sınırlarına sahip olmalı"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, fuzzy, gcc-internal-format
 #| msgid "Character length of component '%s' needs to be a constant specification expression at %L."
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Bileşen karakter uzunluğu '%s'in %L'de bir sabit belirtim ifadesi olması gerekir"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be of INTEGER type"
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "%L'deki ifade INTEGER türünde olmalı"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 #| msgid "The component '%s' is a PRIVATE type and cannot be a component of '%s', which is PUBLIC at %L"
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Bileşen '%s' bir PRIVATE türdür ve '%s' (%L'de PUBLIC tanımlı) bileşeni olamaz"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component %s of SEQUENCE type declared at %C does not have the SEQUENCE attribute"
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "SEQUENCE türünün %s bileşeni SEQUENCE özniteliğine sahip değil (%C'de)"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected an initialization expression at %C"
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "%C'de bir ilklendirme ifadesi umuluyordu"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' of '%s' at %L must have constant array bounds."
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "'%s' ('%s'in bileşeni) %L'de sabit dizi sınırlarına sahip olmalı"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type '%s' at %C is being used before it is defined"
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Türetilmiş '%s' türü (%C'deki) tanımından önce kullanılıyor"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array '%s' in namelist '%s'at %C is not allowed."
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "'%s' tahmini boyutlu dizisine '%s' isim listesinde izin verilmiyor (%C'de)."
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 #| msgid "PRIVATE symbol '%s' cannot be member of PUBLIC namelist at %L"
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "'%s' PRIVATE simgesi %L'de PUBLIC isim listesi üyesi olamaz"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 #| msgid "PRIVATE symbol '%s' cannot be member of PUBLIC namelist at %L"
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "'%s' PRIVATE simgesi %L'de PUBLIC isim listesi üyesi olamaz"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 #| msgid "Parameter array '%s' at %L cannot be automatic or assumed shape"
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Parametre dizisi '%s' %L'de özdevinimli veya tahmini biçimli olamaz"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, fuzzy, gcc-internal-format
 #| msgid "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type"
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Örtük olarak  PARAMETER türlü '%s' %L'de sonraki bir IMPLICIT türle eşleşmiyor"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "%L'de PARAMETER içindeki türetilmiş tür uyumsuz"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LOGICAL operands are required in expression at %L"
 msgid "Expecting constant expression near %L"
 msgstr "%L'deki ifadede LOGICAL terimler gerekiyor"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "Possible frontend bug: Deferred array size without pointer or allocatable attribute."
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Olası önyüz hatası: gösterici veya tahsis edilebilir öznitelik olmaksızın ertelenmiş dizi boyutu"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "PROCEDURE özniteliği '%s' içinde NAMELIST özniteliği ile çelişiyor (%L'de)"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad specification for assumed size array at %C"
 msgid "Bad specification for assumed size array at %L"
 msgstr "%C'deki tahmini boyutlu dizi için belirtim hatalı"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "%L'deki tahmini boyutlu dizi bir sözde argüman olmalı"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Tahmini boyutlu dizi bir sözde argüman olmalı"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assumed shape array at %L must be a dummy argument"
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Tahmini boyutlu dizi bir sözde argüman olmalı"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "%L'deki simge bir DUMMY değişken değil"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 #| msgid "Character-valued statement function '%s' at %L must have constant length"
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Karakter değerli deyim işlevi '%s'  %L'de sabit uzunlukta olmalı"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Türetilmiş %qs türü %L'de tanımlanmamış olan %qs türündedir."
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Loop variable at %C cannot have the POINTER attribute"
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "%C'deki döngü değişkeni POINTER özniteliğinde olamaz"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "'%s' %L'de bu bağlam için sabit karakter uzunluklu olmalı"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 #| msgid "PUBLIC function '%s' at %L cannot be of PRIVATE type '%s'"
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "PUBLIC işlev '%s' %L'de PRIVATE '%s' türünde olamaz"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "INTENT(OUT) sözde argüman %qs %L'de ASSUMED SIZE olduğundan bir öntanımlı ilklerdiriciye sahip olamaz"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Sözde argüman '%s' (%L'de) INTENT(OUT) olamaz"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Sözde argüman '%s' (%L'de) INTENT(OUT) olamaz"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "işlev sonucu '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L cannot have a deferred shape"
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "'%s' dizisi %L'de ertelenmiş bir biçimde olamaz"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable array '%s' at %L must have a deferred shape"
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Ayrılabilir '%s' dizisi %L'de ertelenmiş bir biçimde olmalı"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy procedure at %L not allowed in ELEMENTAL procedure"
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "%L'deki sözde yordama ELEMENTAL yordamında izin verilmez"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist %s cannot be renamed by USE association to %s."
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "İsim listesinin ismi %s USE ilişkisiyle %s yapılamaz"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "Object '%s' at %L must have the SAVE attribute %s"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "Nesne '%s' (%L'de), %s SAVE özniteliğine sahip olmalı"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Ayrılabilir '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting definable entity near %L"
 msgstr "%s deyimi umuluyordu (%C'de)"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "BLOCK DATA öğesi %qs %L'de COMMON içinde olmalıdır"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "Sözde '%s'  %L'de bir ilklendiriciye sahip olamaz"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Öğesel yordamın '%s' argümanı POINTER özniteliğine sahip olamaz (%L'de)"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "DATA deyiminde %L'de sabit olmayan dizi bölümü"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "%L'deki DATA deyiminde değerden çok değişken var"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "DATA deyiminde %L'de sabit olmayan dizi bölümü"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Step expression in DO loop at %L cannot be zero"
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "%L'de Do döngüsündeki adım ifadesi sıfır olamaz"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "%L'deki DATA deyiminde değişkenden çok değer var"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "%d yaftası %L'de tanımlanmış ama kullanılmamış"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "%d yaftası %L'de tanımlanmış ama kullanılamıyor"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Türetilmiş tür değişkeni %qs %L'de bir EQUIVALENCE nesnesi olarak SEQUENCE özniteliğine sahip olmalı"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de gösterici bileşen(ler)le bir EQUIVALENCE nesnesi olamaz"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L with default initializer cannot be an EQUIVALENCE object"
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de öntanımlı ilklendiriciyle bir EQUIVALENCE nesnesi olamaz"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Türetilmiş tür değişkeni %qs %L'de gösterici bileşen(ler)le bir EQUIVALENCE nesnesi olamaz"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "%L'deki EQUIVALENCE deyiminde söz dizimi hatası"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 #| msgid "Common block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "Ortak blok üyesi %qs %L'de, %qs pure yordamındaki bir EQUIVALENCE nesnesi olamaz"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "%qs isimli sabiti %L'de bir EQUIVALENCE nesnesi olamaz"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "%L'deki EQUIVALENCE deyiminde söz dizimi hatası"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Sınırları sabit olmayan %qs dizisi %L'de bir EQUIVALENCE nesnesi olamaz"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Yapı bileşeni %qs %L'de bir EQUIVALENCE nesnesi olamaz"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "%L'deki altdizge sıfır uzunlukta"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in character length specification at %C"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "%C'deki karakter uzunluğu belirtiminde sözdizimi hatası"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY %qs %L'de hiç IMPLICIT tür içermiyor"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Yerleşik işleç arayüzü %qs %L'de bir FUNCTION olmalı"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Kullanıcı işleci yordamı %qs %L'de tahmini karakter uzunluğunda olamaz"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Kullanıcı işleci yordamı %qs %L'de için en azından bir argüman bulunmalı"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "%L'deki işleç arayüzünün ilk argümanı isteğe bağlı olamaz"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "%L'deki işleç arayüzünün ikinci argümanı isteğe bağlı olamaz"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "%L'deki işleç arayüzünün en fazla iki argümanı olmalı"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -96724,105 +96912,105 @@ msgstr " olmayan \"%s\" dizini yok sayılıyor\n"
 msgid "%qs is not a directory"
 msgstr "%q+D bir işlev değil,"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "%L'deki satır kırpıldı"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad continuation line at %C"
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "%C'deki devam satırı hatalı"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 #| msgid "Missing '&' in continued character constant at %C"
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "%C'deki devamlı karakter sabitinde '&' eksik"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad character '%c' in OPERATOR name at %C"
 msgid "Invalid character 0x%s at %C"
 msgstr "OPERATOR isminde '%c' karakteri geçersiz (%C'de)"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: file %s left but not entered"
 msgid "file %qs left but not entered"
 msgstr "%s:%d: %s dosyası solda ama girilmemiş"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Illegal preprocessor directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s:%d: önişlemci yönergesi kuraldışı"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file '%s'"
 msgid "Cannot open file %qs"
 msgstr "`%s' dosyası açılamıyor"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open included file %qs"
 msgstr "İçerilmiş '%s' dosyası açılamıyor"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "İçerilmiş '%s' dosyası açılamıyor"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "Included file %qs is not a regular file"
@@ -97003,231 +97191,231 @@ msgstr "%L'de ATAN2'nin ilk argümanı sıfırsa, ikinci argümanı sıfır olma
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "%L'deki IACHAR'ın argümanı bir uzunlukta olmalı"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of IACHAR at %L must be of length one"
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "%L'deki IACHAR'ın argümanı bir uzunlukta olmalı"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "%L'de IBITS'in ikinci ve üçüncü argümanının toplamı bit boyutunu aşıyor"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "%L'de ICHAR'ın argümanı bir uzunlukta olmalı"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Second argument of IBCLR exceeds bit size at %L"
 msgid "Second argument of %s is negative at %L"
 msgstr "%L'de IBCLR'nin ikinci argümanı bit boyutunu aşıyor"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFT exceeds bit size at %L"
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "%L'de ISHFT'in ikinci argümanının genliği bit boyutunu aşıyor"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFTC exceeds third argument at %L"
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "%L'de ISHFTC'nin ikinci argümanının genliği üçüncü argümanı aşıyor"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "%L'de LOG'un argümanı sıfır veya sıfırdan küçük olamaz"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "%L'de DIM'in argümanı sınırların dışında"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "%L'de LOG'un argümanı sıfır veya sıfırdan küçük olamaz"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "%L'de LOG'un karmaşık argümanı sıfır olamaz"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "%L'de LOG10'un argümanı sıfır veya sıfırdan küçük olamaz"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L may not be zero"
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "%L'de NEAREST'ın ikinci argümanı sıfır olmayabilir"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_trans_code(): Hatalı deyim kodu"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "Second argument of NEAREST at %L may not be zero"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "%L'de NEAREST'ın ikinci argümanı sıfır olmayabilir"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Result of SCALE overflows its kind at %L"
 msgid "Result of NEAREST is NaN at %L"
 msgstr "%L'de SCALE sonucu kendi çeşidini üstten taşırıyor"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer too large at %C"
 msgid "Reshaped array too large at %C"
 msgstr "%C'deki tamsayı çok büyük"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "%L'de SCALE sonucu kendi çeşidini üstten taşırıyor"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "`%s' argümanı `%s' yerleşiği için  (%L'de) %d. sırada olmalı"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Sabit ifadesinde tür hatalı"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "%L'de SQRT'nin argümanı negatif değer içeriyor"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid second argument of IBSET at %L"
 msgid "invalid argument of SQRT at %L"
 msgstr "%L'de IBSET'in ikinci argümanı geçersiz"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -97597,81 +97785,81 @@ msgstr "%C'de sonlandıran isim umuluyordu"
 msgid "Labeled DO statement at %L"
 msgstr "%C'deki IMPLICIT deyimi boş"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'"
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "'%s' ismi (%C'deki) '%s'e '%s' modülünden belirsiz bir başvurudur"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "%qs ismi (%C'deki) şu an ki program biriminden %qs'e belirsiz bir başvurudur"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "%qs simgesi (%C'deki) zaten konakla ilişkiliymiş"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de bir EQUIVALENCE nesnesi olarak SEQUENCE özniteliğine sahip olmalı"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected %s statement in CONTAINS section at %C"
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "CONTAINS bölümünde umulmadık %s deyimi (%C'de)"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de bir EQUIVALENCE nesnesi olarak SEQUENCE özniteliğine sahip olmalı"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' requires an argument list at %C"
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "'%s' işlevi %C'de bir argüman listesi gerektiriyor"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de bir EQUIVALENCE nesnesi olarak SEQUENCE özniteliğine sahip olmalı"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Türetilmiş tür değişkeni '%s' %L'de bir EQUIVALENCE nesnesi olarak SEQUENCE özniteliğine sahip olmalı"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -97703,29 +97891,35 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "%C'deki G/C listesinde virgül umuluyordu"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "Bir sabit ifadesine indirgenmeyen '%s' parametresi %L'de ya bildirilmemiş ya da değişken değil"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "yürüyüş sırasında ifade türü hatalı (%d)"
@@ -97844,125 +98038,125 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr "%C'de bir ilklendirme ifadesi umuluyordu"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgid "%s at %L has no default type"
 msgstr "ENTRY %qs %L'de hiç IMPLICIT tür içermiyor"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "bir yordam olmayan yerleşik değişken"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return value of function %qs at %L not set"
 msgstr "FPU yazmaçlarındaki işlevlerin değerleri döner"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "Deferred type parameter not yet supported"
 msgstr "%L'deki gösterici atamasında parametreler farklı çeşit türlerinde"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "modül değişkeni %qs için artyüz bildirimi zaten mevcut"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared %s"
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "gerçekleme değişkeni %qs %s olarak bildirilmiş"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C has already been host associated"
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "%qs simgesi (%C'deki) zaten konakla ilişkiliymiş"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Sözde argüman '%s' (%L'de) INTENT(OUT) olamaz"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 #| msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "INTENT(OUT) sözde argüman '%s' %L'de ASSUMED SIZE olduğundan bir öntanımlı ilklerdiriciye sahip olamaz"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "Unused dummy argument %qs at %L"
 msgstr "%s için argümanlar %L'de çok fazla"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 #| msgid "instance variable %qs is declared %s"
 msgid "Unused variable %qs declared at %L"
 msgstr "gerçekleme değişkeni %qs %s olarak bildirilmiş"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD declared void"
 msgid "Unused parameter %qs declared at %L"
 msgstr "parametre %qD void olarak bildirilmiş"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 #| msgid "Return values of functions in FPU registers"
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "FPU yazmaçlarındaki işlevlerin değerleri döner"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "sorry, unimplemented: "
 msgid "Unsigned not yet implemented"
 msgstr "özür, daha gerçeklenmedi: "
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -97993,13 +98187,13 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "Bilinmeyen yerleşik terim"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "Unknown argument list function at %L"
 msgstr "'%s' işlevinde argüman listesi eksik (%C'de)"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -98016,12 +98210,12 @@ msgstr "Yerleşik işlev %qs (%d) tanınmiyor"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "`dim' argümanı `%s' yerleşiği için  (%L'de) geçerli bir boyut indisi değil"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Complex argument of LOG at %L cannot be zero"
 msgid "The event variable at %L shall not be coindexed"
@@ -98049,202 +98243,202 @@ msgstr "bu hedefte -fprefetch-loop-arrays desteklenmiyor"
 msgid "implicit mapping of assumed size array %qD"
 msgstr "%C'deki tahmini boyutlu dizi için belirtim hatalı"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "optional class parameter"
 msgstr "argüman yok"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "İfade türü umuluyordu"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "ifade umuluyordu"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared here"
 msgid "Used here"
 msgstr "burada bildirilmiş %q+D"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_code(): Hatalı deyim kodu"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "İsim '%s' %C'de işlev ismidir"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "argument to %qs must be a 2-bit unsigned literal"
 msgid "The base name at %L must not be an entry name"
 msgstr "%qs argümanı 2 bitlik işaretsiz bir sabit olmalı"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Iterator step at %L cannot be zero"
 msgid "The base name at %L must not be a generic name"
 msgstr "%L'deki yineleyici adımı sıfır olamaz"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Data transfer element at %L cannot have POINTER components"
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "%L'deki veri aktarım elemanının POINTER bileşenleri olamaz"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Symbol '%s' at %L already has an explicit interface"
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "'%s' simgesi %L'de zaten bir aleni arayüze sahip"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D aliased to undefined symbol %qs"
 msgid "Cannot find symbol %qs at %L"
 msgstr "%q+D tanımsız %qs simgesine rumuzlu"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "'%s' yordamı (%s içinde, %L'de) be işlev ne de altyordam"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D is not a function,"
 msgid "variant %qs at %L is the same as base function"
 msgstr "%q+D bir işlev değil,"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "assert: %s %s ile uyumlu atanıyor"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk in formal argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "%C'deki biçimsel argüman listesinde umulmadık döküntü"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Substring end index at %L must be scalar"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "%L'deki altdizge son indisi bir değişmez olmalıdır"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "%L'de * sözde argümanı olmaksızın diğer return"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Deyim işlevinin '%s' argümanı değişmez olmalı (%L'de)"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Öğesel yordamın '%s' argümanı POINTER özniteliğine sahip olamaz (%L'de)"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "Array specification at %C has more than %d dimensions"
 msgid "%qs at %L is specified more than once"
 msgstr "%C'deki dizi belirtimi %d boyuttan fazlasına sahip"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "Different kind type parameters in pointer assignment at %L"
 msgid "%<need_device_addr%> not yet supported"
@@ -98623,7 +98817,7 @@ msgstr "fclose %s"
 msgid "two or more sections for %s"
 msgstr "%qs bildiriminde iki veya daha fazla veri türü"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -98991,34 +99185,34 @@ msgstr "dizi ilklendirici hatalı"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a constant"
 msgid "requested alignment is not a constant"
 msgstr "istenen hizalama bir sabit değil"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "requested alignment is not a power of 2"
 msgstr "istenen hizalama 2 nin kuvveti değil"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "istenen hizalama çok büyük"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -101949,10 +102143,6 @@ msgstr ""
 #~ msgid "%qs and floating point or vector arguments"
 #~ msgstr "%q+D ya iki argüman alır ya da hiç almaz"
 
-#, fuzzy, gcc-internal-format
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "%2$qE işlevinin %1$d. argümanı için tür uyumsuz"
-
 #, gcc-internal-format
 #~ msgid "selector must be an immediate"
 #~ msgstr "seçici bir anlık değer olmalı"
@@ -102505,6 +102695,11 @@ msgstr ""
 #~ msgid "expected integer expression before ')'"
 #~ msgstr "ifade umuluyordu"
 
+#, fuzzy, gcc-internal-format
+#~| msgid "argument %qd is not a constant"
+#~ msgid "%qD is not a constant"
+#~ msgstr "%qd argümanı bir sabit değil"
+
 #, fuzzy, gcc-internal-format
 #~| msgid "code model %<large%> not supported yet"
 #~ msgid "using parameters for %<linear%> step is not supported yet"
@@ -103441,10 +103636,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "statik olmayan yöntem %q+D statik yönteme zorlanıyor"
 
-#, gcc-internal-format
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D bildirim öncesi kullanılmış"
-
 #, gcc-internal-format
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "%+D içinde: %d de birbiri içine geçmis değişken ve olağandışılık aralıkları"
--- a/src/gcc/po/uk.po
+++ b/src/gcc/po/uk.po
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 14.2.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2024-09-06 12:23+0300\n"
 "Last-Translator: Volodymyr M. Lisivka <vlisivka@gmail.com>\n"
 "Language-Team: Ukrainian <trans-uk@lists.fedoraproject.org>\n"
@@ -1269,12 +1269,12 @@ msgstr "Псевдонім:"
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Відомі версії PTX ISA (для використання з опцією -mptx=):"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "Вказати версію PTX ISA, яку слід використовувати."
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr "Ініціалізувати регістри ptx."
@@ -2095,13 +2095,13 @@ msgstr "Увімкнути типові перетворення між __float1
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "Використовувати заданий захисник стека."
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2552,7 +2552,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Припустити, що цільовий процесор налаштований як big endian."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Припустити, що цільовий процесор налаштований як little endian."
@@ -2628,7 +2628,7 @@ msgstr "Використовуйте менший, але повільніший
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr "Конвертувати адреси BASE + LARGE_OFFSET в NEW_BASE + SMALL_OFFSET, щоб дозволити генерувати більше доступів до памʼяті у вигляді стиснених інструкцій. Наразі цілі спрямовані на 32-бітові завантаження/збереження цілочисельних."
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2667,7 +2667,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr "Увімкнути перевірку CSR для ISA-залежних CSR та тільки для читання CSR. ISA-залежні CSR дійсні лише при встановленій конкретній ISA. Тільки для читання CSR не можуть бути записані інструкціями CSR."
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Пропустити вказівник рамки в листових функціях."
@@ -2777,7 +2777,7 @@ msgstr "-param=vsetvl-strategy=<рядок>\tВстановити рівень 
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2826,7 +2826,7 @@ msgstr "-mrvv-vector-bits=<рядок>\tВстановити тип бітів 
 msgid "The possible TLS dialects:"
 msgstr "Можливі діалекти TLS:"
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5101,7 +5101,7 @@ msgstr "Підтримка вбудованих функцій та генера
 msgid "Enable conservative small loop unrolling."
 msgstr "Увімкнути консервативне розгортання невеликих циклів."
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr "Обмежити, наскільки далеко автовекторизатор може розгорнути цикл."
@@ -5465,7 +5465,7 @@ msgstr "При звʼязуванні для цілей з великим пор
 msgid "Cost to assume for a branch insn."
 msgstr "Вартість, яку слід припустити для інструкції гілки."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr "Використовуйте функції захисту гілок."
@@ -5772,212 +5772,217 @@ msgstr "Обхід для помилки ARM Cortex-A53 з номером 835769
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr "Обхід для помилки ARM Cortex-A53 з номером 843419."
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, no-c-format
 msgid "The register used to access the thread pointer:"
 msgstr "Регістр, який використовується для доступу до вказівника потоку (thread pointer):"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Вказати регістр вказівника потоку (thread pointer)."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr "Не припускати, що незбалансований доступ обробляється системою."
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Вказує розмір бітів негайних зсувів TLS. Допустимі значення: 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "Використовуйте можливості архітектури ARCH."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "Використовуйте можливості та оптимізуйте для процесора."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr "Оптимізувати для процесора."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, no-c-format
 msgid "Generate code that conforms to the specified ABI."
 msgstr "Створюйте код, який відповідає вказаному ABI."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr "-moverride=<рядок>\tТільки для досвідчених користувачів! Перевизначте параметри оптимізації процесора."
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "Відомі AArch64 ABI (для використання з опцією -mabi=):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr "Завантаження літералів відносно PC."
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr "Вибрати область підпису повернення адреси."
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Підтримувана область підпису повернення адреси AArch64 (для використання з опцією -msign-return-address=):"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Увімкнути наближення оберненої квадратного кореня. Увімкнення цієї опції знижує точність результатів оберненого квадратного кореня до приблизно 16 біт для одинарної точності і 32 біт для подвійної точності."
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr "Увімкнути наближення квадратного кореня. Увімкнення цієї опції знижує точність результатів квадратного кореня до приблизно 16 біт для одинарної точності і 32 біт для подвійної точності. Якщо ввімкнено, це означає -mlow-precision-recip-sqrt."
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr "Увімкнути наближення ділення. Увімкнення цієї опції знижує точність результатів ділення до приблизно 16 біт для одинарної точності і до 32 біт для подвійної точності."
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr "Вкажіть, коли увімкнути ранній етап розподілу регістрів. Можливості: всі функції, функції, які мають доступ до інструкцій з кроковим доступом до пам'яті для багатореєстрових операцій, і жодні функції."
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "Можливі довжини векторів SVE:"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr "-msve-vector-bits=<число>\tВстановити кількість бітів у регістрі вектора SVE."
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr "Увімкнути докладне виведення моделі витрат у файлах виведення налагодження."
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr "Генерувати код для відстеження, коли процесор може неправильно спекулювати."
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr "Увімкнути оптимізацію пари операцій завантаження/зберігання AArch64, яка виконується перед розподілом регістрів."
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr "Включити оптимізацію пари операцій завантаження/збереження для архітектури AArch64, яка виконується після розподілу регістрів."
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Використовуйте системний регістр, вказаний у командному рядку, як регістр захисту стека. Ця опція призначена для використання з fstack-protector-strong і не призначена для використання в коді користувача."
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr "Використовуйте негайний зсув від реєстра-охоронця стека, sp_el0. Ця опція призначена для використання з fstack-protector-strong і не призначена для використання в коді користувача."
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, no-c-format
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Генерувати локальні виклики до атомних операцій, що знаходяться поза лінією."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr "При векторизації розглядайте можливість використання декількох різних підходів і використовуйте модель коштів для вибору найдешевшого."
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr "Кількість ітерацій Ньютона для обчислення оберненого значення для типу float. Точність ділення пропорційна цьому параметру, коли ввімкнено наближене ділення. Значення за замовчуванням - 1."
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr "Кількість ітерацій Ньютона для обчислення оберненого значення для типу double. Точність ділення пропорційна цьому параметру, коли ввімкнено наближення ділення. Значення за замовчуванням - 2."
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr "Константний розмір memcpy в байтах, після якого починається використання послідовності MOPS."
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr "Константний розмір memmove в байтах, після якого починається використання послідовності MOPS."
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr "Константний розмір memset в байтах, з якого починається використання послідовності MOPS."
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr "--param=aarch64-ldp-policy=[default|always|never|aligned] Деталізована політика для пар інструкцій завантаження в архітектурі ARM64."
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr "--param=aarch64-stp-policy=[default|always|never|aligned] Деталізована політика для пар інструкцій збереження в архітектурі ARM64."
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr "Обмеження на кількість перевірок псевдонімів, які виконуються при спробі утворити ldp/stp."
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr "Параметр для керування тими можливостями запису, які ми намагаємося обробити на етапі злиття пар завантаження/збереження. Значення нуль вимкне обробку запису. Один означає, що ми намагаємося формувати пари, які включають один або кілька існуючих окремих доступів до запису, де це можливо. Значення два також означає, що ми намагаємося випадково формувати можливості запису шляхом згортання в кінці руйнівних оновлень регістра бази, який використовується парою."
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "This option is deprecated and has no effect."
 msgid "This option is deprecated."
@@ -11424,7 +11429,7 @@ msgstr "Увімкнути векторизацію петлі для плава
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18428,93 +18433,93 @@ msgstr "Відповідати стандарту ISO 2014 C++."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "Відповідати ISO 2020 стандарту C++ (експериментальна та неповна підтримка)."
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a map"
 msgid "argument must be passed by copying"
 msgstr "аргумент 1 повинен бути мапою"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 #| msgid "caller edge count does not match BB count"
 msgid "callee does not return"
 msgstr "кількість ребер викликача не відповідає кількості BB"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "змінна %qD має тип функції"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "очікується функція"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "different number of parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "різна кількість параметрів"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s не підтримує розбиття блоку"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "value argument"
 msgid "variable size arguments"
 msgstr "аргумент-значення"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "passing too large argument on stack"
 msgid "hidden string length argument passed on stack"
 msgstr "передача занадто великого аргументу у стеку"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "static assertion failed"
 msgid "tail call production failed"
@@ -18639,12 +18644,12 @@ msgstr "операнд '%%l' не є міткою"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "неправильне використання плаваючої константи"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -19979,13 +19984,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "це інструкція:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "invalid operand address"
 msgid "unable to reload address in "
 msgstr "недійсна адреса операнда"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "не вдалося згенерувати перезавантаження для:"
 
@@ -20204,7 +20209,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sГеуритика GGC: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<анонімний>"
@@ -20596,20 +20601,20 @@ msgstr "непідтримуваний операнд для коду '%c'"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "недійсний операнд для '%%%c'"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, c-format
 msgid "invalid vector constant"
 msgstr "недійсна векторна константа"
@@ -20654,99 +20659,99 @@ msgstr "неприпустимий префікс операнда '%%%c'"
 msgid "invalid address mode"
 msgstr "неприпустимий режим адреси"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from type %<bfloat16_t%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "недійсне перетворення з типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %<bfloat16_t%>"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "недійсне перетворення до типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "negation operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "plus operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "minus operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "multiply operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "divide operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "shift operation not permitted on svbool_t"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 #| msgid "stack usage computation not supported for this target"
 msgid "subscript operation not supported on svbool_t"
 msgstr "обчислення використання стеку не підтримується для цільової платформи"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 #, fuzzy
 #| msgid "operation not permitted on type %<bfloat16_t%>"
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "операція не дозволена для типу %<bfloat16_t%>"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "не можна комбінувати вектори GNU та SVE в бінарній операції"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -20763,13 +20768,13 @@ msgid "invalid %%r value"
 msgstr "неприпустиме значення %%r"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "неприпустиме значення %%R"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "неприпустиме значення %%N"
@@ -20784,7 +20789,7 @@ msgstr "недійсне значення %%P"
 msgid "invalid %%h value"
 msgstr "недійсне значення %%h"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "недійсне значення %%L"
@@ -20799,7 +20804,7 @@ msgstr "недійсне значення %%m"
 msgid "invalid %%M value"
 msgstr "недійсне значення %%M"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "недійсне значення %%U"
@@ -21138,7 +21143,7 @@ msgstr "непідтримуваний операнд"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21383,127 +21388,127 @@ msgstr "неприпустима константа з плаваючою ком
 msgid "Expected register or constant integer."
 msgstr "Очікувався регістр або константне цілочисельне."
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "неприпустиме UNSPEC як операнд"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, c-format
 msgid "invalid use of register '%s'"
 msgstr "неприпустиме використання регістра '%s'"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "неприпустиме використання виводу прапорця asm"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "неприпустимий розмір операнду для коду операнду 'O'"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "неприпустимий розмір операнду для коду операнду 'z'"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "неприпустимий тип операнду, використаний з кодом операнду '%c'"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "неприпустимий розмір операнду для коду операнду '%c'"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "операнд не є кодом умови, неприпустимий код операнду 'Y'"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "операнд не є кодом умови, неприпустимий код операнду 'D'"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "операнд не є кодом умови, недійсний код операнду '%c'"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "операнд не є памʼяті зі зсувом, недійсний код операнду 'H'"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "операнд не є цілочисельним, недійсний код операнду 'K'"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "операнд не є конкретним цілочисельним, недійсний код операнду 'r'"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "операнд не є цілочисельним, недійсний код операнду 'R'"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "операнд не є конкретним цілочисельним, недійсний код операнду 'R'"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "операнд не є памʼяті зі зсувом, недійсний код операнду 'H'"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "недійсний код операнду '%c'"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "недійсні обмеження для операнду"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, c-format
 msgid "invalid vector immediate"
 msgstr "недійсне векторне негайне значення"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "невідомий режим інструкції"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "недійсне перетворення з типу %<__bf16%> без опції %<-msse2%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "недійсне перетворення з типу %<_Float16%> без опції %<-msse2%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "недійсне перетворення до типу %<__bf16%> без опції %<-msse2%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "недійсне перетворення до типу %<_Float16%> без опції %<-msse2%>"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr "операція не дозволена для типу %<__bf16%> без опції %<-msse2%>"
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr "операція не дозволена для типу %<_Float16%> без опції %<-msse2%>"
 
@@ -21582,9 +21587,9 @@ msgstr "«%%%c» не є дійсним префіксом операнда"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "неприпустиме використання '%%%c'"
@@ -21649,7 +21654,7 @@ msgid "insn contains an invalid address !"
 msgstr "інструкція містить неправильну адресу!"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "неправильна адреса"
 
@@ -21724,7 +21729,7 @@ msgstr "недійсна перевстановлення"
 msgid "invalid %%H value"
 msgstr "недійсне значення %%H"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "недійсне значення %%d"
@@ -21774,34 +21779,34 @@ msgstr "непідтримувана адреса константи:"
 msgid "unsupported memory expression:"
 msgstr "непідтримуваний вираз памʼяті:"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, c-format
 msgid "invalid vector operand"
 msgstr "недійсний операнд вектора"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "недійсний операнд для модифікатора 'b'"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "%<V%> modifier on non-integer register"
 msgid "modifier 'H' is for integer registers only"
 msgstr "Модифікатор %<V%> на нецілому регістрі"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -21861,7 +21866,7 @@ msgstr "Неправильний 128-бітний хід"
 msgid "invalid %%A value"
 msgstr "неправильне значення %%A"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "неправильне значення %%D"
@@ -21901,7 +21906,7 @@ msgstr "неправильний код %%J"
 msgid "invalid %%k value"
 msgstr "неправильне значення %%k"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "неправильне значення %%K"
@@ -21931,17 +21936,17 @@ msgstr "недійсне значення %%T"
 msgid "invalid %%u value"
 msgstr "недійсне значення %%u"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "недійсне значення %%v"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "недійсне значення %%V"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "недійсне значення %%x"
@@ -22151,27 +22156,27 @@ msgstr "недійсний операнд %%s"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "константа з плаваючою точкою не є дійсним негайним операндом"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "операнд 'B' не є константою"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "операнд 'B' має встановлено кілька бітів"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "операнд 'o' не є константою"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, c-format
 msgid "'h' operand is not SImode register"
 msgstr "Операнд 'h' не є регістром типу SImode"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: невідомий код"
@@ -22227,24 +22232,24 @@ msgstr "неприпустима адреса операнда (4)"
 msgid "Unable to load DLL."
 msgstr "Не вдалося завантажити DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "неправильний тест"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "неприпустима маска"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "недійсне значення %%t/%%b"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "немає реєстра в адресі"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "зсув адреси не є константою"
 
@@ -22276,7 +22281,7 @@ msgstr "{помилковий}"
 msgid "aka"
 msgstr "також відомий як"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({анонімний})"
 
@@ -22301,8 +22306,8 @@ msgstr "({анонімний})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "очікувався %<;%>"
@@ -22330,7 +22335,7 @@ msgstr "очікується %<:%> або %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "очікувався %<)%>"
@@ -22338,7 +22343,7 @@ msgstr "очікувався %<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "очікувався %<]%>"
@@ -22358,13 +22363,13 @@ msgstr "очікувався %<;%>, %<,%> або %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "очікувався %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "очікувався %<[%>"
@@ -22373,7 +22378,7 @@ msgstr "очікувався %<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22390,13 +22395,13 @@ msgstr "очікувався %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "очікувався %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "очікувався %<while%>"
@@ -22406,7 +22411,7 @@ msgstr "очікувався %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "очікувався %<,%>"
@@ -22416,18 +22421,18 @@ msgid "expected %<.%>"
 msgstr "очікувався %<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "очікувався %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "очікувався %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "очікувався %<,%> або %<)%>"
@@ -22437,45 +22442,45 @@ msgstr "очікувався %<,%> або %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "очікувалось %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "очікується %<)%> або %<,%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "очікувалось %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "очікувалось %<else%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "очікувалось %<#pragma omp section%> або %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr "<повідомлення невідоме на етапі компіляції>"
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(анонімний)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "очікувалось %<<%>"
@@ -22503,7 +22508,7 @@ msgstr "кандидат є:"
 msgid "  after user-defined conversion:"
 msgstr "  після користувацького перетворення:"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "кандидат є:"
@@ -22604,7 +22609,7 @@ msgstr "<помилка параметра шаблону>"
 msgid "<statement>"
 msgstr "<оператор>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<невідомий>"
@@ -22631,328 +22636,374 @@ msgstr "<лямбда>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<помилка-виразу>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<невідомий оператор>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "У глобальному контексті:"
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "Акумулятор не є сталим цілочисельним"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "expected constant size"
 msgid "reflect_constant failed"
 msgstr "очікуваний сталий розмір"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "Акумулятор не є сталим цілочисельним"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "функція не повертає рядковий тип"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "redeclaration of friend %q#D may not have default template arguments"
 msgid "reflection does not have template arguments"
 msgstr "перевизначення друга %q#D не може мати аргументів шаблону за замовчуванням"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "called object is not a function or function pointer"
 msgid "reflection does not represent a function or function type"
 msgstr "обʼєкт, що був викликаний, не є функцією або вказівником на функцію"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "%<-Werror=%> argument %qs is not valid for %s"
 msgid "operators argument is not a valid operator"
 msgstr "аргумент %qs для %<-Werror=%> не є дійсним для %s"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not name a type"
 msgid "reflection does not have a type"
 msgstr "%qE не є імʼям типу"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return a value to test"
 msgid "reflection does not represent an entity with parent"
 msgstr "функція не повертає значення для перевірки"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "оголошення дружнього елемента не називає клас або функцію"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 #| msgid "called object is not a function or function pointer"
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "обʼєкт, що був викликаний, не є функцією або вказівником на функцію"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 #| msgid "non-constant condition for static assertion"
 msgid "non-constant offset for offset_of"
 msgstr "неконстантна умова для статичного твердження"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "conversion to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "конвертація в неповний тип"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment."
 msgid "reflection not suitable for alignment_of"
 msgstr "Не налаштовувати вирівнювання записуваних даних."
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "assignment of function %qD"
 msgid "alignment_of on function type"
 msgstr "присвоєння функції %qD"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 #| msgid "indirection will not access object of incomplete type %qT in statement"
 msgid "reflection with incomplete type in alignment_of"
 msgstr "розіменування не отримає доступ до обʼєкта неповного типу %qT в операторі"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 #, fuzzy
 #| msgid "function does not return a value to test"
 msgid "reflection does not represent a complete type or type alias"
 msgstr "функція не повертає значення для перевірки"
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "expected function name"
 msgid "reflect_function failed"
 msgstr "мало бути вказано назву функції"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "invalid embedcfg: missing Files"
 msgid "value member missing"
 msgstr "неправильний embedcfg: відсутній Files"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "expected loop number"
 msgid "unexpected value of value member"
 msgstr "очікуваний номер циклу"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "функція не повертає рядковий тип"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "%qD does not have integral or enumeration type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "%qD не має цілочисельного або перелічувального типу"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 #| msgid "iterator step with non-integral type"
 msgid "reflection represents non-integral or bool type"
 msgstr "крок ітератора з не-цілочисельним типом"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "функція не повертає рядковий тип"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qE attribute"
 msgid "invalid argument to can_substitute"
 msgstr "недійсний аргумент атрибуту %qE"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "target is not pointer or reference"
 msgid "type is not object or reference type"
 msgstr "ціль не є вказівником або посиланням"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 #, fuzzy
 #| msgid "conversion from %qT to %qT may change value"
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "перетворення з %qT на %qT може змінити значення"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%<%c%> is not a valid character in an identifier"
 msgid "name is not a valid identifier"
 msgstr "%<%c%> не є допустимим символом в ідентифікаторі"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 #, fuzzy
 #| msgid "variant %qD is a built-in"
 msgid "name is a built-in trait"
 msgstr "варіант %qD є вбудованим"
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "не вказано імʼя регістру для %q+D"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "alignment may not be specified for %qD"
 msgid "both alignment and bit_width specified"
 msgstr "вирівнювання не може бути вказане для %qD"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "специфікатор ширини поля"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "лічильник зсуву вправо є відʼємним"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+#| msgid "alignment specified for type name in cast"
+msgid "name unspecified and type is const"
+msgstr "вказано вирівнювання для імені типу в приведенні типів"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+#| msgid "alignment specified for type name in cast"
+msgid "name unspecified and type is volatile"
+msgstr "вказано вирівнювання для імені типу в приведенні типів"
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a power of 2"
 msgid "alignment is not power of two"
 msgstr "вимагане вирівнювання не є степенем числа 2"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 #| msgid "argument %i value %s is negative"
 msgid "alignment is negative"
 msgstr "аргумент %i має значення %s, яке є відʼємним"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 #| msgid "alignment of %qD is bigger than original declaration"
 msgid "alignment is smaller than alignment_of"
 msgstr "вирівнювання %qD більше, ніж у початковому оголошенні"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "%qE does not have pointer or array type"
+msgid "reflection does not have non-array object type"
+msgstr "%qE не має типу вказівника або масиву"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "%qD does not refer to a function"
+msgid "current scope does not represent a function"
+msgstr "%qD не посилається на функцію"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "оголошення дружнього елемента не називає клас або функцію"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 #| msgid "incomplete implementation of class %qE"
 msgid "incomplete parent class"
 msgstr "неповна реалізація класу %qE"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qE is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qE не є класом або простором імен"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "source is of incomplete class type"
 msgid "not a complete class type"
 msgstr "джерело є неповним типом класу"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "a template cannot be defaulted"
 msgid "value cannot be extracted"
@@ -22998,52 +23049,52 @@ msgstr "перетворення відкидає константність"
 msgid "source type is not polymorphic"
 msgstr "тип джерела не є поліморфним"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "кандидати:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "неправильний тип аргументу для унарного мінуса"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "неправильний тип аргументу для унарного плюса"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "неправильний тип аргументу для бітового доповнення"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "неправильний тип аргументу для abs"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "неправильний тип аргументу для конʼюгації"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "в аргументі для унарного !"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "немає оператора преінкремента для цього типу"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "немає оператора постінкремента для цього типу"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "немає оператора предекремента для цього типу"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "немає оператора постдекремента для цього типу"
 
@@ -23063,73 +23114,73 @@ msgstr " [див. %<-fno-allow-invalid-boz%>]"
 msgid "BOZ constant truncated at %L"
 msgstr "Лінія обрізана на %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "аргументи 'a%d' та 'a%d' для вбудованої функції '%s'"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "аргументи '%s' та '%s' для вбудованої функції %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "аргументи '%s' та '%s' для вбудованої функції '%s'"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "%qD is not a pointer variable"
 msgid "NULL() is not interoperable"
 msgstr "%qD не є змінною-вказівником"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "недійсна константа"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "End expression in DO loop"
 msgid "Expression is polymorphic"
 msgstr "Кінцевий вираз у циклі DO"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 #| msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgid "Expression is a noninteroperable derived type"
 msgstr "%qs в виразі EXTENDS на %C не є похідним типом"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected argument"
 msgid "Procedure unexpected as argument"
 msgstr "неочікуваний аргумент"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 #| msgid "Old-style character length at %C"
 msgid "Type shall have a character length of 1"
 msgstr "Старий стиль довжини символу на %C"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "типи не зовсім сумісні"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 #| msgid "Assumed size array %qs in namelist %qs at %C is not allowed"
 msgid "Assumed-size arrays are not interoperable"
@@ -23207,7 +23258,7 @@ msgstr "Видалена функція:"
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "присвоєння масиву"
 
@@ -23216,17 +23267,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr "Індексна змінна %qs перевизначена в %L у процедурі %qs, викликаній зсередини циклу DO в %L"
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr "Неправильний розмір аргументу B в вбудованій функції MATMUL у розмірності 1: %ld, повинен бути %ld"
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr "Несумісні межі масиву для розмірності 1 масиву (%ld/%ld)"
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr "Несумісні межі масиву для розмірності 2 масиву (%ld/%ld)"
@@ -23404,11 +23455,11 @@ msgstr "блок IF"
 msgid "implied END DO"
 msgstr "неявний END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "присвоєння"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "присвоєння вказівника"
 
@@ -23416,125 +23467,125 @@ msgstr "присвоєння вказівника"
 msgid "simple IF"
 msgstr "простий IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "елементарна процедура"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "аргумент, який може бути виділений"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "асинхронний аргумент"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "необовʼязковий аргумент"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "аргумент-вказівник"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "аргумент-ціль"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "аргумент-значення"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "аргумент-змінний"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "аргумент з припущеною формою"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "аргумент з припущеним рангом"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "аргумент-ко-масив"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "аргумент з параметризованим похідним типом"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "аргумент-поліморф"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "fтрибут NO_ARG_CHECK"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "fргумент з припущеним типом"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "результат-масив"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "dказівник або результат, що можна виділити"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr "результат з незмінною довжиною символів"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "процедура bind(c)"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Змінна циклу"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "змінна ітератора"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Початковий вираз у циклі DO"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "Кінцевий вираз у циклі DO"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Вираз кроку у циклі DO"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "ЗВІЛЬНИТИ обʼєкт"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "ВИДІЛИТИ обʼєкт"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "змінна STAT"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "змінна ERRMSG"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "елемент у READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "змінна ACQUIRED_LOCK"
 
@@ -23543,31 +23594,31 @@ msgstr "змінна ACQUIRED_LOCK"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Різні довжини CHARACTER (%ld/%ld) у конструкторі масиву"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "Переповнення цілочисельного типу при обчисленні обсягу памʼяті для виділення"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr "Значення параметра PDT LEN '%s' не збігається з тим, що в декларації-пустуні"
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Фактична довжина рядка не відповідає оголошеній для фіктивного аргументу '%s' (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Фактична довжина рядка коротша за визначену для фіктивного аргументу '%s' (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "Ціль перенумерування рангу занадто мала (%ld < %ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Присвоєння скаляру невиділеному масиву"
 
@@ -23630,27 +23681,27 @@ msgstr "Аргумент NCOPIES інтринсичної функції REPEAT
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Аргумент NCOPIES інтринсичної функції REPEAT є занадто великим"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "Аргумент FROMPOS (%ld) поза межами діапазону 0:%d в інтринсичній функції MVBITS"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "Аргумент LEN (%ld) поза межами діапазону 0:%d в інтринсичній функції MVBITS"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "Аргумент TOPOS (%ld) поза межами діапазону 0:%d в інтринсичній функції MVBITS"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) в інтринсичній функції MVBITS"
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) в інтринсичній функції MVBITS"
@@ -23747,7 +23798,7 @@ msgid "expected boolean type"
 msgstr "очікувався булевий тип"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "очікувалася цілочисельна величина"
@@ -23810,7 +23861,7 @@ msgstr "недостатньо аргументів"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "забагато аргументів"
@@ -24205,7 +24256,7 @@ msgstr "підтримка профілювання для VxWorks"
 msgid "target OS does not support unaligned accesses"
 msgstr "цільова ОС не підтримує незбалансований доступ"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "профілювання ще не реалізовано для цієї архітектури"
@@ -24450,13 +24501,13 @@ msgstr "Невідома опція: %qs"
 msgid "Global declarative %s for %s"
 msgstr "стара декларація %q#D"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -24625,13 +24676,13 @@ msgstr "%qs застаріло; використовуйте -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs застаріло; використовуйте -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown stack check parameter %qs"
 msgid "unknown autovec preference %qs"
 msgstr "невідомий параметр перевірки стеку %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "невідома політика LDP/STP %qs"
@@ -25077,8 +25128,8 @@ msgstr "атрибут %qE ігнорується, оскільки він ко
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "попереднє оголошення тут"
@@ -25095,7 +25146,7 @@ msgstr "директива атрибуту %qE ігнорується"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "директива атрибуту в області %<%E::%E%> ігнорується"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "вказано неправильну кількість аргументів для атрибуту %qE"
@@ -25105,7 +25156,7 @@ msgstr "вказано неправильну кількість аргумен
 msgid "expected %i or more, found %i"
 msgstr "очікувалося %i або більше, знайдено %i"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "очікувалося %i, знайдено %i"
@@ -25188,12 +25239,12 @@ msgstr "атрибути типу ігноруються після вже ви
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25321,138 +25372,138 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "ребро %s->%s не має відповідного call_stmt"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 #| msgid "no corresponding deallocation function for %qD"
 msgid "corresponding source location"
 msgstr "немає відповідної функції звільнення для %qD"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, fuzzy, gcc-internal-format
 #| msgid "location of the previous reduction for %qE"
 msgid "location of the second call"
 msgstr "розташування попереднього зведення для %qE"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of functions"
 msgid "location is after end of function"
 msgstr "створення масиву функцій"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "Неочікуваний тег."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "не вдається відкрити файл профілю %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr "Магічне число профілю AutoFDO не збігається"
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "Версія профілю AutoFDO %u не відповідає %u"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read string table from %s"
 msgid "cannot read summary information from %s"
 msgstr "не вдалося прочитати таблицю рядків з %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "не вдалося прочитати таблицю рядків з %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "не вдалося прочитати профіль функції з %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read function profile from %s"
 msgid "cannot read module profile from %s"
@@ -25463,7 +25514,7 @@ msgstr "не вдалося прочитати профіль функції з
 msgid "offset %qwi outside bounds of constant string"
 msgstr "зміщення %qwi знаходиться поза межами константного рядка"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qE оголошено тут"
@@ -25566,7 +25617,7 @@ msgstr "не-константний аргумент 0 для %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "неприпустимий аргумент 0 для %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -25641,12 +25692,12 @@ msgstr "останній аргумент %qD не є цілою констан
 msgid "cannot tail-call: %s"
 msgstr "неможливо зробити хвостовий виклик: %s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "виклик функції має агрегатне значення"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "передача занадто великого аргументу у стеку"
@@ -26290,345 +26341,345 @@ msgstr "базові блоки не розташовані послідовно
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "кількість bb-приміток у послідовності команд (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr "неправильна кількість ребер викликувача"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr "відсутній непрямий виклик у послідовності спекулятивних викликів"
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr "непрямий виклик у послідовності спекулятивних викликів не має прапорця спекуляції"
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr "спекулятивні ребра не сусідні"
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr "прямий виклик до %s у послідовності спекулятивних викликів не має прапорця спекуляції"
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr "прямий виклик до %s у послідовності спекулятивних викликів має спекулятивний ідентифікатор %i, що виходить за межі"
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr "подвійний прямий виклик до %s у спекулятивній послідовності викликів з ідентифікатором спекуляції %i"
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr "хеш виклику stmt не вказує на перше пряме ребро спекулятивної послідовності виклику"
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr "подвійне посилання %s у спекулятивній послідовності виклику з ідентифікатором спекуляції %i"
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "відсутній прямий виклик для спекуляції %i"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, gcc-internal-format, gfc-internal-format
 msgid "missing ref for speculation %i"
 msgstr "відсутнє посилання для спекуляції %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr "кількість спекулятивних цілей %i не збігається з num_speculative_call_targets %i"
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "поле aux встановлено для ребра %s->%s"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr "недійсний підрахунок cgraph"
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "клон inline в тому ж списку групи comdat"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "кількість клонів inline несумісна"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "tp_first_run повинен бути не відʼємним"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "локальні символи повинні бути визначені"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "зовнішньо видимий клон inline"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "клон inline з взятою адресою"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "клон у рядку примушено виводиться"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 #| msgid "inline clone is forced to output"
 msgid "inline clone is referenced by assembly"
 msgstr "клон у рядку примушено виводиться"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr "calls_comdat_local встановлено поза групою comdat"
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr "недійсний прапорець calls_comdat_local"
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "атрибут malloc повинен використовуватися для функції, яка повертає вказівник"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr "невідповідність семантичної перехоплення"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "поле aux встановлено для непрямого ребра з %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "кількість ребер несумісна з кількістю функцій"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "edge count is not compatible with function count"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "кількість ребер несумісна з кількістю функцій"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "Непряме ребро з %s не позначено як непряме або має повʼязану індиректну інформацію, відповідне твердження: "
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr "ребро має як call_stmt, так і lto_stmt_uid встановлені"
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr "функція локального comdat, яку викликає %s поза своїм comdat"
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "вказівник inlined_to неправильний"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "декілька викликачів в режимі inline"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "вказівник inlined_to встановлений для не inline викликачів"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "кількість ребер викликача не відповідає кількості BB"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "кількість непрямих викликів не відповідає кількості BB"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr "посилання має встановлені як stmt, так і lto_stmt_uid"
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "вказівник inlined_to встановлений, але не знайдено попередників"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "вказівник inlined_to посилається на себе"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "cgraph_node має неправильний clone_of"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "cgraph_node має неправильний список клонів"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "cgraph_node знаходиться в списку клонів, але це не клон"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "cgraph_node має неправильний вказівник prev_clone"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "подвійний звʼязаний список клонів пошкоджений"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "Alias має ребра виклику"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "Псевдонім має посилання, яке не є псевдонімом"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "Псевдонім має більше одного посилання на псевдонім"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "Аналізований псевдонім не має посилання"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "Відсутнє ребро з тункового вузла"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "Більше одного ребра з тункового вузла"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "У тунку не повинно бути тіла"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "спільний call_stmt:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "ребро вказує на неправильне оголошення:"
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "непряме ребро з невідомим викликаним, що відповідає call_stmt з відомим оголошенням:"
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "відсутнє ребро callgraph для call stmt:"
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "посилання на мертвий оператор"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, fuzzy, gcc-internal-format
 #| msgid "edge has both call_stmt and lto_stmt_uid set"
 msgid "edge has both callback and has_callback set"
 msgstr "ребро має як call_stmt, так і lto_stmt_uid встановлені"
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "ребро %s->%s не має відповідного call_stmt"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "непряме ребро з %s не має відповідного call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr "відсутнє походження для вузла в вкладеному списку"
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "походження вказує на іншого батька"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "перевірка вузла cgraph не вдалася"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "%s: розділ %s.%d відсутній"
@@ -27397,17 +27448,17 @@ msgstr "загальний розмір локальних обʼєктів пе
 msgid "impossible constraint in %<asm%>"
 msgstr "неможлива обмеження в %<asm%>"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "змінна %q+D може бути знищена %<longjmp%> або %<vfork%>"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "аргумент %q+D може бути знищений %<longjmp%> або %<vfork%>"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "функція повертає агрегат"
@@ -28076,7 +28127,7 @@ msgstr "%qD вказана межа %E дорівнює довжині джер
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "гнучкий елемент масиву %qD не має чітко визначених бітів заповнення для %qs"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr "обробка бітових полів PDP11 не підтримується в %qs"
@@ -28116,7 +28167,7 @@ msgstr "%qD має більше ніж %u блоків, максимум, яки
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr "%qD визначено тут"
@@ -28136,24 +28187,24 @@ msgstr "дереференція нульового вказівника"
 msgid "function may return address of local variable"
 msgstr "функція може повертати адресу локальної змінної"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "функція повертає адресу локальної змінної"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -29056,7 +29107,7 @@ msgstr "очікується від %E до %E байтів у регіоні р
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr "%qD викликано на вказівнику %qE з ненульовим зміщенням%s"
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, gcc-internal-format
 msgid "returned from %qD"
 msgstr "повернено з %qD"
@@ -29126,206 +29177,206 @@ msgstr "у виклику функції виділення памʼяті %qD,
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "невідомий специфікатор архітектури в моделі памʼяті %wi для %qD"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "недійсна модель памʼяті %qs для %qD"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "недійсна модель памʼяті %wi для %qD"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "valid models are %s"
 msgid "valid models are %e"
 msgstr "дійсні моделі: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "недійсна модель памʼяті з помилкою %qs для %qD"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "дійсні моделі з помилкою: %qs, %qs, %qs, %qs"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "модель памʼяті невдачі %qs не може бути сильнішою, ніж модель памʼяті успіху %qs для %qD"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "модель памʼяті невдачі %wi не може бути сильнішою, ніж модель памʼяті успіху %wi для %qD"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "звʼязаний аргумент %i має значення %s, яке є відʼємним для аргументу %i змінної довжини масиву типу %s"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "аргумент %i має значення %s, яке є відʼємним"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr "аргумент %i є нульовим, але відповідне значення аргументу розміру %i є %s"
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "посилання на аргумент %u типу %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "у виклику функції %qD, оголошеної з атрибутом %qs"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "у виклику з типом %qT та атрибутом %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "у виклику функції %qD"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "у виклику з типом %qT"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr "%qD викликано на невиділеному обʼєкті %qD"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr "%qD викликано на вказівнику до невиділеного обʼєкту %qE"
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, gcc-internal-format
 msgid "assigned here"
 msgstr "присвоєно тут"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD викликано на вказівнику, поверненому з неправильної функції виділення"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr "%qD викликано на вказівнику до невиділеного обʼєкту"
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "вказівник %qE може бути використаний після %qD"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "вказівник %qE використовується після %qD"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr "вказівник може бути використаний після %qD"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, gcc-internal-format
 msgid "pointer used after %qD"
 msgstr "вказівник використовується після %qD"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, gcc-internal-format
 msgid "call to %qD here"
 msgstr "виклик %qD тут"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr "можливе використання висячого вказівника %qE до %qD"
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, gcc-internal-format
 msgid "using dangling pointer %qE to %qD"
 msgstr "використання висячого вказівника %qE до %qD"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr "можливе використання висячого вказівника до %qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, gcc-internal-format
 msgid "using a dangling pointer to %qD"
 msgstr "використання висячого вказівника до %qD"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD оголошено тут"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr "можливе використання висячого вказівника %qE до безіменного тимчасового"
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr "використання висячого вказівника %qE до безіменного тимчасового"
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr "можливе використання висячого вказівника до безіменного тимчасового"
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "використання висячого вказівника до безіменного тимчасового"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "неназваний тимчасовий визначений тут"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "%qD викликано на вказівнику %qE, переданому до невідповідної функції виділення %qD"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "%qD викликано на вказівнику, переданому до невідповідної функції перерозподілу %qD"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, gcc-internal-format
 msgid "call to %qD"
 msgstr "виклик %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, gcc-internal-format
 msgid "storing the address of local variable %qD in %qE"
 msgstr "збереження адреси локальної змінної %qD в %qE"
@@ -30149,265 +30200,265 @@ msgstr "токен %u має %<y-location == %u%>"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "недійсне використання атрибуту %<fallthrough%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "віртуальна таблиця типу %qD порушує правило однозначного визначення"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr "змінна з таким самим імʼям асемблера, як віртуальна таблиця, визначена в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr "віртуальна таблиця типу %qD містить інформацію про RTTI"
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr "але переважається однією без RTTI-інформації з іншої одиниці перекладу"
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "RTTI не буде працювати для цього типу"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr "конфліктуючий тип, визначений в іншому модулі перекладу, має віртуальну таблицю іншого розміру"
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr "конфліктуючий тип, визначений в іншому модулі перекладу, має іншу інформацію про RTTI"
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr "конфліктуючий тип, визначений в іншому модулі перекладу"
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "містить додатковий віртуальний метод %qD"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr "конфліктуючий тип, визначений в іншому модулі перекладу, має віртуальну таблицю з більшою кількістю записів"
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "віртуальний метод %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr "повинен відповідати віртуальному методу %qD, але не відповідає"
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr "конфліктуючий тип, визначений в іншому перекладовому блоку, має віртуальну таблицю з різним вмістом"
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "тип %qT (псевдонім для %qT) порушує правило єдиної визначеності в C++"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "тип %qT порушує правило єдиної визначеності в C++"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "в іншому перекладовому блоку визначений інший тип"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr "перша різниця відповідних визначень - поле %qD"
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr "перша різниця відповідних визначень - метод %qD"
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr "тип %qT, визначений в анонімному просторі імен, не може відповідати типу %qT за межами одиниці перекладу"
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr "тип %qT, визначений в анонімному просторі імен, не може відповідати за межами одиниці перекладу"
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "несумісний тип, визначений в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "імʼя типу %qs повинно відповідати імені типу %qs"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "несумісний тип визначений тут"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "типи масивів мають різні межі"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "несумісність типу значення, що повертається"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr "несумісні типи неявного вказівника this"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "несумісні типи в параметрі %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "типи мають різну кількість параметрів"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "тип %qT сам по собі порушує правило однозначного визначення C++"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "тип %qT повинен відповідати типу %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr "тип з різною точністю визначений в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 #| msgid "a type with different number of fields is defined in another translation unit"
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "у іншому перекладному блоку визначено тип з різною кількістю полів"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr "тип з різним знаком визначений в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr "він визначений як вказівник в іншому просторі адрес в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr "він визначений як вказівник на інший тип в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr "масив різного розміру визначений в іншому перекладовому блоку"
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "має різне значення повернення в іншому перекладовому блоку"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "має різні параметри в іншому перекладовому блоку"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr "тип, визначений в іншому перекладовому блоку, не є поліморфним"
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr "тип, визначений в іншому перекладовому блоку, є поліморфним"
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr "тип з різними вказівниками на віртуальну таблицю визначений в іншому перекладовому блоку"
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr "тип з різними базами визначений в іншому перекладовому блоку"
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "у іншому перекладному блоку визначено поле з іншою назвою"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr "у іншому перекладному блоку визначено поле з такою самою назвою, але з іншим типом"
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "у іншому перекладному блоку поля мають різний макет"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr "одне поле є бітовим полем, а інше - ні"
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr "у іншому перекладному блоку визначено тип з різною кількістю полів"
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr "у іншому перекладному блоку визначено тип з різним розміром"
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr "один тип потребує конструювання, а інший - ні"
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "несумісність розташування в памʼяті"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "додаткова база визначена тут"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
@@ -30415,7 +30466,7 @@ msgstr[0] "Оголошення типу %qD як final дозволить де
 msgstr[1] "Оголошення типу %qD як final дозволить девіртуалізацію %i викликів"
 msgstr[2] "Оголошення типу %qD як final дозволить девіртуалізацію %i викликів"
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
@@ -30423,7 +30474,7 @@ msgstr[0] "Оголошення типу %qD як final дозволить де
 msgstr[1] "Оголошення типу %qD як final дозволить девіртуалізацію %i викликів, виконаних %lli разів"
 msgstr[2] "Оголошення типу %qD як final дозволить девіртуалізацію %i викликів, виконаних %lli разів"
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
@@ -30431,7 +30482,7 @@ msgstr[0] "Оголошення віртуального деструктора
 msgstr[1] "Оголошення віртуального деструктора %qD як final дозволить девіртуалізацію %i викликів"
 msgstr[2] "Оголошення віртуального деструктора %qD як final дозволить девіртуалізацію %i викликів"
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
@@ -30439,7 +30490,7 @@ msgstr[0] "Оголошення методу %qD як final дозволить 
 msgstr[1] "Оголошення методу %qD як final дозволить девіртуалізацію %i викликів"
 msgstr[2] "Оголошення методу %qD як final дозволить девіртуалізацію %i викликів"
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
@@ -30447,7 +30498,7 @@ msgstr[0] "Оголошення віртуального деструктора
 msgstr[1] "Оголошення віртуального деструктора %qD як final дозволить девіртуалізацію %i викликів, виконаних %lli разів"
 msgstr[2] "Оголошення віртуального деструктора %qD як final дозволить девіртуалізацію %i викликів, виконаних %lli разів"
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
@@ -30455,47 +30506,47 @@ msgstr[0] "Оголошення методу %qD як final дозволить 
 msgstr[1] "Оголошення методу %qD як final дозволить девіртуалізацію %i викликів, виконаних %lli разів"
 msgstr[2] "Оголошення методу %qD як final дозволить девіртуалізацію %i викликів, виконаних %lli разів"
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "тип %qs порушує правило однозначного визначення C++"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "перелічування з різною кількістю значень визначено в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr "перелічування з різними іменами значень визначено в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr "перелічування з різними значеннями визначено в іншій одиниці перекладу"
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "імʼя %qs відрізняється від імені %qs, визначеного в іншому перекладному блоку"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "імʼя %qs визначено як %u-біт, тоді як інший перекладний блок визначає його як %u-біт"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "імʼя %qs визначено як %wd, тоді як інший перекладний блок визначає його як %wd"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "імʼя %qs визначено з іншим значенням в іншому перекладному блоку"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr "неспівпадаюче визначення"
@@ -30515,7 +30566,7 @@ msgstr "відсутня підсумкова інлайн-інформація
 msgid "IPA modref summary is missing in input file"
 msgstr "відсутня підсумкова інформація IPA modref во вхідному файлі"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "недійсна функція переходу в потоці LTO"
@@ -30752,12 +30803,12 @@ msgstr "досягнуто максимальну кількість прохо
 msgid "unable to find a register to spill"
 msgstr "не вдалося знайти регістр для вивільнення"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "неспівпадають обмеження операндів у %<asm%>"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "досягнуто максимальну кількість згенерованих перезавантажень інструкцій на одну інструкцію (%d)"
@@ -31128,7 +31179,7 @@ msgstr "замикання %qs з модифікатором %<sink%> очіку
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "замикання %qs з модифікатором %<sink%> посилається на ітерацію, яка ніколи не знаходиться в просторі ітерацій"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr "недійсний не-прямокутний крок циклу OpenMP; %<(%E - %E) * %E%> не є кратним кроку %d циклу %qE"
@@ -32529,22 +32580,22 @@ msgstr "регістри, які явно використовуються, по
 msgid "output operand %d must use %<&%> constraint"
 msgstr "вихідний операнд %d повинен використовувати обмеження %<&%>"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "%qs: [%u] неправильний %<next_regno%> для порожнього ланцюга (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "%qs: цикл в ланцюгу %<next_regno%> (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "%qs: [%u] неправильний %<oldest_regno%> (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr "%qs: [%u] непорожній регістр у ланцюгу (%s %u %i)"
@@ -33495,167 +33546,167 @@ msgstr "зовнішня транзакція в функції %<transaction_sa
 msgid "ignoring loop annotation"
 msgstr "ігнорування анотації циклу"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "константа не перелічовується, коли змінюється %<ADDR_EXPR%>"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "побічні ефекти не перелічовуються, коли змінюється %<ADDR_EXPR%>"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "адреса взята, але біт %<TREE_ADDRESSABLE%> не встановлено"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "не скалярний %qs"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "недійсний операнд позиції або розміру для %qs"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr "точність цілочисельного типу результату не відповідає розміру поля %qs"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "розмір режиму не-цілочисельного результату не відповідає розміру поля %qs"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "%qs не-цілочисельного операнда з точністю режиму"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "позиція плюс розмір перевищує розмір посиланого обʼєкта в %qs"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "несумісні типи в посиланні %qs"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "перетворення %qs на лівій стороні %qs"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "перетворення регістра на інший розмір у %qs"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr "не верхнього рівня %qs"
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, gcc-internal-format
 msgid "invalid operands to %qs"
 msgstr "недійсні операнди для %qs"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "несумісні типи в %qs"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "недійсний оператор зсуву %qs"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "недійсний операнд адреси в %qs"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "недійсний операнд зсуву в %qs"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, gcc-internal-format
 msgid "invalid clique in %qs"
 msgstr "недійсний клік в %qs"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, gcc-internal-format
 msgid "%qs in gimple IL"
 msgstr "%qs в GIMPLE-IL"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr "%qs як база, де потрібна нерегістрова змінна"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "недійсний вираз для мінімального lvalue"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "виклик gimple має дві цілі"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "виклик gimple не має цілі"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "недійсна функція в виклику gimple"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "не функція в виклику gimple"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "недійсний стан чистої константи для функції"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "недійсний LHS у виклику gimple"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr "LHS у виклику %<noreturn%>"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "недійсне перетворення у виклику gimple"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "недійсний статичний ланцюжок у виклику gimple"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "статичний ланцюжок з функцією, яка не використовує його"
@@ -33666,603 +33717,603 @@ msgstr "статичний ланцюжок з функцією, яка не в
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "виклик %<__builtin_unreachable%> або %<__builtin_trap%> з аргументами"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr "виклики %<DEFERRED_INIT%> повинні мати однаковий постійний розмір для першого аргументу та LHS"
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "недійсний аргумент у виклику gimple"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "недійсні операнди у порівнянні gimple"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "неспівпадаючі типи операндів порівняння"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "непідтримувана операція або тип для порівняння векторів, що повертають булеве значення"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "невекторні операнди в порівнянні векторів"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "недійсний тип результату порівняння векторів"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "недійсний тип результату порівняння"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "невірний регістр як LHS унарної операції"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "недійсний операнд унарної операції"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "недійсні типи векторів у конвертації nop"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "недійсні типи у конвертації nop"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "недійсні типи у конвертації адресного простору"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "недійсні типи у конвертації фіксованої точки"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "недійсні типи у конвертації до плаваючої точки"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "недійсні типи у конвертації до цілого числа"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "несумісні типи в виразі %qs"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "недійсні типи для %qs"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr "%qs повинен бути від скаляра до подібного вектора"
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types for %qs"
 msgid "invalid type for %qs"
 msgstr "недійсні типи для %qs"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "нетривіальне перетворення в унарній операції"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "некоректний регістр як LHS бінарної операції"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "недійсні операнди в бінарній операції"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "недійсні не-векторні операнди для %qs"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, gcc-internal-format
 msgid "invalid (pointer) operands %qs"
 msgstr "недійсні (вказівникові) операнди %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "очікується векторний тип в %qs"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "несумісні типи в бінарному виразі"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "некоректний регістр як LHS тернарної операції"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "недійсні операнди в тернарній операції"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr "перший аргумент %qs повинен бути булевим векторним типом з такою ж кількістю елементів, як результат"
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "очікується векторний тип у %qs"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "знайдено вектори з різною кількістю елементів у %qs"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "недійсний тип маски у %qs"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, gcc-internal-format
 msgid "not allowed type combination in %qs"
 msgstr "не допускається комбінація типів у %qs"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "недійсна позиція або розмір у %qs"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "%qs в неправильний операнд з точністю режиму"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, gcc-internal-format
 msgid "insertion out of range in %qs"
 msgstr "вставка поза діапазоном у %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%qs не на границі елемента"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "нетривіальне перетворення у %qs"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cpu %qs for %s%qs%s"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "недійсний процесор %qs для %s%qs%s"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "%qs LHS в операторі clobber"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "%qs на лівій стороні оператора присвоєння"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, gcc-internal-format
 msgid "invalid operand in %qs"
 msgstr "недійсний операнд в %qs"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "недійсний розмір аргументу %qs у завантаженні"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "недійсна права сторона для зберігання памʼяті gimple: %qs"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 #| msgid "non-register as LHS of ternary operation"
 msgid "non-register as LHS with vector constructor"
 msgstr "некоректний регістр як LHS тернарної операції"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "неправильний тип елементів вектора %qs"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "неправильна кількість елементів вектора %qs"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr "неправильний тип елементів конструктора вектора"
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr "вектор %qs з ненульовим індексом елемента"
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "елемент вектора %qs не є значенням GIMPLE"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "не вектор %qs з елементами"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "непараметр %qs не може бути пакетом параметрів"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "недійсний операнд в операторі повернення"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "недійсне перетворення в операторі повернення"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "призначення для оператора goto не є міткою або вказівником"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "недійсний операнд для оператора switch"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "оператор switch з не-цілочисельним типом"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "неприпустима мітка default в операторі switch"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "неприпустимий %<CASE_CHAIN%>"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "неприпустима мітка case в операторі switch"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "неприпустимий діапазон case в операторі switch"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "несумісність точності типу в операторі switch"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "несумісність типу для мітки case в операторі switch"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "мітки case не впорядковані в операторі switch"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "контекст мітки не є поточною декларацією функції"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "неправильний запис у %<label_to_block_map%>"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "неправильне встановлення номера блоку відлову"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "недійсний код порівняння в gimple cond"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "недійсні мітки в gimple cond"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "недійсний результат %<PHI%>"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "відсутнє визначення %<PHI%>"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "недійсний аргумент %<PHI%>"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "несумісні типи в аргументі %<PHI%> %u"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "%<verify_gimple%> не вдалося"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "мертва інструкція в таблиці EH"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr "посилання на блок розташоване не в дереві блоків"
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "локальне оголошення з іншої функції"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) встановлено для неправильного базового блоку"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr "PHI-вузол з місцезнаходженням"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "неправильне спільне використання вузлів дерева"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "віртуальний PHI з місцезнаходженням аргументів"
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) встановлено для неправильного базового блоку"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "інструкція позначена для генерації винятку, але цього не робить"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "інструкція позначена для генерації винятку в середині блоку"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "перевірка gimple не вдалася"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK має повʼязаний з ним IL"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK має повʼязаний з ним IL"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "перехід до виходу з блоку бази %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, gcc-internal-format
 msgid "entry block count not initialized"
 msgstr "кількість вхідних блоків не ініціалізована"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, gcc-internal-format
 msgid "exit block count not initialized"
 msgstr "кількість вихідних блоків не ініціалізована"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr "Ймовірно не ініціалізоване ребро з блоку входу"
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "edge count is not compatible with function count"
 msgid "exit block count is not compatible with entry block count"
 msgstr "кількість ребер несумісна з кількістю функцій"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr "кількість bb %d не ініціалізована"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr "ймовірність ребра %d->%d не ініціалізована"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "edge count is not compatible with function count"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "кількість ребер несумісна з кількістю функцій"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr "нелокальна мітка %qD не є першою в послідовності міток в блоку бази %d"
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr "мітка «EH landing pad» %qD не є першою в послідовності міток в блоку бази %d"
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "мітка %qD до блоку не відповідає в блоку бази %d"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "мітка %qD має неправильний контекст в блоку бази %d"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "контроль потоку посередині базового блоку %d"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, gcc-internal-format
 msgid "label %qD in the middle of basic block %d"
 msgstr "мітка %qD посередині базового блоку %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr "виклик returns_twice не є останнім в основному блоку %d"
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr "виклик returns_twice не є першим в основному блоку %d"
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "ребро fallthru після оператора керування в блоку бази %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "істинне/хибне ребро після не-GIMPLE_COND в bb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "неправильні прапори вихідної грані в кінці bb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "явний перехід на кінець bb %d"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "ребро повернення не вказує на вихід в bb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "знайдено стандартний випадок не на початку вектора випадків"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "мітки випадків не впорядковані: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "додаткове вихідне ребро %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "відсутнє ребро %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "функція %<noreturn%> повертає значення"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "керування досягає кінця функції, яка не є void"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "ігнорується значення повернення %qD, оголошене з атрибутом %<warn_unused_result%>"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "ігнорується значення, повернене функцією, оголошеною з атрибутом %<warn_unused_result%>"
@@ -34444,12 +34495,12 @@ msgstr "ціль не підтримує атомне оновлення про
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr "ціль не підтримує атомне оновлення профілю, вибрано одиночний режим"
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "неприпустимий атрибут специфікації fn «%s»"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "неприпустимий атрибут специфікації fn «%s» аргумент %i"
@@ -34974,7 +35025,7 @@ msgstr "векторна умова буде розширена поштовха
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "операція перемішування вектора буде розширена поштовхами"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr "векторизація не відбулася для циклу simd"
@@ -35395,31 +35446,31 @@ msgstr "%<TYPE_CACHED_VALUES_P%> встановлено, хоча цього н
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr "%<TYPE_METHOD_BASETYPE%> не є основним варіантом"
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "відсутній атрибут %<target%> для багатоверсійного %qD"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "попереднє оголошення %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D конфліктує з попереднім оголошенням"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "%q#D conflicts with version inherited from %qT"
 msgid "%qD conflicts for version %qB"
 msgstr "%q#D конфліктує з версією, успадкованою від %qT"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -35500,7 +35551,7 @@ msgstr "Дозволені лише нульові ініціалізатори
 msgid "no initializers are allowed in section %qs"
 msgstr "Дозволені лише нульові ініціалізатори в розділі %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "не вказано імʼя регістру для %q+D"
@@ -35648,7 +35699,7 @@ msgstr "символ %qs %q+D нарешті спрямовується на с
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "символ %qs %q+D повинен мати статичний звʼязок"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "визначення псевдонімів не підтримуються в цій конфігурації"
@@ -35693,53 +35744,53 @@ msgstr "упакований макет"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, gcc-internal-format
 msgid "%qE attribute argument is invalid"
 msgstr "аргумент атрибуту %qE недійсний"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, gcc-internal-format
 msgid "%qE attribute argument %i is invalid"
 msgstr "аргумент атрибуту %qE позиції %i недійсний"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "Аргумент атрибуту %qE має тип %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, gcc-internal-format
 msgid "%qE attribute argument %i has type %qT"
 msgstr "Аргумент атрибуту %qE на позиції %i має тип %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "Значення аргументу атрибуту %qE %qE не є цілочисельною константою"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "Значення аргументу атрибуту %qE на позиції %i %qE не є цілочисельною константою"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "Значення аргументу атрибуту %qE %qE не посилається на параметр функції"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "Аргумент атрибуту %qE на позиції %i зі значенням %qE не посилається на параметр функції"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "Значення аргументу атрибуту %qE %qE перевищує кількість параметрів функції %u"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr "аргумент атрибуту %qE на позиції %i має значення %qE, що перевищує кількість параметрів функції %u"
@@ -35754,12 +35805,12 @@ msgstr "Значення аргументу атрибуту %qE %qE не пос
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr "Значення аргументу атрибуту %qE %i %qE не посилається на список змінних аргументів"
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "Значення аргументу атрибуту %qE %qE посилається на тип параметра %qT"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "Значення аргументу атрибуту %qE %i %qE посилається на тип параметра %qT"
@@ -35966,12 +36017,12 @@ msgstr "не можна використовувати режим %qs для п
 msgid "mode %qs applied to inappropriate type"
 msgstr "режим %qs застосовується до неприпустимого типу"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "атрибути розділу не підтримуються для цільової платформи"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "атрибут розділу не дозволяється для %q+D"
@@ -35981,18 +36032,18 @@ msgstr "атрибут розділу не дозволяється для %q+D"
 msgid "section attribute argument not a string constant"
 msgstr "аргумент атрибуту розділу не є рядковою константою"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "атрибут розділу не може бути вказаний для локальних змінних"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "розділ %q+D конфліктує з попередньою декларацією"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "розділ %q+D не може бути перевизначений"
@@ -36086,7 +36137,7 @@ msgstr "Аргумент %qE не є ідентифікатором"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "атрибут %<readonly%> властивості %qD конфліктує з попереднім оголошенням"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "Вбудована функція %q+D оголошена як слабка"
@@ -36132,12 +36183,12 @@ msgstr "ігнорується атрибут %qE, встановлений дл
 msgid "%qE attribute is only applicable on functions"
 msgstr "атрибут %qE застосовується тільки до функцій"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, gcc-internal-format
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "атрибут %<symver%> застосовується тільки до функцій та змінних"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "атрибут %<symver%> застосовується тільки до символів"
@@ -36147,12 +36198,12 @@ msgstr "атрибут %<symver%> застосовується тільки до
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "аргумент атрибуту %<symver%> не є рядковою константою"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr "аргумент атрибуту «symver» повинен мати формат %<name@nodename%>"
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr "Аргумент атрибуту %<symver%> %qs повинен містити один або два %<@%>"
@@ -36243,23 +36294,23 @@ msgstr "атрибут %qE ігнорується, оскільки %qT вже 
 msgid "visibility argument not a string"
 msgstr "аргумент видимості не є рядком"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "атрибут %qE ігнорується для типів"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "аргумент атрибуту %qE повинен бути одним з %qs, %qs, %qs або %qs"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD перевизначено з іншою видимістю"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD було оголошено %qs, що передбачає видимість за замовчуванням"
@@ -36276,7 +36327,7 @@ msgstr "аргумент %qE повинен бути одним з %qs, %qs, %qs
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "атрибут %qE застосовується лише до функцій"
@@ -36347,7 +36398,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "аргумент 1 атрибуту %qE повинен бути типом вказівника як перший аргумент; має тип %qT"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, gcc-internal-format
 msgid "%qE attribute ignored on a function returning %qT"
 msgstr "атрибут %qE ігнорується на функції, що повертає %qT"
@@ -36423,7 +36474,7 @@ msgstr "%qD несумісний з %qD"
 msgid "%qE argument is not a function"
 msgstr "Аргумент %qE не є функцією"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "Застаріле повідомлення не є рядком"
@@ -36490,7 +36541,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "атрибут %qE ігнорується для типів"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "Атрибут %qE вимагає рядковий аргумент"
@@ -36652,15 +36703,15 @@ msgid "requested position is less than zero"
 msgstr "запитана позиція менше нуля"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "порожній рядок в атрибуті %<target%>"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "аргумент атрибуту %qE не є рядковою константою"
@@ -36928,7 +36979,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "рекомендується використовувати дужки навколо присвоєння, що використовується як значення істинності"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "недійсне використання %<restrict%>"
@@ -37107,8 +37158,8 @@ msgstr "недостатньо змінних аргументів для вст
 msgid "missing sentinel in function call"
 msgstr "відсутній маркер у виклику функції"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "неправильна опція %qs для атрибуту %<optimize%>"
@@ -38124,7 +38175,7 @@ msgstr "непідтримуване нестандартне зʼєднання
 msgid "traditional C rejects string constant concatenation"
 msgstr "традиційне C відкидає зʼєднання констант рядків"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr "%<#pragma omp critical%> з %<hint%> замиканням потребує імені, за винятком випадку, коли використовується %<omp_sync_hint_none%>"
@@ -38179,7 +38230,7 @@ msgstr "тип залежності %<depobj%> вказаний в замика
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "Модифікатор %<iterator%> не може бути вказаний на конструкції %<depobj%>"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "Недійсний тип для змінної ітерації %qE"
@@ -38194,17 +38245,17 @@ msgstr "Змінна ітерації %qE має тип %<_Atomic%>"
 msgid "%qE is not initialized"
 msgstr "%qE не ініціалізовано"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "Відсутній контрольний предикат"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "Недійсний контрольний предикат"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "Відсутній вираз інкремента"
@@ -38214,7 +38265,7 @@ msgstr "Відсутній вираз інкремента"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr "Інкремент не є константою 1 або -1 для умови %<!=%>"
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "Недійсний вираз інкремента"
@@ -38310,18 +38361,18 @@ msgstr "недійсний модифікатор зведення %<task%> на
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr "%<inscan%> %<reduction%> замикання на конструкції, відмінній від %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr "%qD вказано в замиканні %<allocate%>, але не в явному замиканні приватизації"
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD не є аргументом функції"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "бітове поле %qE в замиканні %qs"
@@ -38331,8 +38382,8 @@ msgstr "бітове поле %qE в замиканні %qs"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE не має відображального типу в замиканні %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%> %qE в замиканні %qs"
@@ -38852,7 +38903,7 @@ msgstr "неправильне розташування для %<pragma %s%>, і
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "неправильно сформований %<#pragma %s%>, ігнорується"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "сміття в кінці %<#pragma %s%>"
@@ -38925,8 +38976,8 @@ msgstr "%<#pragma%> не дозволено тут"
 msgid "wrong type argument to %s"
 msgstr "неправильний тип аргументу для %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -39412,17 +39463,17 @@ msgstr "декремент функції %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "функція %qD використовується як %<asm%>вихідне значення"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "присвоєння незмінного місця %qE"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "інкремент незмінного місця %qE"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "декремент незмінного місця %qE"
@@ -39689,7 +39740,7 @@ msgstr[0] "передача аргументу %i в параметр з ква
 msgstr[1] "передача аргументу %i в параметр з кваліфікатором %qs, що є псевдонімом для аргументів %Z"
 msgstr[2] "передача аргументу %i в параметр з кваліфікатором %qs, що є псевдонімом для аргументів %Z"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr "ця умова має ідентичні гілки"
@@ -40640,7 +40691,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "Функція ACLE %qD вимагає розширення ISA %qs"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "Ви можете увімкнути %qs, використовуючи параметр командного рядка %<-march%>, або за допомогою атрибуту або pragma %<target%>"
@@ -41292,7 +41343,7 @@ msgstr "передача %qT в аргумент %d для %qE, але його
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "подвійне визначення %qs"
@@ -41338,7 +41389,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "тип SVE %qT не має визначеного вирівнювання"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "змінні типу %qT не можуть мати тривалості зберігання, специфічної для потоку"
@@ -41390,7 +41441,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%<this%> не дозволено в замиканні %<allocate%>"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -41486,19 +41537,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "Тип SVE %qT не може бути переданий у функцію без прототипу"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr "передача параметра для аргументу типу %qT змінена в GCC 13.1"
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr "передача параметрів для аргументу типу %qT змінилася в GCC 14.1"
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -41544,213 +41595,213 @@ msgstr "виклик функції, яка ділиться станом, кр
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr "використовуйте %<__arm_preserves(\"za\")%>, якщо функція, яку викликають, зберігає ZA."
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr "невідомий прапор переданий в %<-moverride=%s%> (%s)"
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, gcc-internal-format
 msgid "%qs string ill-formed"
 msgstr "рядок %qs неправильно сформований"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "неправильний формат для %<sve_width%>"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, gcc-internal-format
 msgid "invalid %<sve_width%> value: %d"
 msgstr "неправильне значення для %<sve_width%>: %d"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "відсутній настроювальний рядок у параметрі (%s)"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "невідомий параметр настроювання (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr "несумісні параметри %<-mstack-protector-guard=global%> та %<-mstack-protector-guard-offset=%s%>"
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr "обидва параметри %<-mstack-protector-guard-offset%> та %<-mstack-protector-guard-reg%> повинні використовуватися з %<-mstack-protector-guard=sysreg%>"
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr "вказати системний регістр з короткою довжиною рядка"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs не є дійсним зсувом в %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr "%<-fsanitize=shadow-call-stack%> потребує %<-ffixed-x18%>"
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, fuzzy, gcc-internal-format
 #| msgid "%<-fsanitize=shadow-call-stack%> not supported in current platform"
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "%<-fsanitize=shadow-call-stack%> не підтримується на поточній платформі"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, fuzzy, gcc-internal-format
 #| msgid "functions with SME state require the ISA extension %qs"
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "функції з станом SME вимагають розширення ISA %qs"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "потокові функції вимагають розширення ISA %qs"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "функції з станом SME вимагають розширення ISA %qs"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr "підтримуються лише значення 12 (4 КБ) та 16 (64 КБ) для розміру захисного поля. Задане значення %d (%llu КБ) виходить за межі допустимого діапазону"
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr "розмір захисного поля виявлення конфлікту стеку %d повинен бути рівним інтервалу перевірки %d"
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "некоректний аргумент, заданий для %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr "%qs має бути сам по собі для %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument %<%s%> for %<-mharden-sls=%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "недійсний аргумент %<%s%> для %<-mharden-sls=%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %<%s%> being added"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "перемикач %<-mcpu=%s%> конфліктує з перемикачем %<-march=%s%> і призвело до додавання опцій %<%s%>"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, gcc-internal-format
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "асемблер не підтримує %<-mabi=ilp32%>"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "builtin %qF is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "вбудована функція %qF застаріла"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr "підписування адреси повернення підтримується лише для %<-mabi=lp64%>"
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr "модель коду %qs з %<-f%s%>"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "модель коду %qs не підтримується в режимі ilp32"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "функції з станом %qs вимагають розширення ISA %qs"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr "відсутнє імʼя в прагмі або атрибуті %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "недійсне імʼя %qs в прагмі або атрибуті %<target(\"arch=\")%>"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "недійсний модифікатор функції %s зі значенням %qs в директиві або атрибуті %<target()%>"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "відсутнє імʼя в директиві або атрибуті %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "недійсне імʼя %qs в директиві або атрибуті %<target(\"cpu=\")%>"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "недійсний модифікатор функції %qs зі значенням %qs в директиві або атрибуті %<target()%>"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "неприпустиме імʼя %qs в директиві або атрибуті %<target(\"tune=\")%>"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "відсутнє значення в директиві або атрибуті %<target()%>"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "некоректна директива або атрибут %<target()%>"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "директива або атрибут %<target(\"%s\")%> не приймає аргумент"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "директива або атрибут %<target(\"%s\")%> не дозволяє використовувати заперечну форму"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "директива або атрибут %<target(\"%s=%s\")%> недійсний"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -41758,201 +41809,201 @@ msgstr "директива або атрибут %<target(\"%s=%s\")%> неді
 msgid "attribute %<target%> argument not a string"
 msgstr "аргумент атрибуту %<target%> не є рядком"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, fuzzy, gcc-internal-format
 #| msgid "arch extension %<%s%> should be prefixed by %<+%>"
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr "розширення arch %<%s%> повинно передуватися %<+%>"
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "прагма або атрибут %<target(\"%s\")%> недійсний"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "некоректна прагма або атрибут %<target(\"%s\")%>"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "атрибут %<target_version%> має кілька значень"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "аргумент атрибуту %<target_version%> не є рядком"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "відсутнє значення в атрибуті %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "недійсний модифікатор функції %qs з значенням %qs в атрибуті %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "дублікат модифікатора функції %qs з значенням %qs в атрибуті %<target_version%>"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "мультіверсіонування віртуальних функцій не підтримується"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "мультиверсіонування потребує %<ifunc%>, який не підтримується на цій цілі"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%qD було раніше оголошено тут"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr "передача параметра для аргументу типу %qT з %<[[no_unique_address]]%> членами змінилася %{у GCC 10.1%}"
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr "передача параметра для аргументу типу %qT при увімкненні C++17 змінилася, щоб відповідати C++14 %{у GCC 10.1%}"
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr "передача параметра для аргументу типу %qT змінилася %{у GCC 12.1%}"
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "доріжка %wd поза межами %wd - %wd"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "непідтримувана simdlen %wd"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "GCC наразі не підтримує тип повернення %qT для simd"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "непідтримуваний тип повернення %qT для simd"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "GCC наразі не підтримує тип аргументу %qT для simd"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "непідтримуваний тип аргументу %qT для simd"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, gcc-internal-format
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "GCC наразі не підтримує simdlen %wd для типу %qT"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "GCC наразі не підтримує simdclone з simdlens %wd і %wd для цих типів."
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "неможливо застосувати атрибут %qs до %q+D після того, як функція була визначена"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "%q+D визначено тут"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr "нелокальні переходи в функціях з станом SME"
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr "перехоплення невикликових винятків у функціях з станом SME"
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "аргумент %d функції %qE повинен бути цілочисельним константним виразом"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "передача %wd до аргументу %d функції %qE, яка очікує значення %wd"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "передача %wd аргументу %d %qE, який очікує значення в діапазоні [%wd, %wd]"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "передача %wd в аргумент %d %qE, який очікує або %wd або %wd"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "передача %wd в аргумент %d %qE, який очікує %wd, %wd, %wd або %wd"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "передача %wd в аргумент %d %qE, який очікує дійсне значення %qT"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 #| msgid "an empty string cannot be in %<target_clones%> attribute"
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "порожній рядок не може бути в атрибуті %<target_clones%>"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 #| msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "недійсний модифікатор функції %qs з значенням %qs в атрибуті %<target_version%>"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 #, fuzzy
 #| msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "дублікат модифікатора функції %qs з значенням %qs в атрибуті %<target_version%>"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 #| msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
@@ -42142,12 +42193,12 @@ msgstr "аргумент атрибуту %qE не є «ilink» або «firq»"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -42280,22 +42331,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "аргумент атрибута %qE проігноровано"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "атрибут %qE застосовується лише до змінних"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "альтернативи не дозволені в виводі прапорця %<asm%>"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "невідомий вивід прапорця %<asm%> %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "недійсний тип для виводу прапорця %<asm%>"
@@ -42840,12 +42891,12 @@ msgstr "%<-fpie%> не підтримується"
 msgid "%<-fPIE%> is not supported"
 msgstr "%<-fPIE%> не підтримується"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "атрибути функції %qs та %qs взаємовиключні"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "функція %qs не може мати аргументів"
@@ -42855,7 +42906,7 @@ msgstr "функція %qs не може мати аргументів"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "функція %qs не може повертати значення"
@@ -43186,7 +43237,7 @@ msgstr "непрямий виклик у функції, який не підт
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "недійсний аргумент вбудованої функції"
@@ -43504,7 +43555,7 @@ msgstr "використовується %<vector_length (64)%>, ігнорує
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr "використовується %<vector_length (64)%>, ігнорується налаштування виконання"
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr "використовується %<num_workers (%d)%>, ігнорується %d"
@@ -43671,171 +43722,171 @@ msgstr "параметр для вбудованої функції повине
 msgid "parameter to builtin not valid: %s"
 msgstr "параметр для вбудованої функції недійсний: %s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "процедуру обслуговування переривань не можна викликати безпосередньо"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "останній аргумент повинен бути 2-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "пʼятий аргумент повинен бути 8-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "третій аргумент повинен бути 8-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "останній аргумент повинен бути 1-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "останній аргумент повинен бути 3-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "останній аргумент повинен бути 4-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "останній аргумент повинен бути 1-бітним негайним"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE потребує опцію isa %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "останній аргумент повинен бути 5-бітним негайним"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "передостанній аргумент повинен бути 8-бітним негайним"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "останній аргумент повинен бути 8-бітним негайним"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "третій аргумент повинен бути константою порівняння"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "неправильний режим порівняння"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "неправильний операнд округлення"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "негайний аргумент повинен бути 4-бітним негайним"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "негайний аргумент повинен бути 5-бітним негайним"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "негайний аргумент повинен бути 8-бітним негайним"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "четвертий аргумент повинен бути одним з елементів перелічування %qs"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, gcc-internal-format
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "селектор повинен бути цілочисельною константою в діапазоні [0, %wi]"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE потребує невідому опцію isa"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE потребує опцію isa %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "другий, третій і четвертий аргументи повинні бути константами"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "недійсний другий аргумент для %<__builtin_prefetch%>; використовується нуль"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, gcc-internal-format
 msgid "invalid third argument"
 msgstr "недійсний третій аргумент"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr "інструкція prefetch застосовується в режимі 64-бітного режиму з відносним адресуванням RIP та опцією %<-mprefetchi%>; в іншому випадку вони залишаються NOP"
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "недійсний третій аргумент для %<__builtin_ia32_prefetch%>; використовується нуль"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, gcc-internal-format
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "недійсний третій аргумент для %<__builtin_ia32_prefetch%>; використовується нуль"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "другий аргумент повинен бути константою"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "останній аргумент повинен бути 32-бітним негайним значенням"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "останній аргумент повинен бути негайним значенням"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "останній аргумент повинен мати масштаб 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "аргумент вбудованої функції %<xabort%> повинен бути 8-бітним негайним значенням"
@@ -44231,8 +44282,8 @@ msgstr "%qs не є дійсним базовим регістром в %<-mstac
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr "%<-fcf-protection=full%> не увімкнено через %<-fhardened%>, оскільки було вказано на командному рядку"
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%<-fcf-protection%> несумісний з цільовою платформою"
@@ -44475,7 +44526,7 @@ msgstr "ABI передачі структури з елементом %<complex
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "ABI передачі C-структур з біт-полями нульової ширини змінився в GCC %{12.1%}"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr "Повернення регістру SSE з вимкненим SSE2"
@@ -44500,12 +44551,12 @@ msgstr "Аргумент регістра SSE з вимкненим SSE"
 msgid "x87 register return with x87 disabled"
 msgstr "Повернення регістра x87 з вимкненим x87"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "Виклик %qD з конвенцією виклику SSE без увімкненого SSE/SSE2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr "це помилка GCC, яку можна обійти, додавши атрибут used до викликаної функції"
@@ -44515,131 +44566,131 @@ msgstr "це помилка GCC, яку можна обійти, додавши
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "ABI для передачі параметрів з вирівнюванням %d байт змінився в GCC 4.6"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, gcc-internal-format
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "%<-mcall-ms2sysv-xlogues%> несумісний з %s"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "Атрибут %<ms_hook_prologue%> несумісний з %<-mfentry%> для 32-бітного режиму"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr "Динамічне переорієнтування вказівника аргументу (DRAP) не підтримується в обробці переривань. Це можна обійти, уникнувши функцій з агрегатним поверненням."
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "Переорієнтування стеку не підтримується з %<__builtin_eh_return%>"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "Вкладена функція regparm не підтримується з %<__builtin_eh_return%>"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "%<-fsplit-stack%> не підтримує fastcall з вкладеною функцією"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "%<-fsplit-stack%> не підтримує 2 регістрових параметри для вкладеної функції"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "%<-fsplit-stack%> не підтримує 3 регістрових параметри"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren%'t allowed in a function with the %<no_caller_saved_registers%> attribute"
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "інструкції %s не дозволені в функції з атрибутом %<no_caller_saved_registers%>"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren%'t allowed in an exception service routine"
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr "інструкції %s не дозволені в обробнику винятків"
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "%s instructions aren%'t allowed in an interrupt service routine"
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "інструкції %s не дозволені в обробнику переривань"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr "Модифікатор %<V%> на нецілому регістрі"
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr "Непідтримуваний розмір для цілого регістру"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "Розширені регістри не мають високих половин"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "непідтримуваний розмір операнда для розширеного регістру"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "неціле значення операнда використовується з кодом операнда %<z%>"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr "зміни ABI передачі параметрів порожнього класу %qT в %<-fabi-version=12%> (GCC 8)"
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "вирівнювання полів %<_Atomic %T%> змінилося в %{GCC 11.1%}"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "Немає доступного регістру для профілювання %<-mcmodel=large%s%>"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "профілювання %<-mcmodel=large%> з PIC не підтримується"
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr "З версії GCC 13.1 тип %<__bfloat16%> перевизначено з typedef %<short%> на реальний %<__bf16%>, будьте обережні з неявним перетворенням між %<__bf16%> та %<short%>; можливо, тут потрібне явне перетворення бітів"
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "невідома архітектура конкретної моделі памʼяті"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr "%<HLE_ACQUIRE%> не використовується з %<ACQUIRE%> або більш сильною моделлю памʼяті"
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr "%<HLE_RELEASE%> не використовується з %<RELEASE%> або більш сильною моделлю памʼяті"
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "%<-fexcess-precision=16%> несумісний з %<-mfpmath=387%>"
@@ -44690,7 +44741,7 @@ msgstr "%<gp_offset%> (%ld) або %<end_offset%> (%ld) менше нуля"
 msgid "argument %qd is not a constant"
 msgstr "аргумент %qd не є константою"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
 msgstr "%<PRINT_OPERAND_ADDRESS%>, нульовий вказівник"
@@ -44700,7 +44751,7 @@ msgstr "%<PRINT_OPERAND_ADDRESS%>, нульовий вказівник"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "%<PRINT_OPERAND%>: Невідомий розділовий знак %<%c%>"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, gcc-internal-format
 msgid "%<PRINT_OPERAND%> null pointer"
 msgstr "%<PRINT_OPERAND%> нульовий вказівник"
@@ -44855,52 +44906,52 @@ msgstr "прагма або атрибут %<target(\"%s\")%> недійсний
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "аргумент %qs атрибуту %<target%> невідомий"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, fuzzy, gcc-internal-format
 #| msgid "%<order%> clause must not be used together with %<ordered%>"
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "замикання %<order%> не повинен використовуватися разом з %<ordered%>"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "clones for %<target_clones%> attribute cannot be created"
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "не вдається створити клони для атрибуту %<target_clones%>"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 #| msgid "%qs property cannot be set"
 msgid "in attribute %qs priority cannot be empty"
 msgstr "властивість %qs не може бути встановлена"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 #| msgid "value %qs is not supported by attribute %<target%>"
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "значення %qs не підтримується атрибутом %<target%>"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not supported on this target"
 msgid "%qs is not supported in target attribute"
@@ -45654,7 +45705,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr "Вбудовані функції MSP430 працюють лише всередині обробників переривань"
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "неправильний вбудований код"
@@ -45877,82 +45928,82 @@ msgstr "не вдається відкрити проміжний файл ptx"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "опція %s не підтримується разом з %<-fopenacc%>"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr "версія PTX (%<-mptx%>) повинна бути не менше %s для підтримки вибраного %<-misa%> (sm_%s)"
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "Параметр %<-march=%> повинен бути вказаний"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "не генерується область патча, nops не підтримується"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr "статична ініціалізація змінної %q+D в памʼяті %<.shared%> не підтримується"
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr "неможливо створити незбалансовані вказівники в ptx-збірці"
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr "PTX не підтримує слабкі оголошення (тільки слабкі визначення)"
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "атрибут %qE вимагає тип повернення void"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "атрибут %qE не дозволяється з автоматичним класом зберігання"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "значення барʼєру повинно бути в межах [0,15]"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "аргумент complement повинен бути константою"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr "використання %<vector_length (%d)%> через виклик векторно-подільної процедури, ігнорування %d"
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr "використання %<vector_length (%d)%>, ігнорування налаштування часу виконання"
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr "використання %<vector_length (%d)%>, ігнорування %d"
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr "змінна %qD змінена для рівня приватизації OpenACC: %qs"
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "слабкі визначення псевдонімів не підтримуються в цій конфігурації"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "визначення псевдонімів, що не є функціями, не підтримуються в цій конфігурації"
@@ -46199,333 +46250,333 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr "неспівпадіння кількості аргументів для вбудованої функції %qF. Очікувалось: %d отримано %d"
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr "Передача значення %wd в аргумент %d функції %qE, яка очікує значення в діапазоні [%wd, %wd] або %wd"
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "тип RVV %qT не має фіксованого розміру"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "тип RVV %qT не має визначеного вирівнювання"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, gcc-internal-format
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "арифметика з вказівником на тип RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr "члени змінні не можуть мати тип RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "поля не можуть мати тип RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "елементи масиву не можуть мати тип RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, gcc-internal-format
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "не вдається виділити обʼєкти з типом RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "не вдається видалити обʼєкти з типом RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, gcc-internal-format
 msgid "cannot throw or catch RVV type %qT"
 msgstr "не вдається кинути або перехопити тип RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "захоплення копією типу RVV %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> not allowed in %<allocate%> clause"
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%<this%> не дозволено в замиканні %<allocate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> not allowed in %<allocate%> clause"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "%<this%> не дозволено в замиканні %<allocate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> not allowed in %<allocate%> clause"
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%<this%> не дозволено в замиканні %<allocate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> not allowed in %<allocate%> clause"
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "%<this%> не дозволено в замиканні %<allocate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "Вбудована функція %qE вимагає розширення ISA звфгмін або звфг"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "Вбудована функція %qE вимагає розширення ISA звфгмін або звфг"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "Вбудована функція %qE вимагає розширення ISA зве32ф, зве64ф, зве64д або v"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "Вбудована функція %qE вимагає розширення ISA зве64д або v"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "Вбудована функція %qE вимагає розширення ISA зве64х, зве64ф, зве64д або v"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized gcc debugging option: %c"
 msgid "unrecognized RVV builtin"
 msgstr "невизнана опція відлагодження gcc: %c"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "вбудована функція %qE вимагає розширення %qs ISA"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "немає відповідного виклику функції до %qE з порожніми аргументами"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "невідомий процесор %qs для %<-mtune%>"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "ця операція вимагає розширення RVV ISA"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr "ви можете увімкнути RVV, використовуючи параметр командного рядка %<-march%>, або за допомогою атрибуту або прагми %<target%>"
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "ABI для структури зі згладженими полями нульової довжини змінився в GCC 10"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, fuzzy, gcc-internal-format
 #| msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "ABI для структури зі згладженими полями нульової довжини змінився в GCC 10"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, gcc-internal-format
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "Тип RVV %qT не може бути переданий у функцію без прототипу"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "%s %qT вимагає розширення V ISA"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT вимагає розширення zve64x, zve64f, zve64d або v ISA"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "%s %qT вимагає розширення zvfhmin або zvfh ISA"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "%s %qT вимагає розширення zve32f, zve64f, zve64d або v ISA"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "%s %qT вимагає розширення zve64d або v ISA"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr "%s %qT вимагає мінімальної довжини вектора %qd, але задано %qd"
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "атрибут функції %qs вимагає розширення V ISA"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "function attribute %qs requires the V ISA extension"
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "атрибут функції %qs вимагає розширення V ISA"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, fuzzy, gcc-internal-format
 #| msgid "function attribute %qs requires the V ISA extension"
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "атрибут функції %qs вимагає розширення V ISA"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 #| msgid "argument to %qE attribute is not %<\"user\"%>, %<\"supervisor\"%>, or %<\"machine\"%>"
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "аргумент атрибуту %qE не є %<\"user\"%>, %<\"supervisor\"%> або %<\"machine\"%>"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr "%qs працює лише коли вказано %<-mrvv-vector-bits=zvl%>"
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qs застосовано до не-RVV типу %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "%qs вимагає цілочисельної константи"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr "Неправильний розмір вектора RVV %qd, очікуваний розмір %qd на основі LMUL типу і %qs"
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr "%<-mdiv%> вимагає %<-march%>, щоб підкоритися розширенню %<M%>"
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, fuzzy, gcc-internal-format
 #| msgid "this operation requires the SVE ISA extension"
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "ця операція вимагає розширення SVE ISA"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr "Поточний RISC-V GCC не підтримує VLEN понад 4096 біт для розширення 'V'"
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "Поточний RISC-V GCC не підтримує RVV у режимі великого кінця"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "модель коду %qs з %qs"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr "запитана ABI вимагає %<-march%>, щоб підкоритися розширенню %qc"
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr "rv32e вимагає ABI ilp32e"
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr "rv64e вимагає lp64e ABI"
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 не підтримує складні типи"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr "z*inx вимагає ABI ilp32, ilp32e, lp64 або lp64e"
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "ABI вимагає %<-march=rv%d%>"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "%<-mpreferred-stack-boundary=%d%> повинно бути між %d і %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr "Атрибут RISC-V ELF %<-mriscv-attribute%> вимагає GNU as 2.32 [%<-mriscv-attribute%>]"
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs не є дійсним базовим регістром в %qs"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs не є дійсним числом в %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "Функція %qs не може мати різний тип переривання"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr "не вдається виділити регістр vl для %qs на цій цілі"
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "bad value %qs for %<target(\"tune=\")%> attribute"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -47528,22 +47579,22 @@ msgstr "локальні вимоги до памʼяті змінних пер
 msgid "%<function_profiler%> support"
 msgstr "підтримка %<function_profiler%>"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, gcc-internal-format
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "не можна використовувати %<va_start%> у функції переривання"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "оператор switch з %lu елементами занадто великий"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "атрибут %<__BELOW100__%> застосовується тільки до змінних"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "атрибут %<__BELOW100__%> не дозволяється зі зберіганням auto"
@@ -47763,33 +47814,33 @@ msgstr "%qs завантажено, але символ %qs не знайден
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%qs визначено, але підтримка плагінів вимкнена"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "булеві регістри потрібні для опції з плаваючою комою"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, gcc-internal-format
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "%<-f%s%> не підтримується з інструкціями CONST16"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "PIC потрібно, але не підтримується з інструкціями CONST16"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "Тільки неініціалізовані змінні можуть бути розміщені в розділі %<.bss%>"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, fuzzy, gcc-internal-format
 #| msgid "constant literal %qs contains %qc, expected %qs"
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr "константний літерал %qs містить %qc, очікується %qs"
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -47875,7 +47926,7 @@ msgstr "атрибут %qs потребує прототипів з іменов
 msgid "%qs attribute only applies to variadic functions"
 msgstr "атрибут %qs застосовується тільки до функцій зі змінною кількістю аргументів"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -47967,8 +48018,8 @@ msgstr "%qs не є директорією"
 msgid "could not get size of source file"
 msgstr "не вдалося записати до файлу відповіді %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "значення void не ігнорується так, як повинно бути"
@@ -48450,7 +48501,7 @@ msgstr "перехід у switch до виразу заяви"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE визначено як неправильний тип тегу"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "атрибут %qE застосовується до %qD з типом повернення void"
@@ -48600,7 +48651,7 @@ msgstr "ISO C90 не підтримує %<static%> або кваліфікато
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 не підтримує декларатори масиву %<[*]%>"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, gcc-internal-format
 msgid "%<omp::%s%> not allowed to be specified in this context"
 msgstr "%<omp::%s%> не дозволяється вказувати в цьому контексті"
@@ -48610,7 +48661,7 @@ msgstr "%<omp::%s%> не дозволяється вказувати в цьом
 msgid "%q+D is usually a function"
 msgstr "%q+D зазвичай є функцією"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "немає попередньої декларації для %qD"
@@ -48687,7 +48738,7 @@ msgstr "не можна помістити обʼєкт з волатильни
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "незініціалізований %<const %D%> недійсний у C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr "%q+D у директиві «declare target» не має відображального типу"
@@ -48890,7 +48941,7 @@ msgstr "вказано клас зберігання для параметра %
 msgid "storage class specified for unnamed parameter"
 msgstr "вказано клас зберігання для безіменного параметра"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "вказано клас зберігання для typename"
@@ -49064,7 +49115,7 @@ msgstr "імʼя типу оголошено як функцію, що пове
 msgid "function definition has qualified void return type"
 msgstr "визначення функції має кваліфікований тип повернення void"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "кваліфікатори типу ігноруються для типу повернення функції"
@@ -49191,7 +49242,7 @@ msgstr "ISO C забороняє типи функцій const або volatile"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "елемент структури або обʼєднання не може мати змінюваний тип"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "змінна або поле %qE оголошено як void"
@@ -49404,7 +49455,7 @@ msgstr "визначення типу в виразі %qs недійсне в C+
 msgid "%qT defined in underspecified object initializer"
 msgstr "%qT визначено в недостатньому ініціалізаторі обʼєкта"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "оголошення нічого не оголошує"
@@ -49470,7 +49521,7 @@ msgstr "структура не має іменованих членів"
 msgid "struct has no members"
 msgstr "структура не має членів"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -49538,7 +49589,7 @@ msgstr "перевизначення %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr "%<enum%> оголошено з, але визначено без фіксованого базового типу"
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr "вказаний режим занадто малий для перелічованих значень"
@@ -49594,7 +49645,7 @@ msgstr "значення перелічування поза діапазоно
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "Мова ISO C обмежує значення перерахувань діапазоном %<int%> до стандарту C23"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "вбудованій функції %qD надано атрибут %qs"
@@ -49746,12 +49797,12 @@ msgstr "аргумент %qD не відповідає вбудованому п
 msgid "argument %qD doesn%'t match prototype"
 msgstr "аргумент %qD не відповідає прототипу"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "в функції, що повертає не void, відсутня інструкція return"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "параметр %qD встановлено, але не використовується"
@@ -49833,7 +49884,7 @@ msgstr "%<auto%> використовується з %<constexpr%>"
 msgid "two or more data types in declaration specifiers"
 msgstr "два або більше типи даних в специфікаторах оголошення"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> занадто довгий для GCC"
@@ -49943,7 +49994,7 @@ msgstr "ISO C90 не підтримує булеві типи"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "Мова ISO C не підтримує тип %<_Float%d%s%> до стандарту C23"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<_Float%d%s%> не підтримується для цільової платформи"
@@ -50100,12 +50151,12 @@ msgstr "Аргумент %<signed _BitInt%> має бути щонайменше
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "Мова ISO C не підтримує %<%s_BitInt(%d)%> до стандарту C23"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr "%<#pragma omp declare reduction%> комбінатор посилається на змінну %qD, яка не є %<omp_out%> або %<omp_in%>"
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr "%<#pragma omp declare reduction%> ініціалізатор посилається на змінну %qD, яка не є %<omp_priv%> або %<omp_orig%>"
@@ -50173,37 +50224,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs не підтримується з %qs"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "зсув вліво відʼємного значення"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "лічильник зсуву вліво є відʼємним"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "лічильник зсуву вправо є відʼємним"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "лічильник зсуву вліво >= ширини типу"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "лічильник зсуву вправо >= ширини типу"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "лічильник зсуву вліво >= ширини елемента вектора"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "лічильник зсуву вправо >= ширини елемента вектора"
@@ -50223,7 +50274,7 @@ msgstr "маркер конфлікту контролю версій у фай
 msgid "to match this %qs"
 msgstr "щоб відповідати цьому %qs"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "очікуваний кінець рядка"
@@ -50233,7 +50284,7 @@ msgstr "очікуваний кінець рядка"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C забороняє порожній переклад"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -50281,8 +50332,8 @@ msgid "unknown type name %qE"
 msgstr "невідоме імʼя типу: %qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "очікувані специфікатори декларації"
@@ -50317,7 +50368,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "очікується %<;%>, ідентифікатор або %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "префіксні атрибути ігноруються для методів"
@@ -50332,12 +50383,12 @@ msgstr "префіксні атрибути ігноруються для реа
 msgid "unexpected attribute"
 msgstr "неочікуваний атрибут"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "атрибут %<fallthrough%> не слідує за %<;%>"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr "атрибут %<assume%> не слідує за %<;%>"
@@ -50380,7 +50431,7 @@ msgstr "%qs вимагає ініціалізовану декларацію д
 msgid "%qs may only be used with a single declarator"
 msgstr "%qs може використовуватися лише з одним декларатором"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "очікується %<,%> або %<;%>"
@@ -50417,7 +50468,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "функцію %<__RTL%> не можна компілювати з %<-flto%>"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "очікується літерал рядка"
@@ -50447,7 +50498,7 @@ msgstr "вираз в статичному твердженні не є стал
 msgid "static assertion failed: %E"
 msgstr "статична перевірка не вдалася: %E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "статична перевірка не вдалася"
@@ -50502,8 +50553,8 @@ msgstr "не можна використовувати режим %qs для п
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "очікуваний ідентифікатор"
@@ -50533,12 +50584,12 @@ msgstr "недійсний базовий тип для %<enum%>"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "базовий тип для %<enum%> несумісний з попереднім оголошенням"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "кома в кінці списку перелічування"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -50621,22 +50672,22 @@ msgstr "очікується специфікатор декларації аб
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr "дужки повинні бути пропущені, якщо список аргументів атрибуту порожній"
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "очікується імʼя директиви OpenMP"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "очікується %<directive%> або %<sequence%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "атрибут %<omp::%E%> вимагає аргумент"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "атрибут %qE не приймає жодних аргументів"
@@ -50646,7 +50697,7 @@ msgstr "атрибут %qE не приймає жодних аргументів
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C не підтримує атрибути %<[[]]%> перед C23"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, gcc-internal-format
 msgid "variable-sized object may not be initialized except with an empty initializer"
 msgstr "обʼєкт змінної розмірності може бути ініціалізований лише з порожнім ініціалізатором"
@@ -50676,17 +50727,17 @@ msgstr "ISO C90 забороняє вказувати підобʼєкт для
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "застаріле використання призначеного ініціалізатора без %<=%>"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr "внутрішні цикли повинні бути ідеально вкладені в %<#pragma acc loop%>"
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "внутрішні цикли повинні бути ідеально вкладені з клаузою %<ordered%>"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr "внутрішні цикли повинні бути ідеально вкладені з клаузою %<reduction%> %<inscan%>"
@@ -50697,44 +50748,44 @@ msgstr "внутрішні цикли повинні бути ідеально 
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr "внутрішні цикли повинні бути ідеально вкладені в %<#pragma acc loop%>"
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr "змішування директив OpenMP з атрибутами та синтаксисом pragma в одному операторі"
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr "Атрибут OpenMP %<omp::decl%> для оператора"
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "невідома назва директиви OpenMP у аргументі атрибуту %qs"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr "Конструкція OpenMP серед атрибутів %<omp::directive%> вимагає, щоб всі атрибути %<omp::directive%> на одному операторі були в одній %<omp::sequence%>"
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr "Декілька самостійних директив OpenMP серед атрибутів %<omp::directive%> повинні бути всі в одній %<omp::sequence%>"
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr "Самостійні директиви OpenMP в атрибуті %<omp::directive%> можуть зʼявлятися тільки на порожньому операторі"
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr "Змішування директив OpenMP з атрибутом та синтаксисом pragma в одному оголошенні"
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute does not take any arguments"
 msgid "%qs attribute does not take any arguments"
@@ -50766,7 +50817,7 @@ msgstr "ISO C90 забороняє змішані оголошення та ко
 msgid "expected %<}%> before %<else%>"
 msgstr "очікується %<}%> перед %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> без попереднього %<if%>"
@@ -50781,7 +50832,7 @@ msgstr "мітка в кінці складеної інструкції"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "очікується інструкція"
@@ -50818,27 +50869,27 @@ msgstr "Мова ISO C не підтримує десяткові дробові
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "список виразів розглядається як складений вираз в ініціалізаторі"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "очікується декларація"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "рекомендується використовувати фігурні дужки навколо порожнього тіла в операторі %<if%>"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "рекомендується використовувати фігурні дужки навколо порожнього тіла в операторі %<else%>"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "рекомендується використовувати явні фігурні дужки, щоб уникнути неоднозначності %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr "Цикл не дозволений у проміжному коді тіла циклу OpenMP"
@@ -50858,12 +50909,12 @@ msgstr "декілька змінних ітерації в швидкому п
 msgid "invalid iterating variable in fast enumeration"
 msgstr "недійсна змінна ітерації в швидкому перелічуванні"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr "відсутня умова циклу в циклі з прагмою %<GCC ivdep%>"
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr "відсутня умова циклу в циклі з прагмою %<GCC unroll%>"
@@ -50878,8 +50929,8 @@ msgstr "відсутня колекція в швидкому перелічув
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "подвійний %<asm%> кваліфікатор %qE"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr "перший раз побачено тут"
@@ -50901,12 +50952,12 @@ msgstr "ISO C забороняє опускати середній термін
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr "ділення %<sizeof (%T) / sizeof (%T)%> не обчислює кількість елементів масиву"
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "перший операнд %<sizeof%> був оголошений тут"
@@ -51089,7 +51140,7 @@ msgstr "ISO C90 не підтримує попередньо визначени
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "очікується вираз"
@@ -51104,13 +51155,13 @@ msgstr "група в фігурних дужках в межах виразу 
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C забороняє групи з фігурними дужками в межах виразів"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "другий параметр %<va_start%> не є останнім іменованим аргументом"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -51258,7 +51309,7 @@ msgstr "обидва аргументи для %<__builtin___clear_cache%> по
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "аргумент align для %<__builtin_coro_promise%> має бути константою"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "неправильна кількість аргументів для %<__builtin_shuffle%>"
@@ -51300,7 +51351,7 @@ msgstr "аргумент 1 у виклику функції %qs має знак
 msgid "rotate count is negative"
 msgstr "лічильник зсуву вправо є відʼємним"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr "%<omp_all_memory%> може використовуватися тільки в замиканні OpenMP %<depend%>"
@@ -51410,7 +51461,7 @@ msgstr "використання функції обчислення абсол
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr "функція модуля %qD отримала аргумент типу %qT, але має параметр типу %qT, що може призвести до обрізання значення"
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr "Виклики до OpenMP runtime API не дозволені в проміжному коді"
@@ -51450,12 +51501,12 @@ msgstr "очікується оголошення методу objective-c"
 msgid "no type or storage class may be specified here,"
 msgstr "тут не може бути вказано тип або клас зберігання,"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "порожній список атрибутів властивості"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, gcc-internal-format
 msgid "missing property attribute"
 msgstr "відсутній атрибут властивості"
@@ -51465,58 +51516,58 @@ msgstr "відсутній атрибут властивості"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "невідомий атрибут властивості %<%s%s%>"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "невідомий атрибут властивості"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "очікується %<=%> після Objective-C %qE"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "очікується назва селектора %qE"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "назви методів-сеттерів повинні закінчуватися на %<:%>"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr "%<#pragma GCC unroll%> вимагає виразу присвоєння, який обчислюється до невідʼємної цілочисельнної константи менше %u"
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, fuzzy, gcc-internal-format
 #| msgid "intervening code must not contain OpenMP directives"
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr "Проміжний код не повинен містити директив OpenMP"
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma %s%> може використовуватися тільки в складних операторах"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> повинно бути на рівні файлу"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp scan%> може використовуватися тільки в цикловій конструкції з замиканням %<inscan%> %<reduction%>"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> може використовуватись тільки в конструкції %<#pragma omp sections%>"
@@ -51526,12 +51577,12 @@ msgstr "%<#pragma omp section%> може використовуватись ті
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma %s%> може використовуватись тільки на рівні файлу"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "очікується оператор for, while або do"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> повинно бути першим"
@@ -51541,11 +51592,11 @@ msgstr "%<#pragma GCC pch_preprocess%> повинно бути першим"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "забагато замиканнь %qs"
@@ -51560,58 +51611,58 @@ msgstr "вираз повинен бути цілочисельним"
 msgid "%qD is not a variable"
 msgstr "%qD не є змінною"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD не є змінною-вказівником"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "аргумент «collapse» потребує позитивний сталий цілочисельний вираз"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "очікується %<none%> або %<present%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "очікувався %<none%>, %<shared%>, %<private%> або %<firstprivate%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "очікується константне логічне вираження"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "очікувався %<data%>, %<update%>, %<enter%> або %<exit%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "очікувався %<data%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr "занадто багато %<if%> замиканнь з модифікатором %qs"
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "занадто багато %<if%> замиканнь"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "занадто багато %<if%> замиканнь без модифікатора"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr "якщо будь-яке %<if%> замикання має модифікатор, то всі %<if%> замикання повинні використовувати модифікатор"
@@ -51634,22 +51685,22 @@ msgstr "значення %<num_threads%> повинно бути позитив
 msgid "%<num_tasks%> value must be positive"
 msgstr "значення %<num_tasks%> повинно бути позитивним"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "Значення %<grainsize%> повинно бути позитивним"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "Значення %<priority%> повинно бути не відʼємним"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "очікується константний цілочисельний вираз з дійсним значенням sync-hint"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "очікується %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> або %<default%>"
@@ -51659,99 +51710,99 @@ msgstr "очікується %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstpri
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "очікується %<scalar%>, %<aggregate%>, %<pointer%> або %<all%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "занадто багато замиканнь %<defaultmap%> з категорією %qs"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "занадто багато замиканнь %<defaultmap%> з невизначеною категорією"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "вираз %qs повинен бути цілочисельним"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "значення %qs повинно бути позитивним"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "забагато аргументів %<static%>"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "неочікуваний аргумент"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "аргумент %<tile%> повинен бути додатньою цілочисельною константою"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "занадто багато клауз %<self%>"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "очікується %<reproducible%> або %<unconstrained%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "очікується %<concurrent%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "очікується %<teams%>, %<parallel%> або %<thread%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "аргумент %<ordered%> повинен бути позитивним цілим виразом"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "очікується %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> або ідентифікатор"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "вказано обидва модифікатори %<monotonic%> і %<nonmonotonic%>"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "розклад %<runtime%> не приймає параметр %<chunk_size%>"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "розклад %<auto%> не приймає параметр %<chunk_size%>"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "значення розміру частини повинно бути позитивним"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "недійсний тип розкладу"
@@ -51761,38 +51812,38 @@ msgstr "недійсний тип розкладу"
 msgid "%<num_teams%> value must be positive"
 msgstr "значення %<num_teams%> повинно бути позитивним"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr "нижня межа %qE для %<num_teams%> більша за верхню межу %qE"
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "значення %<thread_limit%> повинно бути позитивним"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "вираз вирівнювання для замикання %<aligned%> повинен бути позитивним сталим цілочисельним виразом"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "очікується %<allocator%> або %<align%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, gcc-internal-format
 msgid "duplicate %qs modifier"
 msgstr "подвійний модифікатор %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr "вираз алокатора в замиканні %<allocate%> має тип %qT, а не %<omp_allocator_handle_t%>"
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "аргумент модифікатора %<align%> в замиканні %<allocate%> має бути позитивним константним цілочисельним виразом, яке є степенем двійки"
@@ -51808,23 +51859,23 @@ msgstr "очікується %<class%> або %<typename%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, fuzzy, gcc-internal-format
 #| msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr "Клауза %<uses_allocators%> з ознаками та областями пам’яті"
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "декілька модифікаторів linear"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, gcc-internal-format
 msgid "multiple %<step%> modifiers"
 msgstr "декілька модифікаторів %<step%>"
@@ -51834,7 +51885,7 @@ msgstr "декілька модифікаторів %<step%>"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "вираз кроку в замиканні %<linear%> має бути цілочисельним"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -51849,331 +51900,331 @@ msgstr "вираз в замиканні %<safelen%> має бути позит
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "вираз в замиканні %<simdlen%> має бути позитивним константним цілочисельним"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "Модифікатор %<iterator%> несумісний з %qs"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "Недійсний тип залежності"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "Недійсний тип doacross"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<cancel%> %<if%> clause modifier"
 msgid "expected %<fallback%> modifier"
 msgstr "очікується модифікатор замикання %<cancel%> %<if%>"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "очікується замикання %<read%>, %<write%>, %<update%> або %<capture%>"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "Значення %<priority%> повинно бути не відʼємним"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "illegal comma"
 msgstr "неприпустимий операнд "
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "Забагато модифікаторів %<always%>"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "Забагато модифікаторів %<close%>"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<present%> modifiers"
 msgid "too many %<iterator%> modifiers"
 msgstr "занадто багато модифікаторів %<present%>"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<present%> modifiers"
 msgid "too many %<mapper%> modifiers"
 msgstr "занадто багато модифікаторів %<present%>"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "очікується ідентифікатор або %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "занадто багато модифікаторів %<present%>"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, fuzzy, gcc-internal-format
 #| msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%> or %<present%>"
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "%<map%> клауза з модифікатором типу мапи, відмінним від %<always%>, %<close%> або %<present%>"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "Недійсний тип відображення"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr "Модифікатор пристрою %<ancestor%> не передує директиві %<requires%> з замиканням %<reverse_offload%>"
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "очікувався %<ancestor%> або %<device_num%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "вираз у замиканні %<device%> повинен обчислюватися як %<1%>"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "недійсний тип розподілу розкладу"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "недійсний тип привʼязки процесу"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "очікується %<host%>, %<nohost%> або %<any%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, fuzzy, gcc-internal-format
 #| msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%> or %<present%>"
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "%<map%> клауза з модифікатором типу мапи, відмінним від %<always%>, %<close%> або %<present%>"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "аргумент %<ordered%> повинен бути позитивним цілим виразом"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr "тип обробника події в замиканні %<detach%> - %qT, а не %<omp_event_handle_t%>"
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, gcc-internal-format
 msgid "string literal must not contain %<\\0%>"
 msgstr ""
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown rust compile-until %qs"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "невідомий параметр compile-until rust %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "Expected register or constant integer."
 msgid "expected string literal or constant integer expression"
 msgstr "Очікувався регістр або константне цілочисельне."
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "очікується %<none%> або %<present%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicated %<if%> condition"
 msgid "duplicated %<fr%> preference selector"
 msgstr "подвійна умова %<if%>"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, fuzzy, gcc-internal-format
 #| msgid "%<-march=%s%>: %s must separate with %<_%>"
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr "%<-march=%s%>: %s повинно бути розділено знаком %<_%>"
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "очікується літерал рядка"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs modifier"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "подвійний модифікатор %qs"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs modifier"
 msgid "duplicate %<target%> modifier"
 msgstr "подвійний модифікатор %qs"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs modifier"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "подвійний модифікатор %qs"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<declare target%> or %<assumes%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "очікується %<declare target%> або %<assumes%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "очікується клауза OpenACC"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs недійсний для %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr "замикання в режимі %<simd%> повинні бути розділені комою %<,%>"
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs повинен бути першою замиканням %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "очікується клауза OpenMP"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr "не вказано жодних дійсних замикань в %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "секція масиву в %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "%qD повинна бути глобальною змінною в %<#pragma acc declare link%>"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "недійсне замикання OpenACC у межах файлу"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "недійсне використання %<extern%> змінної %qD в %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "недійсне використання %<global%> змінної %qD в %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "%qD повинна бути змінною, оголошеною в тому ж області, що й %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr "змінна %qD використовується більше одного разу з %<#pragma acc declare%>"
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "мало бути %<data%> після %<#pragma acc %s%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma acc %s data%> не має замикання переміщення даних"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr "конструкція %<host_data%> вимагає клаузи %<use_device%>"
@@ -52188,7 +52239,7 @@ msgstr "%qE не було оголошено"
 msgid "expected function name"
 msgstr "мало бути вказано назву функції"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD не посилається на функцію"
@@ -52198,22 +52249,22 @@ msgstr "%qD не посилається на функцію"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma acc routine%> не негайно слідує за декларацією або визначенням функції"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma acc routine%> не негайно слідує за однією декларацією або визначенням функції"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> має бути застосовано до використання"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> має бути застосовано до визначення"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> повинен містити принаймні одну замикання %<device%> або %<host%> або %<self%>"
@@ -52238,7 +52289,7 @@ msgstr "Змінну %qD в клаузі %<allocator%> не можна змін
 msgid "modified here"
 msgstr "змінено тут"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "аргумент замикання %<align%> повинен бути позитивним сталим виразом цілого числа, яке є степенем двійки"
@@ -52273,110 +52324,110 @@ msgstr "Для статичної змінної %qD потрібна клауз
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr "Клауза %<allocator%> вимагає вказати попередньо визначений аллокатор, оскільки %qD є статичним"
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "очікується замикання %<read%>, %<write%>, %<update%> або %<capture%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "очікується %<seq_cst%>, %<acquire%> або %<relaxed%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "очікується замикання %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> або %<hint%>"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "занадто багато атомних замикання"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "занадто багато замиканнь порядку памʼяті"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "замикання %qs несумісне з замиканнями %<read%> або %<write%>"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, gcc-internal-format
 msgid "%qs clause requires %qs clause"
 msgstr "замикання %qs потребує замикання %qs"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic write%> несумісний з неявно наданою директивою %<requires%> клаузою %<acquire%>"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp atomic read%> несумісний з неявно наданою директивою %<requires%> клаузою %<release%>"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp atomic read%> несумісний з замиканням %<release%>"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp atomic write%> несумісний з замиканням %<acquire%>"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "очікується порівняння %<==%> в умові %<if%>"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr "очікується порівняння %<==%>, %<<%> або %<>%> в умові %<if%>"
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "неправильна форма %<#pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "неочікуваний %<else%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "неправильна форма %<pragma omp atomic compare%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "неправильна форма %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "неправильний оператор для %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr "замикання %<weak%> вимагає атомарного порівняння на рівність"
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> використовує два різних вирази для памʼяті"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "Вираз %<depobj%> не є виразом lvalue"
@@ -52386,27 +52437,27 @@ msgstr "Вираз %<depobj%> не є виразом lvalue"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "Вираз %<destroy%> не є виразом lvalue"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr "вираз %<destroy%> %qE має бути ідентичним аргументу %<depobj%> %qE"
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, gcc-internal-format
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "очікується %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> або %<inoutset%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "очікується замикання %<depend%>, %<destroy%> або %<update%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "очікується %<seq_cst%>, %<acq_rel%>, %<release%> або %<acquire%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr "список %<flush%> вказано разом з замиканням порядку памʼяті"
@@ -52416,32 +52467,32 @@ msgstr "список %<flush%> вказано разом з замиканням
 msgid "expected %<(%> or end of line"
 msgstr "очікується %<(%> або кінець рядка"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr "%<[[omp::directive(%s)]]%> повинен бути єдиним вказаним атрибутом в операторі"
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp scan%> з відсутністю попередніх виконуваних операторів"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "очікується замикання %<inclusive%> або %<exclusive%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "очікується %<#pragma omp scan%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp scan%> з відсутністю наступних виконуваних операторів"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "очікувалася конструкція for"
@@ -52449,69 +52500,69 @@ msgstr "очікувалася конструкція for"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "очікувалася конструкція for"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "очікувалася оголошення або ініціалізація ітерації"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "Недостатньо вкладених циклів"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr "параметр замикання %<ordered%> менше, ніж %<collapse%>"
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "змінна ітерації %qD не повинна бути firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp ordered%> з %qs замиканням може використовуватися лише в складних операторах"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "очікувався %<for%> після %qs"
@@ -52522,7 +52573,7 @@ msgstr "очікувався %<for%> після %qs"
 msgid "expected a function name"
 msgstr "мало бути вказано назву функції"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected target-function call"
@@ -52534,47 +52585,47 @@ msgstr "мало бути вказано назву функції"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma omp declare %s%> повинен бути відстежений декларацією або визначенням функції"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "очікувався %<point%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target data%> з типом відображення, відмінним від %<to%>, %<from%>, %<tofrom%> або %<alloc%> на замиканні %<map%>"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp target data%> повинен містити принаймні одну замикання %<map%>, %<use_device_ptr%> або %<use_device_addr%>"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp target update%> повинен містити принаймні одну замикання %<from%> або %<to%>"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target enter data%> з типом відображення, відмінним від %<to%>, %<tofrom%> або %<alloc%> на замиканні %<map%>"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target enter data%> повинен містити принаймні одну замикання %<map%>"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp target exit data%> з типом відображення, відмінним від %<from%>, %<tofrom%>, %<release%> або %<delete%> на замиканні %<map%>"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp target exit data%> повинен містити принаймні одну замикання %<map%>"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp target%> з типом відображення, відмінним від %<to%>, %<from%>, %<tofrom%> або %<alloc%> на замиканні %<map%>"
@@ -52589,58 +52640,58 @@ msgstr "%<#pragma omp declare %s%> повинен бути відстежени
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> повинен бути відстежений декларацією або визначенням функції"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "очікуване імʼя селектора ознаки"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "Невідомий селектор %qs для набору селекторів контексту %qs"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "селектор %qs не приймає жодних властивостей"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, gcc-internal-format
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<score%> не може бути вказано у властивостях для селектора властивостей %qs"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "аргумент %<score%> повинен бути сталим цілочисельним виразом"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "аргумент %<score%> повинен бути невід'ємним"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, gcc-internal-format
 msgid "expected identifier or string literal"
 msgstr "очікується ідентифікатор або літерал рядка"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "property must be constant integer expression"
 msgid "property must be integer expression"
 msgstr "властивість повинна бути цілим сталим виразом"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "властивості для селектора %<simd%> не можуть бути вказані в %<metadirective%>"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "селектор %<requires%> ще не підтримується"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "очікується ім'я набору селектора контексту"
@@ -52650,30 +52701,30 @@ msgstr "очікується ім'я набору селектора конте
 msgid "variant %qD is not a function"
 msgstr "варіант %qD не є функцією"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr "варіант %qD є вбудованим"
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "variant %qD is not a function"
 msgid "variant %qD is the same as base function"
 msgstr "варіант %qD не є функцією"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "очікується замикання %<at%>, %<severity%> або %<message%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<match%> clauses"
 msgstr "занадто багато %<if%> замиканнь"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 #| msgid "%qs clause at %L specified more than once"
 msgid "%qD is specified more than once"
@@ -52685,7 +52736,7 @@ msgstr "Замикання %qs в %L вказане більше одного р
 msgid "%qD is not of pointer type"
 msgstr "%qD не є змінною-вказівником"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<ancestor%> or %<device_num%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -52697,19 +52748,19 @@ msgstr "очікувався %<ancestor%> або %<device_num%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs недійсний для %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<ancestor%> or %<device_num%>"
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "очікувався %<ancestor%> або %<device_num%>"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<point%>"
 msgid "expected %<interop%>"
 msgstr "очікувався %<point%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<match%>"
 msgid "expected %<match%> clause"
@@ -52732,13 +52783,13 @@ msgstr "селектор %<requires%> ще не підтримується"
 msgid "base function %qD declared here"
 msgstr "Вбудована функція %qD оголошена тут"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "аргумент %d з %qE повинен бути типом вказівника"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "%<setter%> specified here"
 msgid "%<append_args%> specified here"
@@ -52750,7 +52801,7 @@ msgstr "%<setter%> вказано тут"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "варіант %qD та база %qD мають несумісні типи"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, gcc-internal-format
 msgid "variant %qD and base %qD have incompatible types"
 msgstr "варіант %qD та база %qD мають несумісні типи"
@@ -52760,7 +52811,7 @@ msgstr "варіант %qD та база %qD мають несумісні ти
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma omp declare %s%> не негайно слідує за оголошенням або визначенням функції"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma omp declare %s%> не негайно слідує за одним оголошенням або визначенням функції"
@@ -52777,90 +52828,90 @@ msgstr "%<#pragma omp declare %s%> повинен бути відстежени
 msgid "no declaration of base function %qs"
 msgstr "Неявне оголошення функції %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "визначення функції не оголошує параметри"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD вказано як у замиканні declare target %<link%>, так і в замиканні %qs"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "%qD вказано як у замиканні declare target %<link%>, так і в замиканні %<to%> або %<enter%>"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr "директива тільки з клаузами %<device_type%> або %<indirect%>"
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr "клауза %<device_type%> повинна вказувати 'any', коли використовується з клаузою %<indirect%>"
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "очікується %<match%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<present%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "очікується %<none%> або %<present%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<declare target%> or %<assumes%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "очікується %<declare target%> або %<assumes%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma omp end declare target%> без відповідного %<#pragma omp declare target%> або %<#pragma omp begin declare target%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr "%qs в синтаксисі атрибуту завершується %qs в синтаксисі прагми"
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%qs в синтаксисі прагми завершується %qs в синтаксисі атрибуту"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma omp end declare target%> без відповідного %<#pragma omp declare target%> або %<#pragma omp begin declare target%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, fuzzy, gcc-internal-format
 #| msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr "%qs в синтаксисі атрибуту завершується %qs в синтаксисі прагми"
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, fuzzy, gcc-internal-format
 #| msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr "%qs в синтаксисі прагми завершується %qs в синтаксисі атрибуту"
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "очікується %<declare%> або %<assumes%>"
@@ -52889,13 +52940,13 @@ msgstr "повторне оголошення %qs %<#pragma omp declare reductio
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T було раніше оголошено тут"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "unexpected clause"
 msgstr "очікується ключ-клас"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "missing %<PHI%> def"
 msgid "missing %<map%> clause"
@@ -52957,33 +53008,33 @@ msgstr "один з аргументів виклику ініціалізато
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "очікується %<simd%>, %<reduction%>, %<target%> або %<variant%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "очікується %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> або %<seq_cst%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr "очікувалася замикання %<unified_address%>, %<unified_shared_memory%>, %<dynamic_allocators%>, %<reverse_offload%> або %<atomic_default_mem_order%>"
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr "%qs використовується лексично після першої конструкції цілі або API віддаленого виконання"
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr "більше однієї замикання %<atomic_default_mem_order%> в одній компіляційній одиниці"
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr "замикання %<atomic_default_mem_order%> використовується лексично після першої конструкції %<atomic%> без замикання порядку памʼяті"
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr "%<pragma omp requires%> вимагає принаймні одну замикання"
@@ -52998,168 +53049,168 @@ msgstr "тип %qT нульового розміру в замиканні %<red
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "тип зі змінним розміром %qT в замиканні %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<else%>"
 msgid "expected %<sizes%>"
 msgstr "очікувалось %<else%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%<tile%> argument needs positive integral constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "аргумент %<tile%> повинен бути додатньою цілочисельною константою"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "очікується замикання %<at%>, %<severity%> або %<message%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "очікується %qs або %qs"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp error%> з замиканням %<at(execution)%> може використовуватись тільки в складних операторах"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp error%> з замиканням %<at(execution)%> може використовуватись тільки в складних операторах"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr "зустрівся %<pragma omp error%>: %s"
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr "зустрівся %<pragma omp error%>"
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "очікується принаймні одне замикання припущення"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, gcc-internal-format
 msgid "expected directive name"
 msgstr "очікується назва директиви"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid %qs directive at %L in %s clause: declarative, informational and meta directives not permitted"
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr "Недійсна директива %qs в %L в %s замиканні: декларативні, інформаційні та мета-директиви не дозволені"
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr "невідома назва директиви OpenMP в аргументі замикання %qs"
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr "директива %<%s%s%s%s%s%> згадується як у замиканні %<absent%>, так і у замиканні %<contains%>"
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr "директива %<%s%s%s%s%s%> згадується кілька разів у замиканнях %qs"
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "невідомий замикання припущення %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "очікується замикання припущення"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "очікується замикання %<depend%>, %<destroy%> або %<update%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<defaultmap%> clauses with %qs category"
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "занадто багато замиканнь %<defaultmap%> з категорією %qs"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, fuzzy, gcc-internal-format
 #| msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "властивості для селектора %<simd%> не можуть бути вказані в %<metadirective%>"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown directive at %L"
 msgid "unknown directive name"
 msgstr "Невідома директива в %L"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE оголошено як %<threadprivate%> після першого використання"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "автоматична змінна %qE не може бути %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE має неповний тип"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%> без включеної підтримки транзакційної памʼяті"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%> без підтримки транзакційної памʼяті"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%> без підтримки транзакційної памʼяті"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> всередині %<__transaction_relaxed%>"
@@ -53169,7 +53220,7 @@ msgstr "%<__transaction_cancel%> всередині %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "зовнішній %<__transaction_cancel%> не знаходиться всередині зовнішнього %<__transaction_atomic%> або функції %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> не в межах %<__transaction_atomic%>"
@@ -53184,7 +53235,7 @@ msgstr "відсутня закриваюча фігурна дужка"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD має неповний тип %qT"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "неправильне використання виразу типу void"
@@ -53215,172 +53266,172 @@ msgstr "неправильне використання неповного typed
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT і %qT знаходяться в різних іменованих адресних просторах"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "атрибут %qs застосовується тільки до функцій зі змінною кількістю аргументів"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "типи функцій не є дійсно сумісними в ISO C"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "не можна змішувати операнди десяткових плаваючої коми та векторних типів"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "не можна змішувати операнди десяткових плаваючої коми та комплексних типів"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "не можна змішувати операнди десяткових плаваючої коми та інших плаваючих типів"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr "%<_Complex _BitInt(%d)%> не підтримується"
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "неправильне використання вказівників на масиви з різними кваліфікаторами в ISO C до C23"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "типи не зовсім сумісні"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "типи цілей вказівників несумісні в C++"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "типи повернення функцій несумісні через %<volatile%>"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "перетворення складеного літерала масиву на вказівник призводить до висячого вказівника в C++"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "недійсне використання структури з гнучким елементом масиву"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT не має члена з іменем %qE; ви мали на увазі %qE?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT не має члена з іменем %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr "доступ до члена %qE атомної структури %qE"
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "доступ до члена %qE атомного обʼєднання %qE"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr "%qE - це вказівник на вказівник; ви мали на увазі розіменувати його перед застосуванням %<->%> до нього?"
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr "%qE - це вказівник; ви мали на увазі використати %<->%>?"
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "запит на член %qE в чомусь, що не є структурою або обʼєднанням"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "розіменування вказівника %<void *%>"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "індексоване значення не є ані масивом, ані вказівником, ані вектором"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "індекс масиву не є цілочисельним"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "індексоване значення є вказівником на функцію"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "індекс масиву не є цілочисельним"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C забороняє індексацію масиву %<register%>"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 забороняє індексацію масиву, який не є l-значенням"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, gcc-internal-format
 msgid "underspecified %qD referenced in its initializer"
 msgstr "недостатньо визначений %qD, на який посилається в його ініціалізаторі"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "перетворення перелічування при ініціалізації недійсне в C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "константа перелічування визначена тут"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr "%<sizeof%> на параметрі функції масиву %qE поверне розмір %qT"
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "обʼєкт, що був викликаний %qE, не є функцією або вказівником на функцію"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "обʼєкт, що був викликаний %qD, не є функцією або вказівником на функцію"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "обʼєкт, що був викликаний, не є функцією або вказівником на функцію"
@@ -53388,1896 +53439,1896 @@ msgstr "обʼєкт, що був викликаний, не є функцією
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "функція була викликана через несумісний тип"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "викликано функцію з кваліфікованим типом повернення void"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "тип формального параметра %d неповний"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "аргумент %d функції %qE передається як цілочисельне, а не як дійсне через прототип"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "аргумент %d функції %qE передається як цілочисельне, а не як комплексне через прототип"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "аргумент %d функції %qE передається як комплексне число, а не як дійсне через прототип"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "аргумент %d функції %qE передається як дійсне число, а не як ціле через прототип"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "аргумент %d функції %qE передається як комплексне число, а не як ціле через прототип"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "аргумент %d функції %qE передається як дійсне число, а не як комплексне через прототип"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "аргумент %d функції %qE передається як %<float%>, а не %<double%> через прототип"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "передача аргументу %d з %qE як %qT замість %qT через прототип"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "передача аргументу %d з %qE з іншою шириною через прототип"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "передача аргументу %d з %qE як беззнакового через прототип"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "передача аргументу %d з %qE як знакового через прототип"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to method %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "забагато аргументів для методу %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to built-in function %qE expecting %d"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "забагато аргументів для вбудованої функції %qE, очікується %d"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, gcc-internal-format
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "забагато аргументів для вбудованої функції %qE, очікується %d"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, fuzzy, gcc-internal-format
 #| msgid "in a call to function %qD declared with attribute %qs"
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "у виклику функції %qD, оголошеної з атрибутом %qs"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "неявне перетворення з %qT на %qT при передачі аргументу до функції"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to built-in function %qE expecting %u"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "недостатньо аргументів для вбудованої функції %qE, очікується %u"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to built-in function %qE expecting %u"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "недостатньо аргументів для вбудованої функції %qE, очікується %u"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, gcc-internal-format
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "недостатньо аргументів для вбудованої функції %qE, очікується %u"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "порівняння з літералом рядка призводить до невизначеного поведінки"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, gcc-internal-format
 msgid "comparison between pointer and zero character constant"
 msgstr "порівняння між вказівником і нульовою символьною константою"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, gcc-internal-format
 msgid "did you mean to dereference the pointer?"
 msgstr "ви мали на увазі розіменування вказівника?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "нуль як константа нульового вказівника"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "порівняння між %qT і %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "вказівник типу %<void *%> використовується в відніманні"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "вказівник на функцію використовується в відніманні"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "арифметика з вказівником на неповний тип"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "арифметика з вказівником на порожню структуру"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> на булевому виразі"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "чи мали ви на увазі використання логічного заперечення?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C не підтримує %<~%> для комплексної спряженості"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, gcc-internal-format
 msgid "wrong type argument to absu"
 msgstr "неправильний тип аргументу для absu"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "неправильний тип аргументу для унарного знаку оклику"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "інкремент значення перелічування недійсний в C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "декремент значення перелічування недійсний в C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "інкремент булевого виразу"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "декремент булевого виразу"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C не підтримує %<++%> та %<--%> для комплексних типів"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "неправильний тип аргументу для інкременту"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "неправильний тип аргументу для декременту"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "інкремент вказівника на неповний тип %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "декремент вказівника на неповний тип %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "береться адреса виразу типу %<void%>"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "не можна взяти адресу бітового поля %qD"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "не можна взяти адресу скаляра зі зворотним порядком зберігання"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr "запитано адресу масиву зі зворотним порядком зберігання скалярів"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr "запитано адресу зареєстрованого складеного літерала"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "глобальна зареєстрована змінна %qD використовується у вкладеній функції"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "зареєстрована змінна %qD використовується у вкладеній функції"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "запитано адресу глобальної зареєстрованої змінної %qD"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "запитано адресу зареєстрованої змінної %qD"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "масив, який не є lvalue, у умовному виразі"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "defining a type in a compound literal is invalid in C++"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "визначення типу в літералі складного типу недійсне в C++"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "неявне перетворення з %qT на %qT, щоб відповідати іншому результату умовного виразу"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr "операнд %<?:%> змінює знак з %qT на %qT через відсутність знаку іншого операнда"
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C забороняє умовний вираз з однією тільки стороною void"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "використовуються вказівники на розʼєднані адресні простори в умовному виразі"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "вказівник на масив втрачає кваліфікатор в умовному виразі"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "вказівник на масив втрачає кваліфікатор у умовному виразі в ISO C до C23"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C забороняє умовний вираз між %<void *%> та вказівником на функцію"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "несумісні типи вказівників в умовному виразі"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, gcc-internal-format
 msgid "first expression has type %qT"
 msgstr "перший вираз має тип %qT"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, gcc-internal-format
 msgid "second expression has type %qT"
 msgstr "другий вираз має тип %qT"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "несумісність типів вказівник/цілочисельне в умовному виразі"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "несумісність типів в умовному виразі"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "ігнорування значення повернення %qD, оголошеного з атрибутом %<nodiscard%>: %E"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "ігнорування значення повернення %qD, оголошеного з атрибутом %<nodiscard%>"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "ігнорування значення повернення типу %qT, оголошеного з атрибутом %<nodiscard%>: %E"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "ігнорування значення повернення типу %qT, оголошеного з атрибутом %<nodiscard%>"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "при виклику %qD, оголошеному тут"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "лівий операнд кома-виразу не має ефекту"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "правий операнд кома-виразу не має ефекту"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr "приведення додає кваліфікатор %q#v до типу функції"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "приведення відкидає кваліфікатор %qv з типу цілі вказівника"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "для безпеки всі проміжні вказівники в приведенні з %qT до %qT повинні мати кваліфікатор %<const%>"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "приведення вказує тип масиву"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "приведення вказує тип функції"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C забороняє приведення нескалярного типу до того ж типу"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "безглузде перетворення типу на %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C забороняє приведення до типу обʼєднання"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "приведення до типу обʼєднання з типу, якого немає в обʼєднанні"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "приведення до вказівника адресного простору %qs з відокремленим вказівником загального адресного простору"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "приведення до вказівника загального адресного простору з відокремленим вказівником адресного простору %qs"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "приведення до вказівника адресного простору %qs з відокремленим вказівником адресного простору %qs"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "приведення збільшує необхідне вирівнювання цільового типу"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "приведення з вказівника до цілого числа іншого розміру"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "приведення з виклику функції типу %qT до несумісного типу %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "приведення до вказівника з цілого числа іншого розміру"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C забороняє перетворення вказівника на функцію до типу вказівника на обʼєкт"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C забороняє перетворення вказівника на обʼєкт до типу вказівника на функцію"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "приведення між несумісними типами функцій з %qT до %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "визначення типу в приведенні недійсне в C++"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "присвоєння виразу з типом масиву"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "перетворення перелічування в присвоєнні недійсне в C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(біля ініціалізації для %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "масив ініціалізований з заключеної у дужки рядкової константи"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "очікується %qT, але аргумент має тип %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "Тип аргументу %qD %d - %qT, де очікується %qT у виклику вбудованої функції, що оголошена без прототипу"
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr "Аргумент %qD %d перетворюється на %qT, де очікується %qT у виклику вбудованої функції, що оголошена без прототипу"
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "Вбудована функція %qD оголошена тут"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid " declared here"
 msgid "%e declared here"
 msgstr " оголошено тут"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "Конвертація перелічування при передачі аргументу %d %qE недійсна в C++"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "очікується %qT, але аргумент має тип %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "Конвертація перелічування з %qT до %qT при присвоєнні недійсна в C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "Конвертація перелічування з %qT до %qT при ініціалізації недійсна в C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "перетворення enum з %qT на %qT у поверненні недійсне в C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT"
 msgstr "неявне перетворення з %qT на %qT"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "передача аргументу %d з %qE створює кваліфікований вказівник на функцію %q#v з некваліфікованого"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "присвоєння робить кваліфікований вказівник на функцію %q#v з некваліфікованого"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "ініціалізація робить кваліфікований вказівник на функцію %q#v з некваліфікованого"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "повернення робить кваліфікований вказівник на функцію %q#v з некваліфікованого"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "передача аргументу %d з %qE відкидає кваліфікатор %qv з типу цілісного вказівника"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "призначення відкидає кваліфікатор %qv з типу цілі вказівника"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "ініціалізація відкидає кваліфікатор %qv з типу цілі вказівника"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "повернення відкидає кваліфікатор %qv з типу цілі вказівника"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C забороняє перетворення аргументу на тип обʼєднання"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "запит на неявне перетворення з %qT на %qT не дозволено в C++"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "передача аргументу %d з %qE з вказівника в незакритий адресний простір"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "призначення з вказівника в незакритий адресний простір"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "ініціалізація з вказівника в незакритий адресний простір"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "повернення з вказівника на незакритий адресний простір"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "очікувався %qT, але вказівник має тип %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "аргумент %d з %qE може бути кандидатом на атрибут формату"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "ліва частина присвоєння може бути кандидатом на атрибут формату"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "ліва частина ініціалізації може бути кандидатом на атрибут формату"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "тип повернення може бути кандидатом на атрибут формату"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "передача аргументу %d з %qE з несумісним порядком зберігання скалярів"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "присвоєння до %qT з типу вказівника %qT з несумісним порядком зберігання скалярів"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "ініціалізація %qT з типу вказівника %qT з несумісним порядком зберігання скалярних значень"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "повернення %qT з типу вказівника з несумісним порядком зберігання скалярних значень %qT"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C забороняє передачу аргументу %d з %qE між вказівником на функцію та %<void *%>"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C забороняє присвоєння між вказівником на функцію та %<void *%>"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C забороняє ініціалізацію між вказівником на функцію та %<void *%>"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C забороняє повернення між вказівником на функцію та %<void *%>"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr "масив з кваліфікатором на елементі не має кваліфікатора до C23"
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "цілі вказівники в передачі аргументу %d з %qE відрізняються за знаком"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, gcc-internal-format
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "цілі вказівники в присвоєнні з %qT до %qT відрізняються за знаком"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "цілі вказівники в ініціалізації %qT з %qT відрізняються за знаком"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "цілі вказівники в поверненні %qT з функції з типом повернення %qT відрізняються за знаком"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "передача аргументу %d з %qE з несумісним типом вказівника"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "assignment to %qT from pointer to %qD with incompatible type %qT"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "присвоєння до %qT з вказівника на %qD з несумісним типом %qT"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment to %qT from incompatible pointer type %qT"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "присвоєння до %qT з несумісного типу вказівника %qT"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization of %qT from pointer to %qD with incompatible type %qT"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "ініціалізація %qT з вказівника на %qD з несумісним типом %qT"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization of %qT from incompatible pointer type %qT"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "ініціалізація %qT з несумісного типу вказівника %qT"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "returning pointer to %qD of type %qT from a function with incompatible type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "повернення вказівника на %qD типу %qT з функції з несумісним типом %qT"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "returning %qT from a function with incompatible return type %qT"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "повернення %qT з функції з несумісним типом повернення %qT"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "передача аргументу %d з %qE перетворює цілочисельне в вказівник без приведення типу"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "присвоєння %qT з %qT перетворює цілочисельне в вказівник без приведення типу"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "ініціалізація %qT з %qT перетворює цілочисельне в вказівник без приведення типу"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "повернення %qT з функції з типом повернення %qT перетворює цілочисельне в вказівник без приведення типу"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "передача аргументу %d з %qE перетворює вказівник в цілочисельне без приведення типу"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "присвоєння %qT з %qT перетворює вказівник в цілочисельне без приведення типу"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "ініціалізація %qT з %qT перетворює вказівник в цілочисельне без приведення типу"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "повернення %qT з функції з типом повернення %qT перетворює вказівник в ціле число без приведення типу"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "несумісний тип для аргументу %d з %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "несумісні типи при присвоєнні типу %qT з типу %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "несумісні типи при ініціалізації типу %qT за допомогою типу %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "несумісні типи при поверненні типу %qT, але очікувався %qT"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "традиційний C відхиляє автоматичну ініціалізацію агрегатів"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr "ініціалізатор вказівника %<constexpr%> не є нульовим"
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr "ініціалізатор %<constexpr%> не може бути представлений в типі обʼєкта"
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "ініціалізатор цілочисельного %<constexpr%> не є сталим цілочисельним виразом"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "Ініціалізатор %<constexpr%> не є арифметичним сталим виразом"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr "Ініціалізатор %<constexpr%> для дійсного типу є комплексним типом"
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr "Ініціалізатор %<constexpr%> для двійкового типу з плаваючою комою має десятковий тип"
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "ініціалізація гнучкого члена масиву"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr "не вдається ініціалізувати масив з %qT з літералу рядка з типом масиву %qT"
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for %qT is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "рядок ініціалізатора для %qT занадто довгий"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for %qT is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "рядок ініціалізатора для %qT занадто довгий"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "масив неприпустимого типу ініціалізовано зі стрічкової константи"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "неприпустиме використання масиву, який не є lvalue"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "недійсний ініціалізатор"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "елемент ініціалізатора не є константою"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "масив ініціалізовано з неконстантного виразу масиву"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "елемент ініціалізатора не є константним виразом"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT changes value from %qE to %qE"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "перетворення з %qT на %qT змінює значення з %qE на %qE"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "елемент ініціалізатора не обчислюється під час завантаження"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "неможливо ініціалізувати непрозорі векторні типи"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "додаткова група фігурних дужок в кінці ініціалізатора"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "фігурні дужки навколо скалярного ініціалізатора"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "ініціалізація гнучкого елемента масиву вкладеного контексту"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "відсутні фігурні дужки навколо ініціалізатора"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "відсутня ініціалізація для поля %qD типу %qT"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "додаткові елементи в скалярній ініціалізаторі"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "індекс масиву в не масивному ініціалізаторі"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "імʼя поля не в ініціалізаторі запису або обʼєднання"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "індекс масиву в ініціалізаторі не є цілочисельним типом"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "індекс масиву в ініціалізаторі не є цілочисельним константним виразом"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "неконстантний індекс масиву в ініціалізаторі"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "індекс масиву в ініціалізаторі перевищує межі масиву"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "порожній діапазон індексу в ініціалізаторі"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "діапазон індексу масиву в ініціалізаторі перевищує межі масиву"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "ініціалізоване поле перезаписано"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "ініціалізоване поле з побічними ефектами перезаписано"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "перетворення перелічування при ініціалізації недійсне в C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, gcc-internal-format
 msgid "excess elements in %qT initializer"
 msgstr "зайві елементи в ініціалізаторі %qT"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "зайві елементи в ініціалізаторі структури"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr "позиційна ініціалізація поля в %<struct%>, оголошеного з атрибутом %<designated_init%>"
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "нестатична ініціалізація гнучкого елемента масиву"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "зайві елементи в ініціалізаторі обʼєднання"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "традиційний C відхиляє ініціалізацію обʼєднань"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "зайва кількість елементів у ініціалізаторі масиву"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "зайва кількість елементів у ініціалізаторі вектора"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "зайва кількість елементів у ініціалізаторі скаляра"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C не дозволяє додатковий %<;%> поза функцією"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in output operand outside of a function"
 msgstr "ISO C не дозволяє додатковий %<;%> поза функцією"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "вихідний операнд %d повинен використовувати обмеження %<&%>"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "%<asm%> qualifier outside of function body"
 msgid "%<-%> modifier used inside of a function"
 msgstr "вказівник %<asm%> поза тілом функції"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in input operand outside of a function"
 msgstr "ISO C не дозволяє додатковий %<;%> поза функцією"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD не визначено поза областю функції"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C забороняє %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "обчислене перехід має бути типу вказівник"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "функція, оголошена з %<noreturn%>, має оператор %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> без значення в функції, що повертає не-void"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> зі значенням в функції, що повертає void"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C забороняє %<return%> з виразом в функції, що повертає void"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "функція повертає адресу мітки"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "функція повертає адресу локальної змінної"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "кількість виразів у switch не є цілочисельним"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "вираз switch типу %<long%> не перетворено на тип %<int%> у ISO C"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "мітка case не є цілочисельним константним виразом"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "мітка case не знаходиться у блоку switch"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "мітка %<default%> не знаходиться у блоку switch"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "оператор break не знаходиться у циклі або блоку switch"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "недійсний вихід зі структурованого блоку OpenMP"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "оператор break використовується з циклом for OpenMP"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "оператор continue не знаходиться у циклі"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "оператор без ефекту"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "оператор виразу має неповний тип"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "порівняння завжди буде оцінюватися як %<false%> для операнду-вказівника в %qE не повинен бути NULL"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "порівняння завжди буде оцінюватися як %<true%> для операнду-вказівника в %qE не повинен бути NULL"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "порівняння завжди буде оцінюватися як %<false%> для адреси %qE ніколи не буде NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "порівняння завжди буде оцінюватися як %<true%> для адреси %qE ніколи не буде NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "порівняння векторів з різними типами елементів"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "порівняння векторів з різною кількістю елементів"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "порівняння між типами %qT та %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "не вдалося знайти цілочисельний тип такої ж розмірності, як %qT"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "порівнювати числа з рухомою комою за допомогою %<==%> або %<!=%> небезпечно"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "порівняння вказівників на розʼєднані адресні простори"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C забороняє порівняння %<void *%> з вказівником на функцію"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "порівняння різних типів вказівників потребує приведення типів"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "порівняння між вказівником та цілочисельним"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "порівняння повних та неповних вказівників"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C забороняє упорядковані порівняння вказівників на функції"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "упорядковане порівняння вказівника з нульовим вказівником"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "упорядковане порівняння вказівника з цілочисельним нуль"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "неявне перетворення з %qT на %qT для відповідності іншому операнду бінарного виразу"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "використано масив, який не може бути перетворений на вказівник, де потрібний скаляр"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "використано значення типу «struct», де потрібний скаляр"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "використано значення типу «union», де потрібний скаляр"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "використано значення типу «vector», де потрібний скаляр"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancel%> повинен вказувати один з замиканнь %<parallel%>, %<for%>, %<sections%> або %<taskgroup%>"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "очікується модифікатор замикання %<cancel%> %<if%>"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp cancellation point%> повинен вказувати один з замиканнь %<parallel%>, %<for%>, %<sections%> або %<taskgroup%>"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD не є змінною в замиканні %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE не є змінною в замиканні %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%<_Atomic%> %qD в замиканні %qs"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD є змінною, приватною для потоку, в замиканні %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "нижня межа %qE секції масиву не має цілочисельного типу"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "довжина %qE секції масиву не має цілочисельного типу"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "очікується один вказівник у замиканні %qs"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "секція масиву з нульовою довжиною у замиканні %qs"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr "для масиву з невідомою межею типу необхідно вказати вираз довжини"
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr "відʼємна нижня межа в секції масиву у замиканні %qs"
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "відʼємна довжина в секції масиву у замиканні %qs"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr "нижня межа %qE вище розміру секції масиву у замиканні %qs"
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr "довжина %qE більше розміру секції масиву в замиканні %qs"
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr "верхня межа %qE вище розміру розділу масиву в %qs замиканні"
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "для параметра функції масиву необхідно вказати вираз довжини"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "для типу вказівника необхідно вказати вираз довжини"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "розділ масиву не є послідовним в %qs замиканні"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE не має типу вказівника або масиву"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "ітератор %qD не має ні цілочисельного, ні вказівного типу"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "ітератор %qD має тип з %<_Atomic%> кваліфікацією"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "ітератор %qD має тип з const кваліфікацією"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "крок ітератора з не-цілочисельним типом"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr "ітератор %qD має крок 0"
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr "тип ітератора %qD посилається на зовнішній ітератор %qD"
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr "вираз початку посилається на зовнішній ітератор %qD"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "вираз кінця посилається на зовнішній ітератор %qD"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "вираз кроку посилається на зовнішній ітератор %qD"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "очікується вказівник в %qs замиканні"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "%<inscan%> та не-%<inscan%> %<reduction%> замикання на одній конструкції"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "%<inscan%> Замикання %<reduction%> зі зрізом масиву"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD в замиканні %<reduction%> є масивом нульового розміру"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE в замиканні %<reduction%>"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "Тип %qT з розміром 0 в замиканні %qs"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "Тип %qT змінного розміру в замиканні %qs"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE має недійсний тип для %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "не знайдено користувацьку визначену редукцію для %qE"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "Тип елемента змінної довжини в замиканні %<reduction%> масиву"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "%<nowait%> clause must not be used together with %<copyprivate%>"
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "Замикання %<nowait%> не можна використовувати разом з %<copyprivate%>"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE має бути %<threadprivate%> для %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr "модифікатор не повинен бути вказаний в %<linear%> замиканні на конструкціях %<simd%> або %<for%>, коли не використовується модифікатор OpenMP 5.2"
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr "Замикання «linear» застосовано до змінної типу %qT, яка не є цілочисельним або вказівником"
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr "%<_Atomic%> %qD у замиканні %<linear%>"
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "крок замикання %<linear%> %qE не є ані константою, ані параметром"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE не є змінною в замиканні %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD зʼявляється більше одного разу в замиканнях для обміну даними"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD зʼявляється більше одного разу в редукційних замиканнях"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE зʼявляється більше одного разу в замиканнях даних"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD зʼявляється більше одного разу в замиканнях даних"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD зʼявляється як в замиканнях даних, так і в замиканнях відображення"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE не є змінною в замиканні %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE не є змінною в замиканні %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE не є змінною в замиканні %<aligned%>"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "%qE в замиканні %<aligned%> не є ані вказівником, ані масивом"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%<_Atomic%> %qD в замиканні %<aligned%>"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE зʼявляється більше одного разу в замиканнях %<aligned%>"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE не є змінною в замиканні %<nontemporal%>"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE зʼявляється більше одного разу в замиканнях %<nontemporal%>"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE не є змінною в замиканні %<allocate%>"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE зʼявляється більше одного разу в замиканнях %<allocate%>"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, fuzzy, gcc-internal-format
 #| msgid "Allocator %qs at %L in USES_ALLOCATORS must be a scalar integer of kind %<omp_allocator_handle_kind%>"
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr "Аллокатор %qs в %L в USES_ALLOCATORS повинен бути скаляром цілого числа типу %<omp_allocator_handle_kind%>"
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, fuzzy, gcc-internal-format
 #| msgid "Allocator %qs at %L in USES_ALLOCATORS must either a variable or a predefined allocator"
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr "Алокатор %qs у %L в USES_ALLOCATORS повинен бути або змінною, або превизначеним алокатором"
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name %qs cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "Назва %qs не може бути використана як визначений оператор на %C"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "array cannot be initialized with a %qs"
 msgid "traits array must be initialized with constants"
 msgstr "масив не може бути ініціалізований значенням %qs"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr "Замикання %<depend%> з типом залежності %<depobj%> на секції масиву"
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr "%<omp_all_memory%> використовується з типом залежності %<depend%>, відмінним від %<out%> або %<inout%>"
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE не є виразом lvalue або секцією масиву в замиканні %qs"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr "%qE не має типу %<omp_depend_t%> в замиканні %<depend%> з типом залежності %<depobj%>"
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr "%qE не повинен мати тип %<omp_depend_t%> у замиканні %<depend%> залежності з типом залежності, відмінним від %<depobj%>"
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "секція масиву не має відображального типу в замиканні %qs"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "непідтримуваний вираз мапи %qE"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD зʼявляється більше одного разу в замиканнях руху"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD зʼявляється більше одного разу в замиканнях відображення"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD не має відображального типу в замиканні %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE не є змінною або імʼям функції в замиканні %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE зʼявляється більше одного разу в одній і тій же директиві %<declare target%>"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD не є аргументом в замиканні %<uniform%>"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE не є аргументом в замиканні %<uniform%>"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "змінна %qs не є вказівником"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "змінна %qs не є або вказівником, або масивом"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, fuzzy, gcc-internal-format
 #| msgid "%<order%> clause must not be used together with %<ordered%>"
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "замикання %<order%> не повинен використовуватися разом з %<ordered%>"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "занадто багато замиканнь %qs у конструкції задачі"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr "замикання %<inbranch%> несумісний з замиканням %<notinbranch%>"
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in motion clauses"
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD зʼявляється більше одного разу в замиканнях руху"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted %qD must be %<const%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "стандартне значення %qD повинно бути %<const%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not const"
 msgid "%qD shall not be const"
 msgstr "%q#D не є константою"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE є передбаченим %qs для %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "кваліфікована %qE з %<const%> може зʼявлятися тільки у замиканнях %<shared%> або %<firstprivate%>"
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr "значення замикання %<simdlen%> більше, ніж значення замикання %<safelen%>"
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr "модифікатор розкладу %<nonmonotonic%> вказаний разом з замиканням %<ordered%>"
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "замикання %qs вказаний разом з замиканням %<inscan%> %<reduction%>"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr "крок умови %<linear%> є параметром %qD, який не вказаний умовою %<uniform%>"
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr "умову %<nogroup%> не слід використовувати разом з умовою %<reduction%>"
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, fuzzy, gcc-internal-format
 #| msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "умову %<nogroup%> не слід використовувати разом з умовою %<reduction%>"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, fuzzy, gcc-internal-format
 #| msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "умову %<nogroup%> не слід використовувати разом з умовою %<reduction%>"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "умову %<detach%> не слід використовувати разом з умовою %<mergeable%>"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr "обробник події %<detach%> не повинен бути в замиканні, що спільно використовує дані"
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses with %qs modifier"
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr "занадто багато %<if%> замиканнь з модифікатором %qs"
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr "не можна використовувати %<va_arg%> зі зворотним порядком зберігання"
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "другий аргумент для %<va_arg%> має неповний тип %qT"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "другий аргумент для %<va_arg%> має тип функції %qT"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<va_arg%> is a function type %qT"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "другий аргумент для %<va_arg%> має тип функції %qT"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "C++ вимагає підвищеного типу, а не типу перелічування, у %<va_arg%>"
@@ -55549,261 +55600,256 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD should be initialized"
 msgid "%s should not be null"
 msgstr "%qD повинен бути ініціалізований"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE не має відображального типу в замиканні %qs"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid receiver type %qs"
 msgid "%s: Invalid field type %s:"
 msgstr "недійсний тип отримувача %qs"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for ACCEPT statement."
 msgstr "Недійсна форма оператора PROGRAM в %C"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for DISPLAY statement."
 msgstr "Недійсна форма оператора PROGRAM в %C"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 #| msgid "unknown %<#pragma extern_model%> model %qs"
 msgid "unknown %<setop_t%> code %d"
 msgstr "невідома модель %qs для %<#pragma extern_model%>"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT розрішується як %qT, але це не класовий тип"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name %qs at %C is the name of the procedure"
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "Імʼя %qs в %C є імʼям процедури"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -55812,74 +55858,85 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "оголошення похідного типу"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown lam type %qs"
 msgid "Unknown type %d"
 msgstr "невідомий тип lam %qs"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qs is not supported with %qs"
+msgid "%s:%d: Must not call here with %s"
+msgstr "%qs не підтримується з %qs"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -55889,13 +55946,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "забагато вхідних файлів"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "cannot read string table from %s"
 msgid "cannot get %<float%> value from %s"
@@ -55913,65 +55970,65 @@ msgstr "сигнал %s завершив програму %s"
 msgid "%s exited with status %d"
 msgstr "%s повернув статус виходу %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs value must be positive"
 msgid "%s: key must be field"
 msgstr "значення %qs повинно бути позитивним"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s%qs%s is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s%qs%s є недійсним"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: regcomp: %s"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed %s mapper %qs"
 msgid "failed compiling %s"
@@ -56431,7 +56488,7 @@ msgstr "немає задовільного %<operator %s%> для %qT"
 msgid "%q#D is private within this context"
 msgstr "%q#D є приватним у цьому контексті"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr "оголошено приватним тут"
@@ -56441,7 +56498,7 @@ msgstr "оголошено приватним тут"
 msgid "%q#D is protected within this context"
 msgstr "%q#D є захищеним у цьому контексті"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr "оголошено захищеним тут"
@@ -56768,7 +56825,7 @@ msgstr "аргумент %u у виклику функції %qE має вказ
 msgid "constructor delegates to itself"
 msgstr "конструктор делегує на себе"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr "не можу перетворити %qH в %qI"
 
@@ -56787,7 +56844,7 @@ msgstr "немає відповідної функції для виклику %
 msgid "call to non-function %qD"
 msgstr "виклик не-функції %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "не можливо прямо викликати конструктор %<%T::%D%> безпосередньо"
@@ -57386,7 +57443,7 @@ msgstr "гнучкий елемент масиву %qD в іншому поро
 msgid "next member %q#D declared here"
 msgstr "наступний елемент %q#D оголошений тут"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "перевизначення %q#T"
@@ -57396,7 +57453,7 @@ msgstr "перевизначення %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -57528,7 +57585,7 @@ msgstr "недійсний тип для параметра %d функції %<
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr "лямбда-функції є неявно %<constexpr%> лише у C++17 та пізніших версіях"
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<constexpr%> деструктори доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
@@ -57581,7 +57638,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%qD не може бути використана як функція з атрибутом %<constexpr%>, оскільки:"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr "знищення %qE поза його часом життя"
@@ -57619,861 +57676,861 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "не можу розкласти обʼєднаний тип %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute not available to functions with variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "атрибут %qE недоступний для функцій зі змінною кількістю аргументів"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D оголошено зі специфікацією винятку"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "цілочисельний вираз %qE не є константою"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D оголошено зі специфікацією винятку"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%qs does not support feature %qs"
 msgid "%qD called without supportable %qs"
 msgstr "%qs не підтримує функцію %qs"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template arguments"
 msgid "%qD called with unexpected %qs argument"
 msgstr "%qD використовується без аргументів шаблону"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %qs"
 msgid "wrong number of arguments to %qs call"
 msgstr "неправильна кількість аргументів для %qs"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma message: %s%>"
 msgid "constexpr message: %.*s"
 msgstr "%<#pragma message: %s%>"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "виклик %<constexpr%> виходить за межі функції"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E не є константним виразом"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "виклик неконстантної функції %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "розіменування нульового вказівника"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "порівняння зводиться до %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr "%qE обчислюється як false"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr "помилка припущення атрибуту %<assume%>"
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "виклик внутрішньої функції %qE"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "зміна константного обʼєкту %qE не дозволена в константному виразі"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "початково оголошено %<const%> тут"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr "помилка %<dynamic_cast%> посилання"
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "динамічний тип %qT його операнда не має базового класу типу %qT"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "вказівник на віртуальну таблицю використовується неініціалізованим"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr "статичний тип %qT операнда є непублічним базовим класом динамічного типу %qT"
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT є неоднозначним базовим класом динамічного типу %qT свого операнда"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr "динамічний тип %qT операнда не має однозначного публічного базового класу %qT"
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "виклик constexpr-члена-функції %qD через віртуальний базовий підобʼєкт"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "вираз %qE не вказує на %<constexpr%> функцію"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "операнд 'o' не є константою"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "звільнення масиву обʼєкта, виділеного немасивною алокацією"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, gcc-internal-format
 msgid "allocation performed here"
 msgstr "виділення виконується тут"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "невидалення масиву обʼєкта, виділеного з використанням виділення масиву"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr "видалення вже видаленої памʼяті"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr "звільнення памʼяті, яка раніше не була виділена"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD викликано в константному виразі до його повного визначення"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD викликано в константному виразі"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD використовується до його визначення"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "виклик має циклічну залежність"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "глибина оцінки %<constexpr%> перевищує максимальне значення %d (використовуйте %<-fconstexpr-depth=%>, щоб збільшити максимальне значення)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "посилання на %qD не є константним виразом"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "вказівник на %qD не є константним виразом"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr "адреса константного значення змінної %qD може відрізнятися при кожному виклику оточуючої функції; додайте  %<static%>, щоб дати їй сталу адресу."
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "правий операнд виразу зсуву %q+E є відʼємним"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "правий операнд виразу зсуву %q+E більший або дорівнює точності %wu лівого операнда"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "лівий операнд виразу зсуву %q+E є відʼємним"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "вираз зсуву %q+E переповнюється"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr "арифметика з використанням нульового вказівника в %qE"
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "індекс масиву %qE знаходиться поза межами масиву %qD типу %qT"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "ненульовий індекс масиву %qE використовується з масивом %qD типу %qT з невідомими межами"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "індекс масиву %qE знаходиться поза межами масиву типу %qT"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "ненульовий індекс масиву %qE використовується з масивом типу %qT з невідомими межами"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "доступ до неініціалізованого елемента масиву"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr "розіменування нульового вказівника в %qE"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE не є константним виразом"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "змінний %qD не може бути використаний в константному виразі"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "доступ до неініціалізованого члена %qD"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 #| msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "доступ до члена %qD замість ініціалізованого члена %qD в константному виразі"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "доступ до члена %qD замість ініціалізованого члена %qD в константному виразі"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%qs не є константним виразом, оскільки %qT є типом обʼєднання"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%qs не є константним виразом, оскільки %qT містить тип обʼєднання"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qs не є константним виразом, оскільки %qT є типом вказівника"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%qs не є константним виразом, оскільки %qT містить тип вказівника"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%qs не є константним виразом, оскільки %qT є типом посилання"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%qs не є константним виразом, оскільки %qT містить тип посилання"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "%qs не є константним виразом, оскільки %qT є типом вказівника на член"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "%qs не є константним виразом, оскільки %qT містить тип вказівника на член"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%qs не є константним виразом, оскільки %qT є волатильним"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qs не є сталим виразом, оскільки %qT містить волатильний підобʼєкт"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%qs не може бути обчислено як константне на цільовій платформі"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr "%qs не може бути обчислено як константне, оскільки тип занадто великий"
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "%qs не може бути обчислено як константне, оскільки аргумент не може бути закодований"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "%qs отримує доступ до неініціалізованого байта за зміщенням %d"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "%qs не може бути обчислено як константне, оскільки аргумент не може бути інтерпретований"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 #| msgid "accessing value of %qE through a %qT glvalue in a constant expression"
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "доступ до значення %qE через gl-значення %qT в сталому виразі"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "source object allocated here"
 msgid "%qT object created here"
 msgstr "джерельний обʼєкт джерела виділено тут"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D оголошений тут"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "використання виділеного сховища після звільнення в константному виразі"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, gcc-internal-format
 msgid "allocated here"
 msgstr "виділено тут"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr "доступ до %qE поза його терміном існування"
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "вміст неініціалізованого сховища не може бути використаний в сталому виразі"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "значення %qD не може бути використано в константному виразі"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD використовується у своєму власному ініціалізаторі"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D не є константою"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D є волатильним"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD не було ініціалізовано константним виразом"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD не було оголошено як %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD не має цілочисельного або перелічувального типу"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "модифікація виділеної пам'яті після її звільнення не є константним виразом"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "модифікація %qE поза його терміном існування не є константним виразом"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "знищення %qE поза поточним оцінюванням не є константним виразом"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "модифікація %qE поза поточним оцінюванням не є константним виразом"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "зміна активного члена об'єднання з %qD на %qD не є константним виразом до C++20"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr "%qD не починає свій термін існування неявно, оскільки %qT не має невидаленого тривіального конструктора за замовчуванням, використовуйте %<std::construct_at%> замість цього"
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr "ініціалізація %qD вимагає виразу доступу до члена як лівого операнда присвоювання"
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "зміна активного члена обʼєднання з %qD на %qD під час ініціалізації"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "кількість ітерацій циклу %<constexpr%> перевищує обмеження в %d (використовуйте %<-fconstexpr-loop-limit=%>, щоб збільшити обмеження)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "вбудована асемблерна вставка не є константним виразом"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr "у функції %<constexpr%> в C++20 дозволена лише невирахована вбудована асемблерна вставка"
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, gcc-internal-format
 msgid "use of %qD"
 msgstr "використання %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr "його значення може змінюватися між версіями компілятора або з різними прапорцями %<-mtune%> або %<-mcpu%>"
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr "якщо це використання є частиною публічного ABI, замініть його на використання константної змінної, яку ви визначаєте"
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr "значення за замовчуванням для поточної настройки процесора - %d байтів"
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr "ви можете стабілізувати це значення за допомогою %<--param hardware_destructive_interference_size=%d%>, або вимкнути це попередження за допомогою %<-Wno-interference-size%>"
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D оголошено зі специфікацією винятку"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "значення %qE типу %qT не є константним виразом"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "кількість операцій оцінки %<constexpr%> перевищує обмеження %wd (використовуйте %<-fconstexpr-ops-limit=%>, щоб збільшити обмеження)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr "керування проходить через визначення %qD з тривалістю зберігання потоку"
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "керування проходить через визначення %qD зі статичною тривалістю зберігання"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "тимчасовий обʼєкт нелітерального типу %qT в константному виразі"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 #| msgid "invalid return type %qT of %<constexpr%> function %q+D"
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "недійсний тип повернення %qT функції %q+D з атрибутом %<constexpr%>"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "%<reinterpret_cast%> не є константним виразом"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "перетворення з типу вказівника %qT до арифметичного типу %qT в константному виразі"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "Приведення типів з %qT не дозволено в константному виразі, оскільки тип, на який вказує %qT, не схожий на %qT"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "Вказаний об'єкт оголошено тут"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "Приведення типів з %qT не дозволено в константному виразі перед C++26"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "%qE не є константним виразом, коли клас %qT ще не завершений"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%<reinterpret_cast<%T>(%E)%> не є константним виразом"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "Вираз %qE не є константним виразом"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%<goto%> не є константним виразом"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "адреса виклику %qs не є константним виразом"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "вираз не є константним"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "неочікуваний вираз %qE типу %s"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, fuzzy, gcc-internal-format
 #| msgid "accessing %qE outside its lifetime"
 msgid "%qE accesses an object outside its lifetime"
 msgstr "доступ до %qE поза його терміном існування"
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "операнд 'B' не є константою"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "Умова контракту є хибною в константному виразі"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "оператор break не знаходиться у циклі або блоку switch"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> used outside of class"
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%> використовується поза класом"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "jump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "перехід до виразу заяви"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qE не є константним виразом, оскільки він посилається на змінні підобʼєкти %qT"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qE не є константним виразом, оскільки він посилається на результат %<operator new%>"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qE не є константним виразом, оскільки він посилається на результат %<operator new%>"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qE не є константним виразом, оскільки виділене сховище не було звільнено"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr "негайна оцінка повертає адресу негайної функції %qD"
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "Оцінка константи повертає адресу негайної функції %qD"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qE не є константним виразом, оскільки він посилається на неповністю ініціалізовану змінну"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qs не є константним виразом, оскільки %qT містить тип вказівника"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "перетворення lvalue в rvalue від volatile lvalue %qE з типом %qT"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "захоплення лямбди %qE не є константним виразом"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr "тому що воно використовується як glvalue"
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "%<reinterpret_cast%> з цілого числа в вказівник"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "адреса обʼєкта %qE з потоковим локальним або автоматичним сховищем не є константним виразом"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "вираз лямбди не є константним виразом до C++17"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "вираз new не є константним виразом до C++20"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, gcc-internal-format
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "віртуальні функції не можуть бути %<constexpr%> до C++20"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "%<typeid%> не є константним виразом, оскільки %qE має поліморфний тип"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "приведення до нецілочисельного типу %qT в константному виразі"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qD визначено %<thread_local%> в контексті %<constexpr%>"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%qD визначено %<static%> в контексті %<constexpr%>"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "ділення на нуль не є константним виразом"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%<delete[]%> не є константним виразом"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "жодна гілка %<if%> не є константним виразом"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "не константна ініціалізація масиву"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 #| msgid "label definition in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "визначення мітки в функції %<constexpr%> доступне лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "неочікуваний AST типу %s"
@@ -58605,416 +58662,416 @@ msgstr "жоден операнд дизʼюнкції не задовольня
 msgid "the operand %qE is unsatisfied because"
 msgstr "операнд %qE не задовольняється, оскільки"
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy assignable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "  %qT не може бути присвоєно без винятків"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow default constructible"
 msgstr "  %qT не може бути створено без винятків за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "%qT is not nothrow copy constructible"
 msgstr "  %qT не може бути скопійовано без винятків за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially copy assignable"
 msgid "%qT is not trivially copy assignable"
 msgstr "  %qT не може бути присвоєно тривіальним чином"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially default constructible"
 msgid "%qT is not trivially default constructible"
 msgstr "  %qT не може бути створено тривіальним чином за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially copy constructible"
 msgid "%qT is not trivially copy constructible"
 msgstr "  %qT не може бути скопійовано тривіальним чином за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially destructible"
 msgid "%qT is not trivially destructible"
 msgstr "  %qT не може бути знищено тривіальним чином"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "%qT does not have unique object representations, because"
 msgstr "  %qT не має унікальних представлень обʼєктів"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have a virtual destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "  %qT не має віртуального деструктора"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an abstract class"
 msgid "%qT is not an abstract class"
 msgstr "  %qT не є абстрактним класом"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an aggregate"
 msgid "%qT is not an aggregate"
 msgstr "  %qT не є агрегатом"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an array"
 msgid "%qT is not an array"
 msgstr "  %qT не є масивом"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not assignable from %qT"
 msgid "%qT is not assignable from %qT, because"
 msgstr "  %qT не може бути присвоєним з %qT"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT не є базою для %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a bounded array"
 msgid "%qT is not a bounded array"
 msgstr "  %qT не є обмеженим масивом"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T не є класом"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a const type"
 msgstr "%qT не є типом класу"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not default constructible, because"
 msgstr "  %qT не може бути cконструйованим за замовчуванням"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not constructible from %qE"
 msgid "%qT is not constructible from %qT, because"
 msgstr "  %qT не може бути сконструйованим з %qE"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not destructible, because"
 msgstr "%q+T не є літеральним, тому що:"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an empty class"
 msgid "%qT is not an empty class"
 msgstr "  %qT не є порожнім класом"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an enum"
 msgid "%qT is not an enum"
 msgstr "  %qT не є перелічуванням"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a final class"
 msgid "%qT is not a final class"
 msgstr "  %qT не є заключним класом"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "%qT is not a function"
 msgstr "  %qT не є функцією"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT не є типом шаблону"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not invocable, because"
 msgstr "%q+T не є літеральним, тому що:"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qD не є змінною в замиканні %qs"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not layout compatible with %qT"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "  %qT не сумісний за макетом з %qT"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a literal type"
 msgid "%qT is not a literal type"
 msgstr "  %qT не є літеральним типом"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member function pointer"
 msgid "%qT is not a member function pointer"
 msgstr "  %qT не є вказівником на член-функцію"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member object pointer"
 msgid "%qT is not a member object pointer"
 msgstr "  %qT не є вказівником на член-об'єкт"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member pointer"
 msgid "%qT is not a member pointer"
 msgstr "  %qT не є вказівником на член"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow assignable from %qT"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "  %qT не може бути присвоєним з nothrow з %qT"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "  %qT не може бути створено без винятків за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow constructible from %qE"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "  %qT не може бути сконструйованим з nothrow з %qE"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow convertible from %qE"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "  %qT не може бути безпечно перетворений з %qE"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow destructible, because"
 msgstr "  %qT не може бути створено без винятків за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%q+T не є літеральним, тому що:"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow assignable from %qT"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "  %qT не може бути присвоєним з nothrow з %qT"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT is not an object type"
 msgstr "  %qT не є типом об'єкта"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not pointer-interconvertible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "  %qT не є базовим типом, який можна конвертувати в вказівник, для %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a POD type"
 msgid "%qT is not a POD type"
 msgstr "  %qT не є типом POD (Plain Old Data)"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member pointer"
 msgid "%qT is not a pointer"
 msgstr "  %qT не є вказівником на член"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a polymorphic type"
 msgid "%qT is not a polymorphic type"
 msgstr "  %qT не є поліморфним типом"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference"
 msgid "%qT is not a reference"
 msgstr "  %qT не є посиланням"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not the same as %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "  %qT не є таким самим, як %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a scoped enum"
 msgid "%qT is not a scoped enum"
 msgstr "  %qT не є обмеженим перерахуванням"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an standard layout type"
 msgid "%qT is not a standard layout type"
 msgstr "  %qT не є типом зі стандартним розташуванням"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a trivial type"
 msgid "%qT is not a trivial type"
 msgstr "  %qT не є тривіальним типом"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially assignable from %qT"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "  %qT не може бути тривіально присвоєним з %qT"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially default constructible"
 msgid "%qT is not trivially default constructible, because"
 msgstr "  %qT не може бути створено тривіальним чином за допомогою конструктора за замовчуванням"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially constructible from %qE"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "  %qT не може бути тривіально сконструйованим з %qE"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially copyable"
 msgid "%qT is not trivially copyable"
 msgstr "  %qT не є тривіально копійованим"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not trivially destructible"
 msgid "%qT is not trivially destructible, because"
 msgstr "  %qT не може бути знищено тривіальним чином"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a bounded array"
 msgid "%qT is not an unbounded array"
 msgstr "  %qT не є обмеженим масивом"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a union"
 msgid "%qT is not a union"
 msgstr "  %qT не є обʼєднанням"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a direct base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT не є прямим базовим класом %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT не є типом шаблону"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "%q#D is not const"
-msgid "%qT is not consteval-only"
-msgstr "%q#D не є константою"
+#| msgid "  %qT is not a literal type"
+msgid "%qT is not a structural type"
+msgstr "  %qT не є літеральним типом"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE не може бути використано як функцію"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs and %qs cannot both be enabled"
 msgid "%qT and %qT cannot be ordered"
 msgstr "%qs і %qs не можуть бути обидва увімкнені"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not destructurable"
 msgstr "  %qT не може бути cконструйованим за замовчуванням"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr "  %qT не є посиланням, яке звʼязується з тимчасовим обʼєктом типу %qT (пряма ініціалізація)"
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr "  %qT не є посиланням, яке звʼязується з тимчасовим обʼєктом типу %qT (ініціалізація копіюванням)"
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "  %qD is not deducible from %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "  %qD не може бути виведений з %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, gcc-internal-format
 msgid "invalid constraints"
 msgstr "недійсні обмеження"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr "обмеження %qE має тип %qT, а не %<bool%>"
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "вираз %qE обчислюється як %<false%>"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "обмеження не виконуються"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr "встановити %qs як мінімум %d для більш детальної інформації"
@@ -59046,49 +59103,49 @@ msgstr "декларація має іншу кількість контракт
 msgid "previous declaration with fewer contracts here"
 msgstr "початкова декларація з меншою кількістю контрактів тут"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here"
 msgid "parameter declared here"
 msgstr "перевизначено тут"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "декларація додає контракти до %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "first declared here"
 msgstr " оголошено тут"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, gcc-internal-format
 msgid "constructor does not return a value to test"
 msgstr "Конструктор не повертає значення для перевірки"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, gcc-internal-format
 msgid "destructor does not return a value to test"
 msgstr "Деструктор не повертає значення для перевірки"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, gcc-internal-format
 msgid "function does not return a value to test"
 msgstr "функція не повертає значення для перевірки"
@@ -59163,7 +59220,7 @@ msgstr "тип promise для корутини %qT оголошує як %<retur
 msgid "%<return_void%> declared here"
 msgstr "%<return_void%> оголошено тут"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "немає члена з іменем %qE в %qT"
@@ -59236,85 +59293,85 @@ msgstr "тип %qT, на якому можна очікувати, не є ст
 msgid "awaitable type %qT is not a structure"
 msgstr "тип %qT, на якому можна очікувати, не є структурою"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr "%<await_suspend%> повинен повертати %<void%>, %<bool%> або обробник корутини"
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot be used in a varargs function"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qs не може використовуватися в функції зі змінною кількістю аргументів"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "функція, оголошена з %<noreturn%>, має оператор %<co_return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, gcc-internal-format
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "аргумент align для %<__builtin_coro_promise%> має бути константою"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, gcc-internal-format
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "аргумент direction для %<__builtin_coro_promise%> має бути константою"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "немає інформації про точку призупинення для %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, gcc-internal-format
 msgid "duplicate info for %qE"
 msgstr "дубльована інформація для %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, gcc-internal-format
 msgid "await expressions are not permitted in handlers"
 msgstr "вирази await не допускаються в обробниках"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "масиви змінної довжини ще не підтримуються в корутин"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr "%qE надається %qT, але не може бути використаний зі сигнатурою функції %qD"
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr "%qE надається %qT, але %qE не позначений %<throw()%> або %<noexcept%>"
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr "%qE позначений %<throw()%> або %<noexcept%>, але %qT не надає жодного використовуваного %<get_return_object_on_allocation_failure%>"
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr "%qE надається %qT, але %<std::nothrow%> не знайдено"
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "%qE надається %qT, але не може бути використаний зі сигнатурою функції %qD"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -59340,68 +59397,74 @@ msgstr "%qD було підвищено до негайної функції"
 msgid "%qs used outside of constant expressions"
 msgstr "%qE не є константним виразом"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "очікується декларація"
+
+#: cp/cp-gimplify.cc:1317
 #, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "береться адреса негайної функції %qD"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "Виклик функції consteval %qE не є константним виразом"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%<throw%> завжди викликає %<terminate%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "у C++11 деструктори за замовчуванням є %<noexcept%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr "у C++11 цей %<throw%> викличе %<terminate%>, оскільки деструктори за замовчуванням є %<noexcept%>"
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "ігнорується атрибут %qE після попереднього %qE"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "розширення пакунку атрибуту %qE"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr "використовуйте складний вираз в аргументі атрибуту замість цього"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD не є типом"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qD не є типом класу"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qD не має типу %<const char *%>"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qD не має цілочисельного типу"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr "%<std::source_location::__impl%> містить не тільки нестатичні елементи даних %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> і %<_M_column%>"
@@ -59442,7 +59505,7 @@ msgstr "перетворення на неконстантне посиланн
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "конвертація з %qH до %qI відкидає кваліфікатори"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "приведення типу %qT до %qT не розіменовує вказівник"
@@ -59833,7 +59896,7 @@ msgstr "з попереднього оголошення %qF"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "повторне оголошення %qD відрізняється в %qs від попереднього оголошення"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "попереднє оголошення %qD"
@@ -60055,12 +60118,12 @@ msgstr "задано типовий аргумент для параметра %
 msgid "previous specification in %q#D here"
 msgstr "попередня специфікація в %q#D тут"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, gcc-internal-format
 msgid "conflicting exporting for declaration %qD"
 msgstr "конфліктний експорт для оголошення %qD"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "попередньо оголошено тут без експортування"
@@ -60266,7 +60329,7 @@ msgstr "  пропускає ініціалізацію %q#D"
 msgid "  enters %<template for%> statement"
 msgstr "  входить у інструкцію %<constexpr if%>"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, gcc-internal-format
 msgid "%qD used without template arguments"
 msgstr "%qD використовується без аргументів шаблону"
@@ -60311,672 +60374,672 @@ msgstr "%<typename %T::%D%> називає %q#D, який не є типом"
 msgid "template parameters do not match template %qD"
 msgstr "параметри шаблону не відповідають шаблону %qD"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "%<-faligned-new=%d%> не є степенем двійки"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr "%<--param destructive-interference-size=%d%> менше ніж %d"
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param destructive-interference-size=%d%> менше ніж %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr "%<--param constructive-interference-size=%d%> менше ніж %d"
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr "%<--param constructive-interference-size=%d%> більше ніж %<--param l1-cache-line-size=%d%>"
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q#D недійсний; анонімний обʼєднання може мати тільки публічні нестатичні члени даних"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr "ця гнучкість застаріла і буде видалена"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr "анонімна структура з базовими класами"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "член %q+#D з конструктором не допускається в анонімному агрегаті"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "член %q+#D з деструктором не допускається в анонімному агрегаті"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "член %q+#D з оператором присвоєння копіювання не допускається в анонімному агрегаті"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "атрибут ігнорується в оголошенні %q#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "атрибут для %q#T повинен слідувати за ключовим словом %qs"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "декілька типів в одному оголошенні"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "повторне оголошення вбудованого типу C++ %qT"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> може бути вказано тільки для змінних або оголошень функцій"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "відсутнє імʼя типу в оголошенні typedef"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ забороняє анонімні структури"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "%<inline%> може бути вказано тільки для функцій"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%<virtual%> може бути вказано лише для функцій"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> може бути вказано лише всередині класу"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> може бути вказано лише для конструкторів"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "клас сховища може бути вказано лише для обʼєктів та функцій"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%<const%> може бути вказано лише для обʼєктів та функцій"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%<volatile%> може бути вказано лише для обʼєктів та функцій"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%<__restrict%> може бути вказано лише для обʼєктів та функцій"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%<__thread%> може бути вказано лише для обʼєктів та функцій"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> було проігноровано в цьому оголошенні"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%qs не може бути використано для оголошень типів"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "атрибут проігноровано в явному інстанціюванні %q#T"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "неможливо застосувати атрибут до явного інстанціювання"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "атрибут ігнорується"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "атрибут, що належить до типового специфікатора, ігнорується"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "ігноруються атрибути, застосовані до класового типу %qT поза визначенням"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "ігноруються атрибути, застосовані до залежного типу %qT без повʼязаного оголошення"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD ініціалізовано (використовуйте %qs замість)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "оголошення %q#D має %<extern%> та ініціалізовано"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "визначення %q#D має маркування %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q+#D не є статичним членом даних %q#T"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "декларація неметодного шаблону %qD"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "не відповідає декларації методного шаблону тут"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ не дозволяє визначати %<%T::%D%> як %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "подвійна ініціалізація %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "декларація %q#D поза класом не є визначенням"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr "оголошення зовнішньої області блоку %q#D не повинно бути прикріпленим до іменованого модуля"
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD, визначений як %<thread_local%> у функції %qs, доступний лише з опцією %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 #| msgid "%qD defined %<static%> in %qs function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD може бути визначено %<static%> тільки в функції %qs, доступній лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "змінна %q#D має ініціалізатор, але неповний тип"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "елементи масиву %q#D мають неповний тип"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "агрегат %q#D має неповний тип і не може бути визначений"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD оголошено як посилання, але не ініціалізовано"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "імʼя, використане в GNU-стилі призначеного ініціалізатора для масиву"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "імʼя %qD використане в GNU-стилі призначеного ініціалізатора для масиву"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "не підтримуються складні призначені ініціалізатори"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "індикатор C99 %qE не є цілочисельним константним виразом"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "ініціалізатор не вдалося визначити розмір %qD"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "відсутній розмір масиву в %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "масив нульового розміру %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "розмір сховища %qD невідомий"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "розмір сховища %qD не є сталим"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "вибачте: семантика вбудованої змінної %q#D неправильна (ви отримаєте кілька копій)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "вибачте: семантика статичних даних вбудованої функції %q#D неправильна (ви отримаєте кілька копій)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "Ви можете обійти це, видаливши ініціалізатор"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, gcc-internal-format
 msgid "uninitialized %<const %D%>"
 msgstr "неініціалізована %<const %D%>"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "неініціалізована змінна %qD у функції %<constexpr%>"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "неініціалізована змінна %qD у контексті %<constexpr%>"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T не має конструктора за замовчуванням, наданого користувачем"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "конструктор не наданий користувачем, оскільки він явно заданий за замовчуванням у тілі класу"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "і неявно визначений конструктор не ініціалізує %q#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "недійсний тип %qT як ініціалізатор для вектора типу %qT"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "ініціалізатор для %qT повинен бути включений у фігурні дужки"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%<[%E] =%> використовується в ініціалізаторі з вказівкою у стилі GNU для класу %qT"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "запит на член %qD є неоднозначним"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT не має нестатичного члена даних з іменем %qD"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD не є прямим членом %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "недійсний ініціалізатор для %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "C99-означення %qE поза агрегатним ініціалізатором"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "занадто багато ініціалізаторів для %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "фігурні дужки навколо скалярного ініціалізатора для типу %qT"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, gcc-internal-format
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "занадто багато фігурних дужок навколо скалярного ініціалізатора для типу %qT"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "відсутні фігурні дужки навколо ініціалізатора для %qT"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "структуроване привʼязування має неповний тип %qT"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "елементи масиву %q#T мають неповний тип"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "складний літерал змінної розмірності"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D має неповний тип"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "скалярний обʼєкт %qD вимагає одного елемента в ініціалізаторі"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "у C++98 %qD повинен бути ініціалізований конструктором, а не %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "масив %qD ініціалізований укладеною у дужки літеральною рядковою константою %qE"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "ініціалізатор недійсний для статичного члена з конструктором"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "недопустима неконстантна ініціалізація в класі для статичного члена %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "недопустима неконстантна ініціалізація в класі для неінлайнового статичного члена %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(потрібна ініціалізація поза класом)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "запитано адресу явної регістрової змінної %qD"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "посилання %qD ініціалізовано самим собою"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be a pointer type"
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "аргумент %d з %qE повинен бути типом вказівника"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "не вдалося знайти оголошення варіанту"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "%<declare variant%> на конструкторі %qD"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "%<declare variant%> на деструкторі %qD"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr "%<declare variant%> на за замовчуванням %qD"
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr "%<declare variant%> на видаленому %qD"
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr "%<declare variant%> на віртуальному %qD"
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "присвоєння (не ініціалізація) в оголошенні"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++17 не дозволяє специфікатору класу зберігання %<register%>"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr "використано специфікатор класу зберігання %<register%>"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "оголошення %q#D не має ініціалізатора"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "ініціалізатор для %<decltype(auto) %D%> має тип функції; ви забули %<()%>?"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, gcc-internal-format
 msgid "deduced type %qT for %qD is incomplete"
 msgstr "визначений тип %qT для %qD є неповним"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be defaulted"
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD не може бути заданий за замовчуванням"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "затінення попереднього оголошення типу %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "Атрибут %<constinit%> може бути застосований лише до змінної зі статичною або потоковою тривалістю зберігання"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "структуровані привʼязки доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "функція %q#D ініціалізується як змінна"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "не можу розкласти тип замикання лямбди %qT"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "lambda declared here"
 msgstr " оголошено тут"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "не можна розкласти клас типу %qT, оскільки він має анонімний структурний член"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr "не можна розкласти клас типу %qT, оскільки він має анонімний член обʼєднання"
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "не можна розкласти недоступний член %qD класу %qT"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT не є вкладеним класом в %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr "не можна розкласти клас типу %qT: як він сам, так і його базовий клас %qT мають нестатичні елементи даних"
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr "не вдається розкласти клас типу %qT: його базові класи %qT та %qT мають нестатичні члени даних"
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "структуроване привʼязування посилається на неповний тип %qT"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 #| msgid "cannot value-initialize array of unknown bound %qT"
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "не можна ініціалізувати значення масиву з невідомою межею %qT"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "не можу розкласти масив змінної довжини %qT"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "не можу розкласти вектор змінної довжини %qT"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "%<std::tuple_size<%T>::value%> не є сталим цілочисельним виразом"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "не можу розкласти обʼєднаний тип %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "не можу розкласти тип, який не є масивом або класом %qT"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "структуроване звʼязування посилається на неповний класовий тип %qT"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for structured binding declaration"
 msgid "array initializer for structured binding declaration in condition"
 msgstr "недійсний ініціалізатор для оголошення структурованої привʼязки"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
@@ -60984,7 +61047,7 @@ msgstr[0] "надано %u імʼя для структурованого при
 msgstr[1] "надано %u імен для структурованого привʼязування"
 msgstr[2] "надано %u імен для структурованого привʼязування"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
@@ -60992,7 +61055,7 @@ msgstr[0] "тільки %u імʼя надано для структурован
 msgstr[1] "тільки %u імен надано для структурованого привʼязування"
 msgstr[2] "тільки %u імен надано для структурованого привʼязування"
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
@@ -61000,1752 +61063,1764 @@ msgstr[0] "під час розкладання %qT на %wu елемент"
 msgstr[1] "під час розкладання %qT на %wu елементи"
 msgstr[2] "під час розкладання %qT на %wu елементів"
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr "під час розкладання %qT на %E елементів"
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, fuzzy, gcc-internal-format
 #| msgid "%<std::tuple_element<%u, %T>::type%> is %<void%>"
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr "%<std::tuple_element<%u, %T>::type%> є %<void%>"
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 #| msgid "in initialization of structured binding variable %qD"
 msgid "in initialization of structured binding pack %qD"
 msgstr "при ініціалізації змінної структурованого звʼязування %qD"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "при ініціалізації змінної структурованого звʼязування %qD"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "не можливо розкласти класовий тип %qT без нестатичних членів даних"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr "нелокальна змінна %qD, оголошена %<__thread%>, потребує динамічної ініціалізації"
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "нелокальна змінна %qD, оголошена %<__thread%>, має незвичайний деструктор"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr "C++11 %<thread_local%> дозволяє динамічну ініціалізацію та знищення"
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "ініціалізатор не визначає розмір %qT"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "відсутній розмір масиву в %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "масив нульового розміру %qT"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "деструктор для класу-іноземця %qT не може бути членом"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "конструктор для класу-іноземця %qT не може бути членом"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD оголошено як %<virtual%> змінна"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "Специфікатори функції %<const%> та %<volatile%> на %qD недійсні в оголошенні змінної"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD оголошено як %<virtual%> параметр"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD оголошено як %<inline%> параметр"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "Специфікатори функції %<const%> та %<volatile%> на %qD недійсні в оголошенні параметра"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD оголошено як %<virtual%> тип"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD оголошено як %<inline%> тип"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "Специфікатори функції %<const%> та %<volatile%> на %qD недійсні в оголошенні типу"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD оголошено як %<virtual%> поле"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD оголошено як %<inline%> поле"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "Специфікатори функції %<const%> та %<volatile%> на %qD недійсні в оголошенні поля"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D оголошено як «friend»"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D оголошено зі специфікацією винятку"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "визначення %qD не знаходиться в просторі імен, що оточує %qT"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "статична функція-член %q#D оголошена з кваліфікаторами типу"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "іменовані значення повернення більше не підтримуються"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, gcc-internal-format
 msgid "constraints on a non-templated function"
 msgstr "обмеження на функцію без шаблону"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "обмежений оголошення друга, який не є шаблоном, повинен бути визначенням"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr "шаблон дружньої функції з обмеженнями, що залежать від зовнішніх параметрів шаблону, повинен бути визначенням"
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "визначення явної спеціалізації %qD в декларації друга"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "неприпустиме використання ідентифікатора шаблона %qD в декларації основного шаблону"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "значення за замовчуванням не дозволені в декларації спеціалізації дружнього шаблону %qD"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> не дозволено в оголошенні спеціалізації дружнього шаблону %qD"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "оголошення-друга %qD вказує на аргументи за замовчуванням і не є визначенням"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "не можна оголосити %<::main%> як шаблон"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "не можна оголосити %<::main%> як inline"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "не можна оголосити %<::main%> як %qs"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "не можна оголосити %<::main%> як static"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "не можна оголосити %<::main%> як шаблон"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "функція, не є членом %qD, не може мати cv-кваліфікатор"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "статична функція-член %qD не може мати cv-кваліфікатор"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "явна функція-член об'єкта %qD не може мати cv-кваліфікатора"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "функція, не є методом класу %qD, не може мати кваліфікатор посилання"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "статичний метод класу %qD не може мати кваліфікатор посилання"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "явна функція-член об'єкта %qD не може мати ref-кваліфікатора"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, gcc-internal-format
 msgid "explicit object parameter declared here"
 msgstr "явний параметр об'єкта оголошено тут"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "посібник з виведення %qD повинен бути оголошений в тому ж області видимості, що й %qT"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "  оголошено тут"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "посібник з виведення %qD повинен мати такий самий доступ, як %qT"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr "посібник з виведення %qD не повинен мати тіла функції"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "літеральний оператор зі звʼязком C"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD має недійсний список аргументів"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "суфікс цілого числа %qs затінений реалізацією"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "суфікс числа з плаваючою комою %qs затінений реалізацією"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "суфікси операторів літералів, які не передують %<_%>, зарезервовані для майбутньої стандартизації"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD повинна бути функцією, що не є членом"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> повинна повертати %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "визначення неявно оголошеної %qD"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "визначення явно за замовчуванням %qD"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q#D явно задано тут"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "не оголошено жодної член-функції %q#D в класі %qT "
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "не можна оголосити %<::main%> глобальною змінною"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "нетемплейтна змінна не може бути %<concept%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "концепцію слід визначати на рівні простору імен"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "іменовані значення повернення більше не підтримуються"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "ініціалізація в класі статичного елемента даних %q#D неповного типу"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "потрібно %<constexpr%> для ініціалізації в класі статичного елемента даних %q#D не-цілочисельного типу"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "ініціалізація в класі статичного елемента даних %q#D не літерального типу"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "недійсна ініціалізація в класі статичного члена даних не-цілочисельного типу %qT"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ забороняє ініціалізацію в класі неконстантного статичного члена %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ забороняє ініціалізацію константного члена %qD не-цілочисельного типу %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "розмір масиву %qD має нецілочисельний тип %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "розмір масиву має нецілочисельний тип %qT"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "розмір масиву %qD не є цілочисельним сталим виразом"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "розмір масиву не є цілочисельним сталим виразом"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ забороняє масив нульового розміру %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ забороняє масив нульового розміру"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ забороняє масив змінної довжини %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ забороняє масив змінної довжини"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "використовується масив змінної довжини %qD"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "використовується масив змінної довжини"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "переповнення в розмірі масиву"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD оголошено як масив типу заповнювача шаблону %qT"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, gcc-internal-format
 msgid "creating array of template placeholder type %qT"
 msgstr "створення масиву типу заповнювача шаблону %qT"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "оголошення %qD як масиву типу void"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "створення масиву типу void"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "оголошення %qD як масиву функцій"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "створення масиву функцій"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "оголошення %qD як масиву посилань"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "створення масиву посилань"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "оголошення %qD як масиву елементів-функцій"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "створення масиву з функційними елементами"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "оголошення %qD як багатовимірного масиву повинно мати межі для всіх вимірів, крім першого"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "багатовимірний масив повинен мати межі для всіх вимірів, крім першого"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr "масив змінної довжини з %<auto%>"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "недійсна специфікація типу повернення для конструктора"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "кваліфікатори не дозволені в оголошенні конструктора"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "недійсна специфікація типу повернення для деструктора"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "кваліфікатори не дозволені в оголошенні деструктора"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "вказано тип повернення для оператора %<operator %T%>"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "кваліфікатори не дозволені при оголошенні %<operator %T%>"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, gcc-internal-format
 msgid "return type specified for deduction guide"
 msgstr "тип повернення вказаний для довідника виведення"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "кваліфікатори не дозволені в оголошенні довідника виведення"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "параметр шаблону шаблону %qT в оголошенні довідника виведення"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "%<decl-specifier%> в оголошенні довідника виведення"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "неіменована змінна або поле оголошені як void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "змінна або поле оголошені як void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "специфікатор %<inline%> недійсний для змінної %qD, оголошеної в області блоку"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "змінні «inline» доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it has a base class"
 msgstr "тип несумісний з його варіантом"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "type is not compatible with its variant"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "тип несумісний з його варіантом"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr "%qT як тип, а не просто %<decltype(auto)%>"
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, gcc-internal-format
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "%<decltype(auto)%> не може мати кваліфікаторів cv"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together"
 msgid "%e and %e specified together"
 msgstr "%<signed%> і %<unsigned%> вказані разом"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "неправильне використання кваліфікованого імені %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "неправильне використання кваліфікованого імені %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "неправильне використання кваліфікованого імені %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, gcc-internal-format
 msgid "%q#T is not a class or namespace"
 msgstr "%q#T не є класом або простором імен"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, gcc-internal-format
 msgid "declaration of %qE as non-function"
 msgstr "оголошення %qE як не-функції"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, gcc-internal-format
 msgid "declaration of %qE as non-member"
 msgstr "оголошення %qE як не-члена"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "відсутній ідентифікатор декларатора; використовується зарезервоване слово %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "визначення функції не оголошує параметри"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "оголошення %qD як не-функції"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "оголошення %qD як %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "оголошення %qD як параметра"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr "вказано як %qs, так і %qs"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%qs не може зʼявлятися в оголошенні typedef"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr "можна використовувати не більше одного зі специфікаторів %<constinit%> та %<constexpr%>"
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "два або більше типи даних в оголошенні %qs"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C++ не підтримує просте значення %<complex%>, що означає %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ забороняє декларацію %qs без типу"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int%d%> не підтримується цільовою платформою"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ не підтримує %<__int%d%> для %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qs вказано з %qT"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qs вказано з іменем typedef %qD"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qs вказано з %<decltype%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qs вказано з %<typeof%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "комплексне число недійсне для %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr "відсутній список аргументів шаблону після %qE; для виведення, заповнювач шаблону повинен слідувати за простим ідентифікатором декларатора"
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "елемент %qD не може бути одночасно оголошений як %<virtual%> та %<static%>"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "елемент %qD може бути оголошений як %<virtual%> та %<constexpr%> лише в %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "оголошення typedef недійсне в оголошенні параметра"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "вказано специфікатор зберігання для параметра шаблону %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "вказано специфікатор зберігання для параметра %qs"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "параметр не може бути оголошений як %qs"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> поза оголошенням класу"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "оголошення структурованого звʼязування не може бути %qs"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 #| msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "декларація структурованого звʼязування може бути тільки %qs у %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "декларація структурованого звʼязування може бути тільки %qs у %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "структуроване звʼязування з %<volatile%> є застарілим"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "оголошення структурованого звʼязування не може бути C++98 %<auto%>"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "оголошення структурованого звʼязування не може мати тип %qT"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr "тип повинен бути cv-кваліфікованим %<auto%> або посиланням на cv-кваліфікований %<auto%>"
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "оголошення структурованого звʼязування не може мати обмежений %<auto%> тип %qT"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "оголошення %qs має кілька класів зберігання"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "вказано клас зберігання для %qs"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "вкладена функція %qs оголошена %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "оголошення верхнього рівня для %qs вказує %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "функція %qs в області видимості функції неявно має тип auto і оголошена %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "специфікатори класу зберігання недійсні в оголошеннях дружніх функцій"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, gcc-internal-format
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "зайві дужки в оголошенні %qs"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, gcc-internal-format
 msgid "remove parentheses"
 msgstr "видалити дужки"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "явна функція-член об'єкта доступна тільки з %<-std=c++23%> або %<-std=gnu++23%>"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "тип функції не може мати явного параметра об'єкта"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "вказівник на тип функції не може мати явного параметра об'єкта"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "вказівник на тип функції-члена не може мати явного параметра об'єкта"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr "тип вказівника на явну членську функцію об'єкта є звичайним вказівником на тип функції"
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "тип явної функції-члена об'єкта є звичайним типом функції"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr "тільки перший параметр членської функції може бути оголошений як явний об'єктний параметр"
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr "дійсний явний параметр об'єкта оголошено тут"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "замикання requires в типі повернення"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "функція %qs використовує специфікатор типу %<auto%> без наступного типу повернення"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "Визначений тип повернення доступний лише з %<-std=c++14%> або %<-std=gnu++14%>"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "Віртуальна функція не може мати визначений тип повернення"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "Функція %qs з типом повернення в кінці має тип %qT, а не простий %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "Функція %qs з типом повернення в кінці має тип %<decltype(auto)%>, а не простий %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "Неправильне використання %<decltype(auto)%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "Функція %qs з типом повернення в кінці має тип %qT, а не простий %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "недійсне використання конструктора як шаблону"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "Виявлений тип класу %qD в типі повернення функції"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "Посібник з виведення для %qT повинен мати тип повернення в кінці"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr "Тип повернення в кінці %qT посібника з виведення не є спеціалізацією %qT"
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Тип повернення в кінці доступний лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "Функція %qs з приєднаним типом повернення не оголошена зі специфікатором типу %<auto%>"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "Функція перетворення не може мати приєднаний тип повернення"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "Тип повернення з кваліфікатором %<volatile%> є застарілим"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs оголошено як функцію, що повертає функцію"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs оголошено як функцію, що повертає масив"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<constinit%> на типі повернення функції не дозволено"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "Деструктор не може бути статичною функцією-членом"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "Конструктор не може бути статичною функцією-членом"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "Деструктори не можуть мати кваліфікаторів cv"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "Конструктори не можуть мати кваліфікаторів cv"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "Деструктори не можуть мати кваліфікаторів ref"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "Конструктори не можуть мати кваліфікаторів ref"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "конструктори не можуть бути оголошені як %<virtual%>"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "віртуальні функції не можуть бути друзями"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "Оголошення друзів не визначено в описі класу"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "Не можна визначити дружню функцію %qs в описі локального класу"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr "визначення friend-функції %qs не може мати імені, яке кваліфіковане з %<::%>"
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr "визначення friend-функції %qs не може мати імені, яке кваліфіковане з %<%D::%>"
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "не-членська функція не може мати явного параметра об'єкта"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "явна функція-член об'єкта не може бути %<віртуальною%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "явна членська функція об'єкта не може бути %<static%%>"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD не може бути явною членською функцією об'єкта"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "деструктори не можуть мати параметрів"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "не можна оголосити вказівник на %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "не можна оголосити посилання на %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "не можна оголосити вказівник на елемент %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "не можна оголосити посилання на кваліфікований тип функції %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "не можна оголосити вказівник на кваліфікований тип функції %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "не можна оголосити посилання на %q#T, який не є псевдонімом або аргументом типу шаблону"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "ідентифікатор шаблону %qD використовується як декларатор"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "члени-функції є неявними друзями свого класу"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "додаткова кваліфікація %<%T::%> на члені %qs"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "не можна визначити метод %<%T::%s%> всередині %qT"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "не можна оголосити метод %<%T::%s%> всередині %qT"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "не можна оголосити член %<%T::%s%> всередині %qT"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "непараметр %qs не може бути пакетом параметрів"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "член даних не може мати змінно-модифікований тип %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "параметр не може мати змінно-модифікований тип %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<explicit%> поза оголошенням класу"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<explicit%> в оголошенні friend"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "тільки оголошення конструкторів та операторів перетворення можуть бути %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "неможливо оголосити неметод %qs як %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "неможливо оголосити неметод %qs як %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "функцію %qs не можна оголосити як %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "%qs не може бути оголошено як %<mutable%>, оскільки воно %<static%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "%qs не може бути оголошено як %<mutable%>, оскільки воно %<const%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "посилання %qs не може бути оголошено як %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "typedef не може бути визначенням функції"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "typedef не може бути визначенням методу класу"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<auto%> не дозволено в оголошенні псевдоніма"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef оголошено як %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr "замикання «requires» на typedef"
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "Імʼя typedef не може бути вкладеним іменем-специфікатором"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ забороняє вкладений тип %qD з таким самим імʼям, як усамітнюючий клас"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> вказано для декларації класу friend"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "Параметри шаблону не можуть бути друзями"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "Декларація friend вимагає ключ класу, тобто %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "декларація друга потребує ключ-класу, тобто %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "Спроба зробити клас %qT другом глобального обсягу"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "недійсні кваліфікатори на типі функції, яка не є членом"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr "замикання requires на тип-ідентифікаторі"
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "абстрактний декларатор %qT використовується як декларація"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "замикання requires в декларації типу, що не є функцією %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "не можна використовувати %<::%> в декларації параметра"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "не можна оголосити параметр з %<decltype(auto)%>"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr "відсутній список аргументів шаблона після %qE; шаблонний заповнювач не допускається в параметрі"
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "або використовуйте %<auto%> для скороченого шаблону функції"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%<auto%> параметр не допускається в цьому контексті"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "параметр оголошено як %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "недійсне використання імені шаблону %qE без списку аргументів"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "член даних, оголошений як нестатичний з заповнювачем %qT"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ забороняє гнучкий елемент масиву %qs"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, gcc-internal-format
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C++ забороняє гнучкі елементи масиву"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "недійсне використання %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "оголошення функції %qD в недійсному контексті"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "функцію %qD оголошено як %<virtual%> всередині обʼєднання"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD не може бути оголошено як %<virtual%>, оскільки воно завжди статичне"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "очікувався кваліфікований ідентифікатор у декларації friend для деструктора %qD"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "оголошення %qD як члена %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "деструктор не може бути %qs"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "очікувався кваліфікований ідентифікатор у декларації friend для конструктора %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "конструктор не може бути %<concept%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "концепція не може бути методом класу"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%qD не може бути %qs"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "спеціалізація шаблону змінної %qD оголошена як функція"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr "шаблон змінної оголошено тут"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "поле %qD має неповний тип %qT"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "імʼя %qT має неповний тип"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE не є функцією або методом класу; не може бути оголошений другом"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "безіменне поле не є функцією або методом класу; не може бути оголошений другом"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+#| msgid "%qE attribute applied to extern \"C\" declaration %qD"
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "атрибут %qE застосовується до зовнішньої «C»-декларації %qD"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "визначення явної спеціалізації %qD в декларації друга"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "атрибут, що належить до декларації друга, яка не є визначенням, ігнорується"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "статичний член даних %qE оголошений як %qs"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "статичний член даних %<constexpr%> %qD повинен мати ініціалізатор"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "нестатичний елемент даних %qE оголошений як %qs"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "клас зберігання %<auto%> недійсний для функції %qs"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "клас зберігання %<register%> недійсний для функції %qs"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "клас зберігання %<__thread%> недійсний для функції %qs"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "клас зберігання %<thread_local%> недійсний для функції %qs"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "специфікатор %<constinit%> недійсний для функції %qs"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "специфікатори virt в %qs не дозволені поза визначенням класу"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "специфікатор %<static%> недійсний для функції %qs, оголошеної поза глобальним контекстом"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "специфікатор %<inline%> недійсний для функції %qs, оголошеної поза глобальним контекстом"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "віртуальна функція, що не належить до класу %qs"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs визначено в області, що не належить до класу"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs оголошено в області, що не належить до класу"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "не можна оголосити метод члена %qD зі статичним звʼязуванням"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "не можна оголосити статичну функцію всередині іншої функції"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> не може бути використано при визначенні (на відміну від оголошення) статичного елемента даних"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "статичний член %qD оголошено зі специфікатором %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "не можна явно оголосити члена %q#D зовнішнім звʼязком"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "оголошення змінної %qD з %<constexpr%> не є визначенням"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "змінну не можна оголосити як %<consteval%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs ініціалізовано та оголошено як %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs має як %<extern%>, так і ініціалізатор"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "аргумент за замовчуванням %qE використовує %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "аргумент за замовчуванням %qE використовує локальну змінну %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "неприпустиме використання типу %qT з кваліфікатором cv в оголошенні параметра"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "неприпустиме використання типу %<void%> в оголошенні параметра"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "параметр з кваліфікатором %<volatile%> застарілий"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "параметр %qD неправильно оголошений як тип методу"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "параметр %qD містить вказівник на масив невідомого розміру %qT"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "параметр %qD містить посилання на масив невідомого розміру %qT"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "неправильний конструктор; ви, ймовірно, мали на увазі %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD не може бути оголошений в межах простору імен"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD не може бути оголошений як статичний"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, gcc-internal-format
 msgid "%qD must be a non-static member function"
 msgstr "%qD повинна бути нестатичною функцією-членом"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD повинна бути функцією-членом"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD може бути статичною функцією-членом лише з %<-std=c++23%> або %<-std=gnu++23%>"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD повинна бути або нестатичною функцією-членом, або функцією, що не є членом"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD повинна мати аргумент класу або перелічуваного типу"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ забороняє перевантаження %<operator ?:%>"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD не повинна мати змінну кількість аргументів"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, gcc-internal-format
 msgid "%qD must have either zero or one argument"
 msgstr "%qD повинна мати нуль або один аргумент"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, gcc-internal-format
 msgid "%qD must have either one or two arguments"
 msgstr "%qD повинна мати один або два аргументи"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "постфіксний %qD повинен мати %<int%> як свій аргумент"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, gcc-internal-format
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "постфіксний %qD повинен мати %<int%> як свій другий аргумент"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, gcc-internal-format
 msgid "%qD must have no arguments"
 msgstr "%qD не повинна мати аргументів"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, gcc-internal-format
 msgid "%qD must have exactly one argument"
 msgstr "%qD повинна мати рівно один аргумент"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, gcc-internal-format
 msgid "%qD must have exactly two arguments"
 msgstr "%qD повинна мати рівно два аргументи"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD не може мати аргументів за замовчуванням"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "перетворення %qT в %<void%> ніколи не використовуватиме оператор перетворення типу"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "перетворення %qT в посилання на той самий тип ніколи не використовуватиме оператор перетворення типу"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "перетворення %qT на той самий тип ніколи не використовуватиме оператор перетворення типу"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "перетворення %qT на посилання на базовий клас %qT ніколи не використовуватиме оператор перетворення типу"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "перетворення %qT на базовий клас %qT ніколи не використовуватиме оператор перетворення типу"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "користувацький %qD завжди оцінює обидва аргументи"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "префіксний %qD повинен повертати %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "постфіксний %qD повинен повертати %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD повинен повертати за значенням"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "використання параметра типу шаблону %qT після %qs"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "використання спеціалізації псевдоніма шаблону %qT після %qs"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "використання імені typedef %qD після %qs"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD має попередню декларацію тут"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT згадується як %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%qT має попереднє оголошення тут"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT згадується як перелічування"
@@ -62757,100 +62832,100 @@ msgstr "%qT згадується як перелічування"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "потрібен аргумент шаблону для %<%s %T%>"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "посилання на %qD є неоднозначним"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "шаблон класу %qD перевизначено як не-шаблон"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD має те саме імʼя, що і клас, в якому воно оголошено"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT не є шаблоном"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr "можливо, ви хочете явно додати %<%T::%>"
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "використання перелічування %q#D без попередньої декларації"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "повторне оголошення %qT як не-шаблону"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "похідне обʼєднання %qT недійсне"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT визначено з кількома прямими базами"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT визначено з прямим віртуальним базовим класом"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "базовий тип %qT не є структурою або класом"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "рекурсивний тип %qT не визначений"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "подвійний базовий тип %qT недійсний"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "невідповідність між з областю видимості та без області видимості в перелічуванні %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "попереднє визначення тут"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "невідповідність підставного типу в перелічуванні %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "різний підставний тип в перелічуванні %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "тип основи %qT для %qT повинен бути цілочисельним типом"
@@ -62859,87 +62934,93 @@ msgstr "тип основи %qT для %qT повинен бути цілочи
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "жоден цілочисельний тип не може представити всі значення перелічування для %qT"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "значення перелічування для %qD повинно мати цілочисельний або необмежений тип перелічування"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "значення перелічування для %qD не є цілочисельною константою"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "значення збільшеного перелічування занадто велике для %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "значення збільшеного перелічування занадто велике для %<long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "переповнення значень перелічування на %qD"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "значення перелічування %qE знаходиться поза діапазоном базового типу %qT"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "множинне визначення %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "тип повернення %q#T неповний"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> повинен повертати посилання на %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "в функції, що повертає %qT, відсутні оператори повернення"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "тільки простий тип повернення %<auto%> може бути виведений як %<void%>"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, gcc-internal-format
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "в %<constexpr%> функції, яка повертає не-void, відсутній оператор return"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD вже визначено в класі %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, gcc-internal-format
 msgid "using %qs"
 msgstr "використання %qs"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%qs used with %<auto%>"
+msgid "%qs used without %qs declaration"
+msgstr "%qs використовується з %<auto%>"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "використання %qD до виведення типу %<auto%>"
@@ -63374,357 +63455,357 @@ msgstr "використання функції %qD з незадовільни
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "використання вбудованого пакету параметрів %qD поза шаблоном"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    вставлено з %qD у %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    вставлено з %qD у %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "    вставлено з %qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "У статичній функції-члені %qD"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "У конструкторі копіювання %qD"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "У конструкторі %qD"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "У деструкторі %qD"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "У функції-лямбді"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "У явній членській функції об'єкта %qD"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, gcc-internal-format
 msgid "In member function %qD"
 msgstr "У функції-члені %qD"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr "У функції %qD"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "but %qE is a type"
 msgstr "%qE не є типом"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "type %qs is not an expression"
 msgid "but %qE is an expression"
 msgstr "тип %qs не є виразом"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 #| msgid "<structured bindings>"
 msgid "but %qE is a structured binding"
 msgstr "<структуровані привʼязки>"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is unavailable"
 msgid "but %qE is a variable"
 msgstr "%qE недоступний"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "параметр функції"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "but %qE is a function"
 msgstr "  %qT не є функцією"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a static data member"
 msgid "but %qE is a data member"
 msgstr "%qD не є статичним елементом даних"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD не є шаблоном функції"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class template"
 msgid "but %qE is a class template"
 msgstr "%qE не є шаблоном класу"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable template"
 msgid "but %qE is a variable template"
 msgstr "%qD не є шаблоном змінної"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD є простором імен"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is an enumeration template"
 msgid "but %qE is an enumerator"
 msgstr "%qD є шаблоном перелічування"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 #| msgid "%s: In substitution of %qS:\n"
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s: В заміні %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s: При створенні екземпляра %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from here\n"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "рекурсивно потрібно звідси\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "рекурсивно потрібно для заміни %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "потрібно для заміни %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "рекурсивно потрібно з %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "потрібно з %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "рекурсивно потрібно звідси\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "потрібно звідси\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%r%s:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "%r%s:%d:%R   [ пропускаються %d контексти інстанціювання, використовуйте -ftemplate-backtrace-limit=0, щоб вимкнути ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 #| msgid "%r%s:%d:%R   in %<constexpr%> expansion of %qs"
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%r%s:%d:%R   у розширенні %<constexpr%> %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required by the constraints of %q#D\n"
 msgstr "потрібно для заміни %qS\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required for the satisfaction of %qE"
 msgstr "потрібно для заміни %qS\n"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c required for gnat2scil"
 msgid "required for constraint satisfaction\n"
 msgstr "-c потрібно для gnat2scil"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "requires"
 msgid "in requirements "
 msgstr "потребує"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr "(без аргументів)"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr "[...]"
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "розширені списки ініціалізаторів доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "явні оператори перетворення доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "варіативні шаблони доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ламбда-вирази доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 auto доступний тільки з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "перелічування з областю видимості доступні тільки з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "функції зі значеннями за замовчуванням та видалені функції доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "вкладені простори імен доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "контроль перевизначення (override/final) доступний лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ініціалізатори нестатичних членів даних доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "літерали, визначені користувачем, доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "делегуючі конструктори доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "успадковування конструкторів доступне лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "атрибути C++11 доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-кваліфікатори доступні лише з %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "неповний тип %qT використовується в зазначенні вкладеного імені"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "посилання на %<%T::%D%> є неоднозначним"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD не є членом %qT; ви мали на увазі %qs?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD не є членом %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD не є членом %qD; ви мали на увазі %qs?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD не є членом %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> не було оголошено; ви мали на увазі %qs?"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> не було оголошено"
@@ -63947,7 +64028,7 @@ msgstr "посилання %qD ще не привʼязане до значен
 msgid "member %qD is used uninitialized"
 msgstr "член %qD використовується без ініціалізації"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "масив повинен бути ініціалізований за допомогою ініціалізатора, заключеного у фігурні дужки"
@@ -64063,7 +64144,7 @@ msgstr "тип %qT не є прямим або віртуальним базов
 msgid "type %qT is not a direct base of %qT"
 msgstr "тип %qT не є прямим базовим класом для %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -64255,43 +64336,43 @@ msgstr "виявлено можливу проблему при виклику 
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "ні деструктор, ні специфічний для класу оператор %<delete []%> не будуть викликані, навіть якщо вони оголошені при визначенні класу"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "ініціалізатор закінчується передчасно"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "невідомий розмір масиву в delete"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "тип повернення є неповним типом"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "виявлено можливу проблему при виклику %<operator delete%>"
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "навіть якщо вони оголошені при визначенні класу, ні деструктор, ні специфічний для класу %<operator delete%> не будуть викликані"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "видалення обʼєкта абстрактного класу типу %qT, який має невіртуальний деструктор, призведе до невизначеного поведінки"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "видалення обʼєкта поліморфного класу типу %qT, який має невіртуальний деструктор, може призвести до невизначеного поведінки"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "тип, переданий для векторного видалення, не є або вказівником, або масивом"
@@ -64327,84 +64408,92 @@ msgstr "захоплення копією неповного типу %qT"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "невикористана декларація структурованого звʼязування"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr "спроба захопити %qD при інстанціюванні загального лямбда-виразу"
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr "неявне захоплення %qE через %<[=]%> застаріло в C++20"
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr "додайте явне захоплення %<this%> або %<*this%>"
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> не було захоплено для цієї лямбда-функції"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "конвенція виклику для %qT змінюється в %<-fabi-version=13%> (GCC 8.2)"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "конвенція виклику для %qT змінюється в %<-fabi-version=13%> (GCC 8.2)"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, gcc-internal-format
 msgid "invalid %<#pragma %s%>"
 msgstr "недійсний %<#pragma %s%>"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, gcc-internal-format
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "%<#pragma vtable%> більше не підтримується"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "%<#pragma implementation%> для %qs зʼявляється після включення файлу"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD не визначено"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<requires%> доступно лише з %<-std=c++20%> або %<-fconcepts%>"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, gcc-internal-format
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD не було оголошено в цій області видимості; ви мали на увазі %qs?"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD не було оголошено в цій області видимості"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "немає аргументів для %qD, які залежать від параметра шаблону, тому повинно бути доступне оголошення %qD"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(якщо ви використовуєте %<-fpermissive%>, G++ прийме ваш код, але дозвіл на використання невизначеного імені є застарілим)"
@@ -64414,64 +64503,57 @@ msgstr "(якщо ви використовуєте %<-fpermissive%>, G++ при
 msgid "  # %E"
 msgstr "  # %E"
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "декорування %<typeof%>, використовуйте замість цього %<decltype%>"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr "використання вбудованого трейту %qT в підписі функції; використовуйте замість цього трейти з бібліотеки"
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr "використання вбудованого трейту %qE в підписі функції; використовуйте замість цього трейти з бібліотеки"
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "декорування %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "пропущений середній операнд для %<?:%> операнд не може бути декорований"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr "декороване імʼя для %qD зміниться в C++17, оскільки специфікація винятків є частиною типу функції"
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "декороване імʼя %qD змінилося між %<%s=%d%> (%qD) та %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "декороване імʼя %qD змінюється між %<%s=%d%> (%qD) та %<%s=%d%> (%qD)"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "декороване імʼя тунку для %qD змінюється між %<-fabi-version=%d%> та %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "декороване імʼя %qD змінюється між %<-fabi-version=%d%> та %<-fabi-version=%d%>"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "декороване імʼя змінної-сторожа ініціалізації для %qD змінюється між %<-fabi-version=%d%> та %<-fabi-version=%d%>"
@@ -64873,7 +64955,7 @@ msgstr "існуюча декларація %#qD"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "конфліктна декларація звʼязку мови C %q#D"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting exporting for declaration %qD"
 msgid "conflicting type for imported declaration %#qD"
@@ -64891,446 +64973,446 @@ msgstr "конфліктуюча глобальна декларація мод
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "конфліктний експорт для оголошення %qD"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting exporting for declaration %qD"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "конфліктний експорт для оголошення %qD"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting exporting for declaration %qD"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "конфліктний експорт для оголошення %qD"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting exporting for declaration %qD"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "конфліктний експорт для оголошення %qD"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "конфліктна декларація %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "існуюча декларація %#qD"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "немає стандартного аргументу для %qD"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 #| msgid "built-in %qD declared here"
 msgid "existing default declared here"
 msgstr "Вбудована функція %qD оголошена тут"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument missing for parameter %P of %q#D"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "відсутній аргумент за замовчуванням для параметра %P функції %q#D"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "визначення %qD не відповідає"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "існуюче визначення %qD"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "перелічувач %qD не відповідає ..."
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "... цей перелічувач %qD"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr "додаткові перелічувачі, що починаються з %qD"
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr "діапазон перелічення відрізняється"
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE не є типом %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of alias template %qD"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "спеціалізація псевдоніму шаблону %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D declared here with internal linkage"
 msgid "%qD declared with internal linkage"
 msgstr "%q#D оголошений тут з внутрішнім посиланням"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD не може бути оголошений в межах простору імен"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared within %qD"
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD не було оголошено всередині %qD"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has not been declared within %qD"
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD не було оголошено всередині %qD"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template arguments"
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD використовується без аргументів шаблону"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument for type %qT"
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, fuzzy, gcc-internal-format
 #| msgid "%qD called on unallocated object %qD"
 msgid "%qD refers to TU-local object %qD"
 msgstr "%qD викликано на невиділеному обʼєкті %qD"
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not refer to a function"
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD не посилається на функцію"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr "рекурсивне ліниве завантаження"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, fuzzy, gcc-internal-format
 #| msgid "module %qs declared here"
 msgid "module %qs depends on itself"
 msgstr "модуль %qs оголошено тут"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "модуль %qs оголошено тут"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "непрямий імпорт %qs ще не завантажено"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr "імпорт %qs має невідповідність контрольної суми CRC"
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr "не експортується %<#define %E%>, оскільки це ключове слово"
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "визначення макросу %qE пошкоджено"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "неспівпадаюче визначення імпортованого макросу %qE"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr "%<#undef %E%>"
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr "%<#define %s%>"
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "файл скомпільованого модуля - %qs"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "скомпільований модуль - %sверсія %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr "компілятор - %sверсія %s%s%s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr "знайдено модуль %qs"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr "очікувався заголовок модуля, знайдено модуль %qs"
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr "очікувався модуль %qs, знайдено заголовок модуля"
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr "неспівпадання контрольної суми модуля %qs"
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr "ціль та хост - %qs:%qs, очікувалося %qs:%qs"
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr "Діалект мови відрізняється %qs, очікувався %qs"
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "Модуль містить OpenMP, використовуйте %<-fopenmp%>, щоб увімкнути його"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, fuzzy, gcc-internal-format
 #| msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr "Модуль містить OpenMP, використовуйте %<-fopenmp%>, щоб увімкнути його"
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, fuzzy, gcc-internal-format
 #| msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "Модуль містить OpenMP, використовуйте %<-fopenmp%>, щоб увімкнути його"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "несумісність виправленого дерева"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "інтерфейсна частина не експортується"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "не вдалося прочитати скомпільований модульний кластер %u: %s"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "не вдалося прочитати скомпільований модуль: %s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr "розгляньте використання %<-fno-module-lazy%>, збільшення значення %<-param-lazy-modules=%u%> або збільшення обмеження файлових дескрипторів на процес"
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr "імпорти мають бути побудовані перед імпортом"
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr "повернення до гейту через технічну проблему"
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaring %qD in module %qs conflicts with import"
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "повторне оголошення %qD у модулі %qs конфліктує з імпортом"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "декларація %qD конфліктує з вбудованою функцією"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "повторне оголошення %qD у модулі %qs конфліктує з імпортом"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "повторне оголошення %qD у глобальному модулі конфліктує з імпортом"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "імпорт оголошений прикріплений до модуля %qs"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr "імпорт оголошений у глобальному модулі"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "конфліктне оголошення %qD у модулі %qs"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "конфліктне оголошення %qD у глобальному модулі"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "раніше оголошений у модулі %qs"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "раніше оголошений у глобальному модулі"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration may not name namespace %qD"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "оголошення «using» не може називати простір імен %qD"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "повторне оголошення %q+D без звʼязку"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "читання CMI %qs"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "не вдалося завантажити звʼязування %<%E%s%E%>"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr "не вдалося завантажити звʼязування %<%E%s%E@%s%>"
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr "під час завантаження звʼязування %<%E%s%E%>"
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr "під час завантаження звʼязування %<%E%s%E@%s%>"
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "не вдалося завантажити очікувані одиниці для %<%E%s%E%>"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "під час завантаження очікуваних одиниць для %<%E%s%E%>"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "визначення методу не в контексті @implementation"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "module %qs declared here"
 msgid "module declared here"
@@ -65343,111 +65425,111 @@ msgstr "модуль %qs оголошено тут"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr "імпорт іменованого модуля %qs всередині блоку мовного звʼязку"
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr "модуль вже оголошено"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr "модуль вже імпортовано"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "модуль %qs імпортовано тут"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, fuzzy, gcc-internal-format
 #| msgid "unknown Compiled Module Interface: %s"
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr "невідомий скомпільований інтерфейс модуля (CMI): %s"
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown Compiled Module Interface: %s"
 msgid "unknown compiled module interface: %s"
 msgstr "невідомий скомпільований інтерфейс модуля (CMI): %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr "не вдалося визначити переклад %<#include%> для %s: %s"
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr "включення %qs перекладено як імпорт"
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr "включення %qs оброблено текстово"
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "Модулі C++ несумісні з попередньо скомпільованими заголовками"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Модулі C++ несумісні з традиційною попередньою обробкою"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "неприпустиме імʼя заголовка %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "неприпустиме імʼя модуля %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr "%<-fmodule-only%> використовується для неінтерфейсу"
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "запис CMI %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, fuzzy, gcc-internal-format
 #| msgid "not writing module %qs due to errors"
 msgid "not writing module %qs due to errors in template bodies"
 msgstr "не вдається записати модуль %qs через помилки"
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "first error in %qD appeared here"
 msgstr "підпрограма %qD оголошена тут"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "не вдалося записати скомпільований модуль: %s"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "невідомий тип заголовка %qs"
@@ -65463,7 +65545,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "%q#D оголошений тут з внутрішнім посиланням"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "оголошення незалежні від імені доступні тільки з %<-std=c++2c%> або %<-std=gnu++2c%>"
@@ -65508,152 +65590,163 @@ msgstr "оголошення %q#D затіняє параметр"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "оголошення %qD затіняє член %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %qD but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "оголошення для параметра %qD, але такого параметра немає"
+
+#: cp/name-lookup.cc:4170
 #, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "дружня декларація %qD в локальному класі без попередньої локальної декларації"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %<%s(%E)%> %p %d"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "експортування %q#D, яке не має зовнішнього посилання"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q#D оголошений тут без посилання"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%q#D оголошений тут з внутрішнім посиланням"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q#D оголошений тут з посиланням на модуль"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, gcc-internal-format
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T%s%D%> називає деструктор"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "оголошення «using» для не-члена на рівні області класу"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using%> з областю перелічення %q#T доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qT не є класом, простором імен або переліченням"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "оголошення «using» для не-члена називає конструктор %qT"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr "оголошення «using» для члена на рівні поза класом"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, gcc-internal-format
 msgid "%qT is not a direct base of %qT"
 msgstr "%qT не є прямим базовим класом %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr "ви мали на увазі %<using enum %T::%D%>?"
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD не було оголошено в %qD"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "оголошення «using» не може називати простір імен %qD"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> називає конструктор в %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "оголошення %qD не знаходиться в просторі імен, що оточує %qD"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "явна кваліфікація в оголошенні %qD"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD повинно бути оголошено всередині %qD"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD не було оголошено всередині %qD"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, gcc-internal-format
 msgid "only here as a %<friend%>"
 msgstr "тільки тут як %<friend%>"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "атрибут %qD вимагає одного аргументу NTBS"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "атрибут %qD не має сенсу, оскільки елементи анонімного простору імен отримують локальні символи"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "ігнорується атрибут %qD на анонімному просторі імен"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "ігнорування атрибуту %qD на неінлайновому просторі імен"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "ігнорування директиви атрибуту %qD"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "максимальний ліміт %d просторів імен, що шукаються для %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
@@ -65661,112 +65754,112 @@ msgstr[0] "запропонована альтернатива:"
 msgstr[1] "запропоновані альтернативи:"
 msgstr[2] "запропоновані альтернативи:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr "%<std::%s%> визначено в заголовку %qs; це, ймовірно, можна виправити додаванням %<#include %s%>"
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%<std::%s%> доступний лише з %s"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "макро %qs ще не було визначено"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, gcc-internal-format
 msgid "it was later defined here"
 msgstr "воно було пізніше визначено тут"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "оголошення %<std::initializer_list%> не відповідає %<#include <initializer_list>%>, не є шаблоном"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, gcc-internal-format
 msgid "%<strong%> using directive no longer supported"
 msgstr "%<strong%> директива using більше не підтримується"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr "замість цього ви можете використовувати вбудований простір імен"
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, gcc-internal-format
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<omp::%E%> не може бути вказано в цьому контексті"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 #| msgid "unterminated quoting directive"
 msgid "annotation on using directive"
 msgstr "незавершена директива цитування"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr "не можна вкладати більше %d просторів імен"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%<namespace %E%> є неоднозначним"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "псевдонім простору імен %qD не дозволений тут, припускаємо %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "exporting %q#D that does not have external linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "експортування %q#D, яке не має зовнішнього посилання"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD не може бути оголошений в межах простору імен"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "очікується %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "вбудований простір імен повинен бути вказаний при початковому визначенні"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "простір імен %s %qD конфліктує з досяжним визначенням"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "досяжне визначення %s тут"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, gcc-internal-format
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX входження в %<pop_everything ()%>"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, gcc-internal-format
 msgid "XXX leaving %<pop_everything ()%>"
 msgstr "XXX залишає %<pop_everything ()%>"
@@ -65797,7 +65890,7 @@ msgstr "ідентифікатор %qE є ключовим словом в C++20
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr "%<LEXER_DEBUGGING_ENABLED_P%> не встановлено на true"
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> не негайно слідує за оголошенням або визначенням функції"
@@ -65845,7 +65938,7 @@ msgstr "%<::%E%> не було оголошено"
 msgid "request for member %qE in non-class type %qT"
 msgstr "запит на елемент %qE в не-класовому типі %qT"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> не було оголошено"
@@ -65916,7 +66009,7 @@ msgstr "(можливо, після визначення %qT відсутня к
 msgid "%qE is not a class template"
 msgstr "%qE не є шаблоном класу"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE не є шаблоном"
@@ -66231,1746 +66324,1757 @@ msgstr "pack init-захоплення доступне лише з %<-std=c++20
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "contracts are only available with %<-fcontracts%>"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "контракти доступні лише з %<-fcontracts%>"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected a reflection of a type"
 msgstr "мало бути вказано назву функції"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "expected at least one assumption clause"
-msgid "expected a reflection of a function template"
-msgstr "очікується принаймні одне замикання припущення"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "non-deducible template %qT used without template arguments"
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "недедуктивний шаблон %qT використовується без аргументів шаблону"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class, namespace, or enumeration"
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qT не є класом, простором імен або переліченням"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "фіксовані точкові типи не підтримуються в C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ забороняє групи в фігурних дужках у виразах"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "вирази-оператори не дозволяються поза функціями або у списку аргументів шаблону"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "вирази складання доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "очікується первинний вираз"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> не може бути використаний в цьому контексті"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "оголошення шаблону не може зʼявлятися у блоковому обсязі"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, gcc-internal-format
 msgid "parameter %qD may not appear in this context"
 msgstr "параметр %qD не може зʼявлятися в цьому контексті"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "локальна змінна %qD не може зʼявлятися в цьому контексті"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "contracts are only available with %<-fcontracts%>"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "контракти доступні лише з %<-fcontracts%>"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr "очікувано ключове слово %qs перед залежним іменем шаблону"
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "очікувано вираз ідентифікатора"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "область %qT перед %<~%> не є імʼям класу"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "ключове слово %<template%> не дозволено в імені деструктора"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> доступний лише з %<-std=c++14%> або %<-std=gnu++14%>"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr "шаблонний ідентифікатор не дозволено для деструктора в C++20"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr "видаліть %qs"
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "оголошення %<~%T%> як члена %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "імʼя typedef %qD використовується як декларатор деструктора"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "очікувано некваліфікований ідентифікатор"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD не є шаблоном"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "знайдено %<:%> у вкладеному специфікаторі імені, очікувалося %<::%>"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%<decltype%> обчислюється як %qT, який не є класом або перелічуванням"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "ідентифікатор шаблону функції %qD у вкладеному специфікаторі імені"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "ідентифікатор концепції %qD у вкладеному специфікаторі імені"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "ідентифікатор шаблону змінної %qD у вкладеному специфікаторі імені"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "очікувався вкладений специфікатор імені"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "типи не можуть бути визначені у приведеннях типів"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "типи не можуть бути визначені у виразі %<typeid%>"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "неправильна кількість аргументів для %<__builtin_addressof%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "неправильна кількість аргументів для %<__builtin_launder%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "неправильна кількість аргументів для %<__builtin_assoc_barrier%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "неправильна кількість аргументів для %<__builtin_shufflevector%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, fuzzy, gcc-internal-format
 #| msgid "destroying %<operator delete%> must be a usual deallocation function"
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "знищувальний %<operator delete%> повинен бути звичайною функцією відведення памʼяті"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 #| msgid "deallocation function declared here"
 msgid "selected function declared here"
 msgstr "функція звільнення оголошена тут"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ забороняє складні літерали"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr "два підряд %<[%> можуть вводити лише атрибут"
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "типи не можуть бути визначені у викликах %<__builtin_classify_type%>"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr "неможливо використовувати індекс з декількома вимірами у секції масиву OpenMP"
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "неправильне використання %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> не є членом класу"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "не скалярний тип"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "%<template%> повинен слідувати за вкладеним іменем-специфікатором"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new не може бути застосований до типу посилання"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "%<h%> applied to non-register operand"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<h%> застосовується до не-регістрового операнда"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ не дозволяє %<alignof%> з не-типом"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "Типи не можуть бути визначені в виразах %<noexcept%>"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD не може мати аргументів за замовчуванням"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "Типи не можуть бути визначені в виразах %qs"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "%<__builtin_has_attribute%> залежним аргументом поки не підтримується"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "Типи не можуть бути визначені в новому виразі"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "Обмеження масиву заборонено після типу, заключеного у дужки"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "спробуйте видалити дужки навколо ідентифікатора типу"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr "ініціалізація нового виразу для типу %<auto%> потребує рівно один елемент"
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr "очікується список виразів або ідентифікатор типу"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "Типи не можуть бути визначені в new-type-id"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "атрибути ігноруються при інстанціюванні шаблону"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "Вираз в new-деклараторі повинен мати цілочисельний або перелічувальний тип"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, gcc-internal-format
 msgid "use of old-style cast to %q#T"
 msgstr "використання старого стилю приведення до типу %q#T"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "Оператор %<>>%> розглядається як дві праві кутові дужки в C++11"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "Пропонується використовувати дужки навколо виразу %<>>%>"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ не дозволяє %<?:%> з пропущеним середнім операндом"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "Використання коми на верхньому рівні в індексі масиву застаріло"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "Типи не можуть бути визначені всередині %<__builtin_offsetof%>"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr "наступний аргумент для %<__type_pack_element%> не є типом"
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Лямбда-вираз в невираховуваному контексті доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Лямбда-вираз в аргументі шаблону доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "нелокальний лямбда-вираз не може мати захоплення за замовчуванням"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "очікуваний кінець списку захоплень"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Явне копіювання захоплення %<this%> з копіюванням захоплення за замовчуванням доступне лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "%qD вже захоплено в лямбда-виразі"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "захоплення %<*this%> доступне лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "%<this%> не може бути захоплено посиланням"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "pack init-захоплення доступне лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr "%<&%> повинно бути перед %<...%>"
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "ініціалізатори захоплення лямбда доступні лише з %<-std=c++14%> або %<-std=gnu++14%>"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr "порожній ініціалізатор для захоплення init-capture у лямбда"
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "захоплення незмінної %qE"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "захоплення змінної %qD з неавтоматичним тривалістю зберігання"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr "занадто багато %<...%> в захопленні лямбди"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "явне захоплення (копіюванням) %qD зайве зі стандартним захопленням (копіюванням)"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "явне захоплення (посиланням) %qD зайве зі стандартним захопленням (посиланням)"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "шаблони лямбди доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "вказано значення за замовчуванням для параметра лямбда"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 #| msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Оголошення параметра перед специфікаторами оголошення лямбди є необовʼязковим лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr "лямбда-функція з захопленнями не може мати явного об'єктного параметра непов'язаного типу"
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "специфікатор %<mutable%> для лямбда-функції з явним об'єктним параметром"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr "Об'єкт замикання, що передається, не буде змінено, оскільки він приймається по значенню"
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr "Оголосіть явний об'єктний параметр як неконстантне посилання замість цього"
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr "явний об'єктний параметр вже є змінабельним посиланням"
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "специфікатор %<static%> для лямбда-функції з явним об'єктним параметром"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr "Специфікатор лямбди %<static%> з захопленням лямбди"
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 #| msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Оголошення параметра перед кваліфікатором транзакції лямбди є необовʼязковим лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 #| msgid "parameter declaration before lambda exception specification only optional with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Оголошення параметра перед специфікацією винятку лямбди є необовʼязковим лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 #| msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Оголошення параметра перед поверненим типом лямбди є необовʼязковим лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<constexpr%> лямбда доступна тільки з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%qE declared here"
+msgid "%q#E declared here"
+msgstr "%qE оголошено тут"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 #| msgid "label at end of compound statement only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "Мітка в кінці складного оператора доступна лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "Атрибути на початку інструкції не враховуються"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "очікувалася мітка-оператор"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "мітка case %qE не знаходиться в межах оператора switch"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "потрібно %<typename%> перед %qE, оскільки %qT є залежним областю видимості"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%E%> names the constructor, not the type"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%> позначає конструктор, а не тип"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "складений оператор в функції %<constexpr%>"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, fuzzy, gcc-internal-format
 #| msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr "внутрішні цикли повинні бути ідеально вкладені з клаузою %<ordered%>"
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<if constexpr%> доступний лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 #| msgid "%<if consteval%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<if consteval%> доступний лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr "%<if consteval%> вимагає складений оператор"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ініціалізуюча-інструкція в операторах вибору доступна лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "очікується оператор вибору"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, gcc-internal-format
 msgid "condition declares an array"
 msgstr "умова оголошує масив"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, gcc-internal-format
 msgid "condition declares a function"
 msgstr "умова оголошує функцію"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "типи не можуть бути визначені в умовах"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "очікується ініціалізатор"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "цикли %<for%> засновані на діапазоні з ініціалізатором доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr "змінна циклу %qD типу %qT повʼязується з тимчасовим обʼєктом, побудованим з типу %qT"
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr "використовуйте тип, що не є посиланням %qT, щоб зробити копіювання явним, або %qT, щоб запобігти копіюванню"
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "змінна циклу %qD створює копію з типу %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr "використовуйте тип посилання, щоб запобігти копіюванню"
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "вираз %<for%> на основі діапазону з типом %qT має неповний тип"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "несумісні типи початку/кінця в операторі %<for%> на основі діапазону: %qT і %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "очікується оператор ітерації"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "оголошення псевдоніма в ініціалізуючому операторі доступне лише з %<-std=c++23%> або %<-std=gnu++23%>"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Цикли %<for%> зі змінним діапазоном доступні лише з опцією %<-std=c++11%> або %<-std=gnu++11%>"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "%<auto{x}%> only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<auto{x}%> доступний лише з %<-std=c++2b%> або %<-std=gnu++2b%>"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "C99 designator %qE outside aggregate initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "C99-означення %qE поза агрегатним ініціалізатором"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "structured binding declaration cannot be %qs"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "оголошення структурованого звʼязування не може бути %qs"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 #| msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++2b%> or %<-std=gnu++2b%>"
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<goto%> у функції %<constexpr%> доступний лише з опцією %<-std=c++2b%> або %<-std=gnu++2b%>"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ забороняє обчислювані переходи"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "очікується оператор переходу"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, gcc-internal-format
 msgid "expected module-partition"
 msgstr "очікується module-partition"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, gcc-internal-format
 msgid "expected module-name"
 msgstr "очікується імʼя модуля"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr "оголошення модуля не дозволено в заголовочному модулі"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "import-declaration must be at global scope"
 msgid "module-declaration must be at global scope"
 msgstr "Декларація імпорту повинна бути в глобальному контексті"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "concept defined here"
 msgid "scope opened here"
 msgstr "концепція визначена тут"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, gcc-internal-format
 msgid "private module fragment"
 msgstr "приватний фрагмент модуля"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr "приватний фрагмент модуля дозволений лише в межах інтерфейсу модуля або його частини"
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr "Декларація модуля дозволена лише як перша декларація або закінчення глобального фрагмента модуля"
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr "Імпорти після декларації модуля повинні бути послідовними"
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, fuzzy, gcc-internal-format
 #| msgid "perhaps insert a line break, or other disambiguation, to prevent this being considered a module control-line"
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr "можливо, вставте розрив рядка або іншу розрізнювальну ознаку, щоб запобігти розгляданню цього як керуючої лінії модуля"
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr "Декларація імпорту повинна бути в глобальному контексті"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr "імпортування, що вказує на модуль-розділ, повинно з'являтися після іменованого оголошення модуля"
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr "Імпорти після декларації модуля не повинні бути перекладеними з include"
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr "Імпорти після декларації модуля не повинні бути з включення заголовка"
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr "%qE може зʼявлятися тільки після декларації інтерфейсу модуля"
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "%qE може зʼявлятися тільки один раз в декларації експорту"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr "%<export%> не є частиною наступної директиви модуля"
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C не дозволяє додатковий %<;%> поза функцією"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C не дозволяє додатковий %<;%> поза функцією"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "додатковий %<;%> після визначення функції всередині класу"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "Атрибути не дозволені в цьому місці"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "атрибути можуть бути вставлені тут"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "явна спеціалізація непатрону %qT"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "явна інстанціація нешаблону %q#D"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "module-declaration not permitted in header-unit"
 msgid "export-declarations are not permitted here"
 msgstr "оголошення модуля не дозволено в заголовочному модулі"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> не на початку блоку"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr "незмінна %qD в оголошенні з більш ніж одним декларатором з типом-заповнювачем"
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "неспівпадаюче виведення для %qT: %qT і потім %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "змішування оголошень та визначень функцій заборонено"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "типи не можуть бути визначені в декларації циклу for-range"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "ініціалізатор у циклі %<for%> з діапазоном"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr "декілька оголошень у циклі %<for%> з діапазоном"
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 #| msgid "structured binding has incomplete type %qT"
 msgid "structured binding pack outside of template"
 msgstr "структуроване привʼязування має неповний тип %qT"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "empty structured binding declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "порожнє оголошення структурованої привʼязки"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "структуровані привʼязки доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "структуровані привʼязки доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 #| msgid "in initialization of structured binding variable %qD"
 msgid "annotation on structured binding"
 msgstr "при ініціалізації змінної структурованого звʼязування %qD"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 #| msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "структуровані привʼязки доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "структуровані привʼязки доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "порожнє оголошення структурованої привʼязки"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "недійсний ініціалізатор для оголошення структурованої привʼязки"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "structured binding declaration cannot be %qs"
 msgid "for-range-declaration cannot be %qs"
 msgstr "оголошення структурованого звʼязування не може бути %qs"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, gcc-internal-format
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "%<this%> має бути першим специфікатором у декларації параметра"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> використовується поза класом"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "слово %<bool%> не дозволено в означенні концепції C++20"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr "синтаксис означення концепції C++20: %<concept <name> = <expr>%>"
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "специфікатор %<typedef%> конфліктує з %qs"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> змінює значення в C++11; будь ласка, видаліть його"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "%qD недійсний в умові"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD недійсний в лямбда-виразі"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%qD дозволений лише в лямбда-виразі з %<-std=c++23%> або %<-std=gnu++23%>"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "специфікатор типу недійсний в лямбда-виразі"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr "стандартні атрибути посередині специфікаторів оголошення"
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr "стандартні атрибути повинні передувати специфікаторам оголошення, щоб застосовуватися до оголошення, або слідувати за ними, щоб застосовуватися до типу"
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "визначення класу не може бути оголошеним як друг"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "шаблони не можуть бути %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "типи не можуть бути визначені в явному вказівнику"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<explicit(bool)%> доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "недійсна специфікація звʼязку"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "%<static_assert%> без повідомлення доступний лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<static_assert%> з повідомленням, що не є рядком, доступний лише з %<-std=c++2c%> або %<-std=gnu++2c%>"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "специфікатор типу %<decltype(auto)%> доступний лише з %<-std=c++14%> або %<-std=gnu++14%>"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "типи не можуть бути визначені в виразах %<decltype%>"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "типи не можуть бути визначені в ідентифікаторах типу конверсії"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "недійсне використання %<auto%> в операторі конвертації"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "використання %<auto%> в операторі конвертації шаблону члена ніколи не може бути виведено"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "лише конструктори приймають ініціалізатори членів"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "не вдається розгорнути ініціалізатор для члена %qD"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "ініціалізатор mem для %qD слідує за делегуванням конструктора"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "делегування конструктора слідує за ініціалізатором mem для %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "анахронічний старий стиль ініціалізатора базового класу"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "слово %<typename%> не дозволено в цьому контексті (якісний ініціалізатор члена неявно є типом)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between two arrays is deprecated in C++20"
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "порівняння двох масивів застаріло в C++20"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "неочікуване ключове слово; видаліть пробіл між лапками та суфіксним ідентифікатором"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "очікується суфіксний ідентифікатор"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "після ключового слова %<operator%> очікується порожній рядок"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "недійсний префікс кодування в літеральному операторі"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "очікується оператор"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "ключове слово %<export%> не реалізовано і буде проігноровано"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, gcc-internal-format
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "ключове слово %<export%> застаріло і буде проігноровано"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> is enabled with %<-fmodules-ts%>"
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "ключове слово %<export%> включено за допомогою %<-fmodules-ts%>"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "недійсний обмежений типовий параметр"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "типовий параметр з кваліфікатором cv"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "недійсне використання %<auto%> в аргументі за замовчуванням шаблону"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "пакет параметрів шаблону %qD не може мати аргумент за замовчуванням"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "пакети параметрів шаблону не можуть мати аргументів за замовчуванням"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "очікувався ідентифікатор шаблону"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "%<<::%> не може починати список аргументів шаблону"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> є альтернативним написанням для %<[%>. Вставте пробіл між %<<%> та %<::%>"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(якщо ви використовуєте %<-fpermissive%> або %<-std=c++11%>, або %<-std=gnu++11%>, G++ прийме ваш код)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "недійсний список аргументів шаблону"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr "імʼя функції як лівий операнд %<<%> неправильно сформовано в C++20; оберніть імʼя функції у %<()%>"
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "очікується %<(%> після списку аргументів шаблону"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "помилка розбору в списку аргументів шаблону"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "очікуване імʼя шаблону"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "не шаблон %qD використовується як шаблон"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "використовуйте %<%T::template %D%>, щоб показати, що це шаблон"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "очікувано пакет параметрів перед %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "очікуваний аргумент шаблону"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "недійсний аргумент шаблону без типу"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 #| msgid "expression cannot be used as a function"
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "вираз не може бути використаний як функція"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "явна інстанціація не повинна використовувати специфікатор %<inline%>"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "явна інстанціація не повинна використовувати специфікатор %<constexpr%>"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "явна інстанціація не повинна використовувати специфікатор %<consteval%>"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "спеціалізація шаблону зі звʼязуванням C"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "очікується вказівник типу"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "використання %<auto%> у оголошенні параметра лямбди доступно лише з %<-std=c++14%> або %<-std=gnu++14%>"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "використання %<auto%> у оголошенні параметра доступно лише з %<-std=c++20%> або %<-fconcepts%>"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "використання %<auto%> у оголошенні параметра доступне лише з %<-std=c++14%> або %<-std=gnu++14%>"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in template argument"
 msgid "use of %<auto%> in template argument"
 msgstr "недійсне використання %<auto%> в аргументі шаблону"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "очікується template-id для типу"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "очікується імʼя типу"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, gcc-internal-format
 msgid "%qE does not constrain a type"
 msgstr "%qE не обмежує тип"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, gcc-internal-format
 msgid "concept defined here"
 msgstr "концепція визначена тут"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "неправильне використання %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "очікується %<auto%> або %<decltype(auto)%> після %qE"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr "неочікуваний заповнювач у обмеженому типі результату"
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "розширений тип-специфікатор для перелічування з областю дії не повинен використовувати ключове слово %qD"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "оголошення %qD нічого не оголошує"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "атрибути ігноруються на неінстанційованому типі"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "атрибути ігноруються при інстанціюванні шаблону"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "атрибути ігноруються на розширеному тип-специфікаторі, який не є передньою декларацією"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD є шаблоном перелічування"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD не є іменем перелічування в %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "не дозволяється безіменне перелічування з областю видимості"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "типи не можуть бути визначені в основі перелічування"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr "оголошення перерахування з фіксованим типом основи та без списку елементів можливе лише як окреме оголошення."
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "очікується %<;%> або %<{%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "не можна додати список перелічувань до шаблонного інстанціювання"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "вкладений специфікатор імені %qT для оголошення перелічування не називає клас або простір імен"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "оголошення %qD в просторі імен %qD, який не включає %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "оголошення %qD в %qD, який не включає %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "додаткова кваліфікація не дозволена"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ забороняє порожнє безіменне перелічування"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "специфікатор непрозорого перелічування без імені"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "специфікатор непрозорого перелічування повинен використовувати простий ідентифікатор"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr "нерозгорнутий пакет параметрів у перелічувачі в лямбді"
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD не є імʼям простору імен; ви мали на увазі %qs?"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD не є імʼям простору імен"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "очікувалося імʼя простору імен"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "вкладені визначення простору імен в режимі inline доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr "стандартні атрибути на простори імен повинні передувати імені простору імен"
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "вкладені визначення простору імен доступні лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "потрібне імʼя вкладеного простору імен"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr "потрібне імʼя простору імен"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr "визначення вкладеного простору імен не може мати атрибутів"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr "визначення вкладеного простору імен не може бути вбудованим"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr "увійшли в простір імен %qD"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "тут не дозволено визначення %<namespace%>"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "розширення пакета в декларації «using» доступне лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "template-id не може зʼявлятися в using-оголошенні"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "розділений комами список у використанні-оголошенні доступний лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "оголошення доступу застарілі на користь using-декларацій; пропозиція: додайте ключове слово %<using%>"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<using enum%> доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "%<using enum%> залежного типу %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%<using enum%> неперелічувального типу %q#T"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "%<using enum%> неповного типу %qT"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr "%<using enum%> %qT перед його enum-специфікатором"
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "непрозоре-оголошення-перелічування тут"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "типи не можуть бути визначені в оголошеннях шаблонів псевдонімів"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 #| msgid "Expected register or constant integer."
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "Очікувався регістр або константне цілочисельне."
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<asm%> у функції %<constexpr%> доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, gcc-internal-format
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "подвійне вказівник %<asm%> %qT"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "вказівник %<asm%> %qT ігнорується поза тілом функції"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, gcc-internal-format
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT не є вказівником %<asm%>"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "вказівник %<asm%> поза тілом функції"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "атрибути ігноруються на оголошенні %<asm%>"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "порожні дужки були розʼяснені як оголошення функції"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "видаліть дужки, щоб встановити значення за замовчуванням змінної"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr "або замініть дужки фігурними дужками для агрегатної ініціалізації змінної"
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr "або замініть дужки фігурними дужками для ініціалізації змінної значенням"
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, gcc-internal-format
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "дужки розпізнані як оголошення функції"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr "замініть дужки на фігурні дужки, щоб оголосити змінну"
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "додайте дужки, щоб оголосити змінну"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot be used in a varargs function"
 msgid "cannot handle qualified name for variant function"
 msgstr "%qs не може використовуватися в функції зі змінною кількістю аргументів"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on constructor declaration"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "кваліфікатори не дозволені в оголошенні конструктора"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on destructor declaration"
 msgid "declare variant directives are not allowed on destructors"
 msgstr "кваліфікатори не дозволені в оголошенні деструктора"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "Аргумент %qE не є ідентифікатором"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of function %qD in invalid context"
 msgid "no declaration of base function %qs in this scope"
 msgstr "оголошення функції %qD в недійсному контексті"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "посилання на %qD є неоднозначним"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, fuzzy, gcc-internal-format
 #| msgid "%<allocate%> directive must be in the same scope as %qD"
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr "Директива %<allocate%> повинна бути в тому самому області видимості, що і %qD"
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, fuzzy, gcc-internal-format
 #| msgid "%<allocate%> directive must be in the same scope as %qD"
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr "Директива %<allocate%> повинна бути в тому самому області видимості, що і %qD"
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "атрибути не дозволяються для визначення функції"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "атрибути не дозволяються для визначення функції"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "атрибути не дозволяються для визначення функції"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "атрибути не дозволяються для визначення функції"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "тут не дозволяється визначення функції"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "специфікація %<asm%> не дозволяється для визначення функції"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "атрибути не дозволяються для визначення функції"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "очікується конструктор, деструктор або перетворення типу"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "початкове значення надано для функції"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "атрибути після заключеної в дужки початкової ініціалізації ігноруються"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "не-функцію %qD оголошено як неявний шаблон"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "межа масиву не є цілою константою"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "не можна визначити член залежного typedef %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> не є типом"
@@ -67979,278 +68083,278 @@ msgstr "%<%T::%E%> не є типом"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "недійсний декларатор"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "недійсне використання конструктора як шаблону"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "використовуйте %<%T::%D%> замість %<%T::%D%>, щоб назвати конструктор з кваліфікованим імʼям"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "кваліфікований ідентифікатор в декларації"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "очікувався декларатор"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD є простором імен"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "не можна створити вказівник на член не-класу %q#T"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "очікувався оператор вказівника"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "подвійний cv-кваліфікатор"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "декілька ref-кваліфікаторів"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "%qE потребує %<-fgnu-tm%>"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "подвійний virt-специфікатор"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "відсутні аргументи шаблону після %qE"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "%qT не допускається в аргументі шаблону"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "неправильне використання %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "типи не можуть бути визначені в аргументах шаблону"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "недійсне використання %<auto%> в аргументі шаблону"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "очікується тип-специфікатор"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between two arrays is deprecated in C++20"
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr "порівняння двох масивів застаріло в C++20"
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "очікується %<,%> або %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "типи не можуть бути визначені в типах параметрів"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, gcc-internal-format
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "специфікатор %<this%> у декларації шаблону параметра"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> specifier in template parameter declaration"
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr "специфікатор %<this%> у декларації шаблону параметра"
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "явний об'єктний параметр не може бути пакунком параметрів функції"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "аргументи за замовчуванням дозволені тільки для параметрів функції"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "параметр пакету %qD не може мати значення за замовчуванням"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "параметр пакету шаблону не може мати значення за замовчуванням"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "параметр пакету не може мати значення за замовчуванням"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "явний об'єктний параметр може не мати значення за замовчуванням"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "тіло function-try-block конструктора %<constexpr%> доступне лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "тіло function-try-block функції %<constexpr%> доступне лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "позначені ініціалізатори C++ доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, gcc-internal-format
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ не дозволяє використовувати іменовані ініціалізатори GNU"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ не дозволяє використовувати іменовані ініціалізатори C99"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr "або всі замикання ініціалізатора повинні бути іменовані, або ж жоден з них не повинен бути іменованим"
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "%<...%> не дозволяється в іменованому списку ініціалізаторів"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr "іменований елемент %<.%s%> використовується кілька разів в одному списку ініціалізаторів"
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "очікується імʼя класу"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "очікується %<;%> після визначення класу"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "очікується %<;%> після визначення структури"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "очікується %<;%> після визначення обʼєднання"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "повторний вказівник %qD"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "очікувався %<{%> або %<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "глобальна кваліфікація імені класу недійсна"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "кваліфіковане імʼя не називає клас"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "слово %<template%> не дозволено в імені голови класу"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "недійсне імʼя класу в оголошенні %qD"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "визначення явної спеціалізації %qD в декларації друга"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "явна спеціалізація повинна передувати %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "шаблон функції %qD перевизначено як шаблон класу"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "не вдалося визначити тип typename"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "попереднє визначення %q#T"
@@ -68258,279 +68362,279 @@ msgstr "попереднє визначення %q#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr "нерозгорнутий пакет параметрів у локальному класі в лямбді"
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "очікується ключ-клас"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "ISO C++ забороняє ключ typename в параметрі шаблону шаблону; використовуйте %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "очікується %<class%> або %<typename%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "у C++03 ключ-клас повинен використовуватися при оголошенні дружнього елемента"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 #| msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "оголошення незалежні від імені доступні тільки з %<-std=c++2c%> або %<-std=gnu++2c%>"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "оголошення дружнього елемента не називає клас або функцію"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr "клас зберігання на анонімному агрегаті в області класу не дозволяється"
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "ініціалізатори за замовчуванням для бітових полів доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "дефолтний ініціалізатор для безіменного біт-поля"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr "ISO C++ дозволяє атрибути біт-полів лише перед токеном %<:%>"
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "біт-поле %qD має нецілочисельний тип %qT"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "чистий специфікатор на визначенні функції"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "зайвий %<,%> в кінці оголошення члена"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "очікувався %<;%> в кінці оголошення члена"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 #| msgid "defaulted %qD only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "стандартне значення %qD доступне лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "недійсний чистий специфікатор (дозволено лише %<= 0%>)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "ініціалізатор, заключений у фігурні дужки, тут не дозволяється"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "method attributes must be specified at the end"
 msgid "attributes on base specifiers are ignored"
 msgstr "атрибути методу повинні бути вказані в кінці"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "%<virtual%> вказано більше одного разу в базовому специфікаторі"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "більше одного специфікатора доступу в базовому специфікаторі"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "слово %<typename%> не дозволено в цьому контексті (базовий клас є неявно типом)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "типи не можуть бути визначені в специфікації винятків"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "ISO C++17 не дозволяє динамічні специфікації винятків"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "динамічні специфікації винятків застаріли в C++11"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "неправильне використання %<auto%> в специфікації винятків"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<try%> у функції %<constexpr%> доступний лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "типи не можуть бути визначені в оголошеннях винятків"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> в порожньому оголошенні"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD не може мати аргументів за замовчуванням"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "очікується аргумент атрибуту у вигляді збалансованої послідовності токенів"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "атрибут, що використовує префікс, використовується разом з токеном атрибуту з областю дії"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "очікується ідентифікатор для назви атрибуту"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr "дужки повинні бути пропущені, якщо список аргументів атрибуту %qE порожній"
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "атрибут %qs вказано кілька разів"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "очікується атрибут перед %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "атрибут без аргументів не містить параметрів пакунків"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected goto expression"
 msgid "expected conditional-expression"
 msgstr "очікуваний вираз «goto»"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %qs"
 msgid "%qs is only available with %qs"
 msgstr "%qs несумісний з %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "Атрибут %qE ігнорується для %qE"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "атрибути ігноруються на неінстанційованому типі"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 #| msgid "contracts are only available with %<-fcontracts%>"
 msgid "contracts are only available with %qs"
 msgstr "контракти доступні лише з %<-fcontracts%>"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "оголошення незалежні від імені доступні тільки з %<-std=c++2c%> або %<-std=gnu++2c%>"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "атрибут, що використовує префікс, доступний лише з %<-std=c++17%> або %<-std=gnu++17%>"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "вираз повинен бути укладений у дужки"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr "відсутнє додаткове %<requires%>, щоб почати вимогу-вираз"
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr "перевірка, чи є ідентифікатор концепції дійсним виразом; додайте %<requires%>, щоб перевірити задоволеність"
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, gcc-internal-format
 msgid "result type is not a plain type-constraint"
 msgstr "тип результату не є простою обмеженням типу"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "%<return-type-requirement%> не є обмеженням типу"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "спеціалізація члена %<%T::%E%> вимагає синтаксису %<template<>%>"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "недійсна декларація %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "занадто мало списків параметрів шаблону"
@@ -68539,433 +68643,433 @@ msgstr "занадто мало списків параметрів шаблон
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "занадто багато списків параметрів шаблону"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr "template-id не дозволено для конструктора в C++20"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "іменовані значення повернення більше не підтримуються"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr "ISO C++ не прийняв операторні шаблони літералів рядків, які приймають набір аргументів з символів"
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "шаблон оператора літералу %qD має неприпустимий список параметрів; очікувався набір не-типових параметрів шаблону %<<char...>%> або один не-типовий параметр класового типу"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "шаблон оператора літералу %qD має неприпустимий список параметрів; очікувався шаблон для набору не-типових аргументів %<<char...>%>"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "недійсна декларація шаблону члена в локальному класі"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "шаблон з C-звʼязком"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "недійсна явна спеціалізація"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "декларація шаблону %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr "декларація шаблону класу не повинна декларувати щось інше"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "явна спеціалізація шаблону не може мати клас зберігання"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%> повинно бути %<> >%> в межах вкладеного списку аргументів шаблону"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "неправильне використання %<>>%>, використовуйте %<>%>, щоб закінчити список аргументів шаблону"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, gcc-internal-format
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "%qs повинно бути %qs для завершення списку аргументів шаблону"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "аргумент %<sizeof...%> повинен бути оточений дужками"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "неправильне використання %qD в специфікації звʼязку"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "вказівник %qD конфліктує з %qs"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> перед %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "вказівник %qD конфліктує з %<typedef%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 не підтримує %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "вказано як %<__thread%>, так і %<thread_local%>"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "подвійне %qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "подвійне %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "очікується %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "очікується %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "очікується %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "очікується %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "очікується %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "очікується %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "очікується %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "очікується %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "очікується %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "очікується %<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "очікувався %<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "очікувався %<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "очікувався %<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "очікувався %<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "очікувався %<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "очікувався %<auto%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "очікувався %<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "очікувався %<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "очікувався %<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "очікувався %<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "очікувався %<__transaction_atomic%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "очікувався %<__transaction_relaxed%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "очікувався %<co_yield%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "очікувався %<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "очікувався %<...%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "очікувався %<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "очікувався %<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "очікувався %<:%> або %<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "очікувався %<class%>, %<typename%> або %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "очікувався %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr "зайвий ключ переліку %<enum%s%> у посиланні на %q#T"
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "тег %qs використовується при наданні імені %q#T"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T було раніше оголошено тут"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, gcc-internal-format
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "зайвий ключ класу %qs у посиланні на %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT оголошено з несумісним ключем класу %qs"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr "видаліть ключ класу або замініть його на %qs"
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "замініть ключ класу на %qs"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "%qT визначено як %qs тут"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qT вперше оголошено як %qs тут"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD повторно оголошено з різним доступом"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "у C++98 %<template%> (як розрізнювач) дозволено лише в межах шаблонів"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "файл закінчується на типовий аргумент"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "неправильно розташований конструкт Objective-C++ %<@%D%>"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "очікується отримувач повідомлення objective-c++"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "очікується аргумент(и) повідомлення objective-c++"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> повинен вказувати тип як аргумент"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "недійсне імʼя селектора Objective-C++"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "очікується оголошення методу objective-c++"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "атрибути методу повинні бути вказані в кінці"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "зайвий %qs між методами Objective-C++"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "недійсний тип для змінної екземпляра"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "очікується ідентифікатор після %<@protocol%>"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "атрибути не можуть бути вказані перед ключовим словом Objective-C++ %<@%D%>"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "Префіксні атрибути ігноруються перед %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "Недійсний тип для властивості"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "Невідомий атрибут властивості %qE"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "Очікувалась список цілочисельних виразів"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "Вираз %<wait%> повинен бути цілочисельним"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "очікується %<scalar%>, %<aggregate%>, %<all%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "Недійсний ідентифікатор зведення"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "Типи не можуть бути визначені в типі ітератора"
@@ -68974,178 +69078,178 @@ msgstr "Типи не можуть бути визначені в типі іт
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, gcc-internal-format
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "%<#pragma omp allocate%> ще не підтримується"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "У круглих дужках ініціалізація не дозволена в циклі OpenMP %<for%>"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "Замикання %<ordered%> з параметром в циклі %<for%> з діапазоном"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "ітераційна змінна %qD не повинна бути зведенням"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp declare %s%> за яким слідує %<#pragma omp declare %s%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma omp declare %s%> повинен бути відстежений декларацією або визначенням функції"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qD is not a C pointer"
 msgstr "%qD не є змінною-вказівником"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr "Директива OpenMP, відмінна від %<declare simd%> або %<declare variant%>, належить до оголошення"
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "очікується %<target%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "недійсне замикання ініціалізатора"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "очікується id-вираз (аргументи)"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr "одним з аргументів виклику ініціалізатора повинен бути %<omp_priv%> або %<&omp_priv%>"
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "типи не можуть бути визначені в списку типів для зведення"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr "попередньо визначений арифметичний тип %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr "тип функції або масиву %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr "тип посилання %qT в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "тип %qT з кваліфікаторами %<const%>, %<volatile%> або %<__restrict%> в %<#pragma omp declare reduction%>"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in iterator type"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "Типи не можуть бути визначені в типі ітератора"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "очікується %<simd%>, %<reduction%>, %<target%> або %<variant%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr "%<#pragma acc routine%> називає набір перевантажень"
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD не посилається на функцію в області простору імен"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "compound-statement in %<constexpr%> function"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "складений оператор в функції %<constexpr%>"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr "%<atomic_cancel%>"
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "зовнішній %<__transaction_cancel%> не знаходиться всередині зовнішнього %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  або функція %<transaction_may_cancel_outer%>"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "неправильно сформований %<#pragma GCC pch_preprocess%>"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp requires%> може використовуватися тільки на рівні файлу або простору імен"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp assumes%> може використовуватися тільки на рівні файлу або простору імен"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "%<#pragma GCC %s%> має бути всередині функції"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, gcc-internal-format
 msgid "multi-source compilation not implemented for C++"
 msgstr "багатоджерельна компіляція не реалізована для C++"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, gcc-internal-format
 msgid "placeholder type not allowed in this context"
 msgstr "тип-заповнювач не дозволений в цьому контексті"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "імпліцитні шаблони не можуть бути %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr "звʼязування %<extern \"C\"%> почалося тут"
@@ -69626,17 +69730,23 @@ msgstr "використовуйте %<template<>%> для явної спеці
 msgid "redeclaration of %qD with different constraints"
 msgstr "повторна декларація %qD з різними обмеженнями"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+#| msgid "lambda-expression in template parameter type"
+msgid "local class in lambda in template parameter list"
+msgstr "Лямбда-вираз в типі параметра шаблону"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT не є типом шаблону"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "специфікатори шаблону не вказані в оголошенні %qD"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
@@ -69644,7 +69754,7 @@ msgstr[0] "повторно оголошено з %d параметром шаб
 msgstr[1] "повторно оголошено з %d параметрами шаблону"
 msgstr[2] "повторно оголошено з %d параметрами шаблону"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
@@ -69652,127 +69762,127 @@ msgstr[0] "попереднє оголошення %qD використовув
 msgstr[1] "попереднє оголошення %qD використовувало %d параметри шаблону"
 msgstr[2] "попереднє оголошення %qD використовувало %d параметрів шаблону"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "параметр шаблону %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "перевизначено тут як %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr "перевизначено тут"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "оголошення параметра шаблону %q+#D з різними обмеженнями"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "оригінальне оголошення зʼявилося тут"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "перевизначення %q#D з різними обмеженнями"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "це повинна бути адреса функції з зовнішнім звʼязком"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "це повинно бути імʼя функції з зовнішнім звʼязком"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT, оскільки %qD не має звʼязку"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT, оскільки %qD не має зовнішнього звʼязку"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "він повинен бути вказівником на член у вигляді %<&X::Y%>"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, gcc-internal-format
 msgid "because it is a member of %qT"
 msgstr "тому що він є членом %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  не вдалося вивести параметр шаблону %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  типи %qT і %qT мають несумісні cv-якірники"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  несумісні типи %qT і %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "  параметр шаблону %qD не є пакетом параметрів, але аргумент %qD є"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "  аргумент шаблону %qE не відповідає сталому вказівнику на члена %qE"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE не еквівалентний %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  непослідовна виведення пакету параметрів з %qT і %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  виведені конфліктуючі типи для параметра %qT (%qT та %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  виведені конфліктуючі значення для параметра не-типу %qE (%qE та %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "  тип масиву змінної розмірності %qT не є допустимим аргументом шаблона"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  тип функції-члена %qT не є допустимим аргументом шаблона"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
@@ -69780,7 +69890,7 @@ msgstr[0] "  кандидат очікує принаймні %d аргумен
 msgstr[1] "  кандидат очікує принаймні %d аргументи, надано %d"
 msgstr[2] "  кандидат очікує принаймні %d аргументів, надано %d"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
@@ -69788,340 +69898,340 @@ msgstr[0] "  кандидат очікує %d аргумент, надано %d"
 msgstr[1] "  кандидат очікує %d аргументи, надано %d"
 msgstr[2] "  кандидат очікує %d аргументів, надано %d"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  не вдається перетворити %qE (тип %qT) в тип %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT є неоднозначним базовим класом для %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT не походить від %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  параметри шаблона шаблонного аргумента несумісні з іншими виведеними шаблонними аргументами"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  не можу вивести шаблон для %qT з нешаблонного типу %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "  аргумент шаблона %qE не відповідає %qE"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE не є дійсним аргументом шаблона типу %qT, оскільки %qE не є змінною або функцією"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE не є дійсним аргументом шаблона типу %qT в C++98, оскільки %qD не має зовнішнього звʼязку"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE не є дійсним аргументом шаблону типу %qT, оскільки %qD не має звʼязку"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "адреса %qD не є дійсним аргументом шаблону"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "адреса підобʼєкта %qT обʼєкта %qD не є дійсним аргументом шаблону"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "адреса %qD не є дійсним аргументом шаблону, оскільки вона не має статичної тривалості зберігання"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD не є дійсним аргументом шаблону, оскільки %qD є змінною, а не адресою змінної"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE не є дійсним аргументом шаблону для %qT, оскільки це не є адреса змінної"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT, оскільки рядкові літерали ніколи не можуть бути використані в цьому контексті"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "у аргументі шаблону для типу %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "аргумент шаблону %qE для типу %qT не є константою часу компіляції"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT через конфлікти в cv-кваліфікації"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT, оскільки він не є l-значенням"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D не є допустимим аргументом шаблону для типу %qT, оскільки змінна посилання не має сталої адреси"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT, оскільки це вказівник"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "спробуйте використовувати %qE замість цього"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE не є дійсним аргументом шаблону для типу %qT, оскільки він має тип %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "ігнорування атрибутів на аргументі шаблону %qT"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "ігнорування атрибутів в аргументі шаблону %qE"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "використання введеного імені класу %qD як аргументу шаблону"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "недійсне використання деструктора %qE як типу"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "щоб посилатися на член типу параметра шаблону, використовуйте %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "неспівпадіння типу/значення в аргументі %d у списку параметрів шаблону для %qD"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  очікувався константний тип %qT, отримано %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "  неоднозначний аргумент шаблону для неперемінного параметра шаблону розглядається як функційний тип"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  очікувався класовий шаблон, отримано %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  очікувався тип, отримано %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  очікувався тип, отримано %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  очікувався класовий шаблон, отримано %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  очікувався шаблон типу %qD, отримано %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "несумісні обмеження для аргументу %d у списку параметрів шаблону для %qD"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  очікувався %qD, отримано %qD"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "не вдалося конвертувати аргумент шаблона %qE з %qT в %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "аргумент шаблону %d недійсний"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "неправильна кількість аргументів шаблону (%d, повинно бути %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "неправильна кількість аргументів шаблону (%d, повинно бути щонайменше %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr "надано для %qD"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "аргумент розширення пакету для непакетного параметра %qD псевдоніма шаблону %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "аргумент розширення пакету для непакетного параметра %qD концепції %qD"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr "таким чином будь-яка інстанціація з непорожньою пакетом параметрів буде некоректною"
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D не є шаблоном функції"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "тип %qT, який не є шаблоном, використовується як шаблон"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "для оголошення шаблону %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, gcc-internal-format
 msgid "template constraint failure for %qD"
 msgstr "помилка обмеження шаблону для %qD"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "використання недійсного шаблону змінної %qE"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "глибина інстанціювання шаблону перевищує максимум %d (використовуйте %<-ftemplate-depth=%>, щоб збільшити максимум)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "аргумент score повинен бути цілим сталим виразом"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "аргумент score повинен бути не відʼємним"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "властивість повинна бути цілим сталим виразом або літералом рядка"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "властивість повинна бути цілим сталим виразом"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-class template %qD"
 msgid "instantiating erroneous template"
 msgstr "явна інстанціація не-класового шаблону %qD"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "first specified here"
 msgid "first error appeared here"
 msgstr "перший вказаний тут"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "гнучкий елемент масиву %qD в обʼєднанні"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr "згортка порожньої розгортки над %O"
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, gcc-internal-format
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE не є повністю шаблоном розгортки пакету"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "невідповідні довжини пакету аргументів при розгортанні %qT"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "невідповідні довжини пакету аргументів при розгортанні %qE"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is instantiated for an empty pack"
 msgid "cannot index an empty pack"
 msgstr "%qD інстанціюється для порожнього пакету"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "  при створенні значення за замовчуванням для виклику %qD"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "створення вказівника на функцію-член некласового типу %qT"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr "невідповідні довжини наборів аргументів (%d проти %d)"
@@ -70139,128 +70249,128 @@ msgstr "невідповідні довжини наборів аргумент
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "змінна %qD має тип функції"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "недійсний тип параметра %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "у оголошенні %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "функція, що повертає масив"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "функція, що повертає функцію"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not defined as a type"
 msgid "%qE is not usable in a splice type"
 msgstr "%qs не визначено як тип"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE не є змінною в замиканні %qs"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "створення посилання на тип «void»"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "створення вказівника на тип посилання %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "створення посилання на тип посилання %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "створення вказівника на кваліфікований тип функції %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "формування посилання на кваліфікований тип функції %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "створення вказівника на член типу, що не є класом %qT"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "створення вказівника на тип посилання на член %qT"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "створення вказівника на член типу void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "створення масиву з %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "припускається, що масив %q+D має один елемент"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr "%qD інстанціюється для порожнього пакету"
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT не є класом, структурою або обʼєднанням"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT розрішується як %qT, який не є перелічуванням"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT розрішується як %qT, але це не класовий тип"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT розрішується як %qT, який не є перелічуванням"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected a reflection of a type template"
 msgstr "очікується оператор вибору"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "використання %qs у шаблоні"
@@ -70268,207 +70378,207 @@ msgstr "використання %qs у шаблоні"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "exception specification of %qD depends on itself"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "специфікація винятку %qD залежить від себе"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "тип, що кваліфікує %qT, не відповідає імені деструктора ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "залежне імʼя %qE розбирається як не-тип, але інстанціювання повертає тип"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "використовуйте %<typename %E%>, якщо мається на увазі тип"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "ініціалізатор для %q#D розширюється до порожнього списку виразів"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "неправильне використання виразу розгортання пакету"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "використовуйте %<...%>, щоб розгорнути пакет аргументів"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "порожня ініціалізатор в захопленні ініціалізатора лямбди"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD не було оголошено в цій області видимості, і жодних оголошень не було знайдено за допомогою пошуку залежного від аргументу в точці інстанціювання"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "оголошення в залежній базі %qT не знайдені за допомогою некваліфікованого пошуку"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "використовуйте замість цього %<this->%D%>"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "використовуйте замість цього %<%T::%D%>"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qD оголошено тут, пізніше в одиниці перекладу"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "неправильна кількість аргументів для %<__builtin_convertvector%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "неправильна кількість аргументів для атрибуту %<assume%>"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT не є класом або простором імен"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD не є класом або простором імен"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "використання недійсного поля %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT є/використовує безіменний тип"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "аргумент шаблону для %qD використовує локальний тип %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT є типом зміненої модифікації"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "цілочисельний вираз %qE не є константою"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  спроба інстанціювати %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "неоднозначна інстанціація шаблону для %q#T"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "неоднозначна інстанціація шаблону для %q#D"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr "%s %#qS"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "явна інстанціація нешаблону %q#D"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD не є статичним елементом даних класу-шаблону"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "не знайдено відповідного шаблону для %qD"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "тип %qT для явної інстанціації %qD не відповідає оголошеному типу %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "явна інстанціація %q#D"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "подвійна явна інстанціація %q#D"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ 1998 забороняє використання %<extern%> при явних інстанціаціях"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "клас зберігання %qD застосований до інстанціації шаблону"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "явна інстанціація не-класового шаблону %qD"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "явна інстанціація не-шаблонного типу %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "явна інстанціація %q#T перед визначенням шаблону"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ забороняє використання %qE при явних інстанціаціях"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "подвійна явна інстанціація %q#T"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, gcc-internal-format
 msgid "exception specification of %qD depends on itself"
 msgstr "специфікація винятку %qD залежить від себе"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 #| msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgid "exception specification of %qD is not available until end of class definition"
@@ -70481,542 +70591,605 @@ msgstr "специфікатори virt в %qs не дозволені поза
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "явна інстанціація %qD, але відсутня визначення"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "глибина інстанціювання шаблону перевищує максимум %d при інстанціюванні %q+D, можливо, з генерації віртуальної таблиці (використовуйте %<-ftemplate-depth=%>, щоб збільшити максимум)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "нетипізовані параметри шаблону з виведеним типом класу доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%qT не є дійсним типом для нетипізованого параметра шаблону, оскільки він не є структурним"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "не-типізовані параметри шаблону класу доступні лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "недійсний не-типізований параметр шаблону"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T не є дійсним типом для нетипізованого параметра шаблону"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "слово %<template%> не дозволено в declarator-id"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "концепцію не можна обмежити"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "концепція %qE не знаходиться в області простору імен"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr "концепція %qE має кілька списків параметрів шаблону"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "виведення зі списку ініціалізаторів, заключених у фігурні дужки, потребує %<#include <initializer_list>%>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, gcc-internal-format
 msgid "non-deducible template %qT used without template arguments"
 msgstr "недедуктивний шаблон %qT використовується без аргументів шаблону"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "виведення псевдоніма шаблону доступне лише з %<-std=c++20%> або %<-std=gnu++20%>"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, gcc-internal-format
 msgid "use %qD directly instead"
 msgstr "використовуйте безпосередньо %qD замість цього"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr "не вдається вивести аргументи шаблону для копіювальної ініціалізації %qT, оскільки він не має неявних вказівок виведення або користувацьких конструкторів"
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "не вдається вивести аргументи шаблону %qT, оскільки він не має придатних посібників для виведення"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "не вдалося вивести аргументи шаблону класу:"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, gcc-internal-format
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "експліцитні посібники для виведення не враховуються при копіювальній ініціалізації"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "не вдалося вивести аргументи шаблону класу для %qT: вибрано експліцитний посібник для виведення при копіювальній ініціалізації списком"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "експліцитний посібник для виведення оголошено тут"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "%qT, можливо, не планує підтримувати виведення аргументів для шаблону класу"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr "додайте посібник з виведенням, щоб прибрати це попередження"
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr "пряма ініціалізація списком %<auto%> потребує рівно один елемент"
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr "для виведення до %<std::initializer_list%> використовуйте копіювальну ініціалізацію списком (тобто додайте %<=%> перед %<{%>)"
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "не вдається вивести тип повернення лямбда-функції з %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "не вдається вивести %qT з %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr "обмеження для заповнювача не виконуються"
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "виведений ініціалізатор не відповідає обмеженням для заповнювача"
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "виведений тип повернення не відповідає обмеженням для заповнювача"
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr "виведений тип виразу не відповідає обмеженням для заповнювача"
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new не може бути застосований до типу посилання"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new не може бути застосований до типу функції"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be applied to non-pointer type %qT"
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "атрибут %qE не може бути застосований до типу %qT, який не є вказівником"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be applied to non-pointer type %qT"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "атрибут %qE не може бути застосований до типу %qT, який не є вказівником"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new не може бути застосований до типу функції"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new не може бути застосований до типу функції"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "passing %qT to argument %d of %qE, which expects %qT"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "передача %qT до аргументу %d функції %qE, яка очікує %qT"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%E%> is not a class or namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<::%E%> не є класом або простором імен"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, fuzzy, gcc-internal-format
 #| msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "%<decltype%> обчислюється як %qT, який не є класом або перелічуванням"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "очікується %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not open Go dump file %qs: %m"
 msgid "couldn%'t look up %qs"
 msgstr "Не вдалося відкрити файл з дампом Go %qs: %m"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  очікувався тип, отримано %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT must be an object type"
 msgstr "  %qT не є типом об'єкта"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a member function"
 msgid "%qT must be a function type"
 msgstr "%qD повинна бути функцією-членом"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "очікуваний аргумент шаблону"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qs with %<warn_if_not_aligned%> type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "не можна оголосити біт-поле %qs з типом %<warn_if_not_aligned%>"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "enum constant defined here"
 msgid "%<consteval%> block defined here"
 msgstr "константа перелічування визначена тут"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %<PHI%> argument"
 msgid "invalid %<access_context%> argument"
 msgstr "недійсний аргумент %<PHI%>"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected %<else%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "неочікуваний %<else%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "неочікуваний аргумент"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "passing %qT to argument %d of %qE, which expects %qs"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "передача %qT до аргументу %d функції %qE, яка очікує %qs"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+#| msgid "vector type expected in %qs"
+msgid "incorrect %qT return type, expected %qs"
+msgstr "очікується векторний тип в %qs"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+#| msgid "vector type expected in %qs"
+msgid "incorrect %qT return type, expected %qT"
+msgstr "очікується векторний тип в %qs"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown metafunction %qD"
 msgstr "невідома функція специфікації %qs"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be constant integer expression at %C"
 msgid "splice argument must be an expression of type %qs"
 msgstr "аргумент %<score%> повинен бути сталою цілочисельним виразом у %C"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot call a concept as a function"
+msgid "cannot splice a null reflection"
+msgstr "неможливо викликати концепцію як функцію"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "не можна використовувати %<::%> в декларації параметра"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<constexpr%>"
 msgid "add %<constexpr%>"
 msgstr "%qE використовується з %<constexpr%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "function concept must be called"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "функційне поняття повинно бути викликане"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "очікується булевий вираз"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "слово %<typename%> не дозволено поза шаблонами"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 #| msgid "expected constructor, destructor, or type conversion"
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "очікується конструктор, деструктор або перетворення типу"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "не можна явно оголосити члена %q#D зовнішнім звʼязком"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "invalid cast to abstract class type %qT"
+msgid "invalid class member access of type template %qE"
+msgstr "недійсне приведення до абстрактного класу %qT"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %qs as a call-used register"
+msgid "cannot use %qE to access a class member"
+msgstr "не можна використовувати %qs як регістр, що використовується при виклику"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 #| msgid "use of local variable with automatic storage from containing function"
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "Використання локальної змінної з автоматичним сховищем з вмістної функції"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 #| msgid "call to consteval function %qE is not a constant expression"
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "Виклик функції consteval %qE не є константним виразом"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about uses of a comma operator within a subscripting expression."
 msgid "cannot use a data member specification in a splice expression"
 msgstr "Попереджувати про використання оператора коми в межах виразу підскриптування."
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "expected at least one assumption clause"
+msgid "expected a reflection of a function template"
+msgstr "очікується принаймні одне замикання припущення"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, gcc-internal-format
 msgid "cannot use %<typeid%> with %<-fno-rtti%>"
@@ -71350,604 +71523,604 @@ msgstr "неприпустиме визначення кваліфіковано
 msgid "invalid base-class specification"
 msgstr "неприпустима специфікація базового класу"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "не можна захопити член %qD анонімного обʼєднання"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD не захоплено"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "лямбда не має захоплення за замовчуванням"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr "Лямбда-функція в локальному класі %q+T не може захоплювати змінні з оточуючого контексту"
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "Використання локальної змінної з автоматичним сховищем з вмістної функції"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "Використання параметра з вмістної функції"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "Використання параметра поза тілом функції"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, gcc-internal-format
 msgid "missing template arguments"
 msgstr "Відсутні аргументи шаблону"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "Параметр шаблону %qD типу %qT не допускається в цілочисельному сталому виразі, оскільки він не є цілочисельним або перелічувальним типом"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "Використання класового шаблону %qT як виразу"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "Запит на елемент %qD є неоднозначним у гратці множинного успадкування"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD не може зʼявлятися у константному виразі"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "тип %qE невідомий"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT не є перелічувальним типом"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "розмір масиву має нецілочисельний тип %qT"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "%<__type_pack_element%> index is not an integral constant"
 msgid "pack index is not an integral constant"
 msgstr "індекс %<__type_pack_element%> не є цілочисельною сталою"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "argument %i value %qE is negative"
 msgid "pack index %qE is negative"
 msgstr "аргумент %i значення %qE є відʼємним"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "Пакет параметрів %<__bases%> дійсний лише в оголошенні шаблону"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "не можна застосовувати %<offsetof%> до деструктора %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "не можна застосовувати %<offsetof%> до функції-члена %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "не можна застосовувати %<offsetof%> до функції-члена"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "не можна застосовувати %<offsetof%> до перелічування %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "%<offsetof%> в межах типу %qT, який не відповідає стандартному розташуванню, підтримується умовно"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "відповідність вказівника на член %qE не підтримується"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "Пошук зменшення, визначеного користувачем, є неоднозначним"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %#qD"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "%qE в замиканні %<reduction%> є масивом нульового розміру"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE має тип const для %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr "Користувацьке визначення зменшення з ініціалізатором конструктора для базового класу %qT"
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, fuzzy, gcc-internal-format
 #| msgid "function or array type in %<#pragma omp declare reduction%>"
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr "тип функції або масиву у %<#pragma omp declare reduction%>"
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "%qD повинна бути глобальною змінною в %<#pragma acc declare link%>"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "property must be a constant integer expression at %C"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "властивість повинна бути сталим цілочисельним виразом в %C"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr "у замиканні %<linear%> на конструкціях %<simd%> або %<for%> вказано модифікатор, відмінний від %<val%>, при використанні модифікаторів OpenMP 5.2"
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr "замикання %qs модифікатора linear застосована до змінної, яка не є посиланням, з типом %qT"
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr "Замикання 'linear' застосовано до змінної типу %qT, яка не є цілочисельним або вказівником"
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "Вираз кроку 'linear' повинен бути цілочисельним"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr "%<this%> дозволено в OpenMP тільки в замиканнях %<declare simd%>"
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD не є змінною в замиканні %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD не є змінною в замиканні %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD не є змінною в замиканні %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "Вираз статичного %<gang%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "Значення статичного %<gang%> повинно бути позитивним"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "Вираз номера %<gang%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "Вираз довжини %<vector%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "Вираз номера %<worker%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "Значення %<gang%> повинно бути позитивним"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "Значення довжини %<vector%> повинно бути позитивним"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "Значення номера %<worker%> повинно бути позитивним"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "Вираз розміру частини розкладу повинен бути цілочисельним"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "Вираз довжини %qs повинен бути цілочисельним"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "Вираз довжини %qs повинен бути позитивним сталим цілим виразом"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "Вираз %<async%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "Вираз %<thread_limit%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "Ідентифікатор %<device%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "Вираз розміру частини %<dist_schedule%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD не є змінною в замиканні %<aligned%>"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr "%qE в замиканні %<aligned%> не є вказівником, масивом або посиланням на вказівник або масив"
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD зустрічається більше одного разу в замиканнях %<aligned%>"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "вираз вирівнювання в замиканні %<aligned%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD не є змінною в замиканні %<nontemporal%>"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD зустрічається більше одного разу в замиканнях %<nontemporal%>"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%<this%> не дозволено в замиканні %<allocate%>"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD не є змінною в замиканні %<allocate%>"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD зустрічається більше одного разу в замиканнях %<allocate%>"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<allocate%> clause"
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "%qE не є змінною в замиканні %<allocate%>"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name %qs cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "Назва %qs не може бути використана як визначений оператор на %C"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length arrays are not yet supported in coroutines"
 msgid "variable length traits arrays are not supported"
 msgstr "масиви змінної довжини ще не підтримуються в корутин"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD не є виразом lvalue або секцією масиву в замиканні %qs"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "шаблон %qE в замиканні %qs"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr "перевантажене імʼя функції %qE в замиканні %qs"
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "вираз %<grainsize%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "вираз %<priority%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "вираз %<hint%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "вираз %<hint%> повинен бути сталим цілочисельним виразом"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "dираз %<filter%> повинен бути цілочисельним"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "Змінна %qs не є вказівником або посиланням на вказівник"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "Змінна %qs не є вказівником, масивом або посиланням на вказівник або масив"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "Аргумент для %<tile%> повинен мати цілочисельний тип"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr "Кваліфікований %qE з %<const%>, без члена %<mutable%>, може зʼявлятися тільки в замиканнях %<shared%> або %<firstprivate%>"
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD не є змінною з областю видимості файлу, простору імен або блоку"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "Директива %<threadprivate%> %qE не визначена в %qT"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "різниця між %qE та %qD не має цілочисельного типу"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<#pragma omp simd%> використовується з ітераційною змінною класу %qE"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic update%> використовує два різних вирази для памʼяті"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message must be a string literal or object with %<size%> and %<data%> members"
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr "Повідомлення %<static_assert%> має бути рядком або об'єктом з членами %<size%> і %<data%>"
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr "Повідомлення %<static_assert%>: розмір %<size()%> має бути неявно перетворюваним у %<std::size_t%>"
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message %<data()%> must be implicitly convertible to %<const char*%>"
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr "Повідомлення %<static_assert%>: %<data()%> має автоматично перетворюватися на %<const char*%>"
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message %<size()%> must be a constant expression"
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "повідомлення %<static_assert%> %<size()%> повинно бути сталим виразом"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message %<size()%> %qE too large"
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr "Розмір повідомлення %<static_assert%> завеликий: %<size()%> %qE "
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message %<data()[%d]%> must be a constant expression"
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "повідомлення %<static_assert%> %<data()[%d]%> повинно бути сталим виразом"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 #| msgid "%<static_assert%> message %<data()%> must be a core constant expression"
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "повідомлення %<static_assert%> %<data()%> повинно бути основним сталим виразом"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "статична перевірка не пройдена: %.*s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "неконстантна умова для статичного твердження"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "аргумент для %<decltype%> повинен бути виразом"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%<decltype%> не може вирішити адресу перевантаженої функції"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT не є типом класу"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an standard layout type"
 msgid "%qT is not a standard-layout type"
 msgstr "  %qT не є типом зі стандартним розташуванням"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr "%<__builtin_is_pointer_interconvertible_with_class%> потребує один аргумент"
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr "Аргумент %<__builtin_is_pointer_interconvertible_with_class%> не є вказівником на член"
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr "%<__builtin_is_corresponding_member%> не чітко визначений для анонімних обʼєднань"
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_is_corresponding_member%> потребує два аргументи"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr "Аргумент %<__builtin_is_corresponding_member%> не є вказівником на член"
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_is_pointer_interconvertible_with_class%> потребує один аргумент"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference"
 msgid "%qs argument %qT is a reference"
 msgstr "  %qT не є посиланням"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qD не є класом або псевдонімом шаблону"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "Операнд складеного виразу не має нерозгорнутих пакетів параметрів"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "обидва аргументи в бінарному складеному мають нерозгорнуті пакети параметрів"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr "немає нерозгорнутих пакетів параметрів у бінарному складанні"
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_call_with_static_chain%> must be a pointer type"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -71956,365 +72129,365 @@ msgstr "другий аргумент для %<__builtin_call_with_static_chain%
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr "тип призначення %qT %<__builtin_bit_cast%> є типом масиву"
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr "тип призначення %qT %<__builtin_bit_cast%> не є простим для копіювання"
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "тип призначення %qT %<__builtin_bit_cast%> є типом масиву"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr "тип джерела %qT %<__builtin_bit_cast%> не є простим для копіювання"
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr "розмір джерела %qE %<__builtin_bit_cast%> не дорівнює розміру типу призначення %qE"
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "кваліфікатори %qV не можуть бути застосовані до %qT"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr "%<-fabi-version=13%> (GCC 8.2) виправляє конвенцію виклику для %qT, яка була помилково змінена в 8.1"
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr "%<-fabi-version=12%> (GCC 8.1) випадково змінює конвенцію виклику для %qT"
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr " оголошено тут"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr "конвенція виклику для %qT змінюється в %<-fabi-version=13%> (GCC 8.2)"
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr " оскільки всі його конструктори копіювання та переміщення видалені"
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a function, not a type"
 msgid "%qT is a floating-point type"
 msgstr "%qD - це функція, а не тип"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a function, not a type"
 msgid "%qT is a fixed-point type"
 msgstr "%qD - це функція, а не тип"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT не є базою для %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr "  %qT не має унікальних представлень обʼєктів"
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T має члени даних, які є вказівниками"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "base %qT does not have unique object representations"
 msgstr "  %qT не має унікальних представлень обʼєктів"
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "%qD with type %qT does not have unique object representations"
 msgstr "  %qT не має унікальних представлень обʼєктів"
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "порівняння між %qT і %qT"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, fuzzy, gcc-internal-format
 #| msgid "pointer used after %qD"
 msgid "padding occurs after %qD"
 msgstr "вказівник використовується після %qD"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs не є файлом даних gcov"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "базовий клас %qT не є публічним"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%qD не є публічним"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD є змінним"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qD має неструктурний тип"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "Атрибут %qE можна застосовувати тільки до функцій або параметрів"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "Аргумент атрибуту %qE повинен бути рядковою константою"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "Атрибут %qE можна застосовувати тільки до функцій або до класів або перелічувань"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "Атрибут %qE можна застосовувати тільки до нестатичних членів даних"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, gcc-internal-format
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "Атрибут %qE не може бути застосований до поля бітів"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "Атрибут %qE не приймає аргументів"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "Атрибут ISO C++ %qE не застосовується до функцій; розглядається як %<[[gnu::%E]]%>"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "%<inline%> в порожньому оголошенні"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT не є перелічувальним типом"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> застосовується до бітового поля"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qD не має цілочисельного або перелічувального типу"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "%qE on unnamed bit-field"
 msgstr "вказано вирівнювання для безіменного біт-поля"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %qD but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "оголошення для параметра %qD, але такого параметра немає"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, gcc-internal-format
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "запитаний %<init_priority%> не є цілочисельним"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "можна використовувати атрибут %qE тільки на визначеннях обʼєктів класу на рівні файлу"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "запитаний %<init_priority%> %i знаходиться поза межами діапазону [0, %i]"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "запитаний %<init_priority%> %i зарезервований для внутрішнього використання"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "повторне оголошення %qD додає мітку abi %qE"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "атрибут %qE вимагає аргументів"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "аргументи атрибуту %qE повинні бути вузькими літералами рядка"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "аргументи для атрибуту %qE повинні містити дійсні ідентифікатори"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%c%> не є допустимим першим символом для ідентифікатора"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%c%> не є допустимим символом в ідентифікаторі"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "атрибут %qE застосовується до типу %qT, який не є класом або перелічуванням"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "атрибут %qE застосовується до %qT після його визначення"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "ігнорується атрибут %qE, застосований до інстанціювання шаблону %qT"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "ігнорується атрибут %qE, застосований до спеціалізації шаблону %qT"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "атрибут %qE застосовується до %qD, який не є функцією або змінною"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "атрибут %qE застосовується до зовнішньої «C»-декларації %qD"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "аргумент атрибуту %qE повинен бути виразом, який оцінюється як істина або хиба"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about semicolon after in-class function definition."
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "Попереджувати про крапку з комою після визначення функції в класі."
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "атрибут %qE застосовується лише до змінних"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 #| msgid "alignment specified for unnamed bit-field"
 msgid "annotation on unnamed bit-field"
 msgstr "вказано вирівнювання для безіменного біт-поля"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "параметр функції"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral type"
 msgid "annotation does not have structural type"
 msgstr "%qD не має цілочисельного типу"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "annotation does not have copy constructible type"
 msgstr "  %qT не може бути скопійовано без винятків за допомогою конструктора за замовчуванням"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, gcc-internal-format
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
 msgstr "%<lang_*%> перевірка: не вдалося в %s, на %s:%d"
@@ -72520,797 +72693,803 @@ msgstr "%q#T не має члена з іменем %qE; мали на уваз
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%q#T не має члена з іменем %qE; мали на увазі %qE?"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> не є членом %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD не є членом %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD не є шаблонною функцією-членом"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT не є типом вказівника на обʼєкт"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "неприпустиме використання індексування масиву на вказівнику на член"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "неприпустиме використання унарного %<*%> на вказівнику на член"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "неприпустиме використання неявного перетворення на вказівнику на член"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr "лівий операнд %<->*%> повинен бути вказівником на клас, але є вказівником на член типу %qT"
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "відсутній індекс в посиланні на масив"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "індексація масиву, оголошеного як %<register%>"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "індексоване значення не є або масивом, або вказівником"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "використання %qE без обʼєкта"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion in %qs"
 msgid "no default version in scope"
 msgstr "нетривіальне перетворення у %qs"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ забороняє викликати %<::main%> з програми"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "необхідно використовувати %<.*%> або %<->*%> для виклику функції-члена, що вказує на вказівник, в %<%E (...)%>, наприклад, %<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE не може бути використано як функцію"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE не може бути використано як функцію"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD не може бути використано як функцію"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "вираз не може бути використаний як функція"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "забагато аргументів для конструктора %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "замало аргументів для конструктора %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "занадто багато аргументів для функції-члена %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "занадто мало аргументів для функції-члена %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "занадто багато аргументів для функції %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "занадто мало аргументів для функції %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "занадто багато аргументів для методу %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "занадто мало аргументів для методу %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "занадто багато аргументів для функції"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "занадто мало аргументів для функції"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "параметр %P функції %qD має неповний тип %qT"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "параметр %P має неповний тип %qT"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "адреса %qE ніколи не буде NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "адреса обʼєкту %qD ніколи не буде NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "компілятор може припустити, що адреса %qE ніколи не буде NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr "порівняння результату додавання вказівника %qE та NULL"
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "компілятор може припустити, що адреса %qD ніколи не буде NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "бітові операції між різними перераховуваними типами %qT та %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "операція побітового І або АБО між різними типами перелічування %qT та %qT застаріла"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "арифметичні операції між різними перераховуваними типами %qT та %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "арифметична операція між різними типами перелічування %qT та %qT застаріла"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "порівняння перераховуваного типу %qT з типом з плаваючою комою %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "порівняння типу з плаваючою комою %qT з перераховуваним типом %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr "Порівняння перелічувального типу %qT з типом з плаваючою комою %qT є застарілим"
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "Порівняння типу з плаваючою комою %qT з перелічувальним типом %qT є застарілим"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "арифметичні операції між перерахуванням типу %qT і типом з плаваючою комою %qT"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "арифметичні операції між типом з плаваючою комою %qT і перерахуванням типу %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr "Арифметика між перелічувальним типом %qT та типом з плаваючою комою %qT є застарілою"
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr "Арифметика між типом з плаваючою комою %qT та перелічувальним типом %qT є застарілою"
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "Припускається приведення до типу %qT з перевантаженої функції"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL використовується в арифметиці"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ забороняє порівняння між вказівником та цілочисельним"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "Типи операндів: %qT та %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr "Тристороннє порівняння векторів"
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "упорядковане порівняння вказівника з нулем (%qT та %qT)"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, gcc-internal-format
 msgid "unordered comparison on non-floating-point argument"
 msgstr "неупорядковане порівняння з нечисловим аргументом"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "неявне перетворення з %qH на %qI для відповідності іншому операнду бінарного виразу"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "недійсні операнди типів %qT і %qT для бінарного %qO"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ забороняє використання відʼємного відʼємного типу %<void *%>"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ забороняє використання відʼємного відʼємного типу для функції"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ забороняє використання відʼємного відʼємного типу для методу"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "недійсне використання вказівника на неповний тип в арифметиці вказівників"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "береться адреса конструктора %qD"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "береться адреса деструктора %qD"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "недійсне використання %qE для створення вказівника на член-функцію"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  потрібно вказати кваліфікований ідентифікатор"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "Дужки навколо %qE не можуть бути використані для створення вказівника на член-функцію"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ забороняє взяти адресу некваліфікованої або укладеної нестатичної член-функції для створення вказівника на член-функцію. Скажіть %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ забороняє брати адресу некваліфікованої або дужкової нестатичної функції-члена для формування вказівника на явну функцію-член об'єкта"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ забороняє взяти адресу привʼязаної член-функції для створення вказівника на член-функцію. Скажіть %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ забороняє брати адресу прив'язаної функції-члена для формування вказівника на явну функцію-член об'єкта"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "вказівник на явну функцію-член об'єкта може бути сформований тільки з %<&%T::%D%>"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, gcc-internal-format
 msgid "taking address of rvalue"
 msgstr "береться адреса rvalue"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ забороняє взяти адресу функції %<::main%>"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "не можна створити вказівник на посилання на член %qD"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "спроба взяти адресу бітового поля"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<~%> на виразі типу %<bool%>"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr "чи мали ви на увазі використання логічного заперечення (%<!%>)?"
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ забороняє збільшувати перелічування"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ забороняє зменшувати перелічування"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "не можна збільшити вказівник на неповний тип %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "не можна зменшити вказівник на неповний тип %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ забороняє збільшення вказівника типу %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ забороняє зменшення вказівника типу %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr "Вираз %qs з кваліфікатором %<volatile%> є застарілим"
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr "Використання операнда типу %qT в %<operator--%> заборонено"
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr "Використання операнда типу %qT в %<operator++%> заборонено в C++17"
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr "використання операнда типу %qT в %<operator++%> є застарілим"
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "не можна взяти адресу %<this%>, який є виразом rvalue"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "запитано адресу для %qD, яка оголошена як %<register%>"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "ініціалізатор списку для типу, що не є класом, не повинен бути у дужках"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "список виразів розглядається як складений вираз в ініціалізаторі"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "список виразів розглядається як складений вираз в mem-ініціалізаторі"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "список виразів розглядається як складений вираз в функціональному приведенні типу"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "список виразів %s розглядається як складений вираз"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "немає контексту для визначення типу %qE"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "приведення типу %qT до типу %qT видаляє кваліфікатори"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%<static_cast%> з типу %qT до типу %qT видаляє кваліфікатори"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "%<reinterpret_cast%> з типу %qT до типу %qT видаляє кваліфікатори"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "непотрібне приведення до типу %q#T"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, gcc-internal-format
 msgid "type qualifiers ignored on cast result type"
 msgstr "кваліфікатори типу ігноруються на типі результату приведення"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, gcc-internal-format
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "неприпустиме %<static_cast%> з типу %qT до типу %qT"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "тип класу %qT є неповним"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 msgid "converting from %qH to %qI"
 msgstr "перетворення з %qH на %qI"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, gcc-internal-format
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "недійсне приведення типу виразу prvalue типу %qT до типу %qT"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 msgid "cast from %qH to %qI loses precision"
 msgstr "приведення з %qH до %qI втрачає точність"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr "приведення між несумісними типами функцій з %qH до %qI"
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "приведення між несумісними типами вказівників на члени від %qH до %qI"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "приведення від %qH до %qI збільшує необхідне вирівнювання цільового типу"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "приведення між вказівником на функцію та вказівником на обʼєкт підтримується умовно"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "недійсне приведення з типу %qT до типу %qT"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "недійсне використання %<const_cast%> з типом %qT, який не є вказівником, посиланням або вказівником на член даних"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "недійсне використання %<const_cast%> з типом %qT, який є вказівником або посиланням на тип функції"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, gcc-internal-format
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "недійсне %<const_cast%> rvalue типу %qT до типу %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, gcc-internal-format
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "недійсне %<const_cast%> з типу %qT до типу %qT"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ забороняє приведення до типу масиву %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "недійсне приведення до типу функції %qT"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr "переміщення %qE типу %qT в самого себе"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  при оцінці %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "присвоєння масиву зі списку ініціалізаторів"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "несумісні типи при присвоєнні %qT до %qT"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "масив використовується як ініціалізатор"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "недійсне присвоєння масиву"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "   при перетворенні на вказівник на функцію-член"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "перетворення на вказівник на член через віртуальну базу %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "   при перетворенні на вказівник на член"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "недійсне перетворення на тип %qT з типу %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "не можна перетворити %qH на %qI в аргументі за замовчуванням"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "не можна перетворити %qH на %qI при передачі аргументу"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "не можна перетворити %qH на %qI при ініціалізації"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr "не можна перетворити %qH на %qI при поверненні"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "не можна перетворити %qH на %qI в присвоєнні"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "параметр %qP з %qD може бути кандидатом на атрибут формату"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "параметр може бути кандидатом на атрибут формату"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "ціль конвертації може бути кандидатом на атрибут формату"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "ціль ініціалізації може бути кандидатом на атрибут формату"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "ліва сторона присвоєння може бути кандидатом на атрибут формату"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "при передачі аргументу %P з %qD"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "повернення посилання на тимчасовий обʼєкт"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, gcc-internal-format
 msgid "returning pointer to temporary"
 msgstr "повертається вказівник на тимчасовий об'єкт"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr "повернення тимчасового %<initializer_list%> не продовжує термін дії базового масиву"
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "повернуто посилання на локальну змінну %qD"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr "повернення локальної змінної %<initializer_list%> %qD не продовжує термін існування базового масиву"
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "повернуто адресу мітки %qD"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "повернуто адресу локальної змінної %qD"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr "переміщення тимчасового обʼєкта запобігає оптимізації копіювання"
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr "видаліть виклик %<std::move%>"
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr "переміщення локального обʼєкта в операторі повернення запобігає оптимізації копіювання"
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "зайве переміщення в операторі повернення"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "зайве переміщення в ініціалізації"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "повернення значення з деструктора"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "не можна повернути з обробника блоку function-try-блоку конструктора"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "повернення значення з конструктора"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "return-оператор без значення, у функції, що повертає %qT"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr "повернення списку ініціалізаторів"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "несумісні типи %qT та %qT виведені для типу повернення лямбди"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "неспівпадаюче виведення для типу автоматичного повернення: %qT і потім %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, gcc-internal-format
 msgid "return-statement with a value, in function returning %qT"
 msgstr "return-оператор зі значенням, у функції, що повертає %qT"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> не повинен повертати NULL, якщо він не оголошений %<throw()%> (або %<-fcheck-new%> активований)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "не проводиться оптимізація копіювання при поверненні з %qD"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr "не скорочуємо копіювання при поверненні в %qD"
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "використання rvalue як lvalue"
@@ -73721,17 +73900,17 @@ msgstr "не вдалося відкрити файл журналу %<vtv_set_p
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "не вдалося відкрити файл журналу %<vtv_count_data.log%>: %m"
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "невідомий атрибут %qs"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%q+D оголошено слабким після використання"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr "дозволені тільки прапорці %<inbranch%> та %<notinbranch%> для атрибуту %<simd%>"
@@ -73756,43 +73935,43 @@ msgstr "перекриваючий ініціалізатор для поля %q
 msgid "the address of %qD will never be %<null%>"
 msgstr "адреса %qD ніколи не буде %<null%>"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr "потрібен %<this%> для доступу до члена %qE"
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr "спроба виконати ділення за модулем з плаваючою точкою на %qT"
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, gcc-internal-format
 msgid "cannot get frame pointer to %qs"
 msgstr "не вдалося отримати вказівник на рамку до %qs"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, gcc-internal-format
 msgid "nested function missing body"
 msgstr "вкладена функція без тіла"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qs є вкладеною функцією і не може бути доступна з %qs"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr "змінна %qs має обмежений час життя, не можна створити замикання"
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, gcc-internal-format
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "явна реєстрова змінна %qs не може бути використана вкладеною функцією"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "передача посилання на фрейм %qs"
@@ -73873,32 +74052,32 @@ msgstr "невірний аргумент для %<-fmodule-file%>: %qs"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "невірний аргумент для %<-fversion%>: %qs"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, gcc-internal-format
 msgid "unable to open %s for writing: %m"
 msgstr "не вдалося відкрити %s для запису: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, gcc-internal-format
 msgid "writing output file %s: %m"
 msgstr "запис вихідного файлу %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, gcc-internal-format
 msgid "unable to open %s for reading: %m"
 msgstr "не вдалося відкрити %s для читання: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, gcc-internal-format
 msgid "reading ddoc file %s: %m"
 msgstr "читання файлу ddoc %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr "аргумент %<-fonly=%> відрізняється від імені першого вхідного файлу"
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr "не вдається вирішити впередню посилання в означенні"
@@ -73995,7 +74174,7 @@ msgstr "не знаю, як видалити %qs"
 msgid "%qs is not an associative array"
 msgstr "%qs не є асоціативним масивом"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr "потрібно %<this%> для доступу до члена %qs"
@@ -74010,22 +74189,22 @@ msgstr "делегати можуть бути тільки для нестат
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs не є полем, а %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "рекурсивне посилання %qs"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, gcc-internal-format
 msgid "non-constant expression %qs"
 msgstr "неконстантний вираз %qs"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%qs не є виразом"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "тип %qs не є виразом"
@@ -74116,17 +74295,17 @@ msgstr "не можна кидати обʼєкти COM"
 msgid "D inline assembler statements are not supported in GDC."
 msgstr "Вбудовані оператори асемблера D не підтримуються в GDC."
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr "вираз %qs потребує %<object.TypeInfo%> і не може використовуватися з %<-fno-rtti%>"
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<object.TypeInfo%> не може використовуватися з %<-fno-rtti%>"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr "%<object.TypeInfo%> не знайдено, але він використовується неявно"
@@ -74454,8 +74633,8 @@ msgstr "Посилання на масив у %C не може мати біль
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "Комасиви вимкнені у %C, використовуйте %<-fcoarray=%>, щоб увімкнути"
@@ -74734,7 +74913,7 @@ msgstr "Літеральна константа BOZ на %L не може бут
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "Аргументи %qs на %L і %L не можуть обидва бути літеральними константами BOZ"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "Недійсне використання літеральної константи BOZ на %L"
@@ -74813,7 +74992,7 @@ msgstr "Аргумент %qs вбудованої функції %qs на %L п
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути типу INTEGER або PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути константою"
@@ -74955,7 +75134,7 @@ msgstr "Літеральна константа BOZ на %L не може зʼя
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "Аргументи %qs та %qs вбудованої функції %qs на %L повинні мати однаковий тип"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "Різні види типів на %L"
@@ -74970,7 +75149,7 @@ msgstr "NULL на %L не допускається як фактичний ар
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "Аргумент %qs вбудованої функції %qs на %L не повинен мати спільного індексу"
@@ -75113,8 +75292,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "Аргумент errmsg= на %L повинен бути змінною типу CHARACTER з типом за замовчуванням"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "Комасиви вимкнені на %L, використовуйте %<-fcoarray=%>, щоб увімкнути"
@@ -75218,9 +75397,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "Константа BOZ на %L не може зʼявлятися в підпрограмі вбудованої функції COMPLEX"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "Інтринсек %qs з аргументом KIND на %L"
@@ -75235,12 +75414,12 @@ msgstr "Аргумент %qs інтринсеку %qs на %L має недій
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "Аргумент %qs інтринсеку %qs на %L повинен мати ранг %d або бути скалярним"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "Аргумент %qs інтринсичної функції %qs на %L повинен бути числовим або ЛОГІЧНИМ"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "Типи аргументів вбудованої функції %qs у %L повинні збігатися (%s/%s)"
@@ -75335,631 +75514,631 @@ msgstr "Аргумент %qs вбудованої функції %qs на %L п
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "Вбудована функція %qs на %L повинна мати принаймні два аргументи"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "Відсутній аргумент %qs для вбудованої функції %s на %L"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "Повторний аргумент %qs на %L для вбудованої функції %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "Невідомий аргумент %qs на %L для вбудованої функції %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "Різні види символів у %L"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "Аргумент %<a%d%> вбудованої функції %qs у %L повинен бути %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "Вбудована функція %qs з аргументом CHARACTER у %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "Аргумент %<a1%> вбудованої функції %qs у %L повинен бути INTEGER, REAL або CHARACTER"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "Аргумент %<a1%> вбудованої функції %qs у %L повинен бути INTEGER, REAL або CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "Різна форма на розмірності 1 для аргументів %qs і %qs у %L для вбудованої функції matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "Різна форма на розмірності 2 для аргументу %qs і розмірності 1 для аргументу %qs у %L для вбудованої функції matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен мати ранг 1 або 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен відповідати типу аргументу %qs на %L"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути INTEGER або REAL"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути INTEGER"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Аргумент FROM в MOVE_ALLOC на %L не повинен бути коіндексованим"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "Аргумент TO в MOVE_ALLOC на %L не повинен бути коіндексованим"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "Аргументи TO в MOVE_ALLOC на %L повинні бути поліморфними, якщо FROM є поліморфним"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "Аргументи FROM і TO вбудованої функції MOVE_ALLOC на %L повинні мати однаковий ранг %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "Аргументи FROM і TO інструкції MOVE_ALLOC на %L повинні мати однаковий коранк %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr "Аргументи FROM і TO на %L порушують обмеження на псевдонімізацію (F2003 12.4.1.7)"
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "Аргумент %<S%> інструкції NEAREST на %L не повинен бути нулем"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "Аргумент %qs інструкції %qs на %L повинен бути POINTER, ALLOCATABLE або вказівником на процедуру"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "Інструкція NULL з резервованим MOLD на %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must have a type of either REAL or INTEGER"
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "Аргумент %qs вбудованої функції %qs в %L повинен мати тип REAL або INTEGER"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "Аргумент %qs інструкції %qs на %L повинен містити принаймні стільки ж елементів, скільки є значень .TRUE. в %qs (%ld/%d)"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "Аргумент %qs інтринсеки %qs на %L повинен бути змінною-дамі"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "Аргумент %qs інтринсеки %qs на %L повинен бути змінною-дамі OPTIONAL"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "Аргумент %qs вбудованої функції %qs на %L не може бути підобʼєктом %qs"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "Аргумент вбудованої функції RANK на %L повинен бути обʼєктом даних"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The A argument at %L of CO_REDUCE shall not be polymorphic"
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "Аргумент A на %L CO_REDUCE не повинен бути поліморфним"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The stat= argument at %L must be a kind=4 integer variable"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "Аргумент stat= на %L повинен бути змінною типу INTEGER з kind=4"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DTIO dummy argument at %L must be a scalar"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "Фіктивний аргумент DTIO при %L повинен бути скалярним"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "Аргумент %<shape%> вбудованої функції %<reshape%> на %L повинен бути масивом сталого розміру"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "Аргумент %qs вбудованої функції %qs на %L є порожнім"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "Аргумент %<shape%> вбудованої функції %<reshape%> на %L має більше ніж %d елементів"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "Аргумент %qs вбудованої функції %qs на %L має відʼємний елемент (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "Аргумент %qs вбудованої функції %qs на %L має неправильну кількість елементів (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "Аргумент %qs вбудованої функції %qs на %L має розмір, що виходить за межі (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "Аргумент %qs вбудованої функції %qs на %L має недійсну перестановку розмірів (розмірність %qd повторюється)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "Без заповнення, вбудована функція RESHAPE на %L має недостатньо елементів для відповідності формі"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "Аргумент %qs вбудованої функції %qs на %L не може бути типу %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути розширюваним типом"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "SELECTED_REAL_KIND без аргументу %<P%> або %<R%> на %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "вбудована функція %qs з аргументом RADIX на %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "аргумент %<source%> вбудованої функції %<shape%> на %L не може бути масивом з припущеним розміром"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "аргумент %qs вбудованої функції %qs на %L не може бути процедурою"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "аргумент %qs вбудованої функції %qs на %L не може бути TYPE(*)"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "аргумент %qs вбудованої функції %qs на %L не може бути масивом з припущеним розміром"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr "is_c_interoperable(): gfc_simplify_expr не вдалося"
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "аргумент %qs вбудованої функції %qs на %L повинен бути взаємодійною даними: %s"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr "Аргумент C_PTR_1 в %L для C_ASSOCIATED повинен мати тип TYPE(C_PTR) або TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1: %s instead of %s"
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr "Аргумент C_PTR_2 в %L для C_ASSOCIATED повинен мати такий самий тип, як C_PTR_1: %s замість %s"
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr "Аргумент CPTR на %L для C_F_POINTER повинен мати тип TYPE(C_PTR)"
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "Аргумент FPTR на %L для C_F_POINTER повинен бути вказівником"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "Аргумент FPTR на %L для C_F_POINTER не повинен бути поліморфним"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "Аргумент FPTR на %L для C_F_POINTER не може бути співіндексованим"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Неочікуваний аргумент SHAPE на %L до C_F_POINTER з скалярним FPTR"
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr "Очікується аргумент SHAPE для C_F_POINTER з масивом FPTR на %L"
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "Аргумент SHAPE на %L до C_F_POINTER повинен мати такий же розмір, як RANK FPTR"
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "Аргумент FPTR на %L для C_F_POINTER не повинен бути поліморфним"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr "Неочікуваний аргумент SHAPE на %L до C_F_POINTER з скалярним FPTR"
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "Аргумент SHAPE на %L до C_F_POINTER повинен мати такий же розмір, як RANK FPTR"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr "Поліморфний FPTR на %L до C_F_POINTER"
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "Аргумент FPTR для C_F_POINTER у %L є функцією, яка повертає вказівник"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "Несумісний з інтерфейсом масив FPTR аргумент для C_F_POINTER у %L: %s"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr "Аргумент CPTR на %L до C_F_PROCPOINTER повинен мати тип TYPE(C_FUNPTR)"
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "Аргумент FPTR у %L для C_F_PROCPOINTER повинен бути вказівником на процедуру"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "Аргумент FPTR у %L для C_F_PROCPOINTER не може бути коіндексованим"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr "Несумісний вказівник на процедуру у %L для C_F_PROCPOINTER"
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "Аргумент X у %L для C_FUNLOC не може бути коіндексованим"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "Результат функції %qs у %L недійсний як аргумент X для C_FUNLOC"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr "Аргумент X у %L для C_FUNLOC повинен бути процедурою або вказівником на процедуру"
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "Несумісна процедура у %L для C_FUNLOC"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "Аргумент X у %L для C_LOC не може бути коіндексованим"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "Аргумент X у %L для C_LOC не може бути поліморфним"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "Аргумент X у %L для C_LOC повинен мати атрибут POINTER або TARGET"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "Аргумент X у %L для C_LOC не повинен бути рядком нульової довжини"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "Аргумент у %L для C_LOC не повинен бути поліморфним"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "Несумісний масив у %L як аргумент для C_LOC: %s"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr "Масив взаємодіючого типу у %L для C_LOC, який не може бути виділений памʼять і не має ні припущеного розміру, ні явного розміру"
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "Розділ масиву у %L для C_LOC"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "аргумент REAL без подвійної точності для вбудованої функції %s у %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен бути меншим за ранг %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "Аргумент %qs вбудованої функції %qs на %L не є дійсним індексом розмірності"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "Аргумент %qs вбудованої функції %qs на %L повинен мати довжину не менше 1"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "Аргумент %s для IMAGE_INDEX повинен бути одновимірним масивом на %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "Кількість елементів масиву аргументу SUB для IMAGE_INDEX на %L повинна бути %d (коранг), а не %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Забагато аргументів для %s на %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, fuzzy, gcc-internal-format
 #| msgid "DIM argument without COARRAY argument not allowed for THIS_IMAGE intrinsic at %L"
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "Аргумент DIM без аргументу COARRAY не допускається для вбудованої функції THIS_IMAGE на %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "STAT= argument to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "Аргумент STAT= для %s на %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr "Аргумент %<MOLD%> вбудованої функції %<TRANSFER%> на %L є масивом і не повинен мати розміру 0, коли аргумент %<SOURCE%> має розмір більший за 0"
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "аргумент %<SOURCE%> %<TRANSFER%> всередині у %L не може бути %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "аргумент %<MOLD%> %<TRANSFER%> всередині у %L не може бути %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "Аргумент %<MOLD%> вбудованої функції %<TRANSFER%> на %L не повинен бути %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "Вбудована функція TRANSFER у %L має частково невизначений результат: розмір джерела %zd < розмір результату %zd"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "Аргумент %qs інтринсичної функції %qs на %L повинен мати такий самий ранг, як %qs або бути скалярним"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "Аргументи %qs і %qs інтринсичної функції %qs на %L повинні мати однакову форму."
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "Аргумент VALUES для DATE_AND_TIME у %L має тип, відмінний від стандартного"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "Аргумент VALUES для DATE_AND_TIME у %L повинен мати діапазон десяткового експонента не менше чотирьох"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "Розмір аргументу %qs вбудованої функції %qs на %L занадто малий (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Забагато аргументів для %s на %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr "Рядок fe_runtime_error повинен бути завершений нульовим символом"
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "fe_runtime_error: Неправильна кількість аргументів (%d замість %d)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Аргумент COUNT для SYSTEM_CLOCK на %L має нестандартний тип"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Аргумент COUNT для SYSTEM_CLOCK у %L з типом меншим за стандартний цілий"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr "Аргумент COUNT_RATE з реальним числом для SYSTEM_CLOCK на %L"
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Аргумент COUNT_RATE для SYSTEM_CLOCK на %L має нестандартний тип"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Аргумент COUNT_RATE для SYSTEM_CLOCK у %L з типом меншим за стандартний цілий"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "Аргумент COUNT_MAX для SYSTEM_CLOCK на %L має нестандартний тип"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "Аргумент COUNT_MAX для SYSTEM_CLOCK у %L з типом меншим за стандартний цілий"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "Цілочисельні аргументи для SYSTEM_CLOCK у %L з різними параметрами типу"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "Аргумент %qs інтринсичної функції %qs на %L повинен бути типу, не ширшого за тип за замовчуванням (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "Фактичний аргумент на %L інтринсичної функції %qs повинен бути повʼязаним вказівником"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "Аргумент %qs інтринсичної функції %qs на %L повинен бути INTEGER, LOGICAL або літеральною константою BOZ"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr "Інтринсична функція NULL на %L не може бути фактичним аргументом для STORAGE_SIZE, оскільки вона повертає розʼєднаний вказівник"
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "Максимальний рівень розширення досягнутий з типом %qs на %L"
@@ -76026,12 +76205,12 @@ msgstr "Невикористана рядок ініціалізації на %L
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "Рядок ініціалізації у %L був скорочений, щоб вміститися у змінну (%wd/%wd)"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "Початковий індекс підстроки на %L менше одиниці"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "Кінцевий індекс підстроки на %L перевищує довжину рядка"
@@ -76081,2077 +76260,2077 @@ msgstr "Обʼєкт %qs без вказівника зі стандартною
 msgid "Simplification error"
 msgstr "Помилка спрощення"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr "Параметр запиту не може зʼявлятися в списку обʼєктів оператора DATA на %C"
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "Змінна, повʼязана з хостом %qs, не може бути вказана в операторі DATA в %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "Ініціалізація змінної загального блоку %qs в операторі DATA в %C"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "Символ %qs повинен бути ПАРАМЕТРОМ в операторі DATA в %C"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "Недійсний ініціалізатор %s в операторі DATA в %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "BOZ на %L не може зʼявлятися в ініціалізації старого стилю"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr "Літеральна константа BOZ біля %L не може бути присвоєна змінній %qs в ініціалізації старого стилю"
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "Ініціалізація в %C не дозволена в чистій процедурі"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "DATA-оператор на %C не може зʼявлятися всередині INTERFACE"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "Недійсна підстрічка в data-implied-do на %L в операторі DATA"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr "Алокаційний компонент або відкладений масив форми біля %C в операторі DATA"
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "Літеральна константа BOZ на %L не може зʼявлятися в конструкторі структури"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "Оператор DATA на %C не дозволений в чистій процедурі"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr "part-ref з атрибутом вказівника біля %L не є найправішим part-ref обʼєкта data-stmt"
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "Порожній список ініціалізаторів старого стилю на %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "Масив у списку ініціалізаторів на %L повинен мати явну форму"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "Недійсна специфікація повторення в скалярному ініціалізаторі на %C"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "Специфікація повторення повинна бути цілочисельним на %C"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Очікувана константа даних після специфікації повторення на %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr "Очікуваний кінець скалярного ініціалізатора на %C"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "Недостатньо елементів у списку ініціалізаторів масиву на %C"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "Забагато елементів у списку ініціалізаторів масиву на %C"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Синтаксична помилка у списку ініціалізаторів старого стилю на %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "Масив з припущеним рангом на %C не повинен мати кодимензії"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr "Сума рангу масиву %d та корангу %d в %C перевищує максимально допустимі розміри %d"
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "Неправильна специфікація INTENT в %C"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "відкладений тип параметра в %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr "Очікується скалярний INTEGER вираз в %L"
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Старий стиль довжини символу на %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "Синтаксична помилка в специфікації довжини символу на %C"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Процедура %qs на %C вже визначена на %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Вкладена процедура %qs на %C конфліктує з процедурою, визначеною на %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Імʼя %qs в %C вже визначено як загальний інтерфейс в %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "Процедура %qs на %C має явний інтерфейс з попереднього оголошення"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr "Процедура %qs, визначена в тілі інтерфейсу в %L, конфліктує з внутрішньою процедурою, визначеною в %C"
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "Процедура %qs в %L повинна мати атрибут BIND(C), щоб бути сумісною з C"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "Змінна %qs в %L є фіктивним аргументом для процедури BIND(C) %qs, але не є сумісною з C, оскільки похідний тип %qs не є сумісним з C"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "Змінна %qs на %L є фіктивним аргументом процедури BIND(C) %qs, але не є сумісною з C через поліморфізм"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "Змінна %qs на %L є фіктивним аргументом процедури BIND(C) %qs, але може не бути сумісною з C"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "Фіктивний аргумент %qs на %L не може бути вказівником з атрибутом CONTIGUOUS, оскільки процедура %qs має BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 #| msgid "Default-initialized %s dummy argument %qs at %L is not permitted in BIND(C) procedure %qs"
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "Фіктивний аргумент %s зі значенням за замовчуванням %qs на %L не дозволений у процедурі BIND(C) %qs"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Фіктивний аргумент з символьними змінними, які можна виділяти %qs на %L повинен мати відкладену довжину, оскільки процедура %qs є BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "Аргумент-заглушка символьного типу з вказівником %qs на %L повинен мати відкладену довжину, оскільки процедура %qs має атрибут BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Аргумент-заглушка символьного типу з відкладеною довжиною %qs на %L процедури %qs з атрибутом BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "Аргумент-заглушка символьного типу %qs на %L повинен мати довжину 1, оскільки він має атрибут VALUE"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "Аргумент-заглушка символьного типу з припущеною довжиною %qs на %L процедури %qs з атрибутом BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr "Аргумент-заглушка символьного типу %qs на %L повинен мати сталу довжину одиниці або припущену довжину, якщо він не має припущеної форми або припущеного рангу, оскільки процедура %qs має атрибут BIND(C)"
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "Змінна %qs на %L з атрибутом ALLOCATABLE у процедурі %qs з атрибутом BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "Змінна %qs на %L з атрибутом POINTER у процедурі %qs з BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "Змінна %qs на %L не може мати одночасно атрибути OPTIONAL та VALUE, оскільки процедура %qs має BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "Змінна %qs на %L з атрибутом OPTIONAL у процедурі %qs, яка має BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Масив з припущеною формою %qs на %L як фіктивний аргумент до процедури BIND(C) %qs на %L"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Символ %qs на %C також оголошений як тип на %L"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "Змінна %qs у спільному блоку %qs на %C повинна бути оголошена з сумісним з C типом, оскільки спільний блок %qs має BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "Довжина CHARACTER повинна бути константою на %L"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "Вираз CHARACTER на %L обрізається (%ld/%ld)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "Елементи CHARACTER конструктора масиву на %L повинні мати однакову довжину (%ld/%ld)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "Ініціалізатор не дозволений для PARAMETER %qs на %C"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "PARAMETER на %L не має ініціалізатора"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "Змінна %qs на %C з ініціалізатором вже зустрічається в операторі DATA"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "Не вдається ініціалізувати масив параметрів у %L з елементами змінної довжини"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "Несумісність рангу масиву у %L та його ініціалізатора (%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "Не вдається ініціалізувати масив з неявною формою у %L з скаляром"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "Неправильна форма ініціалізатора на %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "Не вдається визначити форму ініціалізатора на %L"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Неконстантна нижня межа в оголошенні з неявною формою на %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "Сутність %qs на %L несумісна з літеральною константою BOZ"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "Компонент на %C повинен мати атрибут POINTER"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Компонент %qs з CLASS у %C повинен бути алокованим або вказівником"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "Масивний компонент структури у %C повинен мати явну або відкладену форму"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Компонент %qs у %C вже оголошений у %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "Масивний компонент вказівників структури на %C повинен мати відкладену форму"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Алокований компонент структури у %C повинен мати відкладену форму"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "Масивний компонент структури у %C повинен мати явну форму"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "Параметр типу %qs у %C не має відповідного запису у списку імен параметрів типу у %L"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "Ініціалізація NULL() в %C є неоднозначною"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "Ініціалізація NULL() в %C може не мати MOLD"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "Ініціалізація вказівника в %C не дозволена в чистій процедурі"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Помилка при ініціалізації вказівника на %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "Ініціалізація ненульового вказівника в %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr "Змінна RESULT %qs в %L забороняє використання імені FUNCTION %qs в %C в специфікаційному операторі"
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "%qs не дозволено поза STRUCTURE в %C"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%qs на %C є розширенням DEC, активуйте його за допомогою %<-fdec-structure%>"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "Сутність %qs не може мати атрибути в %C"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Недійсний символ %qc в імені змінної на %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Символ Non-PARAMETER %qs на %L не може мати неявну форму"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Масив з неявною формою в %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "Явна форма масиву в %C повинна бути константою типу INTEGER, а не типу %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr "Масив з явною формою з неконстантними межами в %C"
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %C is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr "%qs на %C є перевизначенням оголошення в відповідному інтерфейсі для MODULE PROCEDURE %qs"
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "%qs entity cannot have an initializer at %C"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Сутність %qs не може мати ініціалізатор в %C"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Подвійна специфікація масиву для Cray pointee в %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "Не вдалося встановити специфікацію масиву для pointee."
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Ініціалізація старого стилю в %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "Недійсна ініціалізація старого стилю для компонента похідного типу в %C"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Синтаксична помилка в ініціалізації старого стилю %s в %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "Ініціалізація в %C не є для змінної-вказівника"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "Ініціалізація вказівника в %C потребує %<=>%>, а не %<=%>"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "Очікувався вираз ініціалізації в %C"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "Ініціалізація змінної в %C не дозволена в чистій процедурі"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "Ініціалізація компонента, який може бути виділеним, у %C не дозволяється"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "Ініціалізація компонента структури зі сталою HOLLERITH у %L не дозволяється"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr "Компонент з атрибутом KIND або LEN у %C не зʼявляється у списку параметрів типу у %L"
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr "Компонент у %C, який зʼявляється у списку параметрів типу у %L, не має атрибуту KIND або LEN"
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "Компонент у %C, який є параметром типу, повинен бути скалярним"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Літеральна константа BOZ у %L не може зʼявлятися як ініціалізатор"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr "Несумісна ініціалізація між сутністю похідного типу та сутністю з типом %qs у %C"
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "Старомодна декларація типу %s*%d не підтримується у %C"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Нестандартна декларація типу %s*%d у %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "Відсутня права дужка у %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "Очікується вираз ініціалізації у %C"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "Очікується скалярний вираз ініціалізації у %C"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Тип %d не підтримується для типу %s у %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "Параметр типу C-типу призначений для типу %s, але тип у %L - %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "Відсутня права дужка або кома у %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Тип %d не підтримується для CHARACTER на %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "Синтаксична помилка в оголошенні CHARACTER на %C"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr "RECORD на %C є розширенням, увімкніть його за допомогою %<-fdec-structure%>"
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Очікується назва структури після RECORD на %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr "Список специфікацій параметрів типу на %C не може містити як ASSUMED, так і DEFERRED параметри"
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "Список специфікацій параметрів типу на %C не містить достатньо виразів параметрів"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "Похідний параметр %qs на %C не має значення за замовчуванням"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "Вираз параметра на %C повинен бути типу INTEGER, а не типу %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "Вираз параметра на %C повинен бути типу INTEGER, а не типу %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "Параметр виразу на %C не спрощується до цілого числа"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr "Параметр KIND %qs на %C не може бути або ASSUMED, або DEFERRED"
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "Значення для параметра KIND %qs на %C не зводиться до сталого виразу"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr "Список специфікацій параметрів типу на %C містить забагато параметрів"
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "Параметризований похідний тип на %C є неоднозначним"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "Тип BYTE на %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "Тип BYTE, використаний на %C, недоступний на цільовій машині"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "Припущений тип на %C не дозволяється для компонентів"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "Припущений тип у %C"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "ТИП з вбудованою типовою специфікацією у %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "Неправильно сформована типова специфікація у %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "DOUBLE COMPLEX у %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "Імʼя типу %qs у %C є неоднозначним"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "Оператор CLASS у %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "Імʼя типу %qs у %C конфліктує з попередньо оголошеною сутністю у %L, яка має те саме імʼя"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "Подвійна інструкція IMPLICIT NONE у %C"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "IMPLICIT NONE зі списком специфікацій у %C"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "Відсутній діапазон символів у IMPLICIT у %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "Літери повинні бути в алфавітному порядку в інструкції IMPLICIT у %C"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "IMPLICIT-заява на %C після заяви IMPLICIT NONE (типу)"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "Порожня IMPLICIT-заява на %C"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "Заява IMPORT на %C дозволена лише в тілі INTERFACE"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "F2008: Заява IMPORT на %C не дозволена в тілі інтерфейсу процедури модуля"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "Заява IMPORT на %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 #| msgid "import-declaration must be at global scope"
 msgid "import-name %qs at %C is in the local scope"
 msgstr "Декларація імпорту повинна бути в глобальному контексті"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "Неможливо IMPORT %qs зі змінної області хоста на %C - не існує."
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "%qs вже ІМПОРТовано зі змінної області хоста на %C"
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "Синтаксична помилка в операторі ІМПОРТ на %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "F2008: Заява IMPORT на %C не дозволена в тілі інтерфейсу процедури модуля"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "F2008: Заява IMPORT на %C не дозволена в тілі інтерфейсу процедури модуля"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "Очікується список названих сутностей на %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "Відсутня специфікація кодименсії на %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "Відсутня специфікація розмірності на %C"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Подвійний атрибут %s на %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s на %L є розширенням DEC, активуйте його за допомогою %<-fdec-static%>"
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Атрибут ALLOCATABLE на %C в означенні ТИПу"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут ALLOCATABLE на %C в означенні СТРУКТУРИ"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Атрибут KIND на %C в означенні ТИПу"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут KIND на %C в означенні СТРУКТУРИ"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "Компонент з атрибутом KIND на %C повинен бути ЦІЛИМ"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Атрибут LEN на %C в означенні ТИПу"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Атрибут LEN на %C в означенні СТРУКТУРИ"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "Компонент з атрибутом LEN на %C повинен бути ЦІЛИМ"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "Атрибут на %L не дозволений в означенні ТИПУ"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "Атрибут на %L не дозволений в означенні СТРУКТУРИ"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Атрибут %s на %L у визначенні ТИПУ"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "Атрибут %s на %L не дозволений поза специфікаційною частиною модуля"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "Атрибут на %L не дозволений поза визначенням ТИПУ"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "Атрибут ASYNCHRONOUS на %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "Атрибут CONTIGUOUS на %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "Атрибут PROTECTED на %C дозволений лише в специфікаційній частині модуля"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "Атрибут PROTECTED на %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "Атрибут VALUE на %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "Атрибут VOLATILE на %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr "match_attr_spec(): Неправильний атрибут"
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "Декілька ідентифікаторів надано з одним специфікатором NAME= на %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "Неявно оголошена функція BIND(C) %qs на %L може не бути сумісною з C"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "Змінна %qs у загальному блоку %qs на %L може не бути сумісним з C видом, хоча загальний блок %qs має BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "Оголошення типу %qs на %L не є сумісним з C, але має атрибут BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "Змінна %qs на %L може не бути сумісним з C видом, але має атрибут BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "Змінну %qs у загальному блоку %qs на %L не можна оголосити з атрибутом BIND(C), оскільки вона не є глобальною"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "Змінна %qs на %L не може мати одночасно атрибути POINTER та BIND(C)"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "Змінна %qs на %L не може мати одночасно атрибути ALLOCATABLE та BIND(C)"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "Тип повернення функції BIND(C) %qs на %L не може бути масивом"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Тип повернення функції BIND(C) %qs з типом символу на %L повинен мати довжину 1"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %L is marked PRIVATE but has been given the binding label %qs"
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "Символ %qs на %L позначений як PRIVATE, але має мітку звʼязування %qs"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "Необхідно вказати або імʼя сутності, або імʼя спільного блоку для оператора вказівки атрибуту на %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "Відсутнє імʼя сутності або спільного блоку для оператора вказівки атрибуту на %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Відсутній символ"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "Оператор BIND(C) на %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "Сутність CLASS на %C не може мати атрибут PARAMETER"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "Похідний тип на %C не був попередньо визначений і, отже, не може зʼявлятися в означенні похідного типу"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Синтаксична помилка в анонімному оголошенні структури на %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "Синтаксична помилка в оголошенні даних на %C"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "Префікс MODULE на %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "Префікс MODULE на %C знайдено поза модулем, підмодулем або інтерфейсом"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "Нечиста процедура на %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE і IMPURE не можуть одночасно зʼявлятися на %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Відсутній префікс ELEMENTAL в інтерфейсі MODULE PROCEDURE на %L"
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Відсутній префікс PURE в інтерфейсі MODULE PROCEDURE на %L"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Відсутній префікс RECURSIVE в інтерфейсі MODULE PROCEDURE на %L"
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "Необхідний список параметрів типу в %C"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "Аргумент альтернативного повернення в %C"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "Необхідне імʼя параметра в %C"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "Імʼя %qs в %C є імʼям процедури"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Очікується список параметрів у оголошенні типу на %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "Неочікувані непотрібні елементи у списку формальних аргументів на %C"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Повторне імʼя %qs у списку параметрів на %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Повторний символ %qs у списку формальних аргументів на %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "Формальний аргумент MODULE PROCEDURE %qs конфліктує з альтернативним поверненням у %C"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr "Формальний аргумент MODULE PROCEDURE є альтернативним поверненням і конфліктує з %qs у окремому оголошенні на рядку %C"
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr "Неспівпадіння імен формальних аргументів MODULE PROCEDURE (%s/%s) на %C"
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Неспівпадіння в кількості формальних аргументів MODULE PROCEDURE на %C"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "Змінна RESULT на %C повинна відрізнятися від назви функції"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "Неочікувані непотрібні символи після оголошення функції на %C"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Атрибут BIND(C) на %L не може бути вказаний для внутрішньої процедури"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "Атрибут BIND(C) на %C вимагає інтерфейсу з BIND(C)"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "Процедура BIND(C) з імʼям не може мати атрибут POINTER на %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "Фіктивна процедура на %C не може мати атрибут BIND(C) з імʼям"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Процедура %qs на %L вже має основний тип %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "Синтаксична помилка в операторі PROCEDURE на %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "Очікувався %<::%> після атрибутів привʼязки на %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "Необхідний NOPASS або явний інтерфейс на %C"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Компонент вказівника на процедуру на %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "Синтаксична помилка в компоненті вказівника на процедуру на %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "PROCEDURE на %C повинен бути в загальному інтерфейсі"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "дві подвійні двокрапки в операторі MODULE PROCEDURE на %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "Оператор PROCEDURE на %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "Очікувався формальний список аргументів у визначенні функції на %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "Атрибут BIND(C) на %L може використовуватися лише для змінних або спільних блоків"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr "Неспівпадіння імен BIND(C) (%qs/%qs) у %C"
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "Заява ENTRY на %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах PROGRAM"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах модуля"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах підмодуля"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку даних"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах інтерфейсу"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку STRUCTURE"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку DERIVED TYPE"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку IF-THEN"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку DO"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку SELECT"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку FORALL"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "Заява ENTRY на %C не може зʼявлятися в межах блоку WHERE"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "Заявка ENTRY на %C не може зʼявлятися всередині вкладеної підпрограми"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Неочікувана інструкція ENTRY в %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "Інструкція ENTRY в %C не може зʼявлятися вкладеній процедурі"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "Відсутні обовʼязкові дужки перед BIND(C) в %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "Інструкція ENTRY в %L з BIND(C) заборонена в елементарній процедурі"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "Альтернативний повернений фіктивний аргумент не може зʼявлятися в SUBROUTINE з атрибутом BIND(C) на %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "Недійсний ідентифікатор C в специфікаторі NAME= на %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "Синтаксична помилка в специфікаторі NAME= для мітки звʼязування на %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "Специфікатор NAME= на %C повинен бути константним виразом"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr "Параметр NAME= на %C повинен бути скаляром типу символу за замовчуванням"
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "Відсутня закриваюча дужка для мітки звʼязування на %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "У BIND(C) на %C не дозволяється вказувати імʼя звʼязування"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "Для фіктивної процедури %s у BIND(C) на %C не дозволяється вказувати імʼя звʼязування"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "У BIND(C) для АБСТРАКТНОГО ІНТЕРФЕЙСУ на %C не дозволяється вказувати NAME"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Неочікувана інструкція END в %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "Інструкція END замість інструкції %s в %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "Очікується інструкція %s в %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "Очікується інструкція %s в %L"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "Очікується імʼя блоку %qs в інструкції %s в %L"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Очікувано заключне імʼя в %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "Очікується мітка %qs для інструкції %s в %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "Відсутня специфікація масиву в %L в інструкції DIMENSION"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "Розміри вказані для %s в %L після його ініціалізації"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "Відсутня специфікація масиву в %L в інструкції CODIMENSION"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "Специфікація масиву повинна бути відкладена на %L"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "Неочікуваний символ у списку змінних на %C"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "Очікувалося %<(%> на %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Очікувано імʼя змінної на %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Вказівник Cray на %C повинен бути цілочисельним"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Вказівник Cray на %C має точність %d байтів; адреси памʼяті вимагають %d байтів"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Очікувалося «,» на %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "Не вдалося встановити специфікацію масиву Cray pointee."
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "Подвійна специфікація масиву для Cray pointee в %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Очікувалося «)» на %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "Очікувалося %<,%> або кінець виразу на %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT не дозволений всередині BLOCK на %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "ОПЦІОНАЛЬНИЙ не дозволений всередині БЛОКУ на %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Оголошення вказівника Cray на %C вимагає прапорець %<-fcray-pointer%>"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "Оператор CONTIGUOUS на %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "Специфікація доступу оператора %s на %C вже була вказана"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "Специфікація доступу до оператора .%s. в %C вже була вказана"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "Оператор PROTECTED в %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "Синтаксична помилка в операторі PROTECTED в %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "Оператор PRIVATE в %C дозволений тільки в специфікаційній частині модуля"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "Оператор PUBLIC в %C дозволений тільки в специфікаційній частині модуля"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "Очікувано імʼя змінної в операторі PARAMETER в %C"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "Очікувано знак = в операторі PARAMETER в %C"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "Очікувано вираз в операторі PARAMETER в %C"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "Ініціалізація вже ініціалізованої змінної в %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr "PARAMETER без '()' в %C"
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "Неочікувані символи в операторі PARAMETER в %C"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr "%s в %C є розширенням DEC, увімкніть його за допомогою %<-fdec-static%>"
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Очікується список сутностей в операторі AUTOMATIC в %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Синтаксична помилка в операторі AUTOMATIC в %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Очікується список сутностей в операторі STATIC в %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Синтаксична помилка в операторі STATIC в %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Оператор SAVE без параметрів в %C слідує за попереднім оператором SAVE"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "SAVE-заявка на %C слідує за загальною SAVE-заявкою"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 #| msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "Вибачте, !$ACC DECLARE на %L не дозволено в конструкції BLOCK"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "Синтаксична помилка в SAVE-заявці на %C"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "VALUE не дозволяється всередині BLOCK на %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "VALUE-заявка на %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "Синтаксична помилка в VALUE-заявці на %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "VOLATILE-заявка на %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "Вказується VOLATILE для змінної coarray %qs на %C, яка повʼязана з use-/host"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "Синтаксична помилка в VOLATILE-заявці на %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Оператор ASYNCHRONOUS на %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "Синтаксична помилка в операторі ASYNCHRONOUS на %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "Оголошення MODULE PROCEDURE на %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "MODULE PROCEDURE на %C повинен бути в загальному інтерфейсі модуля"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "Вбудована процедура на %L не може бути MODULE PROCEDURE"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "Неоднозначний символ в означенні TYPE на %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "Символ %qs на %C не був попередньо визначений"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "%qs в виразі EXTENDS на %C не є похідним типом"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "%qs не може бути розширеним на %C, оскільки він має BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%qs не може бути розширеним на %C, оскільки він є типом SEQUENCE"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "Похідний тип на %C може бути тільки PRIVATE в специфікаційній частині модуля"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "Похідний тип на %C може бути тільки PUBLIC в специфікаційній частині модуля"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "АБСТРАКТНИЙ тип на %C"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "Не вдалося створити тип структури '%s' на %C"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Визначення типу %qs на %C вже було визначено на %L"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "Сміття після оператора MAP на %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Сміття після оператора UNION на %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%s у %C є розширенням DEC, увімкніть його за допомогою %<-fdec-structure%>"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "Очікується імʼя структури в оголошенні невкладеної структури у %C"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Залишки після оператора STRUCTURE у %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Назва структури %qs у %C не може бути такою ж, як вбудований тип"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Очікується :: в означенні TYPE у %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "Змінене означення похідного типу у %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Назва типу %qs у %C не може бути такою ж, як вбудований тип"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "Назва похідного типу %qs у %C вже має базовий тип %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Назва похідного типу %qs у %C вже має базовий тип"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "Фіктивний аргумент %qs у %L не може бути похідним типом у %C"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "Означення похідного типу %qs у %C вже було визначено"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "Сміття після оголошення ПАРАМЕТРИЗОВАНОГО ТИПУ на %C"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Cray Pointee на %C не може бути припущеним масивом"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "ENUM та ENUMERATOR на %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "Перелічувач перевищує цілочисельний тип C на %C"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L не ініціалізовано цілочисельним виразом"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "Очікується оператор визначення ENUM перед %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "Синтаксична помилка в означенні ENUMERATOR на %C"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "Повторний специфікатор доступу на %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "Атрибути звʼязування вже вказують на передачу, недопустимий NOPASS на %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "Атрибути звʼязування вже вказують на передачу, недопустимий PASS на %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "Повторний атрибут POINTER на %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "Повторний NON_OVERRIDABLE на %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "Повторний DEFERRED на %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Очікується специфікатор доступу на %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Очікується атрибут звʼязування на %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE і DEFERRED не можуть одночасно зʼявлятися на %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "Атрибут POINTER обовʼязковий для компонента вказівника на процедуру на %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Очікується імʼя інтерфейсу після %<(%> у %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "Очікується %<)%> у %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "Інтерфейс повинен бути вказаний для відкладеного звʼязування у %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "PROCEDURE(interface) у %C повинно бути оголошено як DEFERRED"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Очікуване імʼя звʼязування в %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "Список PROCEDURE в %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%<=> target%> недійсний для відкладеного звʼязування в %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "%<::%> потрібно в звʼязуванні PROCEDURE з явним ціллю в %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "Очікувана ціль звʼязування після %<=>%> в %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "Тип %qs, що містить відкладене звʼязування в %C, не є АБСТРАКТНИМ"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Вже існує процедура з імʼям звʼязування %qs для похідного типу %qs в %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "Очікувано %<::%> в %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "Очікувано загальне імʼя або дескриптор оператора на %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "Неправильна GENERIC-інструкція на %C"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "Очікувано %<=>%> на %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Range specification at %L can never be matched"
 msgid "The access specification at %L not in a module"
 msgstr "Специфікація діапазону на %L ніколи не може збігатися"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, fuzzy, gcc-internal-format
 #| msgid "The base name at %L does not match the name of the current procedure"
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr "Базове імʼя на %L не відповідає імені поточної процедури"
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Вже існує негенерична процедура з імʼям звʼязування %qs для похідного типу %qs на %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "Специфікація доступу оператора %s на %C вже була вказана"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "Специфікація доступу оператора %s на %C вже була вказана"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 #| msgid "Binding at %C must have the same access as already defined binding %qs"
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "Звʼязування на %C повинно мати такий самий доступ, як вже визначене звʼязування %qs"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected module procedure name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Очікується імʼя процедури модуля на %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 #| msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%qs вже визначено як конкретне звʼязування для загального %qs на %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Junk after UNION statement at %C"
 msgid "Junk after GENERIC statement at %C"
 msgstr "Сміття після оператора UNION на %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "GENERIC в %C повинен бути в середині CONTAINS похідного типу"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "Вже існує негенерична процедура з імʼям звʼязування %qs для похідного типу %qs на %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "Звʼязування на %C повинно мати такий самий доступ, як вже визначене звʼязування %qs"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "Очікувано конкретне імʼя звʼязування на %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%qs вже визначено як конкретне звʼязування для загального %qs на %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "Сміття після GENERIC звʼязування на %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "Оголошення FINAL на %C повинно бути в середині розділу CONTAINS похідного типу"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "Оголошення похідного типу з FINAL на %C повинно бути в специфікаційній частині МОДУЛЯ"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "Порожній FINAL на %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "Очікується імʼя процедури модуля на %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "Очікується %<,%> на %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Невідоме імʼя процедури %qs на %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "%qs на %C вже визначено як FINAL-процедуру"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Невідомий атрибут в інструкції !GCC$ ATTRIBUTES на %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "Синтаксична помилка в інструкції !GCC$ ATTRIBUTES на %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr "Директива %<GCC unroll%> вимагає невідʼємну цілочисельну сталу, меншу або рівну %u на %C"
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Синтаксична помилка в директиві !GCC$ UNROLL на %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Синтаксична помилка в директиві !GCC$ IVDEP на %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Синтаксична помилка в директиві !GCC$ VECTOR на %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
 msgstr "Синтаксична помилка в директиві !GCC$ NOVECTOR на %C"
@@ -78294,409 +78473,409 @@ msgstr "RE частина_посилання на %C"
 msgid "IM part_ref at %C"
 msgstr "IM частина_посилання на %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "елементарні аргументи функції на %C не відповідають"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "У виразі на %L потрібні числові або символьні операнди"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "Оператор конкатенації в виразі на %L повинен мати два символьні операнди"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "Оператор конкатенації на %L повинен конкатенувати рядки одного типу"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "Оператор .NOT. в виразі на %L повинен мати логічний операнд"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "У виразі на %L потрібні логічні операнди"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "У виразі на %L можна використовувати лише вбудовані оператори"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "У виразі на %L потрібні числові операнди"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "Недійсний вираз ініціалізації для компонента ALLOCATABLE %qs у конструкторі структури на %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "Припущена або відкладена змінна довжини символу %qs в константному виразі на %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "Трансформаційна вбудована функція %qs на %L не дозволяється в ініціалізаційному виразі"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "Оцінка нестандартного виразу ініціалізації на %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "Функція %qs в виразі ініціалізації на %L повинна бути вбудованою функцією"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "Вбудована функція %qs на %L не дозволяється в виразі ініціалізації"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "ПАРАМЕТР %qs використовується на %L до того, як його визначення завершено"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "Масив з припущеною розмірністю %qs на %L не дозволяється в виразі ініціалізації"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Масив з припущеною формою %qs на %L не дозволяється в виразі ініціалізації"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "Масив з припущеною формою %qs на %L не дозволяється в виразі ініціалізації"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "Відкладений масив %qs в %L не допускається в виразі ініціалізації"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "Масив %qs у %L є змінною, яка не зводиться до константного виразу"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "Масив з припущеним рангом %qs у %L не допускається в виразі ініціалізації"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "Параметр %qs у %L не був оголошений або є змінною, яка не зводиться до константного виразу"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "check_init_expr(): Невідомий тип виразу"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "Специфікаційна функція %qs у %L не може бути функцією-оператором"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "Специфікаційна функція %qs на %L не може бути внутрішньою функцією"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "Специфікаційна функція %qs на %L повинна бути PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Специфікаційна функція %qs на %L не може бути RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "Фіктивний аргумент %qs не допускається в виразі на %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "Фіктивний аргумент %qs на %L не може бути OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "Фіктивний аргумент %qs на %L не може бути INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Змінна %qs не може зʼявлятися в виразі на %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "check_restricted(): Невідомий тип виразу"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "Вираз на %L повинен бути типу INTEGER, знайдено %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "Функція %qs на %L повинна бути PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Вираз на %L повинен бути скалярним"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr "Переповнення optype_msgid: %d"
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Несумісні ранги в %s (%d і %d) на %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "Різна форма для %s на %L по розмірності %d (%d і %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "використання параметра типу шаблону %qT після %qs"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "Присвоєння LEN або KIND part_ref на %L не дозволяється"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%qs на %L не є VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr "Недопустиме присвоєння зовнішній процедурі на %L"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "Несумісні ранги %d і %d в присвоєнні на %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "Тип змінної невідомий в присвоєнні на %L"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "NULL зʼявляється на правій стороні при присвоєнні на %L"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "Функція з POINTER-значенням зʼявляється на правій стороні при присвоєнні на %L"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr "Літеральна константа BOZ поблизу %L не може бути присвоєна змінній %qs"
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "Присвоєння компоненту KIND або LEN параметризованого типу на %L не дозволено"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "Несумісні типи в операторі DATA на %L; спроба перетворення %s на %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "Ціль присвоєння вказівника не є POINTER на %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "%qs в присвоєнні вказівника на %L не може бути l-значенням, оскільки це процедура"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "Очікується вказівка меж для %qs у %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Вказівка меж для %qs у присвоєнні вказівника на %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "Крок не повинен бути вказаний на %L"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Переіндексація рангу вимагає списку специфікацій %<lower-bound : upper-bound%> на %L"
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr "Очікується список специфікацій %<lower-bound :%> або список специфікацій %<lower-bound : upper-bound%> на %L"
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "Обʼєкт-вказівник на %L не повинен мати спільного індексу"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "Недійсне призначення вказівника процедури на %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "Результат функції %qs є недійсним як ціль процедури у присвоєнні вказівника на процедуру у %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "Абстрактний інтерфейс %qs недійсний при присвоєнні вказівника на процедуру в %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "Функція-оператор %qs недійсна при присвоєнні вказівника на процедуру в %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Внутрішня процедура %qs недійсна при присвоєнні вказівника на процедуру в %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "Вбудована функція %qs в %L недійсна при присвоєнні вказівника на процедуру"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Невбудована елементарна процедура %qs недійсна при присвоєнні вказівника на процедуру в %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "Неспівпадіння при присвоєнні вказівника на процедуру в %L: неспівпадіння у конвенції виклику"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "Несумісність інтерфейсу при присвоєнні вказівника на процедуру в %L: %qs не є підпрограмою"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Для компонента %qs на %L потрібний явний інтерфейс: %s"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "Для %qs на %L потрібний явний інтерфейс: %s"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "Несумісність інтерфейсу при присвоєнні вказівника на процедуру на %L: %s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr "Ціль вказівника на процедуру %qs на %L повинна бути або вбудованою, або повʼязаною з хостом або use, або посилатися на неї, або мати атрибут EXTERNAL"
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "Ціль присвоєння вказівника не може бути константою на %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr "Обʼєкт-вказівник даних на %L повинен бути необмежено поліморфним або мати атрибут BIND або SEQUENCE, щоб бути сумісним з необмежено поліморфною ціллю"
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "Різні типи в призначенні вказівника на %L; спроба призначити %s до %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "Різні параметри типу виду в призначенні вказівника на %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "Різні ранги в призначенні вказівника на %L"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "Ціль ремапінгу рангу менша за розмір вказівника (%ld < %ld) на %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "Ціль рангового перенаправлення повинна мати ранг 1 або бути просто послідовною на %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Ціль перенаправлення рангу не має рангу 1 на %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The assumed-rank array at %C shall not have a codimension"
 msgid "The assumed rank data-target at %L must be contiguous"
@@ -78705,197 +78884,197 @@ msgstr "Масив з припущеним рангом на %C не повин
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "Ціль даних на %L не повинна мати співіндексу"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "Вираз цілі в призначенні вказівника на %L повинен повертати результат вказівника"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr "Виявлено масив нульового розміру на %L, де очікується сутність з атрибутом TARGET"
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "Ціль призначення вказівника в виразі ініціалізації не має атрибуту TARGET на %L"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "Кожний індекс підпису специфікації цілі на %L повинен бути константним виразом"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr "Початкова і кінцева точки підстрічки специфікації цілі на %L повинні бути константними виразами"
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "Ціль призначення вказівника не є TARGET або POINTER на %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "Недійсна ціль в призначенні вказівника в чистій процедурі на %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "Призначення вказівника з векторним підписом на rhs на %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "Ціль призначення вказівника має атрибут PROTECTED на %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr "Призначення послідовного вказівника з непослідовної цілі на %L"
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "Вказівник на %L в призначенні вказівника може пережити ціль вказівника"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "Ціль ініціалізації вказівника на %L не повинна бути ALLOCATABLE"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "Ціль ініціалізації вказівника на %L повинна мати атрибут TARGET"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "Ціль ініціалізації вказівника на %L повинна мати атрибут SAVE"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "Ціль ініціалізації вказівника на процедуру на %L не може бути вказівником на процедуру"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Внутрішня процедура %qs недійсна в ініціалізації вказівника на процедуру на %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Функція-заглушка %qs недійсна в ініціалізації вказівника на процедуру на %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr "generate_isocbinding_initializer(): неправильний тип iso_c_binding, очікувався %<c_ptr%> або %<c_funptr%>"
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008: Функції-вказівники в контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Не змінний вираз у контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "Іменована константа %qs у контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%qs у контексті визначення змінної (%s) на %L не є змінною"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Не POINTER у контексті асоціації вказівника (%s) на %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "Тип недоступний у контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE у контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_EVENT у контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "Запит параметра %qs для %qs у контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "Фіктивний аргумент %qs з INTENT(IN) в контексті асоціації вказівника (%s) на %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "Фіктивний аргумент %qs з INTENT(IN) в контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Змінна %qs є PROTECTED і не може зʼявлятися в контексті асоціації вказівника (%s) на %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "Змінна %qs є PROTECTED і не може зʼявлятися в контексті визначення змінної (%s) на %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Змінна %qs не може зʼявлятися в контексті визначення змінної (%s) на %L у чистій процедурі"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "%qs на %L, повʼязаний з вектор-індексованою ціллю, не може бути використаний в контексті визначення змінної (%s)"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "%qs на %L, повʼязаний з виразом, не може бути використаний в контексті визначення змінної (%s)"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "%qs у %L пов'язаний з цільовою функцією вказівника, яка використовується у контексті визначення змінної (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Імʼя асоціації %qs не може зʼявлятися в контексті визначення змінної (%s) на %L, оскільки його ціль на %L також не може"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "Елементи з однаковим значенням на %L і %L в підписі вектора в контексті визначення змінної (%s)"
@@ -78916,7 +79095,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr "Недопустимий ідентифікатор в copy_walk_reduction_arg"
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -78977,42 +79156,42 @@ msgstr "Змінна %qs на %L встановлена як невизначе
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "Змінна %qs на %L не може бути визначена всередині циклу, що починається на %L, як аргумент INTENT(INOUT) для підпрограми %qs"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "Посилання на масив на %L поза межами (%ld < %ld) в циклі, що починається з %L"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "Посилання на масив на %L поза межами (%ld > %ld) в циклі, що починається з %L"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "Змінна %qs на %L встановлена на невизначене значення всередині циклу, що починається з %L, як аргумент INTENT(OUT) для функції %qs"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "Змінну %qs на %L неможливо визначити всередині циклу, що починається з %L, як аргумент INTENT(INOUT) для функції %qs"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr "Код для перерозподілу виділеного масиву на %L буде доданий"
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr "Скаляризація за допомогою DIMEN_RANGE не реалізована"
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr "Обмін петель на %L"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "%s між %L і %L"
@@ -79137,12 +79316,12 @@ msgstr "Перший аргумент визначеного присвоєнн
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "Другий аргумент визначеного присвоєння на %L повинен бути INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "Перший аргумент інтерфейсу оператора на %L повинен бути INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "Другий аргумент інтерфейсу оператора на %L повинен бути INTENT(IN)"
@@ -79574,307 +79753,313 @@ msgstr "Фактичний аргумент для %qs повинен бути A
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr "Фактичний аргумент для %qs на рядку %L є результатом функції, а формальний аргумент має властивість ALLOCATABLE"
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "Фактичний аргумент з розділом масиву з векторними підскриптами на %L несумісний з атрибутом INTENT(OUT), INTENT(INOUT), VOLATILE або ASYNCHRONOUS для фіктивного аргументу %qs"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Фактичний аргумент з припущеною формою на %L несумісний з фіктивним аргументом без припущеної форми %qs через атрибут VOLATILE"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Фактичний аргумент з розділом масиву на %L несумісний з фіктивним аргументом без припущеної форми %qs через атрибут VOLATILE"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "Аргумент фактичної форми, який є масивом вказівників на %L, вимагає аргумента-заглушки з припущеною формою або масиву вказівників %qs через атрибут VOLATILE"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of assumed type"
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "Припущений тип фактичного аргументу на %L вимагає, щоб фіктивний аргумент %qs був припущеним типом"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "Відсутня альтернативна специфікація повернення в підпрограмному виклику на %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Відсутній фактичний аргумент для аргументу %qs на %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "compare_actual_expr(): Поганий код компонента"
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr "check_some_aliasing(): Неспівпадіння списку"
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr "check_some_aliasing(): пошкоджені дані"
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "Той самий фактичний аргумент повʼязаний з аргументом INTENT(%s) %qs та аргументом INTENT(%s) %qs на %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr "check_intents(): Неспівпадіння списку"
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "Аргумент процедури на %L є локальним для PURE процедури та має атрибут POINTER"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Коіндексований фактичний аргумент на %L в PURE процедурі передається аргументу INTENT(%s)"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Коіндексований фактичний аргумент на %L в PURE процедурі передається показчиковому фіктивному аргументу"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Коіндексований поліморфний фактичний аргумент на %L передається поліморфному фіктивному аргументу %qs"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Процедура %qs, яка викликається на %L, не є явно оголошеною; ви мали на увазі %qs?"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Процедура %qs, яка викликається на %L, не є явно оголошеною"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "Процедура %qs, яка викликається з неявним інтерфейсом на %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Обʼєкт-вказівник %qs на %L повинен мати явний інтерфейс функції або бути оголошеним як масив"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "Обʼєкт, який можна виділити %qs на %L, повинен мати явний інтерфейс функції або бути оголошеним як масив"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Функція, яку можна виділити %qs на %L, повинна мати явний інтерфейс функції"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Для поліморфного аргументу на %L потрібний явний інтерфейс"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "Ключовий аргумент вимагає явного інтерфейсу для процедури %qs на %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "Аргумент з припущеним типом %s на %L вимагає явного інтерфейсу"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Фактичний аргумент LOCK_TYPE або з компонентою LOCK_TYPE на %L вимагає явного інтерфейсу для процедури %qs"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "Фактичний аргумент EVENT_TYPE або з компонентою EVENT_TYPE на %L вимагає явного інтерфейсу для процедури %qs"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "Аргумент MOLD для NULL потрібний на %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "Передача вбудованого NULL як фактичного аргументу на %L вимагає явного інтерфейсу"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "Аргумент з припущеним рангом потребує явного інтерфейсу на %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "Компонент вказівника на процедуру %qs викликано з неявним інтерфейсом на %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "Ключовий аргумент потребує явного інтерфейсу для компонента вказівника на процедуру %qs на %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "MOLD= потрібно в аргументі NULL() на %L: Неоднозначність між конкретними функціями %s і %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "Не вдалося знайти символ %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "Сутність %qs на %L вже присутня в інтерфейсі"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "gfc_add_interface(): Поганий тип інтерфейсу"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "Не можу перезаписати ЗАГАЛЬНИЙ %qs в %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%qs в %L перезаписує звʼязування процедури, оголошене як NON_OVERRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "%qs в %L не може бути відкладеним, оскільки воно перезаписує невідкладене звʼязування"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%qs в %L перезаписує чисту процедуру і також повинно бути чистим"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%qs в %L перезаписує елементарну процедуру і також повинно бути елементарним"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%qs в %L перезаписує не елементарну процедуру і також не може бути елементарним"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%qs в %L перевизначає ПІДПРОГРАМУ і також повинно бути ПІДПРОГРАМОЮ"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%qs в %L перевизначає ФУНКЦІЮ і також повинно бути ФУНКЦІЄЮ"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Неспівпадання результату для перевизначеної процедури %qs в %L: %s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%qs в %L перевизначає ГРОМАДСЬКУ процедуру і не повинно бути ПРИВАТНОЮ"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "Фіктивний аргумент %qs у %qs в %L повинен мати назву %qs, щоб відповідати відповідному аргументу перевизначеної процедури"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "Неспівпадання аргументів для перевизначеної процедури %qs в %L: %s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "%qs в %L повинно мати таку саму кількість формальних аргументів, як перевизначена процедура"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%qs в %L перевизначає звʼязування NOPASS і також повинно бути NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%qs в %L перевизначає звʼязування з PASS і також повинно бути PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "Фіктивний аргумент переданого обʼєкту %qs при %L повинен бути на тій самій позиції, що й фіктивний аргумент переданого обʼєкту перевизначеної процедури"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "Фіктивний аргумент DTIO при %L повинен бути типу %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "Фіктивний аргумент DTIO при %L повинен мати KIND = %d"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "Фіктивний аргумент DTIO при %L повинен бути скалярним"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "Фіктивний аргумент DTIO при %L повинен бути ASSUMED SHAPE ARRAY"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Аргумент символьного типу DTIO на %L повинен мати припущену довжину"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "Фіктивний аргумент DTIO на %L повинен мати INTENT %s"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "Альтернативний повернення на %L не допускається в процедурі DTIO"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "Процедура DTIO %qs на %L повинна бути підпрограмою"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Занадто мало фіктивних аргументів в процедурі DTIO %qs на %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "Занадто багато фіктивних аргументів в процедурі DTIO %qs на %L"
@@ -80065,7 +80250,7 @@ msgstr "Конвертація з %s в %s у %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot convert %s to %s at %L"
 msgstr "Неможливо конвертувати %s в %s у %L"
@@ -80612,7 +80797,7 @@ msgstr "NAMELIST %qs в операторі READ на %L містить симв
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "Обʼєкт NAMELIST %qs в списку імен %qs на %L є поліморфним і вимагає визначеної процедури введення/виведення"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "Обʼєкт NAMELIST %qs в списку імен %qs на %L має компоненти ALLOCATABLE або POINTER"
@@ -80783,12 +80968,12 @@ msgstr "переповнення ідентифікатора: %d"
 msgid "check_charlen_present(): length not set"
 msgstr "помилка: check_charlen_present(): довжина не встановлена"
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr "ЗРОБИТИ: необмежений поліморфний MOLD у вбудованій функції TRANSFER на рядку %L"
@@ -81303,7 +81488,7 @@ msgstr "Код STOP на %L повинен бути символьним тип
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "Код STOP на %L повинен бути цілочисельним типом KIND=%d за замовчуванням"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "Специфікатор QUIET на %L повинен бути скалярним типом LOGICAL"
@@ -81817,92 +82002,92 @@ msgstr "Очікуване імʼя блоку %qs конструкції SELECT
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "SELECT TYPE в %C не може зʼявлятися в цьому контексті"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "Помилка синтаксису в операторі SELECT TYPE в %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "Селектор в операторі SELECT TYPE в %C не є іменованою змінною; використовуйте associate-name=>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "Оператор SELECT RANK в %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr "Селектор в операторі SELECT RANK в %C повинен бути змінною з припущеним рангом"
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Помилка синтаксису в операторі SELECT RANK в %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Неочікуваний оператор CASE в %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "Синтаксична помилка в специфікації CASE в %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "Неочікувана інструкція TYPE IS на %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr "Тип-специфікація не повинна вказувати послідовний похідний тип або тип з атрибутом BIND в SELECT TYPE на %C [F2003:C815]"
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr "Усі параметри типу LEN в інструкції TYPE IS на %C повинні бути ПРИПУЩЕНІ"
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "Синтаксична помилка в специфікації TYPE IS на %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "Синтаксична помилка в специфікації CLASS IS на %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected RANK statement at %C"
 msgstr "Неочікувана інструкція RANK на %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "Вираз SELECT RANK CASE на %C повинен бути скалярною цілою константою"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr "Значення виразу SELECT RANK CASE на %C не може бути менше нуля або більше %d"
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "Синтаксична помилка в специфікації RANK на %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "Інструкція ELSEWHERE на %C не вкладена в блок WHERE"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "Мітка %qs на %C не відповідає мітці WHERE %qs"
@@ -82913,7 +83098,7 @@ msgstr "Замикання DEPEND на %L конструкції OMP DEPOBJ не
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr "Замиканя DEPEND на %L конструкції OMP DEPOBJ повинен мати лише один локатор"
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "Замикання MESSAGE на %L вимагає скалярний вираз типу CHARACTER зі стандартним типом"
@@ -82948,12 +83133,12 @@ msgstr "Список вказаний разом з замиканням пор
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "Неочікувані непотрібні символи після оператора $OMP FLUSH на %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr "Перевизначення вбудованого %s !$OMP DECLARE REDUCTION на %L"
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr "Перевизначення вбудованого !$OMP DECLARE REDUCTION на %L"
@@ -83454,7 +83639,7 @@ msgstr "Неочікувані непотрібні символи після NO
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "Замикання %s на %L вимагає скалярний INTEGER вираз"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "INTEGER вираз замикання %s на %L повинен бути позитивним"
@@ -83474,7 +83659,7 @@ msgstr "Обʼєкт вказівника Cray %qs похідного типу 
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Обʼєкт, на який вказує Cray %qs, є похідного типу у замиканні %s на %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "Обʼєкт POINTER %qs поліморфного типу у замиканні %s на %L"
@@ -83504,17 +83689,17 @@ msgstr "Масив з припущеним рангом %qs у замиканн
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "Обʼєкт POINTER %qs в замиканні %s на рядку %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Обʼєкт-вказівник Cray %qs в замиканні %s на рядку %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Обʼєкт-ціль Cray %qs в замиканні %s на рядку %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "Обʼєкт ALLOCATABLE %qs в замиканні %s на рядку %L"
@@ -83636,8 +83821,8 @@ msgstr "Параметр замикання ORDERED менший за COLLAPSE 
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "Замикання ORDER не можна використовувати разом з ORDERED на рядку %L"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "Замикання IF на рядку %L вимагає скалярний логічний вираз"
@@ -83720,7 +83905,7 @@ msgstr "Обʼєкт %qs не є змінною у %L; параметри не 
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "Обʼєкт %qs не є змінною на %L"
@@ -83743,7 +83928,7 @@ msgstr "Замикання SCHEDULE вказано разом з замикан
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "Символ %qs присутній на кількох замиканнях у %L"
@@ -83785,7 +83970,7 @@ msgstr "Символ %qs присутній як у замиканні data, т
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qs з'являється більше одного разу в %<allocate%> в %L"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr "%qs вказано в замиканні %<allocate%> на %L, але не в явному замиканні приватизації"
@@ -84098,615 +84283,625 @@ msgstr "Дозволений лише DEFAULT як модифікатор зве
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr "!$OMP DECLARE REDUCTION %s не знайдено для типу %s на %L"
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr "Модифікатор замикання LINEAR використовується на конструкції DO або SIMD на %L"
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr "Модифікатор LINEAR, відмінний від VAL, використовується на конструкції DO або SIMD на %L"
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "Змінна LINEAR %qs повинна бути INTEGER на %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "Фіктивний аргумент LINEAR %qs з атрибутом VALUE з модифікатором %s на %L"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%qs в замиканні LINEAR на %L потребує скалярний цілочисельний вираз кроку"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%qs в замиканні LINEAR на %L потребує сталий цілочисельний вираз кроку або фіктивний аргумент, вказаний в замиканні UNIFORM"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "Змінна %qs в замиканні %s на %L не є ані ВКАЗІВНИКОМ, ані масивом"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr "Нижня межа NUM_TEAMS на %L більша за верхню межу на %L"
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "Значення HINT-замикання на %L повинно бути дійсним виразом підказки"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "chunk_size замикання DIST_SCHEDULE на %L вимагає скалярний INTEGER вираз"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, fuzzy, gcc-internal-format
 #| msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "Замикання %<DETACH%> на %L не слід використовувати разом з замиканням %<MERGEABLE%>"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, fuzzy, gcc-internal-format
 #| msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "Замикання %<DETACH%> на %L не слід використовувати разом з замиканням %<MERGEABLE%>"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, fuzzy, gcc-internal-format
 #| msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "Замикання %<DETACH%> на %L не слід використовувати разом з замиканням %<MERGEABLE%>"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Несумісне використання TILE та COLLAPSE на рядку %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "TARGET DATA повинен містити принаймні один замикання MAP, USE_DEVICE_PTR або USE_DEVICE_ADDR на рядку %L"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%s повинен містити принаймні один замикання MAP на рядку %L"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "SIZES requires constant expression at %L"
 msgstr "TILE вимагає сталий вираз на %L"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr "%qs на %L повинно бути скаляром типу integer(kind=omp_event_handle_kind)"
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "Обробник події на %L не повинен бути елементом масиву"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "Обробник події на %L не повинен бути частиною похідного типу або класу"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "Замикання %<DETACH%> на %L не слід використовувати разом з замиканням %<MERGEABLE%>"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr "Конструкція %<host_data%> у %L вимагає клаузи %<use_device%>"
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr "Очікувався IF на %L в атомному порівнянні захоплення"
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr "Очікувався ELSE на %L в атомному порівнянні захоплення"
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr "Очікувався атомний вираз порівняння %<==%>, %<.EQ.%> або %<.EQV.%> на %L"
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr "Очікувалася скалярна вбудована змінна на %L у атомному порівнянні"
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "Очікувався скалярний вбудований вираз на %L у атомному порівнянні"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "Директива !$OMP ATOMIC повинна встановлювати скалярну змінну вбудованого типу на %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "Директива !$OMP ATOMIC повинна присвоювати вираз вбудованого типу на %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "!$OMP ATOMIC з ALLOCATABLE змінною на %L"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "Директива !$OMP ATOMIC READ повинна читати з скалярної змінної вбудованого типу на %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr в !$OMP ATOMIC WRITE присвоєнні var = expr повинен бути скалярним і не може посилатися на var на %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC capture-заявка повинна встановлювати скалярну змінну вбудованого типу на %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "!$OMP ATOMIC capture-заявка вимагає скалярну змінну вбудованого типу на %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "!$OMP ATOMIC CAPTURE capture-заявка зчитує з іншої змінної, ніж заявка оновлення записує на %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "Для !$OMP ATOMIC COMPARE, перший операнд у порівнянні на %L повинен бути змінною %qs, в яку заявка оновлення записує на %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr в !$OMP ATOMIC COMPARE присвоєнні var = expr повинен бути скалярним і не може посилатися на var на %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requiries either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr "!$OMP ATOMIC UPDATE на %L з FAIL-замиканням вимагає використання або COMPARE-замикання, або використання вбудованої процедури MIN/MAX"
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "Оператор присвоєння !$OMP ATOMIC повинен бути бінарним +, *, -, /, .AND., .OR., .EQV. або .NEQV. на %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "Присвоєння !$OMP ATOMIC повинно бути var = var op expr або var = expr op var на %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "Вираз !$OMP ATOMIC var = var op expr не математично еквівалентний var = var op (expr) на %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "Вираз в присвоєнні !$OMP ATOMIC var = var op expr повинен бути скалярним і не може посилатися на var на %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "!$OMP ATOMIC вбудована інструкція присвоєння IAND, IOR або IEOR повинна мати два аргументи на %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "!$OMP ATOMIC вбудована інструкція присвоєння повинна бути MIN, MAX, IAND, IOR або IEOR на %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "Аргументи вбудованої інструкції !$OMP ATOMIC, крім одного, не повинні посилатися на %qs на %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "Аргументи вбудованої інструкції !$OMP ATOMIC повинні бути скалярними на %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "Перший або останній аргумент вбудованої інструкції !$OMP ATOMIC повинен бути %qs на %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "!$OMP ATOMIC присвоєння повинно мати оператор або вбудовану функцію на правій стороні на %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "неочікуваний вираз !$OMP ATOMIC на %L"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr "З INSCAN в %L очікується тіло циклу з !$OMP SCAN між двома послідовностями структурованих блоків"
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr "!$OMP SCAN на %L без інструкцій у попередній структурованій послідовності блоків"
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr "!$OMP SCAN в %L з нулем виконуваних інструкцій у наступній структурованій послідовності блоків"
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr "%s не може містити цикл у проміжному коді в %L"
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr "%s не може містити виклик OpenMP API в проміжному коді в %L"
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr "%s не може містити директиву OpenMP в проміжному коді в %L"
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr "Модифікатор замикання LINEAR використовується на конструкції DO або SIMD на %L"
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%s не може бути DO WHILE або DO без керування циклом на %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr "%s не може бути циклом DO CONCURRENT на %L"
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "Ітераційна змінна %s повинна бути цілочисельного типу на %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "Змінна ітерації %s не може бути THREADPRIVATE на %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "Змінна ітерації %s присутня в замиканні, відмінній від PRIVATE, LASTPRIVATE або ALLOCATE на %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "Змінна ітерації %s присутня в замиканні відмінному від PRIVATE, LASTPRIVATE, ALLOCATE або LINEAR на %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "Змінна ітерації %s використовується в більш ніж одній петлі на %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "Змінна ітерації %s в %L є зв'язаною в проміжному коді"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr "Вираз початку петлі %s не знаходиться в канонічній формі на %L"
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr "Вираз початку циклу %s в %L використовує зв'язану змінну в проміжному коді"
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "Вираз кінця петлі %s не знаходиться в канонічній формі на %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr "Вираз кінця циклу %s на %L використовує змінну, визначену в проміжному коді"
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "Межі петлі %s посилаються на різні змінні ітерації на %L"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr "Приріст петлі %s не знаходиться в канонічній формі на %L"
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr "Вираз інкременту циклу %s на %L використовує змінну, визначену в проміжному коді"
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "недостатньо циклів DO для згорнутого %s (рівень %d) в %L"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "Внутрішні цикли %s повинні бути ідеально вкладені з клаузою ORDERED в %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr "Внутрішні цикли %s повинні бути правильно вкладені з клаузою REDUCTION INSCAN в %L"
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "Внутрішні цикли %s повинні бути ідеально вкладені з клаузою ORDERED в %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be constant integer expression at %C"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "аргумент %<score%> повинен бути сталою цілочисельним виразом у %C"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "%<score%> argument must be non-negative at %C"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "аргумент %<score%> повинен бути невід'ємним у %C"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "property must be a constant logical expression at %C"
 msgid "property must be a logical expression at %L"
 msgstr "властивість повинна бути сталою логічною виразом у %C"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "property must be a constant integer expression at %C"
 msgid "property must be an integer expression at %L"
 msgstr "властивість повинна бути сталим цілочисельним виразом в %C"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "property must be a constant logical expression at %C"
 msgid "property must be a constant logical expression at %L"
 msgstr "властивість повинна бути сталою логічною виразом у %C"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "property must be a constant integer expression at %C"
 msgid "property must be a constant integer expression at %L"
 msgstr "властивість повинна бути сталим цілочисельним виразом в %C"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "property must be a conforming device number at %C"
 msgid "property must be a conforming device number at %L"
 msgstr "властивість повинна бути відповідним номером пристрою в %C"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr "Директива %s не може бути вказана всередині області %s на %L"
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$ACC LOOP не може бути DO WHILE або DO без керування циклом на %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "!$ACC LOOP не може бути циклом DO CONCURRENT на %L"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "Ітераційна змінна циклу !$ACC LOOP повинна бути типу integer на %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "Цикли %s !$ACC LOOP не утворюють прямокутний простір ітерацій на %L"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "Цикли %s !$ACC LOOP не є ідеально вкладеними на %L"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "недостатньо DO-циклів для %s !$ACC LOOP на %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr "Плиткована петля не може бути паралелізована одночасно по групах, робітниках та векторах на %L"
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "TILE вимагає сталий вираз на %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, fuzzy, gcc-internal-format
 #| msgid "Object %qs is not a variable at %L; parameters cannot be and need not be copied"
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "Обʼєкт %qs не є змінною у %L; параметри не можуть і не повинні бути скопійовані"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "Розділи масиву: %qs не дозволені в !$ACC DECLARE на %L"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Імʼя %qs не посилається на підпрограму або функцію в !$ACC ROUTINE ( ІМʼЯ ) на %L"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "Імʼя %qs недійсне в !$ACC ROUTINE ( ІМʼЯ ) на %L"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "Область !$OMP TARGET в %L з вкладеними TEAMS в %L не може містити жодної іншої інструкції, декларації або директиви, крім одного конструкту TEAMS."
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr "Область !$OMP TARGET в %L з вкладеними TEAMS не може містити жодної іншої інструкції, декларації або директиви поза одним конструктом TEAMS"
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr "OMP TARGET UPDATE на %L потребує принаймні одну TO або FROM клавішу"
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr "OMP CRITICAL на %L з класом HINT вимагає ІМʼЯ, за винятком випадку використання omp_sync_hint_none"
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr "Неочікуваний !$OMP SCAN на %L поза конструкцією циклу з %<inscan%> REDUCTION замиканням"
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr "!$OMP DECLARE SIMD повинен посилатися на вміщувану процедуру %qs на %L"
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected constant logical expression"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "очікується константне логічне вираження"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected parameter list in type declaration at %C"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "Очікується список параметрів у оголошенні типу на %C"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Змінна, відмінна від OMP_PRIV або OMP_ORIG, використовується в замиканні INITIALIZER !$OMP DECLARE REDUCTION на %L"
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Змінна, відмінна від OMP_OUT або OMP_IN, використовується в комбінаторі !$OMP DECLARE REDUCTION на %L"
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr "Недійсний оператор для !$OMP DECLARE REDUCTION %s на %L"
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr "Довжина CHARACTER в !$OMP DECLARE REDUCTION %s не є сталою на %L"
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr "Виклик підпрограми з альтернативними поверненнями в комбінаторі !$OMP DECLARE REDUCTION на %L"
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr "Виклик підпрограми з альтернативними поверненнями в замиканні INITIALIZER !$OMP DECLARE REDUCTION на %L"
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr "Один з фактичних аргументів підпрограми в замиканні INITIALIZER !$OMP DECLARE REDUCTION повинен бути OMP_PRIV на %L"
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr "Відсутнє замикання INITIALIZER для !$OMP DECLARE REDUCTION похідного типу без ініціалізатора за замовчуванням на %L"
@@ -85376,63 +85571,63 @@ msgstr "Директива %<GCC vector%> не на початку циклу н
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr "Директива %<GCC novector%> не на початку циклу на %C"
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "Вкладена процедура %qs в %C вже є неоднозначною"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "Неочікувана інструкція %s в розділі CONTAINS в %C"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Інструкція CONTAINS без інструкції FUNCTION або SUBROUTINE в %L"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C after the first executable statement"
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "Оператор DATA в %C після першої виконуваної інструкції"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "Інструкція CONTAINS в %C вже знаходиться вкладеною програмною одиницею"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "Глобальне імʼя звʼязування %qs в %L вже використовується як %s в %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "Глобальне імʼя %qs в %L вже використовується як %s в %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Глобальне імʼя звʼязування %qs в %L вже використовується в %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Глобальне імʼя %qs в %L вже використовується в %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "Порожній BLOCK DATA в %C конфліктує з попереднім BLOCK DATA в %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "Неочікувана інструкція %s в BLOCK DATA в %C"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "Неочікувана %s інструкція у модулі на %C"
@@ -85440,7 +85635,7 @@ msgstr "Неочікувана %s інструкція у модулі на %C"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "Два головні PROGRAM у %L та %C"
@@ -85900,1114 +86095,1114 @@ msgstr "ПАРАМЕТР %qs не повинен зʼявлятися в інс
 msgid "%qs at %C is not a variable"
 msgstr "%qs на %C не є змінною"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs на %L є типом ABSTRACT %qs"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "Абстрактний тип %qs використовується на %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "Інтерфейс %qs на %L оголошений у пізнішому операторі PROCEDURE"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "Інтерфейс %qs на %L не може бути загальним"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Інтерфейс %qs на %L не може бути функцією-оператором"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Вбудовану процедуру %qs не дозволяється використовувати в операторі PROCEDURE на %L"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "Інтерфейс %qs на %L повинен бути явним"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "PROCEDURE %qs на %L не може бути використано як свій власний інтерфейс"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "Альтернативний специфікатор повернення в елементарній підпрограмі %qs на %L не дозволяється"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "Альтернативний специфікатор повернення в функції %qs на %L не дозволяється"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "Самореференційний аргумент %qs на %L не дозволяється"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "Фіктивна процедура %qs чистої процедури на %L також повинна бути чистою"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Аргумент %qs чистої функції %qs у %L з атрибутом VALUE, але без INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "Аргумент %qs чистої функції %qs у %L повинен мати INTENT(IN) або VALUE"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Аргумент %qs чистої підпрограми %qs у %L з атрибутом VALUE, але без INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Аргумент %qs чистої підпрограми %qs у %L повинен мати вказаний INTENT або мати атрибут VALUE"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "Аргумент INTENT(OUT) %qs чистої процедури %qs у %L не може бути поліморфним"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Аргумент-заглушка Coarray %qs у %L для елементарної процедури"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Аргумент %qs елементарної процедури на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "Аргумент %qs елементарної процедури на %L не може мати атрибуту ALLOCATABLE"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "Аргумент %qs елементарної процедури на %L не може мати атрибуту POINTER"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "Фіктивна процедура %qs не дозволена в елементарній процедурі %qs на %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "Аргумент %qs елементарної процедури %qs на %L повинен мати вказане його намір або мати атрибут VALUE"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Аргумент %qs функції-оператора %qs на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Аргумент типу символів %qs у функції заяви на %L повинен мати сталу довжину"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "Вкладена процедура %qs на %L має ту саму назву, що й оточуюча процедура"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "Вкладена функція %qs на %L не має неявного типу"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "Результат %qs вкладеної функції %qs на %L не має неявного типу"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Модульна процедура зі значеннями символів %qs на %L не повинна мати припущеної довжини"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Внутрішня функція зі значеннями символів %qs на %L не повинна мати припущеної довжини"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "Функція %s на %L має записи з неправильними специфікаціями масиву"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "Функція %s на %L має запис %s з неправильними характеристиками"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "Функція %s на %L з записами, що повертають змінні різної довжини рядка"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Результат FUNCTION %s не може бути масивом в функції %s на %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Результат ENTRY %s не може бути масивом в функції %s на %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Результат FUNCTION %s не може бути POINTER в функції %s на %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "Результат ENTRY %s не може бути POINTER в функції %s на %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Результат функції %s не може бути ALLOCATABLE в функції %s на %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "Результат ENTRY %s не може бути ALLOCATABLE в функції %s на %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Результат функції %s не може бути типу %s в функції %s на %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "Результат ENTRY %s не може бути типу %s в функції %s на %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Глобальна сутність %qs на %L не може зʼявлятися в блоку COMMON на %L"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Глобальна сутність %qs на %L не може зʼявлятися в блоку COMMON"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr "Блок COMMON на %L"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "Змінна %qs на %L знаходиться в COMMON, але дозволена лише ініціалізація в BLOCK DATA"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "Ініціалізована змінна %qs на %L знаходиться в порожньому COMMON, але ініціалізація дозволена лише в названих блоках COMMON"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr "%qs на %L не може зʼявлятися в COMMON [F2008:C5100]"
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Автоматичний об'єкт %qs в %L не може з'явитися в COMMON в %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "Змінна похідного типу %qs в COMMON на %L не має атрибуту SEQUENCE або BIND(C)"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "Змінна похідного типу %qs в COMMON на %L має кінцеву компоненту, яка може бути виділена"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "Змінна похідного типу %qs в COMMON на %L не може мати типового ініціалізатора"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr "У Fortran 2003 блок COMMON %qs на %L є глобальним ідентифікатором і, отже, повинен мати те саме імʼя звʼязування, що й блок COMMON з таким самим іменем на %L: %s vs %s"
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "Блок COMMON %qs на %L використовує той самий глобальний ідентифікатор, що й сутність на %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "Fortran 2008: Блок COMMON %qs з міткою звʼязування на %L, який спільно використовує ідентифікатор з глобальною сутністю, не є блоком COMMON на %L"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "Блок COMMON на %L з міткою звʼязування %qs використовує той самий глобальний ідентифікатор, що й сутність на %L"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "Блок COMMON %qs на %L використовується як PARAMETER на %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "Блок COMMON %qs на %L не може мати атрибут EXTERNAL"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "Блок COMMON %qs на %L також є вбудованою процедурою"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "Блок COMMON %qs на %L, який також є результатом функції"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "Блок COMMON %qs на %L, який також є глобальною процедурою"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr "Параметр KIND %qs в конструкторі PDT на %C не має значення"
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "Ранг елемента в конструкторі структури на %L не відповідає рангу компонента (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "Елемент в конструкторі структури на %L, для вказівного компонента %qs, є %s, але повинен бути %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Нерівні довжини символів (%wd/%wd) для вказівного компонента %qs в конструкторі на %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "NULL в конструкторі структури на %L застосовується до компонента %qs, який не є або POINTER, або ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "Несумісність інтерфейсу для компонента вказівника на процедуру %qs у конструкторі структури на %L: %s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "Неправильна специфікація масиву компоненти %qs, на яку посилається в конструкторі структури на %L"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "Форма компоненти %qs в конструкторі структури на %L відрізняється від форми оголошеної компоненти для розміру %d (%ld/%ld)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "Елемент в конструкторі структури на %L для компоненти вказівника %qs повинен бути POINTER або TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "Призначення вказівника з векторним підписом на rhs на %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "Неправильний вираз у конструкторі структури для компонента вказівника %qs на %L у чистій процедурі"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "Верхня межа в останньому розмірі повинна зʼявлятися в посиланні на масив з припущеним розміром %qs на %L"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%qs на %L є неоднозначним"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "Загальноприйнята процедура %qs не допускається як фактичний аргумент на %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "Тип, вказаний для вбудованої функції %qs на %L, ігнорується"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Вбудована підпрограма %qs на %L не повинна мати специфікатора типу"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "%qs, оголошений як INTRINSIC на %L, не існує"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "Вбудована функція %qs, оголошена як INTRINSIC у %L, недоступна в поточних налаштуваннях стандарту, але %s. Використовуйте відповідну опцію %<-std=*%> або увімкніть %<-fall-intrinsics%>, щоб використовувати її."
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, fuzzy, gcc-internal-format
 #| msgid "Non-RECURSIVE procedure %qs from module %qs is  possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Нерекурсивна процедура %qs з модуля %qs можливо викликає рекурсивно сама себе у процедурі %qs. Оголосіть її як RECURSIVE або використовуйте %<-frecursive%>"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "Можливо, нерекурсивна процедура %qs у %L викликає рекурсивно сама себе. Оголосіть її як RECURSIVE або використовуйте %<-frecursive%>"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "Мітка %d, на яку є посилання у %L, ніколи не визначена"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Похідний тип %qs використовується як фактичний аргумент у %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "Функція-оператор %qs у %L не дозволена як фактичний аргумент"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Вбудована функція %qs на %L не допускається як фактичний аргумент"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Внутрішня процедура %qs використовується як фактичний аргумент на %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL, не-INTRINSIC процедура %qs не допускається як фактичний аргумент на %L"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "Не вдалося знайти конкретну INTRINSIC процедуру для посилання %qs на %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Символ %qs на %L є неоднозначним"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "Аргумент за значенням на %L не є числовим типом"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "Аргумент за значенням на %L не може бути масивом або секцією масиву"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "Аргумент за значенням на %L не допускається в цьому контексті"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "Передача внутрішньої процедури за адресою у %L не дозволена"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "Компонент вказівника на ELEMENTAL процедуру %qs не дозволений як фактичний аргумент у %L"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Коіндексований фактичний аргумент у %L з остаточною компонентою вказівника"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "Ціль вказівника на процедуру %qs на %L повинна бути або вбудованою, або повʼязаною з хостом або use, або посилатися на неї, або мати атрибут EXTERNAL"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "%qs у %L є масивом та OPTIONAL; Якщо його немає, то воно не може бути фактичним аргументом ELEMENTAL процедури, якщо немає необовʼязкового аргументу з таким самим рангом (Fortran 2018, 15.5.2.12)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "Фактичний аргумент у %L для INTENT(%s) фіктивного аргументу %qs ELEMENTAL підпрограми %qs є скаляром, але інший фактичний аргумент є масивом"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "Неспівпадання типу повернення функції %qs на %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "Неспівпадання інтерфейсу в глобальній процедурі %qs на %L: %s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "Немає конкретної функції для загального %qs на %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "Загальна функція %qs на %L не сумісна з конкретним вбудованим інтерфейсом"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Функція %qs на %L є ВБУДОВАНОЮ, але не сумісна з вбудованою функцією"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Неможливо вирішити конкретну функцію %qs на %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr "Відсутня явна декларація з атрибутом EXTERNAL для символу %qs на %L"
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "Функція %qs в %L не має ІМПЛІЦИТНОГО типу; ви мали на увазі %qs?"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "Функція %qs в %L не має ІМПЛІЦИТНОГО типу"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "Посилання на нечисту функцію %qs в %L всередині DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "Посилання на нечисту функцію %qs в %L всередині FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "Посилання на нечисту функцію %qs в %L всередині DO CONCURRENT %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "Посилання на нечисту функцію %qs на %L всередині ЧИСТОЇ процедури"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "Неочікувані непотрібні символи після %qs на %L"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "%qs на %L не є функцією"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "АБСТРАКТНИЙ ІНТЕРФЕЙС %qs не повинен бути посиланий на %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr "АБСТРАКТНИЙ ІНТЕРФЕЙС %qs на %L не повинен мати припущений результат з довжиною символів (F2008: C418)"
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "Функцію %qs оголошено як CHARACTER(*) і не можна використовувати на %L, оскільки вона не є фіктивним аргументом"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function %qs at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "Відсутній список аргументів у функції %qs на %C"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "resolve_function(): неправильний тип функції"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr "Літеральна константа BOZ на %L не може зʼявлятися як фактичний аргумент у посиланні на функцію"
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "Користувацька нелементальна функція %qs на %L не дозволена у конструкції WORKSHARE"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "ENTRY %qs на %L не може бути викликано рекурсивно, оскільки функція %qs не є RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "Функцію %qs в %L не можна викликати рекурсивно, оскільки вона не є RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "Використання функції %qs в %L є застарілим"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "Блок COMMON %qs на %L не може мати атрибут EXTERNAL"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "Виклик підпрограми %qs в блоку DO CONCURRENT в %L не є PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "Виклик підпрограми %qs в блоку FORALL в %L не є PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "Виклик підпрограми %qs в блоку DO CONCURRENT в %L не є PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "Виклик підпрограми %qs в %L не є PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "Немає конкретної підпрограми для загального %qs в %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "Загальна підпрограма %qs в %L не сумісна з інтегрованим інтерфейсом підпрограми"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "Підпрограма %qs в %L є INTRINSIC, але не сумісна з інтегрованою"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "Не вдалося знайти конкретну підпрограму %qs у %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "%qs у %L має тип, який не відповідає CALL у %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "ВХІД %qs на %L не може бути викликаний рекурсивно, оскільки підпрограма %qs не є РЕКУРСИВНОЮ"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "ПІДПРОГРАМА %qs на %L не може бути викликана рекурсивно, оскільки вона не є РЕКУРСИВНОЮ"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "resolve_subroutine(): неправильний тип функції"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "Використання підпрограми %qs на %L є застарілим"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "Форми для операндів на %L і %L не сумісні"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "logical_to_bitwise(): Погана внутрішня функція"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Нечиста функція %qs на %L може не бути оцінена"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "Нечиста функція на %L може не бути оцінена"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "Літеральна константа BOZ на %L не може бути операндом унарного оператора %qs"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression in %<>= 0%> is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "порівняння беззнакового виразу в %<>= 0%> завжди є правильним"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr "Операнди на %L і %L не можуть бути операндами бінарного оператора %qs"
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Недійсний контекст для вказівника NULL() на %%L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Операнд унарного числового оператора %%<%s%%> на %%L є %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Операнди бінарного числового оператора %%<%s%%> на %%L є %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Неспівпадаючі ранги для оператора на %%L і %%L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected derived-type entities in binary intrinsic numeric operator %%<%s%%> at %%L"
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "Неочікувані сутності з похідним типом у бінарному вбудованому числовому операторі %%<%s%%> на %%L"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Операнди оператора конкатенації рядків на %%L є %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Операнди логічного оператора %%<%s%%> на %%L є %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .not. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Операнд оператора .not. на %%L є %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "КОМПЛЕКСНІ величини не можуть бути порівняні на %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "Літеральна константа BOZ біля %L не може бути операндом реляційного оператора"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Неспівпадаючі ранги для оператора на %%L і %%L"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "Equality comparison for %s at %L"
 msgstr "Порівняння на рівність для %s на %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, gcc-internal-format, gfc-internal-format
 msgid "Inequality comparison for %s at %L"
 msgstr "Порівняння на нерівність для %s на %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Логічні значення на %%L повинні бути порівняні з %s замість %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Операнди оператора порівняння %%<%s%%> на %%L є %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator %%<%s%%> at %%L; did you mean %%<%s%%>?"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "Невідомий оператор %%<%s%%> на %%L; ви мали на увазі %%<%s%%>?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator %%<%s%%> at %%L"
 msgid "Unknown operator %qs at %L"
 msgstr "Невідомий оператор %%<%s%%> на %%L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator %%<%s%%> at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Операнд користувацького оператора %%<%s%%> на %%L є %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Операнди користувацького оператора %%<%s%%> на %%L є %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "resolve_operator(): Поганий вбудований"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Coindex of codimension %d must be a scalar at %L"
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Коіндекс коефіцієнта розмірності %d повинен бути скалярним у %L"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Actual argument to %qs at %L must have the same declared type"
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "Фактичний аргумент для %qs на %L повинен мати той самий оголошений тип"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "Обʼєкт-виділення на %L та вираз-джерело на %L повинні мати однаковий типовий параметр"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "Вираз-джерело на %L та обʼєкт-виділення на %L повинні мати однакову форму"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Посилання на масив на %L виходить за межі (%ld < %ld) в розмірності %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "Посилання на масив на %L виходить за межі (%ld < %ld) в кодимензії %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Посилання на масив на %L виходить за межі (%ld > %ld) в розмірності %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "Посилання на масив на %L виходить за межі (%ld > %ld) в кодимензії %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "Недопустимий крок нульовий на %L"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Нижнє посилання на масив на %L виходить за межі (%ld < %ld) в розмірності %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Нижнє посилання на масив на %L виходить за межі (%ld > %ld) в розмірності %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "Верхнє посилання на масив на %L виходить за межі (%ld < %ld) в розмірності %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "Верхнє посилання на масив на %L виходить за межі (%ld > %ld) в розмірності %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "check_dimension(): Погане посилання на масив"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Права верхня межа розділу масиву припущеного розміру не вказана у %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "Несумісні розмірності в посиланні на масив у %L (%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Несумісні розмірності коіндексу в посиланні на масив у %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Коіндекс коефіцієнта розмірності %d повинен бути скалярним у %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "Індекс масиву у %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "Індекс масиву на %L повинен бути типу INTEGER, знайдено %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "Індекс масиву REAL на %L"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "Аргумент dim на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "Аргумент dim на %L повинен бути типу INTEGER"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "Неприпустима посилання на масив немасивної сутності на %L"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr "find_array_spec(): не використовується as(1)"
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr "find_array_spec(): не використовується as(2)"
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "Індекс масиву на %L є масивом рангу %d"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "Аргумент dim на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "Вираз на %L повинен бути типу INTEGER, знайдено %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "Аргумент dim на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "Аргумент dim на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "Вираз на %L повинен бути типу INTEGER, знайдено %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "Вираз на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "Початковий індекс підстрічки на %L повинен бути типу INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "Початковий індекс підстрічки на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "Кінцевий індекс підстрічки на %L повинен бути типу INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "Кінцевий індекс підстрічки на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "Кінцевий індекс підстрічки на %L занадто великий"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "resolve_ref(): Поганий посилання на масив"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "Компонент справа від часткового посилання з ненульовим рангом не повинен мати атрибут POINTER на %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "Компонент справа від часткового посилання з ненульовим рангом не повинен мати атрибут ALLOCATABLE на %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "Два або більше часткових посилань з ненульовим рангом не повинні бути вказані на %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr "gfc_expression_rank(): Два специфікатори масиву"
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "Illegal coarray index"
 msgstr "неприпустимий операнд "
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK може використовуватися лише як фактичний аргумент"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "Припущена змінна %s на %L може використовуватися лише як фактичний аргумент"
@@ -87016,12 +87211,12 @@ msgstr "Припущена змінна %s на %L може використов
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Припущена змінна %s на %L як фактичний аргумент для функції запиту повинна бути першим аргументом"
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "Припущена змінна %s на %L може використовуватися лише як фактичний аргумент"
@@ -87030,425 +87225,425 @@ msgstr "Припущена змінна %s на %L може використов
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr "Припущена змінна %s на %L як фактичний аргумент для функції запиту повинна бути першим аргументом"
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK не повинна мати посилання на підобʼєкт"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "Припущена змінна типу %s на %L не повинна мати посилання на підобʼєкт"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "Припущена змінна рангу %s на %L не повинна мати посилання на підобʼєкт"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "Скалярна змінна %qs має посилання на масив в %L"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "Змінна %qs, яка використовується в специфікаційному виразі, має посилання на %L до заяви ENTRY, в якій вона є параметром"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "Змінна %qs використовується на %L до заяви ENTRY, в якій вона є параметром"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Поліморфний підобʼєкт коіндексованого обʼєкта на %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Коіндексований обʼєкт з поліморфною видільною підкомпонентою на %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "Використання змінної %qs у %L є застарілим"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference at %L"
 msgstr "Неправильне посилання на масив в %L"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr "%qs у %L повʼязано з хостом у %L в межах вкладеної процедури з внутрішньою процедурою з таким самим імʼям"
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "Помилка у типованому виклику у %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Переданий обʼєкт у %L повинен бути скалярним"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "Базовий обʼєкт для виклику компоненти вказівника на процедуру у %L має абстрактний тип %qs"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "Базовий обʼєкт для типованого виклику процедури у %L має абстрактний тип %qs"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "Базовий обʼєкт для типованого виклику NOPASS-процедури у %L повинен бути скалярним"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "Не знайдено відповідного специфічного звʼязування для виклику GENERIC %qs на %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%qs на %L повинно бути ПІДПРОГРАМОЮ"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs на %L повинно бути ФУНКЦІЄЮ"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "gfc_resolve_expr(): Поганий тип виразу"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s на %L повинно бути скаляром"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s на %L повинно бути цілочисельним"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s на %L повинно бути INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "Вираз кроку в DO-циклі на %L не може бути нулем"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "DO-цикл на %L буде виконано нуль разів"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr "DO-цикл на %L не визначений, оскільки переповнюється"
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr "DO-цикл на %L не визначений, оскільки підповнюється"
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Очікувано імʼя змінної на %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "Змінній %qs на %L не було присвоєно мітку формату"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "Атрибут SAVE на %L не може бути вказаний в чистій процедурі"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 #| msgid "Assumed size array %qs in %s clause at %L"
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "Масив з припущеним розміром %qs у замиканні %s на %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, fuzzy, gcc-internal-format
 #| msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "Обʼєкт ALLOCATABLE %qs в замиканні %s на рядку %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Вказівник Cray %qs в замиканні %s на %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, fuzzy, gcc-internal-format
 #| msgid "List item %qs with allocatable components is not permitted in map clause at %L"
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr "Елемент списку %qs з можливими компонентами для виділення не допускається в замиканні map на %L"
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected intrinsic type %qs at %L"
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Неочікуваний вбудований тип %qs на %L"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of %qs in %s statement at %L"
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "Очікується імʼя блоку %qs в інструкції %s в %L"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "Змінна %qD встановлена, але не використовується"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "Індекс FORALL з іменем на %L повинен бути скалярним ЦІЛИМ"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "Початковий вираз FORALL на %L повинен бути скалярним ЦІЛИМ"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "Кінцевий вираз FORALL на %L повинен бути скалярним ЦІЛИМ"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "Вираз кроку FORALL на %L повинен бути скалярним %s"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "Вираз кроку FORALL на %L не може бути нулем"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "Індекс FORALL %qs не може зʼявлятися в специфікації триплета на %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Обʼєкт розподілу на %L повинен бути ALLOCATABLE або POINTER"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Коіндексований обʼєкт розподілу на %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Allocate-object at %L also appears at %L"
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "Обʼєкт, що виділяється, на %L також зʼявляється на %L"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "Вихідний вираз на %L повинен бути скалярним або мати такий же ранг, як обʼєкт розподілу на %L"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "Вираз-джерело на %L та обʼєкт-виділення на %L повинні мати однакову форму"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "У виразі на %L можна використовувати лише вбудовані оператори"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "Тип сутності на %L несумісний з виразом-джерелом на %L"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "Обʼєкт-виділення на %L та вираз-джерело на %L повинні мати однаковий типовий параметр"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "Вираз-джерело на %L не може бути типу LOCK_TYPE або мати компонент LOCK_TYPE, якщо обʼєкт-виділення на %L є комасивом"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "Вираз-джерело на %L не може бути типу EVENT_TYPE або мати компонент EVENT_TYPE, якщо обʼєкт-виділення на %L є комасивом"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "Виділення %s з базовим типом ABSTRACT на %L вимагає типової специфікації або виразу джерела"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "Виділення %s на %L з типовою специфікацією вимагає такого самого параметра довжини символів, як у декларації"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "У ALLOCATE-операторі на %L потрібна специфікація масиву"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "У ALLOCATE-операторі на %L потрібна специфікація масиву або виразу SOURCE= з масивним значенням"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "У операторі ALLOCATE на %L потрібна специфікація ко-масиву"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "Неправильна специфікація ко-масиву в операторі ALLOCATE на %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr "Верхня межа менша за нижню межу на %L"
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr "Верхня межа менша за нижню межу 1 на %L"
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "Неправильна специфікація масиву в операторі ALLOCATE на %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "%qs не повинно зʼявлятися в специфікації масиву на %L в тому ж операторі ALLOCATE, де воно само алоціюється"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "Очікується %<*%> в специфікації коіндексу в операторі ALLOCATE на %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "Stat-змінна на %L повинна бути скалярною цілочисельною змінною"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Stat-змінна на %L не повинна бути %s в тому ж операторі %s"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "Повідомлення про помилку на %L без тегу STAT нічого не значить"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "Змінна ERRMSG на %L повинна бути скалярною змінною типу CHARACTER за замовчуванням"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "Змінна ERRMSG на %L не повинна бути %s в тій самій %s інструкції"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "Обʼєкт, що виділяється, на %L також зʼявляється на %L"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "Обʼєкт, що виділяється, на %L є підобʼєктом обʼєкта на %L"
@@ -87457,318 +87652,318 @@ msgstr "Обʼєкт, що виділяється, на %L є підобʼєкт
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "Мітка CASE на %L перекривається з міткою CASE на %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "Вираз в операторі CASE на %L повинен бути типу %s"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "Вираз в операторі CASE на %L повинен бути виду %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "Вираз в операторі CASE на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "Вираз вибору в обчисленому операторі GOTO на %L повинен бути скалярним цілим виразом"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "Аргумент оператора SELECT на %L не може бути %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "Аргумент оператора SELECT на %L повинен бути скалярним виразом"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "Вираз у CASE-операторі на %L не знаходиться у діапазоні %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "Оператор DEFAULT CASE на %L не може слідувати за другим оператором DEFAULT CASE на %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "Логічний діапазон у CASE-операторі на %L не дозволяється"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "Константне логічне значення в операторі CASE повторюється на %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "Специфікація діапазону на %L ніколи не може збігатися"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "Логічний блок SELECT CASE на %L має більше двох випадків"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function %qs at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "Неможливо вирішити конкретну функцію %qs на %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "Асоціююча сутність %qs на %L є вказівником на процедуру"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Похідний тип %qs не може бути використаний як змінна на %L"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "Асоціююча сутність %qs на %L є імʼям процедури"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr "Асоціюючий вираз-селектор на %L повертає процедуру"
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "Селектор на %L не може бути NULL()"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "Селектор на %L не має типу"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Асоційоване імʼя %qs на %L використовується як масив"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr "Селектор CLASS на %L потребує тимчасовий обʼєкт, який ще не реалізований"
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "Селектор повинен бути поліморфним в операторі SELECT TYPE на %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "Селектор на %L не повинен бути коіндексованим"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "TYPE IS на %L перекривається з TYPE IS на %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "Похідний тип %qs на %L повинен бути розширюваним"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "Похідний тип %qs на %L повинен бути розширенням %qs"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Неочікуваний вбудований тип %qs на %L"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "Тип-специфікація в %L повинна вказувати, що кожен параметр типу довжини припускається"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "Подвійний блок CLASS IS у операторі SELECT TYPE на %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr "RANK DEFAULT на %L повторюється на %L"
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr "RANK (*) на %L повторюється на %L"
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr "RANK (%i) на %L повторюється на %L"
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr "RANK (*) на %L не може використовуватися з вказівником або виділеною селектором на %L"
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Недійсний контекст для вбудованої функції NULL () на %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "Процедура DTIO %s на %L повинна бути рекурсивною"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "Елемент передачі даних на %L не може бути поліморфним, якщо його не обробляє визначена процедура введення/виведення"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "Елемент передачі даних на %L не може мати компоненти POINTER, якщо він не обробляється визначеною процедурою введення/виведення"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "Елемент передачі даних на %L не може мати компоненти вказівника на процедуру"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "Елемент передачі даних на %L не може мати компоненти ALLOCATABLE, якщо він не обробляється визначеною процедурою введення/виведення"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "Елемент передачі даних на %L не може мати приватні компоненти"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "Елемент передачі даних на %L не може мати приватні компоненти, якщо він не обробляється визначеною процедурою введення/виведення"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "Елемент передачі даних на %L не може бути повною посиланням на масив з припущеним розміром"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "Змінна блокування на %L повинна бути скаляром типу LOCK_TYPE"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "Змінна події на %L повинна бути скаляром типу EVENT_TYPE"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "Аргумент змінної події на %L повинен бути комасивом або коіндексований"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "Аргумент змінної події на %L повинен бути комасивом, але не коіндексований"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "Аргумент STAT= на %L повинен бути скалярною цілочисельною змінною"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "Аргумент ERRMSG= на %L повинен бути скалярною символьною змінною"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "Аргумент ACQUIRED_LOCK= на %L повинен бути скалярною логічною змінною"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "Аргумент UNTIL_COUNT= на %L повинен бути скалярним цілочисельним виразом"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TEAM argument to %qs at %L must be a scalar expression of type TEAM_TYPE"
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr "Аргумент TEAM для %qs на %L повинен бути скалярним виразом типу TEAM_TYPE"
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "Аргумент STAT= на %L повинен бути скалярною цілочисельною змінною"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be a character string of default kind"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "Мітка %s на %L повинна бути символьним рядком типу за замовчуванням"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Аргумент Imageset на %L повинен бути скалярним або ранг-1 цілочисельним виразом"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Аргумент Imageset на %L повинен бути між 1 і num_images()"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "Заява на %L не є дійсною цільовою заявою гілки для заяви гілки на %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "Гілка на %L може призвести до безкінечного циклу"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "Заява GOTO на %L залишає конструкцію CRITICAL для мітки на %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "Заява GOTO на %L залишає конструкцію DO CONCURRENT для мітки на %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
@@ -87777,214 +87972,214 @@ msgstr "Заява GOTO на %L залишає конструкцію CRITICAL 
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "Мітка на %L не знаходиться в тому ж блоку, що й заява GOTO на %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "Маска WHERE на %L має неузгоджену форму"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "Ціль присвоєння WHERE на %L має неузгоджену форму"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Не-елементарне користувацьке призначення в WHERE на %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "Непідтримувана заява всередині WHERE на %L"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "Присвоєння змінній індексу FORALL на %L"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "FORALL з індексом %qs не використовується зліва від призначення на %L, тому може призвести до множинного призначення цього обʼєкта"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "Конструкція FORALL на %L"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "Індекс FORALL з іменем на %L повинен бути скалярною змінною типу цілочисельне"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "Зовнішня конструкція FORALL вже має індекс з таким імʼям на %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Очікувано імʼя змінної на %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "Замикання WHERE/ELSEWHERE на %L вимагає логічний масив"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "gfc_resolve_blocks(): Неправильний тип блоку"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "Змінна в звичайному присвоєнні в %L є компонентом вказівника на процедуру"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "Неможливо конвертувати %s в %s у %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "Вираз CHARACTER буде скорочено в присвоєнні (%wd/%wd) в %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Коіндексований вираз на %L присвоюється змінній похідного типу з POINTER компонентою в PURE процедурі"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr "У чистій підпрограмі INTENT(IN) фіктивний аргумент не повинен використовуватися як вираз на %L в інтегрованій інструкції присвоєння, в якій змінна є похідним типом, якщо похідний тип має POINTER компоненту на будь-якому рівні вибору компоненти."
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "Присвоєння коіндексованій змінній на %L у чистій процедурі"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr "Присвоєння поліморфному спільному масиву на %L не дозволяється"
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "Присвоєння змінній з можливістю виділення памʼяті поліморфного типу на %L"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "Присвоєння змінній з можливістю виділення памʼяті поліморфного типу на %L потребує %<-frealloc-lhs%>"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "Невиділену змінну не повинно бути поліморфною в інтегрованому призначенні на %L - перевірте, що існує відповідна конкретна підпрограма для оператора %<=%>"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "Коіндексована змінна не повинна мати виділеної памʼяті остаточної компоненти в призначенні на %L"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr "TODO: типове обмежене призначення(я) на %L не виконано, оскільки в проміжних виразах виникають посилання на масив з кількома частинами."
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "Призначення вказівника на процедуру на %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "Результат функції на лівій стороні призначення на %L повинен мати атрибут вказівника."
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "Оператор ASSIGNED GOTO на %L вимагає скалярну цілочисельну змінну"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "Змінній %qs не було призначено цільової мітки на %L"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "Альтернативна RETURN-інструкція на %L потребує специфікатора повернення SCALAR-INTEGER"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "Очікувалося вбудоване призначення в OMP WORKSHARE на %L"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "Інструкція ASSIGN на %L потребує скалярну змінну INTEGER за замовчуванням"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "Недійсний NULL на %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "Арифметична IF-інструкція на %L потребує скалярний вираз REAL або INTEGER"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "gfc_resolve_code(): Немає виразу на DO WHILE"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "Умова виходу з циклу DO WHILE на %L повинна бути скалярним логічним виразом"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "Замикання FORALL маски на %L вимагає скалярний логічний вираз"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_resolve_code(): Поганий код оператора"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Використання параметра %qs, оголошеного на %L, є застарілим"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Змінна %qs з міткою привʼязки %qs на %L використовує той самий глобальний ідентифікатор, що й сутність на %L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "Змінна %qs з модуля %qs з міткою звʼязування %qs на %L використовує той самий глобальний ідентифікатор, що й сутність на %L з модуля %qs"
@@ -87992,62 +88187,62 @@ msgstr "Змінна %qs з модуля %qs з міткою звʼязуван
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "Процедура %qs з міткою звʼязування %qs на %L використовує той самий глобальний ідентифікатор, що й сутність на %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "Довжина рядка на %L занадто велика"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "Масив, що може бути виділений %qs на %L, повинен мати відкладену форму або припущений ранг"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "Скалярний обʼєкт %qs на %L не може бути виділеним"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "Вказівник на масив %qs на %L повинен мати відкладену форму або припущений ранг"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "Масив %qs на %L не може мати відкладену форму"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "Тип %qs змінної CLASS %qs на %L не є розширюваним"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "Змінна CLASS %qs на %L повинна бути фіктивною, виділеною або вказівником"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "Тип %qs не може бути повʼязаним з хостом на %L, оскільки його блокує несумісний обʼєкт з таким самим імʼям, оголошений на %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Неявне збереження для змінної модуля %qs на %L, необхідне через типову ініціалізацію"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Сутність %qs на %L має відкладений параметр типу і вимагає атрибут POINTER або ALLOCATABLE"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -88055,1001 +88250,1001 @@ msgstr "Змінна CLASS %qs у %L не може мати атрибут PARAM
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "Масив модуля або головної програми %qs на %L повинен мати сталу форму"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "Сутність з припущеною довжиною символів на %L повинна бути фіктивним аргументом або ПАРАМЕТРОМ"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "%qs на %L повинен мати сталу довжину символів в цьому контексті"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "Змінна COMMON %qs на %L повинна мати сталу довжину символів"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "Змінна з можливістю виділення %qs у %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "Зовнішня змінна %qs у %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "Фіктивна змінна %qs у %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "Вбудована змінна %qs у %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "Результат функції %qs у %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "Автоматичний масив %qs у %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s у %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Функція заяви зі значенням символу %qs у %L повинна мати сталу довжину"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "%qs має приватний тип і не може бути фіктивним аргументом %qs, який є публічним у %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Процедура %qs в публічному інтерфейсі %qs на %L приймає фіктивні аргументи %qs, які є ПРИВАТНИМИ"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Функція %qs на %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "Зовнішній обʼєкт %qs на %L не може мати ініціалізатора"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "ELEMENTAL-функція %qs на %L повинна мати скалярний результат"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "Функція-оператор %qs на %L не може мати атрибуту вказівника або атрибуту виділення памʼяті"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "Функція CHARACTER(*) %qs на %L не може бути масивом"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "Функція CHARACTER(*) %qs на %L не може бути вказівником"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "Функція CHARACTER(*) %qs на %L не може бути чистою"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "Функція CHARACTER(*) %qs у рядку %L не може бути рекурсивною"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "Функція CHARACTER(*) %qs у рядку %L"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "Вказівник на процедуру %qs у рядку %L не може бути елементарним"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "Фіктивна процедура %qs у рядку %L не може бути елементарною"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "Змінна результату функції %qs у рядку %L елементарної функції %qs не може мати атрибут ALLOCATABLE або POINTER"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, fuzzy, gcc-internal-format
 #| msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Коіндексований обʼєкт з поліморфною видільною підкомпонентою на %L"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "Атрибут PROCEDURE конфліктує з атрибутом SAVE у %qs у рядку %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "Атрибут PROCEDURE конфліктує з атрибутом INTENT у %qs у рядку %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "Атрибут PROCEDURE конфліктує з атрибутом RESULT в %qs на %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "Атрибут EXTERNAL конфліктує з атрибутом FUNCTION в %qs на %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "Результат вказівника процедури %qs на %L не має атрибуту вказівника"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Несумісність атрибуту ELEMENTAL між MODULE PROCEDURE на %L та його інтерфейсом в %s"
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Несумісність атрибуту PURE між MODULE PROCEDURE на %L та його інтерфейсом в %s"
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr "Несумісність атрибуту RECURSIVE між MODULE PROCEDURE на %L та його інтерфейсом в %s"
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr "%s між оголошенням MODULE PROCEDURE в MODULE %qs та оголошенням на %L в (SUB)MODULE %qs"
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Інтерфейс %qs на %L повинен бути явним"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "FINAL процедура %qs на %L не є SUBROUTINE"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "FINAL процедура на %L повинна мати рівно один аргумент"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Аргумент FINAL процедури на %L повинен бути типу %qs"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr "FINAL процедура на %L з аргументом з припущеним рангом повинна бути єдиним фіналізатором з такою самою категорією/типом (F2018: C790)"
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "Аргумент FINAL процедури на %L не може бути POINTER"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "Аргумент FINAL процедури на %L не може бути ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "Аргумент FINAL процедури на %L не може бути OPTIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "Аргумент FINAL процедури на %L не може бути INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Нескалярна FINAL процедура на %L повинна мати аргумент з припущеною формою"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "FINAL процедура %qs, оголошена на %L, має такий же ранг (%d), як %qs"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "Тільки масивні FINAL процедури оголошені для похідного типу %qs, визначеного на %L, рекомендується також скалярна, якщо не було оголошено фіналізатор з припущеним рангом"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "%qs та %qs не можуть бути змішані FUNCTION/SUBROUTINE для GENERIC %qs на %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "%qs та %qs для GENERIC %qs на %L є неоднозначними"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "Невизначена конкретна привʼязка %qs як ціль GENERIC %qs на %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "GENERIC %qs на %L повинен мати конкретну привʼязку, %qs також є GENERIC"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "GENERIC %qs на %L не може перезаписати конкретну привʼязку з таким самим імʼям"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Оператор, повʼязаний з типом, на %L не може бути NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "%qs повинен бути процедурою модуля або зовнішньою процедурою з явним інтерфейсом на %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Процедура %qs з PASS(%s) на %L не має аргументу %qs"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "Процедура %qs з PASS на %L повинна мати принаймні один аргумент"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Неполіморфний фіктивний аргумент переданого обʼєкту %qs на %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Аргумент %qs функції %qs з PASS(%s) на %L повинен бути похідним типом %qs"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Аргумент %qs для %qs з PASS(%s) в %L повинен бути типу параметричного похідного типу %qs"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr "Всі параметри типу LEN переданого формального аргументу %qs для %qs на %L повинні бути позначені як ASSUMED."
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Фіктивний аргумент переданого обʼєкту %qs на %L повинен бути скалярним"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Фіктивний аргумент переданого обʼєкту %qs на %L не може бути ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Фіктивний аргумент переданого обʼєкту %qs на %L не може бути POINTER"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "Процедура %qs на %L має ту саму назву, що й компонент %qs"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "Процедура %qs на %L має ту саму назву, що й успадкований компонент %qs"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "Похідний тип %qs, оголошений на %L, повинен бути АБСТРАКТНИМ, оскільки %qs є ВІДКЛАДЕНИМ і не перевизначений"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Компонент комасиву %qs на %L повинен бути виділенням з відкладеною формою"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Компонент %qs на %L з типом TYPE(C_PTR) або TYPE(C_FUNPTR) не може бути комасивом"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "Компонент %qs у %L з компонентом комасиву повинен бути невказівниковим, невиділяемим скаляром"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "Компонент %qs в %L має атрибут CONTIGUOUS, але не є вказівником на масив"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, gcc-internal-format
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Компонент %qs типу BIND(C) в %L повинен мати довжину одиницю"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "Компонент вказівника на процедуру %qs з PASS(%s) в %L не має аргументу %qs"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "Компонент вказівника на процедуру %qs з PASS в %L повинен мати принаймні один аргумент"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Аргумент %qs в %qs з PASS(%s) в %L повинен бути похідним типом %qs"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Аргумент %qs в %qs з PASS(%s) в %L повинен бути скалярним"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "Аргумент %qs в %qs з PASS(%s) в %L не може мати атрибут POINTER"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "Аргумент %qs функції %qs з PASS(%s) на %L не може бути ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "Компонент %qs функції %qs на %L має таке саме імʼя, як успадкована звʼязана з процедурою типу"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "Довжина символів компонента %qs має бути константним виразом специфікації на %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "Вираз довжини символів компонента %qs на %L повинен бути типу INTEGER, знайдено %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "Символьний компонент %qs функції %qs на %L з відкладеною довжиною повинен бути POINTER або ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "компонент %qs є типом PRIVATE і не може бути компонентом %qs, який є PUBLIC на %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Поліморфний компонент %s на %L у типі SEQUENCE або BIND(C) %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "Компонент %s типу SEQUENCE, оголошений на %L, не має атрибуту SEQUENCE"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "Конфліктуючі ініціалізатори в обʼєднанні на %L та %L"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "Оскільки розширюючий тип %qs на %L має компонент coarray, батьківський тип %qs також повинен мати один"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Не розширюваний похідний тип %qs на %L не повинен бути АБСТРАКТНИМ"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr "Параметризований тип %qs не має компонента, що відповідає параметру %qs на %L"
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Загальне імʼя %qs функції %qs на %L збігається з імʼям похідного типу на %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "Похідний тип %qs на %L не був оголошений"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Failed to match clause at %C"
 msgid "Failed to build PDT class component at %L"
 msgstr "Не вдалося знайти відповідний замикання у %C"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "Масив з припущеним розміром %qs у списку імен %qs на %L не дозволяється"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "Обʼєкт масиву NAMELIST %qs з припущеною формою у списку імен %qs в %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "Обʼєкт масиву NAMELIST %qs з незмінною формою у списку імен %qs в %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "Обʼєкт NAMELIST %qs з незмінною довжиною символу у списку імен %qs в %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "Обʼєкт NAMELIST %qs був оголошений як PRIVATE і не може бути членом PUBLIC списку імен %qs в %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "Обʼєкт NAMELIST %qs має використовувані PRIVATE компоненти і не може бути членом списку імен %qs в %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "Обʼєкт NAMELIST %qs має PRIVATE компоненти і не може бути членом PUBLIC списку імен %qs в %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "Атрибут PROCEDURE конфліктує з атрибутом NAMELIST у %qs в %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "Масив параметрів %qs в %L не може бути автоматичним або мати відкладену форму"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "Неявно визначений ПАРАМЕТР %qs у %L не відповідає пізнішому неявному типу"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "Несумісний похідний тип в ПАРАМЕТРІ у %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "Змінна CLASS %qs у %L не може мати атрибут PARAMETER"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "Expecting constant expression near %L"
 msgstr "TILE вимагає сталий вираз на %L"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "Об'єкт %qs на %L має відкладений параметр LEN %qs і вимагає атрибут POINTER або ALLOCATABLE"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr "АВТОМАТИЧНИЙ обʼєкт %qs на %L не повинен мати атрибуту SAVE або бути змінною, оголошеною в головній програмі, модулі або підмодулі (F08/C513)"
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr "Обʼєкт %qs на %L з передбаченими параметрами типу повинен бути фіктивним або вибірником типу SELECT (F08/4.2)"
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr "На жаль, компоненти, які можна виділяти або вказувати, в поліморфних (CLASS) типах комасивів на %L не підтримуються"
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr "%<omp_all_memory%>, оголошений на %L, може використовуватися лише в замиканні OpenMP DEPEND"
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "Атрибут PROTECTED конфліктує з атрибутом EXTERNAL на %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "Атрибут PROCEDURE конфліктує з атрибутом PROTECTED на %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "%qs на %L має атрибут CONTIGUOUS, але не є вказівником на масив або масивом з таємною формою або таємним рангом"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "Неправильна специфікація для масиву з припущеним розміром на %L"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "Масив з припущеним розміром на %L повинен бути фіктивним аргументом"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "Масив з припущеною формою на %L повинен бути фіктивним аргументом"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "Масив з припущеним рангом на %L повинен бути фіктивним аргументом"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr "Масив з припущеним рангом на %L не може мати атрибутів VALUE або CODIMENSION"
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "Символ на %L не є фіктивною змінною"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "%qs на %L не може мати атрибут VALUE, оскільки це не є фіктивним аргументом"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "Фіктивна змінна символьного типу %qs на %L з атрибутом VALUE повинна мати сталу довжину"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "Символьна фіктивна змінна %qs на %L з атрибутом VALUE, сумісна з C, повинна мати довжину одиницю"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "Похідний тип %qs на %L має тип %qs, який не був визначений"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK повинна бути фіктивним аргументом"
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK повинна бути типу TYPE(*) або числового вбудованого типу"
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK не може мати атрибутів ALLOCATABLE, CODIMENSION, POINTER або VALUE"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK не може мати атрибут INTENT(OUT)"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr "Змінна %s на %L з атрибутом NO_ARG_CHECK повинна бути або скаляром, або масивом з передбачуваною розмірністю"
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "Припущений тип змінної %s на %L дозволений лише для фіктивних змінних"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "Змінна %s припущеного типу на %L не може мати атрибути ALLOCATABLE, CODIMENSION, POINTER або VALUE"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "Припущена змінна %s на %L не може мати атрибут INTENT(OUT)"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "Припущена змінна %s на %L не може бути масивом з явною формою"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "Змінна %qs на %L не може бути BIND(C), оскільки вона не є загальним блоком або не оголошена на рівні модуля"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "Змінна BIND(C) %qs на %L повинна мати довжину одиницю"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "ПУБЛІЧНА %s %qs на %L з приватним похідним типом %qs"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "Змінна %s на %L типу LOCK_TYPE або з підкомпонентом типу LOCK_TYPE повинна бути комасивом"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "Змінна %s на %L типу EVENT_TYPE або з підкомпонентою типу EVENT_TYPE повинна бути комасивом"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "Фіктивний аргумент INTENT(OUT) %qs на %L має ASSUMED SIZE і, отже, не може мати значення за замовчуванням"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "Фіктивний аргумент %qs на %L типу LOCK_TYPE не може бути INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "Фіктивний аргумент %qs на %L типу EVENT_TYPE не може бути INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "Результат функції %qs на %L не може бути комасивом або мати комасивну компоненту"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "Змінна %qs на %L типу TYPE(C_PTR) або TYPE(C_FUNPTR) не може бути комасивом"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "Змінна %qs на %L з компонентом комасиву має бути невказівником, неалокаційним скаляром, який не є комасивом"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "Змінна %qs на %L є комасивом і не є ВИДІЛЕНОЮ, ЗБЕРЕЖЕНОЮ або фіктивним аргументом"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape"
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "Комасивна змінна %qs на %L не повинна мати ко-розмірності з відкладеною формою"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Змінна %qs на %L з можливістю виділення памʼяті має мати відкладену форму"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "Змінна %qs на %L має INTENT(OUT) і, отже, не може бути виділеним комасивом або мати компоненти комасиву"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Фіктивна змінна комасиву %qs на %L не дозволена в процедурі BIND(C) %qs"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "ЛОГІЧНИЙ фіктивний аргумент %qs в %L з не-C_Bool видом в процедурі BIND(C) %qs"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "ЛОГІЧНА змінна результату %qs в %L з не-C_Bool видом в процедурі BIND(C) %qs"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Список імен %qs не може бути аргументом підпрограми або функції в %L"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Threadprivate в %L не зберігається"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "Ціль ініціалізації вказівника на %L повинна мати атрибут SAVE"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "variable %q+D with attribute %qs must not have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "змінна %q+D з атрибутом %qs не повинна мати ініціалізатора"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr "Змінна !$OMP DECLARE TARGET %qs на %L не зберігається"
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "Очікується визначений обʼєкт поблизу %L"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "Елемент BLOCK DATA %qs на %L повинен бути в COMMON"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "Масив DATA %qs на %L повинен бути вказаний в попередньому оголошенні"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "Елемент DATA %qs на %L не може мати спільного індексу"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "Елемент DATA %qs на %L є вказівником і, отже, повинен бути повним масивом"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr "Обʼєкт DATA поблизу %L має атрибут вказівника, а відповідне значення DATA не є дійсною початковою ціллю даних"
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "Елемент DATA %qs на %L не може мати атрибут ALLOCATABLE"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Неконстантний розділ масиву у %L в інструкції DATA"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "Інструкція DATA у %L має більше змінних, ніж значень"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Неконстантна довжина символу на %L у операторі DATA"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "початок неявного циклу DO у %L не може бути спрощений до константного значення"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "кінець неявного циклу DO на %L не може бути спрощений до константного значення"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "крок неявного циклу DO на %L не може бути спрощений до сталого значення"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "крок неявного циклу DO на %L не може бути нулем"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "інструкція DATA на %L має більше значень, ніж змінних"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Мітка %d на %L визначена, але не використовується"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "Мітка %d на %L визначена, але не може бути використана"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "Змінна похідного типу %qs на %L повинна мати атрибут SEQUENCE, щоб бути обʼєктом EQUIVALENCE"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "Змінна похідного типу %qs на %L не може мати компоненти ALLOCATABLE, щоб бути обʼєктом EQUIVALENCE"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "Змінна похідного типу %qs на %L зі стандартною ініціалізацією не може бути в EQUIVALENCE змінною в COMMON"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "Змінна похідного типу %qs на %L з компонентами-вказівниками не може бути обʼєктом EQUIVALENCE"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "Помилка синтаксису в операторі EQUIVALENCE на %L"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "Або всі, або жоден з обʼєктів в наборі EQUIVALENCE на %L повинні мати атрибут PROTECTED"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "Елемент блоку COMMON %qs у %L не може бути обʼєктом EQUIVALENCE у чистій процедурі %qs"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Іменована константа %qs на %L не може бути обʼєктом EQUIVALENCE"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "Помилка синтаксису в операторі EQUIVALENCE на %L"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "Масив %qs на %L з неконстантними межами не може бути обʼєктом EQUIVALENCE"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "Компонент структури %qs на %L не може бути обʼєктом EQUIVALENCE"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Підрядок на %L має нульову довжину"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "Самовідсилання в виразі довжини символу для %qs на %L"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "ПУБЛІЧНА функція %qs на %L з ПРИВАТНИМ типом %qs"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY %qs на %L не має ІМПЛІЦИТНОГО типу"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "Процедура користувацького оператора %qs на %L повинна бути ФУНКЦІЄЮ"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "Процедура користувацького оператора %qs на %L не може мати припущену довжину символу"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "Процедура користувача оператора %qs на %L повинна мати принаймні один аргумент"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "Перший аргумент інтерфейсу оператора на %L не може бути необовʼязковим"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "Другий аргумент інтерфейсу оператора на %L не може бути необовʼязковим"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "Інтерфейс оператора на %L повинен мати, як максимум, два аргументи"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "Вкладена процедура %qs на %L PURE-процедури також повинна бути PURE"
@@ -89069,98 +89264,98 @@ msgstr "Неіснуюча директорія включення %qs"
 msgid "%qs is not a directory"
 msgstr "%qs не є директорією"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$ACC на %C починає коментарну лінію, оскільки вона не слідує за пробілом і не є продовжувальною лінією"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP в %C починає коментар, оскільки за ним немає пробілу і це не є продовжувальною лінією"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, fuzzy, gcc-internal-format
 #| msgid "Ignoring '!$omx' vendor-extension sentinel at %C"
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr "Ігнорується позначка розширення виробника '!$omx' на %C"
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Лінія обрізана на %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "Перевищено обмеження %d продовжень у виразі на %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr "Неправильне продовження OpenACC на %C: очікувався !$ACC, отримано !$OMP"
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr "Неправильне продовження OpenMP в %C: очікувалося !$OMP, отримано !$ACC"
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Відсутній %<&%> у продовжуваній символьній константі на %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Некоректний символ табуляції в %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "Недійсний символ 0x%s на %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "%<&%> не дозволено самостійно в рядку %d"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Неправильний символ табуляції в стовпці %d рядка %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "файл %qs був залишений, але не був відкритий"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "Недійсна директива препроцесора"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr "Файл %qs включається рекурсивно"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "Не вдається відкрити файл %qs"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, gcc-internal-format
 msgid "Cannot open included file %qs"
 msgstr "Не вдається відкрити включений файл %qs"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "Не вдається відкрити попередньо включений файл %qs"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "Включений файл %qs не є звичайним файлом"
@@ -89334,218 +89529,218 @@ msgstr "Якщо перший аргумент ATAN2 на %L дорівнює н
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim(): Неправильний тип"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "у gfc_simplify_exp(): Неправильний тип"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor(): Неправильний вид"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "Аргумент IACHAR на %L повинен мати довжину одиницю"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "Аргумент функції IACHAR на %L поза межами діапазону 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "Сума другого і третього аргументів IBITS перевищує розмір бітів на %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr "IBITS: Поганий біт"
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "Аргумент ICHAR на %L повинен мати довжину одиницю"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "Другий аргумент %s є відʼємним на %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "Величина другого аргументу %s перевищує розмір біта на %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "Величина другого аргументу ISHFTC перевищує BIT_SIZE першого аргументу на %C"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "Абсолютне значення SHIFT повинно бути менше або дорівнювати SIZE в %C"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "Аргумент DIM в %L виходить за межі"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "Аргумент LOG в %L не може бути менше або дорівнювати нулю"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "Комплексний аргумент LOG в %L не може бути нулем"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "gfc_simplify_log: неправильний тип"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "Аргумент LOG10 в %L не може бути менше або дорівнювати нулю"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr "simplify_min_max(): неправильний тип в arglist"
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "Аргумент %qs MOD в %L не повинен бути нулем"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_simplify_mod(): неправильні аргументи"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Аргумент %qs функції MODULO на %L не може бути нулем"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr "gfc_simplify_modulo(): Погані аргументи"
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "Результат функції NEAREST на %L є NaN"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "Аргумент NCOPIES вбудованої функції REPEAT на %L є відʼємним"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "Аргумент NCOPIES вбудованої функції REPEAT на %L є занадто великим"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr "Оцінка рядка, довжина якого більша за 2**28, на %L відкладена до часу виконання, очікуйте помилок"
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr "Масив SHAPE для вбудованої функції RESHAPE на %L має відʼємне значення %d для розміру %d"
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr "Форми ORDER на %L та SHAPE на %L відрізняються"
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr "Розміри ORDER на %L та SHAPE на %L відрізняються"
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr "Елемент зі значенням %d в ORDER на %L повинен бути в діапазоні [1, ..., %d] для вбудованої функції RESHAPE неподалік %L"
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr "ORDER на %L не є перестановкою розміру SHAPE на %L"
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "Перетворений масив занадто великий на %C"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "Результат масштабування перевищує його тип на %L"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "Аргумент DIM (%d) для вбудованої функції SIZE на %L поза діапазоном (1:%d)"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "Неправильний тип в gfc_simplify_sign"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "у gfc_simplify_sin(): Неправильний тип"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr "Помилка отримання довжини сталого масиву."
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "Кількість елементів (%d) у конструкторі масиву у %L вимагає збільшення дозволеної верхньої межі %d. Див. параметр %<-fmax-array-constructor%>."
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Спрощення SPREAD для %C ще не реалізовано"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "Аргумент SQRT для %L має відʼємне значення"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "недійсний аргумент SQRT для %L"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "Виходить за межі в IMAGE_INDEX на %L для розмірності %d, SUB має значення %ld, а нижня межа COARRAY - %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "Виходить за межі в IMAGE_INDEX на %L для розмірності %d, SUB має значення %ld, а верхня межа COARRAY - %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "Символ %qs у рядку на %L не може бути перетворений на символьний тип %d"
@@ -89889,75 +90084,75 @@ msgstr "Спільна мітка завершення DO %d на %C"
 msgid "Labeled DO statement at %L"
 msgstr "Позначена інструкція DO в %L"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "Імʼя %qs у %C є неоднозначним посиланням на %qs з модуля %qs"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "Імʼя %qs в %C є неоднозначним посиланням на %qs з поточної одиниці програми"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "Символ %qs в %C вже має асоціацію з хостом"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr "verify_bind_c_derived_type(): Даний символ неочікувано має значення NULL"
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "Похідний тип %qs, оголошений у %L, повинен мати атрибут BIND, щоб бути сумісним з C"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 #| msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "Похідний тип %qs з атрибутом BIND(C) у %L є порожнім і може бути недоступним для супутнього процесора C"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "Похідний тип %qs з атрибутом BIND(C) у %L є порожнім і може бути недоступним для супутнього процесора C"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Компонент %qs у %L не може мати атрибут POINTER, оскільки він є членом похідного типу BIND(C) %qs у %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "Компонент вказівника на процедуру %qs на %L не може бути членом похідного типу BIND(C) %qs на %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "Компонент %qs на %L не може мати атрибут ALLOCATABLE, оскільки він є членом похідного типу BIND(C) %qs на %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "Компонент %qs в похідному типі %qs на %L може бути несумісним з C, навіть якщо похідний тип %qs є BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "Компонент %qs в похідному типі %qs на %L може бути несумісним з C"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "Похідний тип %qs на %L не може мати атрибут SEQUENCE, оскільки він є BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "Символ %qs використовується до того, як він введений на %L"
@@ -89987,30 +90182,36 @@ msgstr "Перекриваються нерівні ініціалізатори
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "Перекриваються нерівні ініціалізатори в EQUIVALENCE на %C"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The structure constructor at %C has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr "Конструктор структури на %C був завершений. Ця функція була видалена за допомогою f08/0011. Використовуйте -std=f2018 або -std=gnu, щоб усунути завершення."
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "Масив %qs у %L є змінною, яка не зводиться до константного виразу"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "Кількість елементів у конструкторі масиву на %L вимагає збільшення дозволеного верхнього обмеження %d. Див. опцію %<-fmax-array-constructor%>"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "Створення тимчасового масиву на %L для аргументу %qs"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "поганий тип виразу під час обходу (%d)"
@@ -90112,114 +90313,114 @@ msgstr "Присвоєння значення, відмінного від 0 а
 msgid "non-constant initialization expression at %L"
 msgstr "Вираз ініціалізації, який не є константою, у %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr "Масив %qs у %L більший за обмеження, встановлене за допомогою %<-fmax-stack-var-size=%>, перенесений зі стеку в статичне сховище. Це робить процедуру небезпечною при рекурсивному виклику або одночасному виклику з кількох потоків. Розгляньте можливість збільшення обмеження %<-fmax-stack-var-size=%> (або використання %<-frecursive%>, що позначає необмежене %<-fmax-stack-var-size%>) - або змініть код для використання масиву типу ALLOCATABLE. Якщо змінна ніколи не використовується одночасно, це попередження можна ігнорувати, і змінну також можна оголосити з атрибутом SAVE."
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "%s на %L не має типу за замовчуванням"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "вбудована змінна, яка не є процедурою"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "Значення повернення функції %qs у %L не встановлено"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "Відкладений параметр типу ще не підтримується"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "обʼява backend для змінної модуля %qs вже існує"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "Невикористовувана ПРИВАТНА змінна модуля %qs, оголошена у %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "Символ %qs у %L має атрибут WEAK, але є фіктивним аргументом"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "Символ %qs у %L має атрибут WEAK, але є локальною змінною"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "Фіктивний аргумент %qs у %L був оголошений з INTENT(OUT), але не був встановлений"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "Аргумент-заглушка похідного типу %qs в %L був оголошений з INTENT(OUT), але не був встановлений і не має значення за замовчуванням"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Не використовуваний аргумент-заглушка %qs в %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "Не використовувана змінна модуля %qs, яка була явно імпортована в %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Не використовувана змінна %qs, оголошена в %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Не використовуваний параметр %qs, оголошений в %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "Не використовуваний параметр %qs, який був явно імпортований в %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Значення повернення %qs функції %qs, оголошеної в %L, не встановлено"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr "Вибачте, !$ACC DECLARE на %L не дозволено в конструкції BLOCK"
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "Builtin not implemented"
 msgid "Unsigned not yet implemented"
 msgstr "Вбудована функція не реалізована"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -90250,12 +90451,12 @@ msgstr "Вибачте, коіндексний доступ до необмеж
 msgid "Unknown intrinsic op"
 msgstr "Невідомий вбудований оператор"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "Невідома функція списку аргументів на %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr "Якщо переналаштування меж вказано на %L, ціль вказівника не повинна бути NULL"
@@ -90271,12 +90472,12 @@ msgstr "Вбудовану функцію %qs (%d) не впізнано"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "Аргумент %<dim%> вбудованої функції %s на %L не є дійсним індексом розміру"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "Вибачте, компонент події похідного типу на %L ще не підтримується"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "Змінна події на %L не повинна бути співіндексованою"
@@ -90301,192 +90502,192 @@ msgstr "Вибачте, поліморфні масиви ще не підтри
 msgid "implicit mapping of assumed size array %qD"
 msgstr "неявне відображення припущеного масиву розміру %qD"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, gcc-internal-format
 msgid "optional class parameter"
 msgstr "необовʼязковий параметр класу"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, gcc-internal-format
 msgid "unhandled expression type"
 msgstr "невідомий тип виразу"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, gcc-internal-format
 msgid "unhandled expression"
 msgstr "невідомий вираз"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr "Клауза %<uses_allocators%> з ознаками та областями пам’яті"
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr "%<!$OMP %s%> в %L вимагає %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr "Всі файли, які можуть звільнити виділену пам'ять такої змінної, повинні бути скомпільовані з %<-fopenmp-allocators%>"
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr "Це включає явне звільнення пам'яті (DEALLOCATE), перевиділення під час внутрішнього присвоювання, INTENT(OUT) для виділених аргументів-заступників та перевиділення виділених компонентів, які були виділені за допомогою OpenMP allocator"
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr "непрямокутна вкладеність циклів з неконстантним кроком для %qs"
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, gcc-internal-format
 msgid "Used here"
 msgstr "Використовується тут"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare(): Поганий код оператора"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, fuzzy, gcc-internal-format
 #| msgid "The base name for 'declare variant' must be specified at %L "
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "Базове імʼя для 'declare variant' повинно бути вказано на %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "Базове імʼя на %L не відповідає імені поточної процедури"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "Базове імʼя на %L не повинно бути іменем входу"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "Базове імʼя на %L не повинно бути загальним імʼям"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "Базове імʼя на %L не повинно бути вказівником на процедуру"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "Базова процедура на %L повинна мати явний інтерфейс"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot find symbol %qs"
 msgid "Cannot find symbol %qs at %L"
 msgstr "Не вдалося знайти символ %qs"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "варіант %qs на %L не є функцією або підпрограмою"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "variant %qs at %L is not a function or subroutine"
 msgid "variant %qs at %L is the same as base function"
 msgstr "варіант %qs на %L не є функцією або підпрограмою"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, gcc-internal-format
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "варіант %qs та база %qs на %L мають несумісні типи: %s"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "Очікується список аргументів на %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "attribute %qs positional argument %i value %wi exceeds number of function arguments %u"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "атрибут %qs позиційний аргумент %i має значення %wi, що перевищує кількість аргументів функції %u"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Upper cobound is less than lower cobound at %L"
 msgid "Upper argument index smaller than lower one at %L"
 msgstr "Верхня межа менша за нижню межу на %L"
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "Альтернативний повернення на %L без * фіктивного аргументу"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "Аргумент %qs функції-оператора %qs на %L повинен бути скалярним"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "Аргумент %qs елементарної процедури на %L не може мати атрибуту ALLOCATABLE"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "%qs clause at %L specified more than once"
 msgid "%qs at %L is specified more than once"
 msgstr "Замикання %qs в %L вказане більше одного разу"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "%<-pipe%> not supported"
 msgid "%<need_device_addr%> not yet supported"
@@ -90827,7 +91028,7 @@ msgstr "закрити: %s"
 msgid "two or more sections for %s"
 msgstr "два або більше розділи для %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr "мінімальний розмір розділу не може бути більшим за максимальний розмір розділу"
@@ -91153,32 +91354,32 @@ msgstr "тип масиву повинен бути ініціалізовани
 msgid "array element value must be the same type as its declaration"
 msgstr "значення елемента масиву повинно бути того ж типу, що й його декларація"
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr "нижня межа піддіапазону переповнена"
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr "верхня межа піддіапазону переповнилася"
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "запитане вирівнювання не є константою"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "вимагане вирівнювання не є степенем числа 2"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "вимагане вирівнювання занадто велике"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "вирівнювання не може бути вказане для %qD"
@@ -93700,10 +93901,6 @@ msgstr "Ти намагаєшся зламати %s? Як ти смієш?"
 #~ msgid "you should use the %<-%s%> option"
 #~ msgstr "ви повинні використовувати опцію %<-%s%>"
 
-#, gcc-internal-format
-#~ msgid "lambda-expression in template parameter type"
-#~ msgstr "Лямбда-вираз в типі параметра шаблону"
-
 #, gcc-internal-format
 #~ msgid "preconditions cannot be statements"
 #~ msgstr "Передумови не можуть бути операторами"
--- a/src/gcc/po/vi.po
+++ b/src/gcc/po/vi.po
@@ -9,7 +9,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 7.1-b20170101\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2017-01-08 08:33+0700\n"
 "Last-Translator: Trần Ngọc Quân <vnwildman@gmail.com>\n"
 "Language-Team: Vietnamese <translation-team-vi@lists.sourceforge.net>\n"
@@ -1322,12 +1322,12 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "Hiểu mức MIPS ISA (để dùng với tùy chọn -mips):"
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr ""
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers."
 msgid "Initialize ptx registers."
@@ -2157,13 +2157,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 #| msgid "Valid arguments to -mfloat-gprs=:"
@@ -2638,7 +2638,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "Coi là CPU đích được cấu hình về cuối lớn."
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, no-c-format
 msgid "Assume target CPU is configured as little endian."
 msgstr "Coi là CPU đích được cấu hình về cuối nhỏ."
@@ -2721,7 +2721,7 @@ msgstr "Sử dụng chương trình con cho đoạn mở/đóng hàm."
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, no-c-format
 msgid "Specify the code model."
@@ -2761,7 +2761,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, no-c-format
 msgid "Omit the frame pointer in leaf functions."
 msgstr "Bỏ qua con trỏ khung trong hàm lá."
@@ -2875,7 +2875,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -2921,7 +2921,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5272,7 +5272,7 @@ msgstr "Hỗ trợ các hàm dựng sẵn và chức năng tạo ra mã loại R
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5646,7 +5646,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "Giá cần coi đối với một câu lệnh nhánh."
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -5967,219 +5967,224 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer."
 msgid "The register used to access the thread pointer:"
 msgstr "Ghi rõ cách truy cập đến con trỏ tuyến trình."
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "Chỉ định lược đồ lưu tuyến cục bộ."
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, no-c-format
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "Ghi rõ kích cỡ bit của hiệu số TLS trực tiếp. giá trị hợp lệ là 12, 24, 32, 48."
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "-march=ARCH\tUse features of architecture ARCH."
 msgid "Use features of architecture ARCH."
 msgstr "-mcpu=KTrúc\tSử dụng các tính năng của Ktrúc đã cho."
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "-mcpu=CPU\tUse features of and optimize for CPU."
 msgid "Use features of and optimize for CPU."
 msgstr "-mcpu=CPU\tDùng các tính năng của và tối ưu hóa cho CPU."
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, fuzzy, no-c-format
 #| msgid "-mtune=CPU\tOptimize for CPU."
 msgid "Optimize for CPU."
 msgstr "-mtune=BXL\tTối ưu hóa kết xuất cho bộ xử lý này."
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "-mabi=ABI\tGenerate code that conforms to the specified ABI."
 msgid "Generate code that conforms to the specified ABI."
 msgstr "-mabi=ABI\tTạo ra mã phù hợp với ABI đưa ra."
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "Không hiểu AArch64 ABIs (để dùng với tùy chọn -mabi=):"
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, fuzzy, no-c-format
 #| msgid "Known address mode (for use with the -maddress-mode= option):"
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "Không hiểu mô hình địa chỉ (để dùng với tùy chọn -maddress-mode=):"
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate code for built-in atomic operations."
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "Tạo ra mã cho các thao tác atomic dựng sẵn."
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "%qs is deprecated"
 msgid "This option is deprecated."
@@ -11634,7 +11639,7 @@ msgstr "Sử dụng câu lệnh dấu chấm động thập phân bằng phần
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -18737,91 +18742,91 @@ msgstr "Làm cho hợp với chuẩn ISO 2014 C++."
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr ""
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 #| msgid "argument 1 must be a map"
 msgid "argument must be passed by copying"
 msgstr "đối số 1 phải là ánh xạ"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 msgid "callee returns twice"
 msgstr ""
 
-#: calls.cc:2588
+#: calls.cc:2589
 msgid "callee does not return"
 msgstr ""
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "biến %qD có kiểu hàm"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "cần hàm"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "different number of parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "khác số lượng đối số"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s không hỗ trợ split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 #| msgid "value argument"
 msgid "variable size arguments"
 msgstr "đối số giá trị"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "passing too large argument on stack"
 msgid "hidden string length argument passed on stack"
 msgstr "chuyển đối số quá lớn cho ngăn xếp"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "static assertion failed"
 msgid "tail call production failed"
@@ -18940,12 +18945,12 @@ msgstr "toán hạng “%%l” không phải là một nhãn"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "sai sử dụng hằng số dấu chấm động"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -20322,13 +20327,13 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "đây là lệnh:"
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 #| msgid "invalid operand address"
 msgid "unable to reload address in "
 msgstr "địa chỉ toán hạng không hợp lệ"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "không thể tạo ra việc nạp lại cho:"
 
@@ -20558,7 +20563,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC tìm ra: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<nặc-danh>"
@@ -20945,20 +20950,20 @@ msgstr "Không hỗ trợ toán hạng cho mã “%c”"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "toán hạng không hợp lệ đối với “%%%c”"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 #| msgid "invalid constant"
 msgid "invalid vector constant"
@@ -21007,87 +21012,87 @@ msgstr "tiền tố toán hạng không hợp lệ “%%%c”"
 msgid "invalid address mode"
 msgstr "sai đặt chế độ đặt địa chỉ"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "sai chuyển đổi từ %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "sai chuyển đổi sang %<__fpreg%>"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 #| msgid "no pre-increment operator for type"
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "không có toán tử tiền gia cho loại"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 #| msgid "no pre-decrement operator for type"
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "không có toán tử giảm gia cho loại"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "no post-increment operator for type"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "không có toán tử hậu gia cho loại"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 #| msgid "no post-decrement operator for type"
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "không có toán tử hậu giảm cho loại"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 msgid "negation operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 #| msgid "-fstack-limit- options are not supported on this cpu"
 msgid "subscript operation not supported on svbool_t"
 msgstr "-fstack-limit- các tùy chọn không được hỗ trợ trên cpu này"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands in binary operation"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "toán hạng không hợp lệ trong phép toán nhị phân"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -21104,13 +21109,13 @@ msgid "invalid %%r value"
 msgstr "giá trị %%r sai"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "giá trị %%R sai"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "giá trị %%N sai"
@@ -21125,7 +21130,7 @@ msgstr "giá trị %%P sai"
 msgid "invalid %%h value"
 msgstr "giá trị %%h sai"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "giá trị %%L sai"
@@ -21140,7 +21145,7 @@ msgstr "giá trị %%m sai"
 msgid "invalid %%M value"
 msgstr "giá trị %%M sai"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "giá trị %%U sai"
@@ -21497,7 +21502,7 @@ msgstr "gặp toán hạng bất thường"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -21746,141 +21751,141 @@ msgstr "hằng không hợp lệ"
 msgid "Expected register or constant integer."
 msgstr "cần giao diện hay con trỏ đến giao diện"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "đặt sai UNSPEC như là toán hạng"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "dùng %<restrict%> không hợp lệ"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, c-format
 msgid "invalid use of asm flag output"
 msgstr "sử dụng kết xuất cờ asm sai"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "sai kích cỡ toán hạng cho mã toán hạng “O”"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "sai kích cỡ toán hạng cho mã toán hạng “z”"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 #| msgid "invalid operand type used with operand code 'Z'"
 msgid "invalid operand type used with operand code '%c'"
 msgstr "sử dụng loại toán hạng không hợp lệ với mã toán hạng “Z”"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 #| msgid "invalid operand size for operand code 'O'"
 msgid "invalid operand size for operand code '%c'"
 msgstr "sai kích cỡ toán hạng cho mã toán hạng “O”"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “Y”"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “D”"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng không hợp lệ “%c”"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr ""
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “Y”"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “Y”"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “Y”"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “Y”"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "toán hạng không phải là một mã điều kiện, mã toán hạng sai “Y”"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "mã toán hạng sai “%c”"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "sai đặt ràng buộc cho toán hạng"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "invalid zero extract"
 msgid "invalid vector immediate"
 msgstr "trích số không không hợp lệ"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "không rõ chế độ lệnh"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "sai chuyển đổi từ %<__fpreg%>"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "sai chuyển đổi từ %<__fpreg%>"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to %<__fpreg%>"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "sai chuyển đổi sang %<__fpreg%>"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -21959,9 +21964,9 @@ msgstr "“%%%c” không phải là một tiền tố toán hạng đúng"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "sai sử dụng “%%%c”"
@@ -22026,7 +22031,7 @@ msgid "insn contains an invalid address !"
 msgstr "insn chứa một địa chỉ sai !"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "địa chỉ sai"
 
@@ -22102,7 +22107,7 @@ msgstr "toán hạng không hợp lệ"
 msgid "invalid %%H value"
 msgstr "giá trị %%H sai"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "giá trị %%d sai"
@@ -22161,36 +22166,36 @@ msgstr "Hóa hợp không được hỗ trợ: %s"
 msgid "unsupported memory expression:"
 msgstr "không hỗ trợ chuyển đổi dấu chấm cố định"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 #| msgid "invalid %%r operand"
 msgid "invalid vector operand"
 msgstr "sai toán hạng %%r"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, fuzzy, c-format
 #| msgid "'h' applied to non-register operand"
 msgid "modifier 'N' require register operand"
 msgstr "“h” áp dụng cho toán không nguyên"
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "sai đặt toán hạng cho sự sửa đổi “b”"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, fuzzy, c-format
 #| msgid "'h' applied to non-register operand"
 msgid "modifier 'H' require register operand"
 msgstr "“h” áp dụng cho toán không nguyên"
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, c-format
 msgid "modifier 'H' is for integer registers only"
 msgstr ""
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, c-format
 msgid "modifier 'H' cannot be applied to R31"
 msgstr ""
@@ -22260,7 +22265,7 @@ msgstr "Di chuyển 128-bit sai"
 msgid "invalid %%A value"
 msgstr "giá trị %%J sai"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "giá trị %%D sai"
@@ -22300,7 +22305,7 @@ msgstr "mã %%J sai"
 msgid "invalid %%k value"
 msgstr "giá trị %%k sai"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "giá trị %%K sai"
@@ -22331,18 +22336,18 @@ msgstr "giá trị %%T sai"
 msgid "invalid %%u value"
 msgstr "giá trị %%u sai"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "giá trị %%v sai"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%J value"
 msgid "invalid %%V value"
 msgstr "giá trị %%J sai"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "giá trị %%x sai"
@@ -22565,28 +22570,28 @@ msgstr "toán hạng %%s sai"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "hằng số dấu chấm động không phải là một giá trị trực tiếp hợp lệ"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "toán hạng “B” không phải là một hằng số"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "toán hạng “B” có nhiều bit được đặt"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "toán hạng “o” không phải là một hằng số"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "toán hạng “B” không phải là một hằng số"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand: gặp mã không rõ"
@@ -22644,24 +22649,24 @@ msgstr "địa chỉ toán hạng không hợp lệ (4)"
 msgid "Unable to load DLL."
 msgstr "Tạo ra mã cho một DLL."
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "sai kiểm tra"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "bộ lọc sai"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "giá trị %%t/%%b sai"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "địa chỉ không chứa thanh ghi"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "hiệu số địa chỉ không phải là một hằng số"
 
@@ -22695,7 +22700,7 @@ msgstr "{nặc danh}"
 msgid "aka"
 msgstr "được biết là"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({nặc danh})"
 
@@ -22720,8 +22725,8 @@ msgstr "({nặc danh})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "cần %<;%>"
@@ -22750,7 +22755,7 @@ msgstr "cần %<,%> hoặc %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "cần %<)%>"
@@ -22758,7 +22763,7 @@ msgstr "cần %<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "cần %<]%>"
@@ -22778,13 +22783,13 @@ msgstr "cần %<;%>, %<,%> hoặc %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "cần %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "cần %<[%>"
@@ -22793,7 +22798,7 @@ msgstr "cần %<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -22810,13 +22815,13 @@ msgstr "cần %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "cần %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "cần %<while%>"
@@ -22826,7 +22831,7 @@ msgstr "cần %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "cần %<,%>"
@@ -22836,18 +22841,18 @@ msgid "expected %<.%>"
 msgstr "cần %<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "cần %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "cần %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "cần %<,%> hoặc %<)%>"
@@ -22857,14 +22862,14 @@ msgstr "cần %<,%> hoặc %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "cần %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<)%> or %<,%>"
@@ -22872,32 +22877,32 @@ msgstr "cần %<,%> hoặc %<)%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "cần %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<else%>"
 msgstr "cần %<delete%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "cần %<#pragma omp section%> hoặc %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(nặc danh)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "cần %<<%>"
@@ -22927,7 +22932,7 @@ msgstr "ứng cử là:"
 msgid "  after user-defined conversion:"
 msgstr "Bật câu lệnh được người dùng xác định."
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "ứng cử là:"
@@ -23027,7 +23032,7 @@ msgstr "<lỗi tham số mẫu>"
 msgid "<statement>"
 msgstr "<lời khai báo>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<không rõ>"
@@ -23055,304 +23060,347 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<lỗi biểu thức>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<không rõ toán hạng>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "Theo phạm vi toàn cục:"
 
-#: cp/reflect.cc:565
+#: cp/reflect.cc:408
 #, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "thanh ghi tổng không phải là số nguyên hằng"
+#| msgid "template constraint failure"
+msgid "reflect_constant_array failed"
+msgstr "ràng buộc mẫu gặp lỗi nghiêm trọng"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 #| msgid "template constraint failure"
 msgid "reflect_constant failed"
 msgstr "ràng buộc mẫu gặp lỗi nghiêm trọng"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "thanh ghi tổng không phải là số nguyên hằng"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 #| msgid "  member function type %qT is not a valid template argument"
 msgid "reflection does not have template arguments"
 msgstr "  kiểu hàm thành viên %qT không phải là một đối số mẫu hợp lệ"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a function or function type"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 #| msgid "%<@throw%> argument is not an object"
 msgid "operators argument is not a valid operator"
 msgstr "%<@throw%> đối số không phải là một đối tượng"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%qE không có kiểu lớp"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr ""
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 #| msgid "return with value in function with no return type"
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "trả về giá trị trong một hàm mà có kiểu không trả về"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr ""
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment."
 msgid "reflection not suitable for alignment_of"
 msgstr "Đừng điều chỉnh sự xếp hàng dữ liệu có thể ghi được."
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 #| msgid "assignment of function %qD"
 msgid "alignment_of on function type"
 msgstr "gán của hàm %qD"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 #| msgid "expected function name"
 msgid "reflect_function failed"
 msgstr "cần tên hàm"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr ""
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 #| msgid "expected end of line"
 msgid "unexpected value of value member"
 msgstr "cần kết thúc dòng"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 #| msgid "expected integer or boolean type"
 msgid "reflection represents non-integral or bool type"
 msgstr "cần số nguyên hoặc lôgíc"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 #| msgid "invalid argument of %qE attribute"
 msgid "invalid argument to can_substitute"
 msgstr "đối số của thuộc tính %qE không hợp lệ"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 #| msgid "target is not pointer or reference"
 msgid "type is not object or reference type"
 msgstr "đích không phải là một hàm trỏ hoặc một tham chiếu"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%qE argument not an identifier"
 msgid "name is not a valid identifier"
 msgstr "%qE đối số không phải là một định danh"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr ""
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "field width specifier"
 msgid "both alignment and bit_width specified"
 msgstr "chỉ định độ rộng trường"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "chỉ định độ rộng trường"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "số lượng dịch trái là số âm"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+msgid "name unspecified and type is const"
+msgstr ""
+
+#: cp/reflect.cc:6030
+msgid "name unspecified and type is volatile"
+msgstr ""
+
+#: cp/reflect.cc:6038
 #, fuzzy
 msgid "alignment is not power of two"
 msgstr "-falign-labels=%d không được hỗ trợ"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 msgid "alignment is negative"
 msgstr "Đối số của hàm %s tại %L là âm"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr ""
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "%qE does not have pointer or array type"
+msgid "reflection does not have non-array object type"
+msgstr "%qE không có con trỏ hay kiểu mảng"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+msgid "current scope does not represent a function"
+msgstr "%qD không phải là hàm thành viên mẫu"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "a concept cannot be a member function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "cấu tử không thể là hàm thành viên tĩnh"
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr ""
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 #| msgid "%qE is not a class or namespace"
 msgid "neither complete class type nor namespace"
 msgstr "%qE không phải một lớp hay namespace"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 #| msgid "source is of incomplete class type"
 msgid "not a complete class type"
 msgstr "nguồn có loại lớp không hoàn toàn"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 #| msgid "a template cannot be defaulted"
 msgid "value cannot be extracted"
@@ -23398,52 +23446,52 @@ msgstr "việc chuyển đổi cũng bỏ trình trạng bất biến"
 msgid "source type is not polymorphic"
 msgstr "nguồn không có loại nhiều dạng"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "các ứng cử là:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "đối số có loại sai đối với dấu trừ nguyên phân"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "đối số có loại sai đối với dấu cộng nguyên phân"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "đối số có loại sai đối với phần bù bit"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "đối số có loại sai đối với bộ tuyệt đối"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "đối số có loại sai đối với phần chia"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "trong đối số tới bộ nguyên phân !"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "không có toán tử tiền gia cho loại"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "không có toán tử hậu gia cho loại"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "không có toán tử giảm gia cho loại"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "không có toán tử hậu giảm cho loại"
 
@@ -23461,67 +23509,67 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "Dòng bị cắt cụt tại %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "đối số “a%d” và “a%d” cho “%s” thực chất"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "đối số “%s” và “%s” cho %s thực chất"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "đối số “%s” và “%s” cho “%s” thực chất"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "%qD is not a pointer variable"
 msgid "NULL() is not interoperable"
 msgstr "%qD không phải là một biến trỏ"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "hằng không hợp lệ"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "End expression in DO loop"
 msgid "Expression is polymorphic"
 msgstr "Biểu thức kết thúc trong vòng lặp DO (làm)"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 msgid "Expression is a noninteroperable derived type"
 msgstr ""
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected argument"
 msgid "Procedure unexpected as argument"
 msgstr "gặp tham số thừa"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 msgid "Type shall have a character length of 1"
 msgstr ""
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 msgid "Coarrays are not interoperable"
 msgstr ""
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 msgid "Assumed-size arrays are not interoperable"
 msgstr ""
 
@@ -23597,7 +23645,7 @@ msgstr "Đặc tính đã bị xóa bỏ:"
 msgid "Unsigned:"
 msgstr "<không tên có ký:"
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "sự gán mảng"
 
@@ -23606,17 +23654,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -23802,11 +23850,11 @@ msgstr "IF (nếu) loại khối"
 msgid "implied END DO"
 msgstr "ngụ ý END DO (kết thúc làm)"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "sự gán"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "sự gán hàm trỏ"
 
@@ -23814,125 +23862,125 @@ msgstr "sự gán hàm trỏ"
 msgid "simple IF"
 msgstr "IF (nếu) đơn giản"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "thủ tục loại yếu tố"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 msgid "allocatable argument"
 msgstr "đối số phân bổ được"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 msgid "asynchronous argument"
 msgstr "đối số không đồng bộ"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "đối số tùy chọn"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 msgid "pointer argument"
 msgstr "đối số con trỏ"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 msgid "target argument"
 msgstr "đối số đích"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 msgid "value argument"
 msgstr "đối số giá trị"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 msgid "volatile argument"
 msgstr "đối số hay thay đổi"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 msgid "assumed-shape argument"
 msgstr "đối số assumed-shape"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 msgid "assumed-rank argument"
 msgstr "đối số assumed-rank"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 msgid "coarray argument"
 msgstr "đối số coarray"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr "đối số kiểu được dẫn suất tham số hóa"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 msgid "polymorphic argument"
 msgstr "đối số polymorphic"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "thuộc tính NO_ARG_CHECK"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 msgid "assumed-type argument"
 msgstr "đối số assumed-type"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "kết quả mảng"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 msgid "pointer or allocatable result"
 msgstr "con trỏ hoặc kết quả cấp phát được"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 msgid "result with non-constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 msgid "bind(c) procedure"
 msgstr "thủ tục bind(c)"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "Biến vòng lặp"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 msgid "iterator variable"
 msgstr "biến iterator"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "Biểu thức bắt đầu trong vòng lặp DO (làm)"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "Biểu thức kết thúc trong vòng lặp DO (làm)"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "Biểu thức bước trong vòng lặp DO (làm)"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 msgid "DEALLOCATE object"
 msgstr "đối tượng DEALLOCATE"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 msgid "ALLOCATE object"
 msgstr "đối tượng ALLOCATE"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 msgid "STAT variable"
 msgstr "biến STAT"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 msgid "ERRMSG variable"
 msgstr "Biến ERRMSG"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 msgid "item in READ"
 msgstr "mục tin trong READ"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 msgid "ACQUIRED_LOCK variable"
 msgstr "biến ACQUIRED_LOCK"
 
@@ -23941,31 +23989,31 @@ msgstr "biến ACQUIRED_LOCK"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "Bộ dựng mảng chứa các chiều dài KÝ_TỰ khác nhau (%ld/%ld)"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr ""
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Chiều dài chuỗi thật không tương ứng với điều khai báo cho đối số giả “%s” (%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "Chiều dài chuỗi thật vẫn nhỏ hơn điều khai báo cho đối số giả “%s” (%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr ""
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr "Gán vô hướng cho mảng chưa cấp phát"
 
@@ -24030,27 +24078,27 @@ msgstr "Tham số NCOPIES của REPEAT (lặp lại) hạn chế là âm (giá t
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "Điều thực chất REPEAT (lặp lại) có đối số NCOPIES (số các bản sao) quá lớn"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -24150,7 +24198,7 @@ msgid "expected boolean type"
 msgstr "cần kiểu boolean"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "Mong đợi một số nguyên"
@@ -24215,7 +24263,7 @@ msgstr "không đủ đối số"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "quá nhiều đối số"
@@ -24628,7 +24676,7 @@ msgstr ""
 msgid "target OS does not support unaligned accesses"
 msgstr "CPU đích không hỗ trợ truy cập chưa cân chỉnh"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr ""
@@ -24893,13 +24941,13 @@ msgstr "Không nhận ra tùy chọn: \"%qs\""
 msgid "Global declarative %s for %s"
 msgstr "khai báo toàn cục %q#D"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -25073,13 +25121,13 @@ msgstr "%qs đã lỗi thời; hãy dùng -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs đã lỗi thời; hãy dùng -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown autovec preference %qs"
 msgstr "không hiểu hàm đặc tả %qs"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -25544,8 +25592,8 @@ msgstr "thuộc tính %s của %qs xung đột với thuộc tính %s tại %L"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, gcc-internal-format
 msgid "previous declaration here"
 msgstr "khai báo trước ở đây"
@@ -25562,7 +25610,7 @@ msgstr ""
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr ""
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr ""
@@ -25573,7 +25621,7 @@ msgstr ""
 msgid "expected %i or more, found %i"
 msgstr "cần %<(%> hoặc xuống dòng"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<,%>"
 msgid "expected %i, found %i"
@@ -25657,12 +25705,12 @@ msgstr ""
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -25780,138 +25828,138 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, gcc-internal-format
 msgid "corresponding call"
 msgstr ""
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, gcc-internal-format
 msgid "corresponding source location"
 msgstr ""
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, gcc-internal-format
 msgid "location of the second call"
 msgstr ""
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of functions"
 msgid "location is after end of function"
 msgstr "tạo mảng hàm"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "Không cần THẺ."
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot open profile file %s."
 msgid "cannot open profile file %s"
 msgstr "Không thể mở tập tin hồ sơ %s"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "quá nhiều đối số cho cho phương thức %qE"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot read string table from %s."
 msgid "cannot read summary information from %s"
 msgstr "Không thể đọc bảng chuỗi từ %s."
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot read string table from %s."
 msgid "cannot read string table from %s"
 msgstr "Không thể đọc bảng chuỗi từ %s."
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Cannot read function profile from %s."
 msgid "cannot read function profile from %s"
 msgstr "không thể đọc hồ sơ hàm từ %s."
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot read LTO mode table from %s"
 msgid "cannot read module profile from %s"
@@ -25922,7 +25970,7 @@ msgstr "không thể đọc chế độ LTO từ %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr ""
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "%qE declared here"
@@ -26033,7 +26081,7 @@ msgstr "đối số hằng nằm ngoài phạm vi cho %qs"
 msgid "illegal argument 0 to %qs"
 msgstr "thiếu đối số đối cho %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -26111,12 +26159,12 @@ msgstr "đối số %qd không phải hằng số"
 msgid "cannot tail-call: %s"
 msgstr "[không tìm thấy %s]"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "cú gọi hàm có giá trị tập hợp"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "chuyển đối số quá lớn cho ngăn xếp"
@@ -26771,348 +26819,348 @@ msgstr ""
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, gcc-internal-format
 msgid "caller edge count invalid"
 msgstr ""
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing counts for called function %s/%i"
 msgid "missing direct call for speculation %i"
 msgstr "Thiếu số lượng cho cú gọi hàm %s/%i"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing barrier after block %i"
 msgid "missing ref for speculation %i"
 msgstr "thiếu chắn sau khối %i"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr ""
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr ""
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "inline clone count is not compatible"
 msgstr "yếu tố khởi tạo không phải hằng số"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "tp_first_run must be non-negative"
 msgstr "%<priority%> giá trị phải dương"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "ký hiệu cục bộ phải được định nghĩa"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr ""
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr ""
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr ""
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr ""
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "target specific option mismatch"
 msgid "semantic interposition mismatch"
 msgstr "tùy chọn đặc trưng cho đích vẫn không tương ứng"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr ""
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "edge count is not compatible with function count"
 msgstr "-mnop-mcount không tương thích với đích này"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "-mnop-mcount không tương thích với đích này"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr ""
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "inlined_to con trỏ là sai"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "nhiều bộ gọi chung dòng"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr ""
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr ""
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr ""
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "con trỏ inlined_to chỉ đến chính nó"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "cgraph_node có clone_of sai"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "cgraph_node có danh sách nhân bản sai"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr ""
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr ""
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr ""
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "Bí danh có cạnh gọi"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "Bí danh có tham chiếu non-alias"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr ""
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr ""
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr ""
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr ""
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "call_stmt được chia sẻ:"
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr ""
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr ""
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr ""
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, gcc-internal-format
 msgid "reference to dead statement"
 msgstr ""
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr ""
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr ""
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node gặp lỗi"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: section %s is missing"
 msgid "%s: section %s.%d is missing"
@@ -27920,17 +27968,17 @@ msgstr ""
 msgid "impossible constraint in %<asm%>"
 msgstr ""
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr ""
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "hàm trả về một tập hợp"
@@ -28657,7 +28705,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr ""
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -28699,7 +28747,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%qD defined here"
@@ -28720,24 +28768,24 @@ msgstr ""
 msgid "function may return address of local variable"
 msgstr "hàm có thể trả về địa chỉ của biến cục bộ"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "hàm trả về địa chỉ của biến cục bộ"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -29618,7 +29666,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 #| msgid "required from %q#D\n"
 msgid "returned from %qD"
@@ -29691,219 +29739,219 @@ msgstr "hàm chung dòng %q+D được khai báo yếu"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model for %<__atomic_load%>"
 msgid "invalid memory model %qs for %qD"
 msgstr "mô hình bộ nhớ không hợp lệ cho %<__atomic_load%>"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "invalid memory model for %<__atomic_load%>"
 msgid "invalid memory model %wi for %qD"
 msgstr "mô hình bộ nhớ không hợp lệ cho %<__atomic_load%>"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 #| msgid "valid arguments to %qs are: %s"
 msgid "valid models are %e"
 msgstr "đối số hợp lệ cho cho %qs là: %s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 #| msgid "invalid failure memory model for %<__atomic_compare_exchange%>"
 msgid "invalid failure memory model %qs for %qD"
 msgstr "mô hình bộ nhớ không hợp lệ cho %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "Đối số của hàm %s tại %L là âm"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "referencing argument %u of type %qT"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "hàm chung dòng %q+D được khai báo yếu"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "không thể tắt hàm dựng sẵn %qs"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "in a call with type %qT"
 msgstr "  trong gọi đến %qD"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "assigned here"
 msgstr "struct được định nghĩa ở đây"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD không phải là hàm thành viên mẫu"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "pointer %qE may be used after %qD"
 msgstr "Con trỏ Cray %qs trong mệnh đề %s tại %L"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "pointer %qE used after %qD"
 msgstr "Con trỏ Cray %qs trong mệnh đề %s tại %L"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, gcc-internal-format
 msgid "pointer may be used after %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %qD"
 msgid "pointer used after %qD"
 msgstr "tham số chưa dùng %q+D"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 msgid "call to %qD here"
 msgstr "%qD được khai báo ở đây"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "chế độ con trỏ %qs không hợp lệ"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, gcc-internal-format
 msgid "dangling pointer to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "chế độ con trỏ %qs không hợp lệ"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "unnamed class defined here"
 msgid "unnamed temporary defined here"
 msgstr "union được định nghĩa ở đây"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "gọi hàm nội bộ"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "gọi hàm nội bộ"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  trong gọi đến %qD"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %qD returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -30718,344 +30766,344 @@ msgstr "thẻ bài %u có y-location == %u"
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "dùng %<auto%> không hợp lệ"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "phương thức ảo %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "định nghĩa trước ở đây"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT should match type %qT"
 msgid "type name %qs should match type name %qs"
 msgstr "kiểu %qT nên khớp kiểu %qT"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "kiểu không tương thích được định nghĩa ở đây"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, gcc-internal-format
 msgid "array types have different bounds"
 msgstr ""
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "không khớp kiểu trong tham số %i"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr ""
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, fuzzy, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "định nghĩa trước ở đây"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "kiểu %qT nên khớp kiểu %qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here, later in the translation unit"
 msgid "fields have different layout in another translation unit"
 msgstr "%+D đã khai báo weakref sau khi được dùng"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr ""
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "định nghĩa trước ở đây"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here, later in the translation unit"
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%+D đã khai báo weakref sau khi được dùng"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr ""
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr ""
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here, later in the translation unit"
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%+D đã khai báo weakref sau khi được dùng"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -31076,7 +31124,7 @@ msgstr ""
 msgid "IPA modref summary is missing in input file"
 msgstr ""
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function in gimple call"
 msgid "invalid jump function in LTO stream"
@@ -31321,12 +31369,12 @@ msgstr "số tối đa các tham số trong một SCoP."
 msgid "unable to find a register to spill"
 msgstr ""
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr ""
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Maximum number of times that an insn could be scheduled."
 msgid "maximum number of generated reload insns per insn achieved (%d)"
@@ -31715,7 +31763,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -33184,22 +33232,22 @@ msgstr ""
 msgid "output operand %d must use %<&%> constraint"
 msgstr ""
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr ""
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr ""
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr ""
@@ -34179,178 +34227,178 @@ msgstr ""
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr ""
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr ""
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 #| msgid "non-scalar type"
 msgid "non-scalar %qs"
 msgstr "kiểu không-scalar"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid position or size operand to %qs"
 msgstr "sai đặt ràng buộc cho toán hạng"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 #| msgid "shift of non-integer operand"
 msgid "%qs of non-mode-precision operand"
 msgstr "dịch của toán hạng không nguyên"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in array reference"
 msgid "type mismatch in %qs reference"
 msgstr "kiểu không khớp trong tham chiếu mảng"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr ""
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr ""
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "sai đặt toán hạng tới %%R"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in parameter %i"
 msgid "type mismatch in %qs"
 msgstr "không khớp kiểu trong tham số %i"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 #| msgid "invalid shift operand"
 msgid "invalid %qs offset operator"
 msgstr "sai đặt toán hạng dời"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%s operand"
 msgid "invalid address operand in %qs"
 msgstr "toán hạng %%s sai"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%t operand '"
 msgid "invalid offset operand in %qs"
 msgstr "sai toán hạng %%t “"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "dùng %qD không hợp lệ"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "IF (nếu) đơn giản"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, gcc-internal-format
 msgid "%qs as base where non-register is required"
 msgstr ""
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr ""
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr ""
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr ""
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "hàm không hợp lệ trong cú gọi gimple"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr ""
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr ""
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr ""
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr ""
@@ -34361,631 +34409,631 @@ msgstr ""
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "%<__builtin_next_arg%> được gọi mà không có đối số"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "đối số không hợp lệ cho cú gọi hàm gimple"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr ""
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr ""
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr ""
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr ""
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr ""
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr ""
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "toán hạng không hợp lệ trong phép toán một ngôi"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid vector types in nop conversion"
 msgstr "các kiểu không hợp lệ trong chuyển đổi nop"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "các kiểu không hợp lệ trong chuyển đổi nop"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr ""
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr ""
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid types in conversion to floating-point"
 msgstr "các kiểu không hợp lệ trong chuyển đổi nop"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr ""
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in shift expression"
 msgid "type mismatch in %qs expression"
 msgstr "kiểu không khớp trong biểu thức dịch"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid types for %qs"
 msgstr "kiểu trừu tượng cho %q+D không hợp lệ"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid type for %qs"
 msgstr "kiểu trừu tượng cho %q+D không hợp lệ"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr ""
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr ""
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "toán hạng không hợp lệ trong phép toán nhị phân"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid non-vector operands to %qs"
 msgstr "sai đặt toán hạng tới %%R"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "chế độ con trỏ %qs không hợp lệ"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "type is deprecated: %s"
 msgid "vector type expected in %qs"
 msgstr "kiểu đã lạc hậu: %s"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "kiểu không khớp trong biểu thức nhị phân"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr ""
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "toán hạng không hợp lệ trong phép toán tam nguyên"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "type is deprecated: %s"
 msgid "vector types expected in %qs"
 msgstr "kiểu đã lạc hậu: %s"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr ""
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid abstract type for %q+D"
 msgid "invalid mask type in %qs"
 msgstr "kiểu trừu tượng cho %q+D không hợp lệ"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "not allowed type combination in %qs"
 msgstr "Hóa hợp không được hỗ trợ: %s"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid position or size in %qs"
 msgstr "chế độ con trỏ %qs không hợp lệ"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 #| msgid "shift of non-integer operand"
 msgid "%qs into non-mode-precision operand"
 msgstr "dịch của toán hạng không nguyên"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for %qs"
 msgid "insertion out of range in %qs"
 msgstr "đối số hằng nằm ngoài phạm vi cho %qs"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a directory"
 msgid "%qs not at element boundary"
 msgstr "%qs không phải là một thư mục"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "invalid version number %qs"
 msgid "non-trivial conversion in %qs"
 msgstr "số thứ tự phiên bản không hợp lệ %qs"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 #| msgid "invalid array assignment"
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "gán mảng không hợp lệ"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "cần biểu thức"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "sai đặt toán hạng tới %%R"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %qD"
 msgid "invalid %qs size argument in load"
 msgstr "đối số không hợp lệ cho %qD"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid register name for %q+D"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "tên thanh ghi cho %q+D không hợp lệ"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr ""
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 msgid "incorrect type of vector %qs elements"
 msgstr "số lượng dịch trái  >= độ rộng của kiểu"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "different number of results"
 msgid "incorrect number of vector %qs elements"
 msgstr "khác số của kết quả"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr ""
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr ""
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr ""
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr ""
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, fuzzy, gcc-internal-format
 #| msgid "invalid CASE_CHAIN"
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "sai CASE_CHAIN"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "nhãn case không hợp lệ trong câu lệnh switch"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr ""
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "kiểu không khớp cho nhãn case trong câu lệnh switch"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "các nhãn case không được sắp xếp trong câu lệnh switch"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "array notations cannot be used in declaration"
 msgid "label context is not the current function declaration"
 msgstr "Cảnh báo về lời khai báo kiểu cũ"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr ""
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr ""
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr ""
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI result"
 msgid "invalid %<PHI%> result"
 msgstr "kết quả PHI không hợp lệ"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<PHI%> def"
 msgstr "thiếu PHI def"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI argument"
 msgid "invalid %<PHI%> argument"
 msgstr "sai tham số PHI"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in send"
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "không tương thích kiểu trong bộ gửi"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_gimple failed"
 msgid "%<verify_gimple%> failed"
 msgstr "verify_gimple gặp lỗi"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr ""
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 msgid "local declaration from a different function"
 msgstr "sự khai báo của %qD như là non-function"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, gcc-internal-format
 msgid "PHI node with location"
 msgstr ""
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr ""
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr ""
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "lệnh được đánh dấu cho throw, nhưng không phải vậy"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "lệnh được đánh dấu cho throw ở giữa một khối"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple gặp lỗi"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr ""
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "gặp nhóm ngoặc móc thừa tại kết thúc của bộ khởi tạo"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "gặp nhóm ngoặc móc thừa tại kết thúc của bộ khởi tạo"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "exit block count is not compatible with entry block count"
 msgstr "-mnop-mcount không tương thích với đích này"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE chưa được khởi tạo"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, gcc-internal-format, gfc-internal-format
 msgid "probability of edge %d->%d not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-mnop-mcount không tương thích với đích này"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "NOTE_INSN_BASIC_BLOCK %d tại giữa của khối cơ bản %d"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr ""
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "nhãn cho case chưa được sắp xếp: "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr ""
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "thiếu edge %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%> hàm trả về"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr ""
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "hàm %qD được khai báo lại là không chung dòng (inline) thuộc "
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "hàm %qD được khai báo lại là không chung dòng (inline) thuộc "
@@ -35166,13 +35214,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid fpu for attribute(target(\"%s\"))"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "thuộc tính(đích(\"%s\")) là không hiểu"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "dùng %<auto%> không hợp lệ"
@@ -35690,7 +35738,7 @@ msgstr ""
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr ""
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -36124,31 +36172,31 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "khai báo trước đây của %qD"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D xung đột với khai báo trước"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 #| msgid "collect2 version %s\n"
 msgid "%qD conflicts for version %qB"
 msgstr "collect2 phiên bản %s\n"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 #| msgid "%q#D conflicts with a previous declaration"
 msgid "%qD conflicts with a previous declaration for version %qB"
@@ -36230,7 +36278,7 @@ msgstr "không thể khởi tạo hàm bạn %qs"
 msgid "no initializers are allowed in section %qs"
 msgstr "không thể khởi tạo hàm bạn %qs"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr ""
@@ -36382,7 +36430,7 @@ msgstr ""
 msgid "%qs symbol %q+D must have static linkage"
 msgstr ""
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr ""
@@ -36428,59 +36476,59 @@ msgstr "Sử dụng bố trí ngăn xếp đóng gói."
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%qE attribute argument is invalid"
 msgstr "thuộc tính %qE cần tham số"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%qE attribute argument %i is invalid"
 msgstr "thuộc tính %qE cần tham số"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "%qE attribute argument has type %qT"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute argument not a string constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "đối số thuộc tính phần không phải là một hằng chuỗi"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute argument not a string constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "đối số thuộc tính phần không phải là một hằng chuỗi"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, gcc-internal-format
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
 msgstr ""
@@ -36495,13 +36543,13 @@ msgstr ""
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a void return type"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "Thuộc tính %qE cần kiểu trả về là void"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a void return type"
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
@@ -36723,12 +36771,12 @@ msgstr "không thể dùng chế độ %qs cho các kiểu liệt kê"
 msgid "mode %qs applied to inappropriate type"
 msgstr ""
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr ""
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr ""
@@ -36738,18 +36786,18 @@ msgstr ""
 msgid "section attribute argument not a string constant"
 msgstr "đối số thuộc tính phần không phải là một hằng chuỗi"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr ""
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr ""
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "phần của %q+D không thể bị ghi đè"
@@ -36843,7 +36891,7 @@ msgstr "%qE đối số không phải là một định danh"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "xung đột với khai báo trước %q#D"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "hàm chung dòng %q+D được khai báo yếu"
@@ -36894,13 +36942,13 @@ msgstr "Thuộc tính %qE trên biến không hay thay đổi"
 msgid "%qE attribute is only applicable on functions"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is only applicable on functions"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -36912,12 +36960,12 @@ msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "đối số thuộc tính phần không phải là một hằng chuỗi"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, gcc-internal-format
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
 msgstr ""
@@ -37016,23 +37064,23 @@ msgstr ""
 msgid "visibility argument not a string"
 msgstr ""
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "Thuộc tính %qE bị lờ đi với các kiểu"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr ""
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr ""
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr ""
@@ -37049,7 +37097,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr ""
@@ -37126,7 +37174,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr ""
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -37206,7 +37254,7 @@ msgstr "%qD không tương thích với %qD"
 msgid "%qE argument is not a function"
 msgstr ""
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr ""
@@ -37275,7 +37323,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "Thuộc tính %qE bị lờ đi với các kiểu"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "Thuộc tính %qE cần tham số là chuỗi"
@@ -37443,16 +37491,16 @@ msgid "requested position is less than zero"
 msgstr ""
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected binding attribute at %C"
 msgid "empty string in attribute %<target%>"
 msgstr "Cần thuộc tính ràng buộc tại %C"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr ""
@@ -37737,7 +37785,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "gợi ý là dùng dấu ngoặc đơn bao quanh phép gán được dùng như là giá trị chân lý"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "dùng %<restrict%> không hợp lệ"
@@ -37914,8 +37962,8 @@ msgstr ""
 msgid "missing sentinel in function call"
 msgstr ""
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr ""
@@ -38955,7 +39003,7 @@ msgstr ""
 msgid "traditional C rejects string constant concatenation"
 msgstr ""
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -39011,7 +39059,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr ""
@@ -39026,17 +39074,17 @@ msgstr "biến iterator"
 msgid "%qE is not initialized"
 msgstr "%qE chưa được khởi tạo"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr ""
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "thiếu biểu thức gia số"
@@ -39046,7 +39094,7 @@ msgstr "thiếu biểu thức gia số"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "biểu thức gia không hợp lệ"
@@ -39142,19 +39190,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an function argument"
 msgid "%qD is not a function argument"
 msgstr "%qD không phải là đối số hàm"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -39164,8 +39212,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE không phải một kiểu ánh xạ được trong mệnh đề %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "%<_Atomic%> %qE trong mệnh đề %qs"
@@ -39715,7 +39763,7 @@ msgstr ""
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "%<#pragma %s%> sai dạng, bị bỏ qua"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "có rác ở cuối %<#pragma %s%>"
@@ -39788,8 +39836,8 @@ msgstr "%<#pragma%> là không được phép ở đây"
 msgid "wrong type argument to %s"
 msgstr "sai kiểu đối số cho %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -40299,17 +40347,17 @@ msgstr "số giảm của hàm %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr ""
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr ""
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr ""
@@ -40576,7 +40624,7 @@ msgid "passing argument %i to %qs-qualified parameter aliases with argument %Z"
 msgid_plural "passing argument %i to %qs-qualified parameter aliases with arguments %Z"
 msgstr[0] ""
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -41570,7 +41618,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr ""
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -42237,7 +42285,7 @@ msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate initialization of %qD"
 msgid "duplicate definition of %qs"
@@ -42290,7 +42338,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr ""
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr ""
@@ -42347,7 +42395,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qE không phải một biến trong mệnh đề %<depend%>"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -42448,19 +42496,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "Đối số véc-tơ bị gửi cho hàm không nguyên mẫu"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -42507,195 +42555,195 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "thuộc tính %qs bị bỏ qua"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid format of %s"
 msgid "invalid format for %<sve_width%>"
 msgstr "định dạng của %s không hợp lệ"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%J value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "giá trị %%J sai"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "không hiểu tùy chọn chỉnh (%s)"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs không hợp lệ cho %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "đối số không hợp lệ cho %<__builtin_frame_address%>"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "đối số không hợp lệ cho %<__builtin_frame_address%>"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "Assembler does not support -mabi=ilp32"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "Assembler không hỗ trợ -mabi=ilp32"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "%<-mpcommit%> was deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%<-mpcommit%> đã lạc hậu"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs with -f%s"
 msgid "code model %qs with %<-f%s%>"
 msgstr "mô hình mã %qs với -f%s"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in x32 mode"
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "mô hình mã %qs không được hỗ trợ trong chế độ x32"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 #| msgid "missing %<=%> (after %<getter%> attribute)"
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "thiếu %<=%> (sau thuộc tính %<getter%>)"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
@@ -42703,26 +42751,26 @@ msgstr "thiếu %<=%> (sau thuộc tính %<getter%>)"
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "%<#pragma init%> sai dạng"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, fuzzy, gcc-internal-format
 #| msgid "%<no-custom-%s%> does not accept arguments"
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "%<no-custom-%s%> không chấp nhận đối số"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 #| msgid "attribute(target(\"%s\")) is unknown"
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "thuộc tính(đích(\"%s\")) là không hiểu"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -42730,207 +42778,207 @@ msgstr "thuộc tính(đích(\"%s\")) là không hiểu"
 msgid "attribute %<target%> argument not a string"
 msgstr "thuộc tính %<target%> không là một chuỗi"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 #| msgid "attribute(target(\"%s\")) is unknown"
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "thuộc tính(đích(\"%s\")) là không hiểu"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %<target%> argument not a string"
 msgid "attribute %<target_version%> has multiple values"
 msgstr "thuộc tính %<target%> không là một chuỗi"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 #| msgid "attribute %<target%> argument not a string"
 msgid "attribute %<target_version%> argument not a string"
 msgstr "thuộc tính %<target%> không là một chuỗi"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 #| msgid "missing %<=%> (after %<getter%> attribute)"
 msgid "missing value in %<target_version%> attribute"
 msgstr "thiếu %<=%> (sau thuộc tính %<getter%>)"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 #| msgid "dwarf version %d is not supported"
 msgid "virtual function multiversioning not supported"
 msgstr "dwarf phiên bản %d không được hỗ trợ"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 #| msgid "the call requires ifunc, which is not supported by this target"
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "__builtin_thread_pointer không được hỗ trợ trên đích này"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%qD trước đã khai báo ở đây"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported simdlen %d"
 msgid "unsupported simdlen %wd"
 msgstr "simdlen không được hỗ trợ %d"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support saturating types"
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "ISO C không hỗ trợ kiểu saturating"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %qD"
 msgid "unsupported return type %qT for simd"
 msgstr "đối số không được hỗ trợ cho %D"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %qD"
 msgid "unsupported argument type %qT for simd"
 msgstr "đối số không được hỗ trợ cho %D"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "tùy chọn -shared (chia sẻ) hiện thời không được hỗ trợ cho VAX ELF"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, gcc-internal-format
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%q+D defined here"
 msgstr "nhãn %qD được định nghĩa ở đây"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "đối số %d của %qE phải là một địa chỉ"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
@@ -43132,12 +43180,12 @@ msgstr "đối số của thuộc tính %qE không hợp lệ"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -43277,23 +43325,23 @@ msgid "argument of %qE attribute ignored"
 msgstr "thuộc tính %qE bị lờ đi"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "Thuộc tính %qE chỉ được áp dụng cho các biến"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr ""
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 #| msgid "unknown linker output %qs"
 msgid "unknown %<asm%> flag output %qs"
 msgstr "không hiểu xuất bộ liên kết %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of asm flag output"
 msgid "invalid type for %<asm%> flag output"
@@ -43860,13 +43908,13 @@ msgstr "-fpie không được hỗ trợ"
 msgid "%<-fPIE%> is not supported"
 msgstr "-fPIE không được hỗ trợ"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 #| msgid "-fwpa and -fltrans are mutually exclusive"
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-fwpa và -fltrans loại trừ lẫn nhau"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "%qs hàm không có đối số"
@@ -43876,7 +43924,7 @@ msgstr "%qs hàm không có đối số"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "%qs hàm không trả về giá trị nào"
@@ -44224,7 +44272,7 @@ msgstr "__builtin_thread_pointer không được hỗ trợ trên đích này"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr ""
@@ -44562,7 +44610,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -44747,177 +44795,177 @@ msgstr "đối số %d của %qE phải nằm trong vùng %d…%d"
 msgid "parameter to builtin not valid: %s"
 msgstr "đối số %qD đặt nhưng chưa được dùng"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr ""
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 2-bít"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "đối số thứ năm phải là giá trị trực tiếp 8-bit"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "đối số thứ ba phải là giá trị trực tiếp 8-bit"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 1-bít"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 3-bít"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 4-bít"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 1-bít"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE cần là tùy chọn %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 5-bít"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr ""
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 8-bít"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "đối số thứ năm phải là giá trị trực tiếp 8-bit"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "chế độ so sánh không đúng"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "lệnh không đúng:"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "đối số trực tiếp phải là giá trị trực tiếp 4-bít"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "đối số trực tiếp phải là giá trị trực tiếp 5-bít"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "đối số trực tiếp phải là giá trị trực tiếp 8-bít"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 #| msgid "the forth argument must be scale 1, 2, 4, 8"
 msgid "the fourth argument must be one of enum %qs"
 msgstr "đối số thứ tư phải là tỷ lệ 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "vectorlength must be an integer constant"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "chiều dài véc-tơ phải là một hằng nguyên"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr ""
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE cần là tùy chọn %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 #| msgid "the third argument must be comparison constant"
 msgid "second, third and fourth argument must be a const"
 msgstr "đối số thứ năm phải là giá trị trực tiếp 8-bit"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "đối số không hợp lệ cho %<__builtin_frame_address%>"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 #| msgid "invalid arguments"
 msgid "invalid third argument"
 msgstr "các đối số không hợp lệ"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "đối số không hợp lệ cho %<__builtin_frame_address%>"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument to %<__builtin_frame_address%>"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "đối số không hợp lệ cho %<__builtin_frame_address%>"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 #| msgid "second argument must be slice or string"
 msgid "second argument must be a const"
 msgstr "đối số thứ hai phải là kiểu slice hay chuỗi"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp 32-bít"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "đối số cuối phải là giá trị trực tiếp"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "đối số cuối phải là tỷ lệ 1, 2, 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "the last argument must be an 8-bit immediate"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -45340,8 +45388,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "%<-fcf-protection%> is not compatible with this target"
@@ -45590,7 +45638,7 @@ msgstr ""
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, gcc-internal-format
 msgid "SSE register return with SSE2 disabled"
 msgstr ""
@@ -45615,12 +45663,12 @@ msgstr ""
 msgid "x87 register return with x87 disabled"
 msgstr ""
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr ""
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -45630,131 +45678,131 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr ""
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not compatible with %qD"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "%qD không tương thích với %qD"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr ""
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, gcc-internal-format
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr ""
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "-mnop-mcount không tương thích với đích này"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr ""
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr ""
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr ""
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, gcc-internal-format
 msgid "unsupported size for integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr ""
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr ""
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand type used with operand code 'Z'"
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "sử dụng loại toán hạng không hợp lệ với mã toán hạng “Z”"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, gcc-internal-format
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr ""
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, gcc-internal-format
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr ""
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 #| msgid "unknown pointer size model %qs"
 msgid "unknown architecture specific memory model"
 msgstr "không hiểu mô hình kích thước con trỏ %qs"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr ""
@@ -45807,7 +45855,7 @@ msgstr "gp_offset (%ld) hay end_offset (%ld) nhỏ hơn không"
 msgid "argument %qd is not a constant"
 msgstr "đối số %qd không phải hằng số"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -45819,7 +45867,7 @@ msgstr "PRINT_OPERAND_ADDRESS, con trỏ null"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND: không hiểu dấu chấm “%c”"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -45981,48 +46029,48 @@ msgstr "thuộc tính(đích(\"%s\")) là không hiểu"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "thuộc tính %<target%> không là một chuỗi"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "SPE not supported in this target"
 msgid "%qs is not supported in target attribute"
@@ -46815,7 +46863,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "mã dựng sẵn sai"
@@ -47051,85 +47099,85 @@ msgstr "Không thể mở tập tin xuất trung gian ptx"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "Thuộc tính %qE cần kiểu trả về là void"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "Thuộc tính %qE chỉ được áp dụng cho các biến"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%<tile%> value must be positive"
 msgid "barrier value must be within [0,15]"
 msgstr "%<tile%> giá trị phải dương"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 #| msgid "second argument must be slice or string"
 msgid "complement argument must be constant"
 msgstr "đối số thứ hai phải là kiểu slice hay chuỗi"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "weakref is not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "weakref không được hỗ trợ trong cấu hình này"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "-fvtable-verify=preinit is not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -47375,341 +47423,341 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "tăng con trỏ tới loại không hoàn toàn %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "useless cast to type %qT"
 msgid "fields cannot have RVV type %qT"
 msgstr "trừ phi ép thành kiểu %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "function parameters cannot have __fp16 type"
 msgid "array elements cannot have RVV type %qT"
 msgstr "tham số hàm không thể có loại __fp16"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 msgid "cannot delete objects with RVV type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<depend%> clause"
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qE không phải một biến trong mệnh đề %<depend%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognizable insn:"
 msgid "unrecognized RVV builtin"
 msgstr "không nhận ra lệnh:"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr ""
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "unknown value %qs for -mtune"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "không hiểu giá trị %qs dành cho -mtune"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr ""
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr ""
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "Vector argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "Đối số véc-tơ bị gửi cho hàm không nguyên mẫu"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 #| msgid "Use the SPE ABI extensions."
 msgid "%s %qT requires the V ISA extension"
 msgstr "Dùng lệnh mở rộng SPE ABI."
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "-mtoc-fusion cần -mpower8-fusion"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE không là kiểu %qT"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "vectorlength must be an integer constant"
 msgid "%qs requires an integer constant"
 msgstr "chiều dài véc-tơ phải là một hằng nguyên"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support ARM mode"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "CPU đích không hỗ trợ chế độ ARM"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs with -f%s"
 msgid "code model %qs with %qs"
 msgstr "mô hình mã %qs với -f%s"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 không hỗ trợ kiểu complex"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, fuzzy, gcc-internal-format
 #| msgid "%E requires %<-fgnu-tm%>"
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "%E cần %<-fgnu-tm%>"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d is not between %d and %d"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d không nằm giữa %d và %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid class name"
 msgid "%qs is not a valid base register in %qs"
 msgstr "“%qs” không phải là một tên lớp đúng"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs không hợp lệ cho %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qs hàm không có đối số"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "missing %<=%> (after %<getter%> attribute)"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -48781,23 +48829,23 @@ msgstr ""
 msgid "%<function_profiler%> support"
 msgstr "hỗ trợ function_profiler"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use %<::%> in parameter declaration"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "không thể dùng %<::%> trong khai báo đối số"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr ""
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
 msgstr "Thuộc tính %qE chỉ được áp dụng cho các biến"
@@ -49038,33 +49086,33 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D được định nghĩa nhưng không dùng"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "-f%s không hỗ trợ với chỉ lệnh CONST16"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "không thể khởi tạo hàm bạn %qs"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -49156,7 +49204,7 @@ msgstr ""
 msgid "%qs attribute only applies to variadic functions"
 msgstr ""
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -49244,8 +49292,8 @@ msgstr "%qs không phải là một thư mục"
 msgid "could not get size of source file"
 msgstr "không thể ghi vào tập tin đáp ứng %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr ""
@@ -49738,7 +49786,7 @@ msgstr ""
 msgid "%qE defined as wrong kind of tag"
 msgstr ""
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "Thuộc tính %qE cần kiểu trả về là void"
@@ -49892,7 +49940,7 @@ msgstr ""
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr ""
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -49903,7 +49951,7 @@ msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 msgid "%q+D is usually a function"
 msgstr "%q+D thường là một hàm"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "chưa có khai báo trước đây cho %qD"
@@ -49982,7 +50030,7 @@ msgstr ""
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "bộ khởi tạo cho %q#D không hợp lệ"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -50185,7 +50233,7 @@ msgstr ""
 msgid "storage class specified for unnamed parameter"
 msgstr ""
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr ""
@@ -50358,7 +50406,7 @@ msgstr ""
 msgid "function definition has qualified void return type"
 msgstr "định nghĩa hàm có kiểu trả về là void"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr ""
@@ -50485,7 +50533,7 @@ msgstr ""
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr ""
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr ""
@@ -50700,7 +50748,7 @@ msgstr ""
 msgid "%qT defined in underspecified object initializer"
 msgstr "%qD được dùng trong bộ khởi tạo của chính nó"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr ""
@@ -50765,7 +50813,7 @@ msgstr "cấu có không thành viên đã đặt tên"
 msgid "struct has no members"
 msgstr "struct không có thành viên nào"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "cấu có không thành viên đã đặt tên"
@@ -50835,7 +50883,7 @@ msgstr "khai báo lại của %<enum %E%>"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, gcc-internal-format
 msgid "specified mode too small for enumerated values"
 msgstr ""
@@ -50892,7 +50940,7 @@ msgstr "đối số hằng nằm ngoài phạm vi cho %qs"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr ""
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %q+D declared weak"
 msgid "inline function %qD given attribute %qs"
@@ -51043,12 +51091,12 @@ msgstr ""
 msgid "argument %qD doesn%'t match prototype"
 msgstr ""
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "%<return%> (trả lại) không có giá trị, trong hàm trả lại non-void (không rỗng)"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "đối số %qD đặt nhưng chưa được dùng"
@@ -51133,7 +51181,7 @@ msgstr "%qE được dùng với %<register%>"
 msgid "two or more data types in declaration specifiers"
 msgstr ""
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> là quá dài đối với GCC"
@@ -51241,7 +51289,7 @@ msgstr "ISO C90 không hỗ trợ kiểu lô-gíc"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C không hỗ trợ kiểu %<__int%d%>"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<__int%d%> không được hỗ trợ cho đích này"
@@ -51407,12 +51455,12 @@ msgstr "đối số cuối phải là giá trị trực tiếp"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ không hỗ trợ %<__int%d%> cho %qs"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -51477,37 +51525,37 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs phải được sử dụng cùng với %qs"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, gcc-internal-format
 msgid "left shift of negative value"
 msgstr "dịch trái của một giá trị âm"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "số lượng dịch trái là số âm"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "số lượng dịch trái là số âm"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "số lượng dịch trái  >= độ rộng của kiểu"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "số lượng dịch phải  >= độ rộng của kiểu"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 msgid "left shift count >= width of vector element"
 msgstr "số lượng dịch trái  >= độ rộng của kiểu"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 msgid "right shift count >= width of vector element"
 msgstr "số lượng dịch phải  >= độ rộng của kiểu"
@@ -51528,7 +51576,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr "không khớp cho"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "cần kết thúc dòng"
@@ -51538,7 +51586,7 @@ msgstr "cần kết thúc dòng"
 msgid "ISO C forbids an empty translation unit"
 msgstr ""
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -51586,8 +51634,8 @@ msgid "unknown type name %qE"
 msgstr "không hiểu tên kiểu %qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "cần các định danh khai báo"
@@ -51625,7 +51673,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "cần %<;%>, định danh hoặc %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr ""
@@ -51640,12 +51688,12 @@ msgstr ""
 msgid "unexpected attribute"
 msgstr "cần thuộc tính"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, gcc-internal-format
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr ""
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, gcc-internal-format
 msgid "%<assume%> attribute not followed by %<;%>"
 msgstr ""
@@ -51691,7 +51739,7 @@ msgstr "%<__auto_type%> cần một khai báo khởi tạo dữ liệu"
 msgid "%qs may only be used with a single declarator"
 msgstr "%<__auto_type%> có lẽ chỉ được dùng với khai báo đơn"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "cần %<,%> hoặc %<;%>"
@@ -51727,7 +51775,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "cấu tử không thể là hàm thành viên tĩnh"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "cần chuỗi văn chương"
@@ -51758,7 +51806,7 @@ msgstr ""
 msgid "static assertion failed: %E"
 msgstr ""
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "thẩm tra tĩnh gặp lỗi"
@@ -51813,8 +51861,8 @@ msgstr "không thể dùng chế độ %qs cho các kiểu liệt kê"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "cần định danh"
@@ -51847,12 +51895,12 @@ msgstr ""
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "%q#D xung đột với khai báo trước"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "dấu phẩy ở cuối của danh dánh liệt kê"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -51935,25 +51983,25 @@ msgstr "cần các định danh khai báo hay %<…%>"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected OpenMP directive name"
 msgstr "cần tên hàm"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "cần %<none%> hoặc %<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "thuộc tính %qE cần tham số"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a string argument"
 msgid "%qE attribute does not take any arguments"
@@ -51965,7 +52013,7 @@ msgstr "Thuộc tính %qE cần tham số là chuỗi"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C không hỗ trợ kiểu %<__int%d%>"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -51997,17 +52045,17 @@ msgstr ""
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr ""
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr ""
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -52017,44 +52065,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a string argument"
 msgid "%qs attribute does not take any arguments"
@@ -52086,7 +52134,7 @@ msgstr ""
 msgid "expected %<}%> before %<else%>"
 msgstr "cần %<}%> trước %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> mà không có %<if%> ở trước"
@@ -52101,7 +52149,7 @@ msgstr ""
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "cần biểu thức"
@@ -52138,27 +52186,27 @@ msgstr "ISO C không hỗ trợ kiểu saturating"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "cần khai báo"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr ""
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr ""
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -52178,12 +52226,12 @@ msgstr ""
 msgid "invalid iterating variable in fast enumeration"
 msgstr ""
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -52199,8 +52247,8 @@ msgstr ""
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "trùng cv-qualifier"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -52223,12 +52271,12 @@ msgstr ""
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 #| msgid "type of field declared here"
 msgid "first %<sizeof%> operand was declared here"
@@ -52416,7 +52464,7 @@ msgstr "ISO C90 không hỗ trợ từ hạn định %<_Atomic%>"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "cần biểu thức"
@@ -52431,13 +52479,13 @@ msgstr ""
 msgid "ISO C forbids braced-groups within expressions"
 msgstr ""
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "đối số thứ hai của %<va_start%> không là đối số có tên cuối"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -52589,7 +52637,7 @@ msgstr "cả hai đối số cho %<__builtin___clear_cache%> phải là các con
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "cả hai đối số cho %<__builtin___clear_cache%> phải là các con trỏ"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "sai số tham số cho %<__builtin_shuffle%>"
@@ -52632,7 +52680,7 @@ msgstr "Cảnh báo khi xóa một con trỏ tới kiểu không hoàn toàn."
 msgid "rotate count is negative"
 msgstr "số lượng quay trái bị âm"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
@@ -52747,7 +52795,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -52787,13 +52835,13 @@ msgstr ""
 msgid "no type or storage class may be specified here,"
 msgstr ""
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "empty property attribute list"
 msgstr "không hiểu thuộc tính tính chất"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -52805,61 +52853,61 @@ msgstr "Thiếu thuộc tính Code (mã)"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "không hiểu thuộc tính tính chất"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "không hiểu thuộc tính tính chất"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<for%> after %qs"
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "cần %<for%> sau %qs"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected %qE selector name"
 msgstr "cần selection-statement"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma omp flush%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<#pragma acc routine%> phải được áp dụng trước %s"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp section%> chỉ có thể sử dụng trong cấu trúc %<#pragma omp sections%>"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%> chỉ có thể sử dụng trong cấu trúc %<#pragma omp sections%>"
@@ -52869,12 +52917,12 @@ msgstr "%<#pragma omp section%> chỉ có thể sử dụng trong cấu trúc %<
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma acc routine%> phải được áp dụng trước %s"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "cần câu lệnh for, while hoặc do"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%> phải là đầu tiên"
@@ -52884,11 +52932,11 @@ msgstr "%<#pragma GCC pch_preprocess%> phải là đầu tiên"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "quá nhiều mệnh đề %qs"
@@ -52903,61 +52951,61 @@ msgstr "chỉ số phải là số nguyên"
 msgid "%qD is not a variable"
 msgstr "%qD không phải là một biến"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD không phải là một biến trỏ"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<none%> or %<present%>"
 msgstr "cần %<none%> hoặc %<shared%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected goto expression"
 msgid "expected constant logical expression"
 msgstr "cần điều lệnh goto"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr ""
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "cần %<data%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "quá nhiều mệnh đề %<if%>"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr ""
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -52980,23 +53028,23 @@ msgstr "%<num_threads%> giá trị phải dương"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_tasks%> giá trị phải dương"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%<grainsize%> giá trị phải dương"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "%<priority%> giá trị phải dương"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>"
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
@@ -53008,105 +53056,105 @@ msgstr "cần %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%>
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "quá nhiều mệnh đề %<if%>"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "biểu thức %qs phải là số nguyên"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%qs giá trị phải dương"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "quá nhiều đối số %<static%>"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "gặp tham số thừa"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<self%> clauses"
 msgstr "quá nhiều mệnh đề %<if%>"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "cần %<none%> hoặc %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%>"
 msgid "expected %<concurrent%>"
 msgstr "cần %<none%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "cần %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> hoặc định danh"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr ""
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "%qs giá trị phải dương"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "kiểu lịch biểu không hợp lệ"
@@ -53116,40 +53164,40 @@ msgstr "kiểu lịch biểu không hợp lệ"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_teams%> giá trị phải dương"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<thread_limit%> giá trị phải dương"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "cần %<,%> hoặc %<)%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "trùng %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
@@ -53166,23 +53214,23 @@ msgstr "cần %<class%>, hoặc %<typename%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "multiple ref-qualifiers"
 msgid "multiple linear modifiers"
 msgstr "đa ref-qualifiers"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "multiple ref-qualifiers"
 msgid "multiple %<step%> modifiers"
@@ -53193,7 +53241,7 @@ msgstr "đa ref-qualifiers"
 msgid "%<linear%> clause step expression must be integral"
 msgstr ""
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -53208,334 +53256,334 @@ msgstr ""
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr ""
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %qs"
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "%qs không tương thích với %qs"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "kiểu phụ thuộc không hợp lệ"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid map kind"
 msgid "invalid doacross kind"
 msgstr "kiểu ánh xạ không hợp lệ"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<scalar%>"
 msgid "expected %<fallback%> modifier"
 msgstr "cần %<scalar%>"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%<priority%> giá trị phải dương"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "illegal comma"
 msgstr "toán hạng không hợp lệ"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<static%> arguments"
 msgid "too many %<always%> modifiers"
 msgstr "quá nhiều đối số %<static%>"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<static%> arguments"
 msgid "too many %<close%> modifiers"
 msgstr "quá nhiều đối số %<static%>"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<static%> arguments"
 msgid "too many %<iterator%> modifiers"
 msgstr "quá nhiều đối số %<static%>"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<static%> arguments"
 msgid "too many %<mapper%> modifiers"
 msgstr "quá nhiều đối số %<static%>"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "cần một định danh hoặc %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<static%> arguments"
 msgid "too many %<present%> modifiers"
 msgstr "quá nhiều đối số %<static%>"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, gcc-internal-format
 msgid "invalid map kind"
 msgstr "kiểu ánh xạ không hợp lệ"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%> or %<typename%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "cần %<class%>, hoặc %<typename%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr ""
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "kiểu dist_schedule không hợp lệ"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "kiểu proc_bind không hợp lệ"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "cần %<;%>, %<,%> hoặc %<)%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "chuỗi văn chương rộng ở %<asm%>"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 #| msgid "unknown pointer size model %qs"
 msgid "unknown foreign runtime identifier %qs"
 msgstr "không hiểu mô hình kích thước con trỏ %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "expected string literal or constant integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%> after %qE"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "cần %<,%> hoặc %<)%> sau %qE"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, gcc-internal-format
 msgid "duplicated %<fr%> preference selector"
 msgstr ""
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "cần chuỗi văn chương"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate virt-specifier"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "trùng virt-specifier"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 msgid "duplicate %<target%> modifier"
 msgstr "lặp lại %<volatile%>"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate virt-specifier"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "trùng virt-specifier"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "cần kết thúc của capture-list"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs không hợp lệ cho %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs phải là mệnh đề đầu tiên của %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected an OpenMP clause"
 msgstr "cần mệnh đề %<#pragma omp%>"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr ""
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "cần %<class%>, hoặc %<typename%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma omp cancel%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -53550,7 +53598,7 @@ msgstr "%qE chưa được khai báo"
 msgid "expected function name"
 msgstr "cần tên hàm"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD không phải là hàm thành viên mẫu"
@@ -53560,24 +53608,24 @@ msgstr "%qD không phải là hàm thành viên mẫu"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma acc routine%> must be applied before %s"
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "%<#pragma acc routine%> phải được áp dụng trước %s"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma acc routine%> must be applied before %s"
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<#pragma acc routine%> phải được áp dụng trước %s"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma acc update%> phải chứa ít nhất là một mệnh đề %<device%> hay %<host%> hay %<self%>"
@@ -53604,7 +53652,7 @@ msgstr ""
 msgid "modified here"
 msgstr "union được định nghĩa ở đây"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
@@ -53640,120 +53688,120 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many atomic clauses"
 msgstr "quá nhiều mệnh đề %qs"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many memory order clauses"
 msgstr "quá nhiều mệnh đề %qs"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %s %s"
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%qs không tương thích với %s %s"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qs clause requires %qs clause"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after union definition"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "cần %<;%> sau định nghĩa kiểu hỗn hợp"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 #| msgid "invalid form of %<#pragma omp atomic%>"
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "sai dạng thức của %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "cần %<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 #| msgid "invalid form of %<#pragma omp atomic%>"
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "sai dạng thức của %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "sai dạng thức của %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "thao tác không hợp lệ cho %<#pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<#pragma omp atomic capture%> sử dụng hai biểu thức khác nhau cho bộ nhớ"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
@@ -53763,30 +53811,30 @@ msgstr "biểu thức %qE không phải là biểu thức hằng"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "cần %<;%>, %<,%> hoặc %<)%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -53796,36 +53844,36 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "cần %<(%> hoặc xuống dòng"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp cancel%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp cancel%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<}%> before %<else%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "cần %<}%> trước %<else%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<#pragma omp scan%>"
 msgstr "cần mệnh đề %<#pragma omp%>"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp cancel%> may only be used in compound statements"
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp cancel%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "cần câu lệnh for"
@@ -53833,71 +53881,71 @@ msgstr "cần câu lệnh for"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "cần câu lệnh for"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "cần khai báo nhắc lại hay sự khởi tạo"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough arguments"
 msgid "not enough nested loops"
 msgstr "không đủ đối số"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr ""
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp ordered%> with %<depend> clause may only be used in compound statements"
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp taskwait%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "cần %<for%> sau %qs"
@@ -53908,7 +53956,7 @@ msgstr "cần %<for%> sau %qs"
 msgid "expected a function name"
 msgstr "cần tên hàm"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected target-function call"
@@ -53919,48 +53967,48 @@ msgstr "cần tên hàm"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr ""
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "cần %<point%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma acc update%> phải chứa ít nhất là một mệnh đề %<device%> hay %<host%> hay %<self%>"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -53976,65 +54024,65 @@ msgstr ""
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma align%> phải xuất hiện trước khai báo của %D, đang lờ đi"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected trait selector name"
 msgstr "cần selection-statement"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr ""
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 #| msgid "%<no-custom-%s%> does not accept arguments"
 msgid "selector %qs does not accept any properties"
 msgstr "%<no-custom-%s%> không chấp nhận đối số"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> chỉ có thể được chỉ định trong một lớp"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<score%> argument must be non-negative"
 msgstr "%<priority%> giá trị phải dương"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "cần chuỗi văn chương"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "Clause not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "Mệnh đề vẫn chưa được hỗ trợ"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected context selector set name"
@@ -54046,30 +54094,30 @@ msgstr "cần selection-statement"
 msgid "variant %qD is not a function"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD redeclared as function"
 msgid "variant %qD is the same as base function"
 msgstr "biến %qD được định nghĩa lại là một hàm"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%> or %<typename%>"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "cần %<class%>, hoặc %<typename%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<match%> clauses"
 msgstr "quá nhiều mệnh đề %<if%>"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr ""
@@ -54080,7 +54128,7 @@ msgstr ""
 msgid "%qD is not of pointer type"
 msgstr "%qD không phải là một biến trỏ"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -54092,18 +54140,18 @@ msgstr "cần %<none%> hoặc %<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs không hợp lệ cho %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<point%>"
 msgid "expected %<interop%>"
 msgstr "cần %<point%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma acc%> clause"
 msgid "expected %<match%> clause"
@@ -54124,12 +54172,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "hàm chung dòng %q+D được khai báo yếu"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "đối số %d của %qE phải là bội số của %d"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "originally specified here"
 msgid "%<append_args%> specified here"
@@ -54140,7 +54188,7 @@ msgstr "nguyên gốc được chỉ định ở đây"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr ""
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD has incomplete type"
 msgid "variant %qD and base %qD have incompatible types"
@@ -54151,7 +54199,7 @@ msgstr "đối số %qD có kiểu chưa đầy đủ"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr ""
@@ -54167,89 +54215,89 @@ msgstr ""
 msgid "no declaration of base function %qs"
 msgstr "khai báo ngầm của hàm %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "định nghĩa hàm không khai báo đối số"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%>"
 msgstr "cần %<catch%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "cần %<none%> hoặc %<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr ""
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute with %s attribute at %L"
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "thuộc tính %s với thuộc tính %s tại %L"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr ""
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%> or %<typename%>"
 msgid "expected %<declare%> or %<assumes%>"
@@ -54277,13 +54325,13 @@ msgstr "sự khai báo của %qD như là thành viên của %qT"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T trước đã khai báo ở đây"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "unexpected clause"
 msgstr "cần class-key"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "missing %<map%> clause"
@@ -54346,33 +54394,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -54389,172 +54437,172 @@ msgstr "%<_Atomic%> %qE trong mệnh đề %<reduction%>"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE trong mệnh đề %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<while%>"
 msgid "expected %<sizes%>"
 msgstr "cần %<while%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "cần biểu thức nguyên"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "cần %<;%>, %<,%> hoặc %<)%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %qs or %qs"
 msgstr "cần %<,%> hoặc %<)%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp ordered%> với mệnh đề %<depend%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp ordered%> với mệnh đề %<depend%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected at least one assumption clause"
 msgstr "cần mệnh đề %<#pragma omp%>"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected directive name"
 msgstr "cần tên hàm"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 #| msgid "unknown excess precision style %qs"
 msgid "unknown assumption clause %qs"
 msgstr "không hiểu kiểu chính xác bị vượt quá %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected assumption clause"
 msgstr "cần tên hàm"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "không hiểu tên thanh ghi: %s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr ""
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr ""
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr ""
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%> nằm trong một %<__transaction_relaxed%>"
@@ -54565,7 +54613,7 @@ msgstr "%<__transaction_cancel%> nằm trong một %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "vòng ngoài hơn %<__transaction_cancel%> không nằm trong vòng ngoài hơn %<__transaction_atomic%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%> không nằm trong %<__transaction_atomic%>"
@@ -54580,7 +54628,7 @@ msgstr "tác vụ bao quanh"
 msgid "%qD has an incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "sử dụng sai biểu thức void"
@@ -54611,172 +54659,172 @@ msgstr ""
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr ""
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr ""
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr ""
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr ""
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr ""
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr ""
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr ""
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, gcc-internal-format
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr ""
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, gcc-internal-format
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT không có thành viên nào mang tên %qE; ý bạn là %qE?"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT không có thành viên nào mang tên %qE"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr ""
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr ""
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr ""
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "chỉ số mảng không phải là số nguyên"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr ""
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "chỉ số mảng không phải là số nguyên"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting to an array type %qT"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C++ cấm việc áp đổi kiểu của mảng %qT"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr ""
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD được khai báo như là một tham chiếu nhưng lại chưa được khởi tạo"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in return is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "chuyển đổi enum trả về thì không hợp lệ trong C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr ""
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr ""
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr ""
@@ -54784,1918 +54832,1918 @@ msgstr ""
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr ""
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr ""
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr ""
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr ""
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to method %qE"
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "quá nhiều đối số cho cho phương thức %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "quá nhiều đối số cho hàm %qE"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "quá nhiều đối số cho hàm %qE"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr ""
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "quá ít đối số cho hàm %qE"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "quá ít đối số cho hàm %qE"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "quá ít đối số cho hàm %qE"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr ""
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about use of multi-character character constants."
 msgid "comparison between pointer and zero character constant"
 msgstr "Cảnh báo về sử dụng hằng số ký tự đa ký tự."
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "did you mean to use logical not?"
 msgid "did you mean to dereference the pointer?"
 msgstr "ý bạn là dùng not lôgíc?"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr ""
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "so sánh giữa %qT và %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr ""
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "con trỏ đến hàm được dùng trong phép trừ"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr ""
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "%<~%> trên một biểu thức lôgíc"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr "ý bạn là dùng not lôgíc?"
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr ""
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "đối số có loại sai đối với bộ tuyệt đối"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr ""
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "phép gia tăng giá trị kiểu liệt kê là không hợp lệ trong C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "phép giảm giá trị kiểu liệt kê là không hợp lệ trong C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "cần một biểu thức lôgíc"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "cần một biểu thức lôgíc"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C90 không hỗ trợ kiểu complex"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "đối số sai kiểu cho gia số"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "sai đối số kiểu để giảm"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "tăng con trỏ tới loại không hoàn toàn %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "giảm con trỏ tới loại không hoàn toàn %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr ""
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr ""
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, gcc-internal-format
 msgid "cannot take address of scalar with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, gcc-internal-format
 msgid "address of array with reverse scalar storage order requested"
 msgstr ""
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, gcc-internal-format
 msgid "address of register compound literal requested"
 msgstr ""
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr ""
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr ""
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "decrement of enumeration value is invalid in C++"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "phép giảm giá trị kiểu liệt kê là không hợp lệ trong C++"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr ""
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr ""
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr ""
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C cấm chỉ biểu thức điều kiện giữa %<void *%> với con trỏ hàm"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "Mong đợi một loại biểu thức"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "Mong đợi một loại biểu thức"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr ""
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "kiểu không khớp trong biểu thức điều kiện"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "hàm %qD được khai báo lại là không chung dòng (inline) thuộc "
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "hàm %qD được khai báo lại là không chung dòng (inline) thuộc "
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "hàm %qD được khai báo lại là không chung dòng (inline) thuộc "
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "hàm %qD được khai báo lại là không chung dòng (inline) thuộc "
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 msgid "in call to %qD, declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr ""
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 msgid "cast adds %q#v qualifier to function type"
 msgstr ""
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr ""
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr ""
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr ""
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr ""
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "trừ phi ép thành kiểu %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C cấm chỉ áp kiểu thành kiểu hỗn hợp"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr ""
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr ""
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr ""
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr ""
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "phép gán %qT cho %qT không tương thích kiểu"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr ""
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "chuyển đổi enum trong bộ khởi tạo thì không hợp lệ trong C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(gần chỗ khởi tạo cho %qs)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "mảng bị khởi tạo từ hằng số chuỗi nằm trong ngoặc đơn"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "built-in %qD declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid "%qD declared here"
 msgid "%e declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in assignment is invalid in C++"
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "chuyển đổi enum trong bộ khởi tạo thì không hợp lệ trong C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "chuyển đổi enum trong bộ khởi tạo thì không hợp lệ trong C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in return is invalid in C++"
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "chuyển đổi enum trả về thì không hợp lệ trong C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "implicit conversion from %qT to %qT"
 msgstr "chuyển đổi từ %qT thành %qT không hợp lệ"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr ""
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 msgid "return discards %qv qualifier from pointer target type"
 msgstr ""
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr ""
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr ""
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr ""
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr ""
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, gcc-internal-format
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr ""
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr ""
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "incompatible types in assignment of %qT to %qT"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "phép gán %qT cho %qT không tương thích kiểu"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, gcc-internal-format
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, gcc-internal-format
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr ""
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "tăng con trỏ tới loại không hoàn toàn %qT"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "tăng con trỏ tới loại không hoàn toàn %qT"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "tăng con trỏ tới loại không hoàn toàn %qT"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "(gần chỗ khởi tạo cho %qs)"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr ""
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 #| msgid "return with value in function with no return type"
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "trả về giá trị trong một hàm mà có kiểu không trả về"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, gcc-internal-format
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "đối số %d của %qE phải là bội số của %d"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, gcc-internal-format
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, gcc-internal-format
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr ""
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "kiểu không tương thích cho đối số %d của %qE"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr ""
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr ""
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không phải là một biểu tượng hằng số nguyên"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không phải là một biểu tượng hằng số nguyên"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "đã khởi tạo một bộ phận mảng dẻo"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, gcc-internal-format
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "mảng loại không thích hợp bị khởi tạo từ hằng số chuỗi"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "sai sử dụng mảng không phải lvalue"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "bộ khởi tạo sai"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "yếu tố khởi tạo không phải hằng số"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "mảng bị khởi tạo từ biểu tượng mảng không phải hằng số"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "yếu tố khởi tạo không phải là một biểu tượng hằng số"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT is ambiguous"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "chuyển đổi từ %qT sang %qT là chưa rõ ràng"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "yếu tố khởi tạo không tính được vào lúc nạp"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr ""
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "gặp nhóm ngoặc móc thừa tại kết thúc của bộ khởi tạo"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "ngoặc chung quanh bộ khởi tạo vô hướng"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "bộ phận mảng dẻo bị khởi tạo trong một ngữ cảnh lồng nhau"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "thiếu ngoặc móc chung quanh bộ khởi tạo"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo vô hướng"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "gặp chỉ mục mảng trong bộ khởi tạo không phải mảng"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "không có tên trường trong bộ khởi tạo hợp hoặc mục ghi"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không có loại số nguyên"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không phải là một biểu tượng hằng số nguyên"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không phải hằng số"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng vượt quá giới hạn mảng"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "bộ khởi tạo chứa phạm vi chỉ mục vẫn trống"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "bộ khởi tạo chứa một phạm vi chỉ mục mảng vượt quá giới hạn mảng"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "trường đã khởi tạo bị ghi đè"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "trường đã khởi tạo với hiệu ứng khác bị ghi đè"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "chuyển đổi enum trong bộ khởi tạo thì không hợp lệ trong C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo hợp"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo cấu trúc"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "một bộ phận mảng dẻo bị khởi tạo một cách không phải tĩnh"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo hợp"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr ""
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo mảng"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo véc-tơ"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo vô hướng"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, gcc-internal-format
 msgid "constraint allows registers outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, gcc-internal-format
 msgid "side-effects in output operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "output operand outside of a function is not constant"
 msgstr "toán hạng “o” không phải là một hằng số"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Cilk_spawn%> may only be used inside a function"
 msgid "%<-%> modifier used inside of a function"
 msgstr "%<_Cilk_spawn%> chỉ có thể được dùng trong một hàm"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, gcc-internal-format
 msgid "side-effects in input operand outside of a function"
 msgstr ""
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "input operand outside of a function is not constant"
 msgstr "toán hạng “B” không phải là một hằng số"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C cấm %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "computed goto must be pointer type"
 msgstr "không thể chuyển đổi thành kiểu con trỏ"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "hàm đã khai báo %<noreturn%> có một câu lệnh %<return%>"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "%<return%> (trả lại) không có giá trị, trong hàm trả lại non-void (không rỗng)"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "%<return%> với một giá trị, trong hàm trả lại void (rỗng)"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr ""
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, gcc-internal-format
 msgid "function returns address of label"
 msgstr "hàm trả về địa chỉ của biến cục bộ"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "hàm trả về địa chỉ của biến cục bộ"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr ""
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr ""
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr ""
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr ""
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr ""
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr ""
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr ""
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "câu lệnh “continue” nằm ở ngoài một vòng lặp"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "câu lệnh không có tác dụng"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr ""
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr ""
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 #| msgid "the compiler can assume that the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "trình biên dịch sẽ coi rằng địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 #| msgid "the compiler can assume that the address of %qD will never be NULL"
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "trình biên dịch sẽ coi rằng địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr ""
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr ""
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr ""
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, gcc-internal-format
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr ""
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr ""
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C cấm chỉ việc so sánh của %<void *%> với con trỏ hàm"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr ""
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr ""
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr ""
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr ""
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr ""
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr ""
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr ""
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr ""
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma acc update%> phải chứa ít nhất là một mệnh đề %<device%> hay %<host%> hay %<self%>"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma simd%> clause"
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "cần mệnh đề %<#pragma simd%>"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE không phải một biến trong mệnh đề %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "%<_Atomic%> %qD trong mệnh đề %qs"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr ""
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected end of file in %qs"
 msgid "expected single pointer in %qs clause"
 msgstr "Gặp kết thúc tập tin bất thường tại %qs"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 #| msgid "%<vector%> length expression must be integral"
 msgid "for array function parameter length expression must be specified"
 msgstr "chiều dài %<vector%> phải là số nguyên"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE không có con trỏ hay kiểu mảng"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, gcc-internal-format
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr ""
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 #| msgid "%<_Atomic%> applied to a qualified type"
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "%<_Atomic%> áp dụng cho kiểu hạn định"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD has incomplete type"
 msgid "iterator %qD has const qualified type"
 msgstr "đối số %qD có kiểu chưa đầy đủ"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr ""
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression for output modifier '%c'"
 msgid "end expression refers to outer iterator %qD"
 msgstr "biểu thức không hợp lệ cho bộ sửa đầu ra “%c”"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "linear step expression must be integral"
 msgid "step expression refers to outer iterator %qD"
 msgstr "biểu thức bước thẳng phải là số nguyên"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected pointer in %qs clause"
 msgstr "cần con trỏ"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr ""
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 #| msgid "%qD in %<reduction%> clause is a zero size array"
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "%qD trong mệnh đề %<reduction%> là một mạng cỡ không"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "%qD trong mệnh đề %<reduction%> là một mạng cỡ không"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "%<_Atomic%> %qE trong mệnh đề %<reduction%>"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "zero sized type %qT in %qs clause"
 msgstr "Con trỏ Cray %qs trong mệnh đề %s tại %L"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array %qD is used"
 msgid "variable sized type %qT in %qs clause"
 msgstr "mảng có độ dài biến đổi %qD được dùng"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE có kiểu không hợp lệ cho %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, gcc-internal-format
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE phải là %<threadprivate%> với %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr ""
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr ""
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE không phải một biến trong mệnh đề %<aligned%>"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%qD không phải một biến trong mệnh đề  %<aligned%>"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<depend%> clause"
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE không phải một biến trong mệnh đề %<depend%>"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not an argument in %<uniform%> clause"
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE không phải một đối số trong mệnh đề %<uniform%>"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE không phải một biến trong mệnh đề %<aligned%>"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE không phải một biến trong mệnh đề %<aligned%>"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr ""
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not initialized with a constant expression"
 msgid "traits array must be initialized with constants"
 msgstr "%qD không được khởi tạo với một biểu thức hằng"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %qs clause"
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE không phải một biến trong mệnh đề %qs"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported argument to %qD"
 msgid "unsupported map expression %qE"
 msgstr "đối số không được hỗ trợ cho %D"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr ""
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE không phải một biến cũng không phải tên hàm trong mệnh đề %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr ""
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD không phải một đối số trong mệnh đề %<uniform%>"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE không phải một đối số trong mệnh đề %<uniform%>"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qs variable is not a pointer"
 msgstr "nguồn không phải là một hàm trỏ"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr ""
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, gcc-internal-format
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %qs clauses on a task construct"
 msgstr "quá nhiều mệnh đề %qs"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD phải nhận %<void%>"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not const"
 msgid "%qD shall not be const"
 msgstr "%q#D không là const"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr ""
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, gcc-internal-format
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, gcc-internal-format
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, gcc-internal-format
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "quá nhiều đối số cho hàm %qE"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "đối số cho %qs quá lớn (tối đa là %d)"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr ""
@@ -56989,257 +57037,252 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD should be initialized"
 msgid "%s should not be null"
 msgstr "%qD cần được khởi tạo"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE không phải một kiểu ánh xạ được trong mệnh đề %qs"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s:%d: Invalid state file; %s"
 msgid "%s: Invalid field type %s:"
 msgstr "%s:%d: Tập tin thống kê không hợp lệ; %s "
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 msgid "Not valid for ACCEPT statement."
 msgstr "tại câu lệnh"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 msgid "Not valid for DISPLAY statement."
 msgstr "tại câu lệnh"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr ""
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs at %C is not a variable"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qs tại %C không phải là một biến"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr ""
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -57248,74 +57291,85 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "lời khai báo loại có hướng"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown type name %qE"
 msgid "Unknown type %d"
 msgstr "không hiểu tên kiểu %qE"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qD is not compatible with %qD"
+msgid "%s:%d: Must not call here with %s"
+msgstr "%qD không tương thích với %qD"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -57325,13 +57379,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "quá nhiều tập tin nhập vào"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 #| msgid "cannot read LTO mode table from %s"
 msgid "cannot get %<float%> value from %s"
@@ -57348,65 +57402,65 @@ msgstr ""
 msgid "%s exited with status %d"
 msgstr "%s trả lại trạng thái thoát %d"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs value must be positive"
 msgid "%s: key must be field"
 msgstr "%qs giá trị phải dương"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s\"%s\"%s is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s\"%s\"%s không hợp lệ"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: regcomp: %s"
 msgstr "%s: %s: %s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -57878,7 +57932,7 @@ msgstr ""
 msgid "%q#D is private within this context"
 msgstr ""
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, gcc-internal-format
 msgid "declared private here"
 msgstr "đã được khai báo ở đây"
@@ -57888,7 +57942,7 @@ msgstr "đã được khai báo ở đây"
 msgid "%q#D is protected within this context"
 msgstr ""
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, gcc-internal-format
 msgid "declared protected here"
 msgstr "được khai báo bảo vệ ở đây"
@@ -58230,7 +58284,7 @@ msgstr "Cảnh báo khi xóa một con trỏ tới kiểu không hoàn toàn."
 msgid "constructor delegates to itself"
 msgstr ""
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 #| msgid "cannot convert %qT to %qT"
 msgid "cannot convert %qH to %qI"
@@ -58252,7 +58306,7 @@ msgstr "cú gọi không khớp tới %<(%T) (%A)%>"
 msgid "call to non-function %qD"
 msgstr ""
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "không thể gọi cấu tử %<%T::%D%> một cách trực tiếp"
@@ -58871,7 +58925,7 @@ msgstr "cấu có không thành viên đã đặt tên"
 msgid "next member %q#D declared here"
 msgstr "thành viên kế %q#D đã khai báo ở đây"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "định nghĩa lại của %q#T"
@@ -58881,7 +58935,7 @@ msgstr "định nghĩa lại của %q#T"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -59016,7 +59070,7 @@ msgstr ""
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
@@ -59069,7 +59123,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%qD không phải là đối số hàm"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -59104,878 +59158,878 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qs hàm không có đối số"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%qD called in a constant expression"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%qD được gọi trong một biểu thức hằng"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "biểu thức nguyên %qE không là hằng"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%qD called in a constant expression"
 msgid "%qD called with no caught exceptions active"
 msgstr "%qD được gọi trong một biểu thức hằng"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s không hỗ trợ %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "%qD called with unexpected %qs argument"
 msgstr "gặp tham số thừa"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_complex%>"
 msgid "wrong number of arguments to %qs call"
 msgstr "đối số sai số lượng cho %<__builtin_complex%>"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma message: %s"
 msgid "constexpr message: %.*s"
 msgstr "lời nhắn #pragma: %s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot be used for type declarations"
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "%<constexpr%> không thể dùng cho khai báo kiểu"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E không phải biểu thức hằng"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "gọi hàm nội bộ"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 msgid "dereferencing a null pointer"
 msgstr "con trỏ rỗng"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %qE"
 msgid "the comparison reduces to %qE"
 msgstr "quá nhiều đối số cho %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr ""
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "gọi hàm nội bộ"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 #| msgid "originally defined here"
 msgid "originally declared %<const%> here"
 msgstr "định nghĩa lần đầu ở đây"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 #| msgid "variable %D of type %<cb%> must be uninitialized"
 msgid "virtual table pointer is used uninitialized"
 msgstr "biến %D của kiểu %<cb%> phải không được khởi tạo"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is an ambiguous base class of %qT"
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "  %qT là lớp cơ sở chưa rõ ràng của %qT"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, gcc-internal-format
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr ""
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "toán hạng “o” không phải là một hằng số"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "allocation performed here"
 msgstr "union được định nghĩa ở đây"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, fuzzy, gcc-internal-format
 #| msgid "Attempting to allocate already allocated variable"
 msgid "deallocation of already deallocated storage"
 msgstr "Đang cố cấp phát một biến đã được cấp phát rồi"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, gcc-internal-format
 msgid "deallocation of storage that was not previously allocated"
 msgstr ""
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr ""
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD được gọi trong một biểu thức hằng"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD được dùng trước khi nó được định nghĩa"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr ""
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "toán hạng phải của biểu thức dịch %q+E là số âm"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 #| msgid "right operand of shift expression %q+E is negative"
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "toán hạng phải của biểu thức dịch %q+E là số âm"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr ""
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr ""
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr ""
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr ""
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, gcc-internal-format
 msgid "dereferencing a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr ""
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr ""
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr ""
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "%s không thể được dùng trong asm ở đây"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr ""
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared here"
 msgid "%qT object created here"
 msgstr "%qT được khai báo ở đây"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D được khai báo ở đây"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in a constant expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "Gặp biểu thức lambda trong biểu thức bất biến"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "allocated here"
 msgstr "được khai báo ở đây"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không phải là một biểu tượng hằng số nguyên"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD được dùng trong bộ khởi tạo của chính nó"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D không là const"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D là volatile"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD không được khởi tạo với một biểu thức hằng"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD chưa được khai báo %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr ""
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "lệnh không phải biểu thức hằng"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr ""
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "inline assembly is not a constant expression"
 msgstr "yếu tố khởi tạo không phải là một biểu tượng hằng số"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "dùng %qD không hợp lệ"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, gcc-internal-format
 msgid "destructor exited with an exception"
 msgstr ""
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr ""
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "lệnh không phải biểu thức hằng"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr ""
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "pointed-to object declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD called in a constant expression"
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "%qD được gọi trong một biểu thức hằng"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 msgid "address of a call to %qs is not a constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "lệnh không phải biểu thức hằng"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr ""
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "toán hạng “B” không phải là một hằng số"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "lệnh không phải biểu thức hằng"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, gcc-internal-format
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr ""
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> used outside of class"
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%> được dùng bên ngoài lớp"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 msgid "%<return%> in a statement expression"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr ""
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr ""
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr ""
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, gcc-internal-format
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in a constant expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "Gặp biểu thức lambda trong biểu thức bất biến"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "hủy tử không thể là %<constexpr%>"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr ""
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr ""
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr ""
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "cần AST thuộc kiểu %s"
@@ -60119,414 +60173,414 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD không phải là một biến trỏ"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "and %qT has no template constructors"
 msgid "%qT is not nothrow default constructible"
 msgstr "và %qT không có các cấu tử mẫu"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qD không phải là một biến trỏ"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid class name"
 msgid "%qT is not trivially copy assignable"
 msgstr "“%qs” không phải là một tên lớp đúng"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially default constructible"
 msgstr "  %q+T có một cấu tử non-trivial"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not trivially copy constructible"
 msgstr "%qD không phải là một biến trỏ"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT is not trivially destructible"
 msgstr "  %q+T có một cấu tử non-trivial"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have a mappable type in %qs clause"
 msgid "%qT does not have unique object representations, because"
 msgstr "%qE không phải một kiểu ánh xạ được trong mệnh đề %qs"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+T has a non-trivial destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "  %q+T có một cấu tử non-trivial"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an abstract class"
 msgstr "%q#T không phải là một lớp"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an aggregate"
 msgstr "%qT không phải một mẫu"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not an array"
 msgstr "%qD không phải là một biến"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT không là cơ sở của %qT"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is not a bounded array"
 msgstr "%qD không phải là một biến trỏ"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T không phải là một lớp"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a const type"
 msgstr "%qT không phải là kiểu lớp"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not default constructible, because"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not destructible, because"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not an empty class"
 msgstr "%q#T không phải là một lớp"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT không phải một mẫu"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a final class"
 msgstr "%q#T không phải là một lớp"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "%qT is not a function"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT không phải là một kiểu mẫu"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not invocable, because"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not compatible with %qD"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qD không tương thích với %qD"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a literal type"
 msgstr "%qT không phải là kiểu lớp"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD không phải là hàm thành viên mẫu"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT không phải là thành viên của %qT"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT không phải là thành viên của %qT"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow destructible, because"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not nothrow invocable, because"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT không phải kiểu con trỏ đến đối tượng"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "kiểu %qT không là cơ sở trực tiếp của %qT"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qT is not a POD type"
 msgstr "%qD không phải là một kiểu"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qT is not a pointer"
 msgstr "nguồn không phải là một hàm trỏ"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a polymorphic type"
 msgstr "%qT không phải là kiểu lớp"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT không phải là một namespace"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT không là cơ sở của %qT"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace or unscoped enum"
 msgid "%qT is not a scoped enum"
 msgstr "%qT không phải là một namespace hay enum không hoạt vi"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT không phải là một kiểu mẫu"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a trivial type"
 msgstr "%qT không phải là kiểu lớp"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr ""
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially copyable"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T is not literal because:"
 msgid "%qT is not trivially destructible, because"
 msgstr "%q+T không là kiểu văn chương vì:"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%qT is not an unbounded array"
 msgstr "%qT không phải một kiểu enumeration"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "%qT is not a union"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT không là cơ sở của %qT"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT không phải là một kiểu mẫu"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-#| msgid "%qD is not a constant"
-msgid "%qT is not consteval-only"
-msgstr "%q#D không là const"
+#| msgid "%qT is not a class type"
+msgid "%qT is not a structural type"
+msgstr "%qT không phải là kiểu lớp"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE không thể dùng như một hàm"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "%q+#D không thể được khai báo"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not captured"
 msgid "%qT is not destructurable"
 msgstr "%qD không bị bắt"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not derived from %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "  %qT không được dẫn xuất từ %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "hằng không hợp lệ"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr ""
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "constant refers to itself"
 msgid "constraints not satisfied"
 msgstr "hằng tham chiếu đến chính nó"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -60558,52 +60612,52 @@ msgstr "sự khai báo lại %q+D khác trong %<constexpr%>"
 msgid "previous declaration with fewer contracts here"
 msgstr "khai báo trước đây của %q+D ở đây"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "array member %q#D declared here"
 msgid "parameter declared here"
 msgstr "thành viên mảng %q#D đã khai báo ở đây"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "khai báo của %q#D"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid "  declared here"
 msgid "first declared here"
 msgstr "  đã được khai báo ở đây"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -60680,7 +60734,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "đã khai báo trước ở đây"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "no member named %qE in %qT"
@@ -60762,90 +60816,90 @@ msgstr "%qs tại %C không phải là thành viên của cấu trúc %qs"
 msgid "awaitable type %qT is not a structure"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%s cannot be used in asm here"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%s không thể được dùng trong asm ở đây"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "hàm đã khai báo %<noreturn%> có một câu lệnh %<return%>"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_paired_predicate must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "đối số 1 của __builtin_paired_predicate phải là một hằng"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "argument 1 of __builtin_paired_predicate must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "đối số 1 của __builtin_paired_predicate phải là một hằng"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %qD"
 msgid "no suspend point info for %qD"
 msgstr "chưa có khai báo nguyên mẫu trước đây cho %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "lặp lại %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "invalid expression as operand"
 msgid "await expressions are not permitted in handlers"
 msgstr "biểu thức như là toán hạng không hợp lệ"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, fuzzy, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "mảng có độ dài biến đổi được dùng"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr ""
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -60872,74 +60926,80 @@ msgstr "%qD không phải là một hàm mẫu"
 msgid "%qs used outside of constant expressions"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "cần khai báo"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "taking address of an immediate function %qD"
 msgstr "lấy địa chỉ của hủy tử %qE"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<concept%>"
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "hủy tử không thể là %<concept%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "dùng %<auto%> không hợp lệ trong đối số mẫu"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qE attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "đối số của thuộc tính %qE không hợp lệ"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, gcc-internal-format
 msgid "use fold expression in the attribute argument instead"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD không phải là một kiểu"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qD is not a class type"
 msgstr "%qT không phải là kiểu lớp"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have pointer or array type"
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qE không có con trỏ hay kiểu mảng"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not have pointer or array type"
 msgid "%qD does not have integral type"
 msgstr "%qE không có con trỏ hay kiểu mảng"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -60988,7 +61048,7 @@ msgstr ""
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "chuyển đổi từ %qT sang %qT là chưa rõ ràng"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr ""
@@ -61385,7 +61445,7 @@ msgstr "từ khai báo trước đây %q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "sự khai báo lại %q+D khác trong %<constexpr%>"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "khai báo trước đây %q#D"
@@ -61621,13 +61681,13 @@ msgstr ""
 msgid "previous specification in %q#D here"
 msgstr "sau đặc tả trước đây trong %q#D"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "khai báo xung đột %q+#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared here without exporting"
@@ -61839,7 +61899,7 @@ msgstr "  bỏ qua sự khởi tạo của %q#D"
 msgid "  enters %<template for%> statement"
 msgstr "cần biểu thức"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "non-class template %qT used without template arguments"
 msgid "%qD used without template arguments"
@@ -61887,556 +61947,556 @@ msgstr "%<%T::%D%> tên cấu tử, không phải kiểu"
 msgid "template parameters do not match template %qD"
 msgstr ""
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "-falign-labels=%d không được hỗ trợ"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, gcc-internal-format
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr ""
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, gcc-internal-format
 msgid "anonymous struct with base classes"
 msgstr ""
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr ""
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr ""
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr ""
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr ""
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr ""
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr ""
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr ""
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, gcc-internal-format
 msgid "%<inline%> can only be specified for functions"
 msgstr "%<inline%> chỉ có thể được chỉ định cho hàm"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, gcc-internal-format
 msgid "%<virtual%> can only be specified for functions"
 msgstr "%<virtual%> chỉ có thể được chỉ định cho hàm"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> chỉ có thể được chỉ định trong một lớp"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "%<explicit%> chỉ có thể được chỉ định cho cấu tử"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr ""
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, gcc-internal-format
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "%<const%> chỉ có thể được chỉ định cho lớp và hàm"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, gcc-internal-format
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "%<volatile%> chỉ có thể được chỉ định cho đối tượng và hàm"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, gcc-internal-format
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "%<__restrict%> chỉ có thể được chỉ định cho đối tượng và hàm"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, gcc-internal-format
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "%<__thread%> chỉ có thể được chỉ định cho đối tượng và hàm"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> bị bỏ qua trong khai báo này"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot be used for type declarations"
 msgid "%qs cannot be used for type declarations"
 msgstr "%<constexpr%> không thể dùng cho khai báo kiểu"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr ""
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr ""
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, gcc-internal-format
 msgid "attribute ignored"
 msgstr "thuộc tính bị bỏ qua"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr ""
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr ""
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is initialized with itself"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "%qD được khởi tạo bằng chính nó"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr ""
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr ""
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q+#D không phải là thành viên tĩnh của %q#T"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr ""
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr ""
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ không cho phép %<%T::%D%> được định nghĩa như là %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "khởi tạo lặp lại cho %qD"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr ""
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 %<thread_local%> only available with -std=c++11 or -std=gnu++11"
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<thread_local%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "việc dùng %<auto%> trong khai báo tham số chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr ""
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr ""
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr ""
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD được khai báo như là một tham chiếu nhưng lại chưa được khởi tạo"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr ""
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr ""
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr ""
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "thiếu kích thước mảng trong %qD"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "mảng có kích thước bằng không %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr ""
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr ""
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr ""
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr ""
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "uninitialized %<const %D%>"
 msgstr "lặp lại %<const%>"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr ""
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr ""
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr ""
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr ""
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr ""
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr ""
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr ""
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr ""
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr ""
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr ""
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD không phải là thành viên của %qT"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "bộ khởi tạo cho %q#D không hợp lệ"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr ""
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "quá nhiều bộ khởi tạo cho %qT"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr ""
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "ngoặc chung quanh bộ khởi tạo vô hướng"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr ""
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "structured binding has incomplete type %qT"
 msgstr "kiểu trả về là một kiểu không hoàn toàn"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr ""
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr ""
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "đối số %q#D có kiểu chưa đầy đủ"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr ""
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr ""
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr ""
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr ""
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "một bộ phận mảng dẻo bị khởi tạo một cách không phải tĩnh"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr ""
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr ""
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "tham chiếu %qD được khởi tạo bằng chính nó"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "đối số %d của %qE phải là bội số của %d"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "could not find variant declaration"
 msgstr "%<[*]%> không trong khai báo"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to constructor %q#D"
 msgid "%<declare variant%> on constructor %qD"
 msgstr "quá ít đối số cho hủy tử %q#D"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ không cho phép %<alignof%> với một non-type"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, gcc-internal-format
 msgid "%<register%> storage class specifier used"
 msgstr ""
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "khai báo của %q#D chưa có bộ khởi tạo"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr ""
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -62444,1932 +62504,1942 @@ msgstr "kiểu trả về %q#T là một kiểu không hoàn toàn"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be defaulted"
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD không thể là mặc định"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr ""
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "Thuộc tính %qE chỉ được áp dụng cho các biến"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr ""
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr ""
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose lambda closure type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid "  declared here"
 msgid "lambda declared here"
 msgstr "  đã được khai báo ở đây"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr ""
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "không thể chuyển đổi %qT thành %qT"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT không phải lớp lồng nhau của %qT"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 #| msgid "source is a pointer to incomplete type"
 msgid "structured binding refers to incomplete type %qT"
 msgstr "nguồn là một hàm trỏ tới loại không hoàn toàn"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "không thể giải mã địa chỉ"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 cấm mảng có kích thước biến đổi %qE"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length vector %qT"
 msgstr "ISO C90 cấm mảng có kích thước biến đổi %qE"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "kích cỡ mảng không phải là biểu thức hằng số nguyên"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "không thể giải mã địa chỉ"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "source is of incomplete class type"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "nguồn có loại lớp không hoàn toàn"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr ""
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "initializer provided for function"
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "bộ khởi tạo được cung cấp cho hàm"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "(gần chỗ khởi tạo cho %qs)"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "(gần chỗ khởi tạo cho %qs)"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr ""
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr ""
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr ""
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "thiếu kích thước mảng trong %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "mảng có kích thước không %qT"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr ""
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD được khai báo là một biến %<virtual%>"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr ""
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD được khai báo như là đối số %<virtual%>"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD được khai báo là một đối số %<inline%>"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD được khai báo như là kiểu %<virtual%>"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD được khai báo là một kiểu %<inline%>"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr ""
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD được khai báo như là trường %<virtual%>"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD được khai báo là một trường %<inline%>"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr ""
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D được khai báo là friend"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr ""
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr ""
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr ""
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "function_profiler support"
 msgid "function concepts are no longer supported"
 msgstr "hỗ trợ function_profiler"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD không phải là một hàm mẫu"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, gcc-internal-format
 msgid "constrained non-template friend declaration must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr ""
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr ""
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, gcc-internal-format
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr ""
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr ""
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr ""
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "không thể khai báo con trỏ đến %q#T"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr ""
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, gcc-internal-format
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr ""
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, gcc-internal-format
 msgid "cannot attach %<::main%> to a named module"
 msgstr ""
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr ""
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "next member %q#D declared here"
 msgid "explicit object parameter declared here"
 msgstr "thành viên kế %q#D đã khai báo ở đây"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr ""
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "  đã được khai báo ở đây"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr ""
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, gcc-internal-format
 msgid "deduction guide %qD must not have a function body"
 msgstr ""
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr ""
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr ""
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr ""
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr ""
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD phải là một hàm không-thành-viên"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> phải trả về %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr ""
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr ""
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q#D đã là mặc định rõ ràng ở đây"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr ""
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr ""
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr ""
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr ""
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "#pragma vtable không còn được hỗ trợ nữa"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr ""
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr ""
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr ""
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr ""
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr ""
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr ""
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "kích cỡ mảng không phải là biểu thức hằng số nguyên"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C++ cấm mảng có kích thước bằng không %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ cấm mảng có kích thước bằng không"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ cấm biến có kích thước biến đổi %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ cấm biến có kích thước biến đổi"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "mảng có độ dài biến đổi %qD được dùng"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "mảng có độ dài biến đổi được dùng"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "tràn kích thước mảng"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as array of %qT"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD được khai báo là mảng của %qT"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "Creating array temporary at %L"
 msgid "creating array of template placeholder type %qT"
 msgstr "Đang tạo mảng tạm tại %L"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "sự khai báo của %qD như là mảng void"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "tạo mảng void"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "sự khai báo của %qD như là mảng của các hàm"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "tạo mảng hàm"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "sự khai báo của %qD như là mảng của các tham chiếu"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "tạo mảng tham chiếu"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "sự khai báo của %qD như là mảng của các thành viên hàm"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "tạo mảng của thành viên hàm"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr ""
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "mảng có độ dài biến đổi được dùng"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, gcc-internal-format
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr ""
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, gcc-internal-format
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr ""
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr ""
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "no processor type specified for linking"
 msgid "return type specified for deduction guide"
 msgstr "chưa ghi rõ loại bộ xử lý cần liên kết"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, gcc-internal-format
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr ""
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "biến hay trường được khai báo là void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "%<inline%> được chỉ định cho khai báo lớp bạn"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr ""
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "%qE không ở đầu của khai báo"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "@catch parameter can not be protocol-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "đối số @catch không thể là từ hạn định giao thức"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together for %qs"
 msgid "%e and %e specified together"
 msgstr "%<signed%> và %<unsigned%> được chỉ định cùng với nhau cho %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "cách dùng không đúng tên từ hạn định %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "cách dùng không đúng tên từ hạn định %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "cách dùng không đúng tên từ hạn định %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT không phải là một lớp hay namespace"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "sự khai báo của %qD như là non-function"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "sự khai báo của %qD như là non-member"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr ""
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "định nghĩa hàm không khai báo đối số"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "sự khai báo của %qD như là non-function"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "sự khai báo của %qD như là %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "khai báo của %qD như là đối số"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "%qs cannot appear in a constant-expression"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%qs không thể xuất hiện trong biểu thức hằng"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr ""
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr ""
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int%d%> không được hỗ trợ cho đích này"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ không hỗ trợ %<__int%d%> cho %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "%qs used with %qE"
 msgid "%qs specified with %qT"
 msgstr "%qs được dùng với %qE"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qE được dùng với %<typedef%>"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qs specified with %<decltype%>"
 msgstr "%qE được dùng với %<typedef%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qs specified with %<typeof%>"
 msgstr "%qE được dùng với %<typedef%>"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "số ảo không hợp lệ cho %qs"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, gcc-internal-format
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr ""
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, gcc-internal-format
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr ""
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "template parameters cannot be friends"
 msgid "a parameter cannot be declared %qs"
 msgstr "các đối số tạm không thể là bạn"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> ngoài khai báo lớp"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "định nghĩa hàm được khai báo là %qs"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr ""
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr ""
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr "định nghĩa hàm được khai báo là %<auto%>"
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "định nghĩa hàm được khai báo là %qs"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr ""
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr ""
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr ""
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr ""
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr ""
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "cho khai báo hàm mẫu %q+D"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "Mong đợi một dấu ngoặc đơn mở"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 #| msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 #| msgid "Function %qs at %L cannot have an initializer"
 msgid "a function type cannot have an explicit object parameter"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 #| msgid "  member function type %qT is not a valid template argument"
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "  kiểu hàm thành viên %qT không phải là một đối số mẫu hợp lệ"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr ""
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, gcc-internal-format
 msgid "valid explicit object parameter declared here"
 msgstr ""
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 #| msgid "deduced return type only available with -std=c++14 or -std=gnu++14"
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "kiểu trả về deduced chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr ""
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "dùng %<auto%> không hợp lệ"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "dùng %<auto%> không hợp lệ"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 msgid "deduced class type %qD in function return type"
 msgstr "kiểu lớp %qT chưa hoàn thiện"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 #| msgid "deduced return type only available with -std=c++14 or -std=gnu++14"
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "kiểu trả về deduced chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr ""
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr ""
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr ""
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr ""
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "cấu tử không thể là hàm thành viên tĩnh"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr ""
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr ""
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not have parameters"
 msgid "constructors may not be ref-qualified"
 msgstr "hủy tử không được có đối số"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, gcc-internal-format
 msgid "constructors cannot be declared %<virtual%>"
 msgstr ""
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr ""
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr ""
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr ""
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 #| msgid "implicit templates may not be %<virtual%>"
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "các mẫu ngầm không nên là %<virtual%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr "định nghĩa hàm được khai báo là %<auto%>"
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a non-member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD phải là một hàm không-thành-viên"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "hủy tử không được có đối số"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "không thể khai báo con trỏ đến %q#T"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "không thể khai báo tham chiếu đến %q#T"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "không thể khai báo con trỏ cho thành viên %q#T"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr ""
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr ""
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "template-id %qD được dùng như bộ khai báo"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr ""
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr ""
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, gcc-internal-format
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "không thể khai báo tham chiếu đến %q#T"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr ""
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr ""
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr ""
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<explicit%> ngoài khai báo lớp"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr ""
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr ""
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "định nghĩa hàm được khai báo là %<auto%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "định nghĩa hàm được khai báo là %<auto%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr ""
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "old-style function definition"
 msgid "typedef may not be a function definition"
 msgstr "định nghĩa hàm theo cách cũ"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "a concept cannot be a member function"
 msgid "typedef may not be a member function definition"
 msgstr "cấu tử không thể là hàm thành viên tĩnh"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%> không trong khai báo"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef được khai báo %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr ""
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr ""
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "%<inline%> được chỉ định cho khai báo lớp bạn"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "các đối số tạm không thể là bạn"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr ""
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr ""
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr ""
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr ""
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr ""
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr ""
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "không thể dùng %<::%> trong khai báo đối số"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "không thể khai báo tham chiếu đến %q#T"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr ""
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr ""
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "thành viên dữ liệu không-tĩnh được khai báo giữ chỗ %qT"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array %qD"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C++ cấm mảng có kích thước bằng không %qD"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 không hỗ trợ thành viên mảng linh động"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "dùng %<::%> không hợp lệ"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr ""
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, gcc-internal-format
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "hàm %qD được khai báo %<virtual%> trong một union"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr ""
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "sự khai báo của %qD như là thành viên của %qT"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "a destructor cannot be %qs"
 msgstr "hủy tử không thể là %<constexpr%>"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr ""
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "cấu tử không thể là %<concept%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "cấu tử không thể là hàm thành viên tĩnh"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "không thể mở %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr ""
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, gcc-internal-format
 msgid "variable template declared here"
 msgstr ""
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr ""
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr ""
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, gcc-internal-format
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr ""
+
+#: cp/decl.cc:16682
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr ""
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "static data member %qD in unnamed class"
 msgid "static data member %qE declared %qs"
 msgstr "thành viên dữ liệu tĩnh %qD trong lớp không tên"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 #| msgid "  non-static data member %qD has non-literal type"
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "  thành viên dữ liệu không-tĩnh %qD có kiểu không-văn-chương"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member declared with placeholder %qT"
 msgid "non-static data member %qE declared %qs"
 msgstr "thành viên dữ liệu không-tĩnh được khai báo giữ chỗ %qT"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr ""
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> can only be specified for functions"
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "%<inline%> chỉ có thể được chỉ định cho hàm"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr ""
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, gcc-internal-format
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr ""
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr ""
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr ""
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr ""
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "%<static%> không sử dụng khi định nghĩa (như ngược với khai báo) một thành viên dữ liệu tĩnh"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr ""
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr ""
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "chưa định nghĩa biến môi trường%qs"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared %<constexpr%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "%qD chưa được khai báo %<constexpr%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr ""
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr ""
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr ""
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr ""
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr ""
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "không thể dùng %<::%> trong khai báo đối số"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr ""
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr ""
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr ""
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr ""
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr ""
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD không được khai báo như là tĩnh"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a non-member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD phải là một hàm không-thành-viên"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a non-member function"
 msgid "%qD must be a member function"
 msgstr "%qD phải là một hàm không-thành-viên"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 #| msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr ""
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr ""
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, gcc-internal-format
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr ""
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr ""
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD cần chính các là một đối số"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD cần chính các là hai đối số"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "postfix %qD phải nhận %<int%> như là đối số của nó"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "postfix %qD phải nhận %<int%> như là đối số thứ hai của nó"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD cần chính các là hai đối số"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD cần chính các là một đối số"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD cần chính các là hai đối số"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD không thể có đối số mặc định"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr ""
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr ""
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "tiền tố %qD cần trả về %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "hậu tố %qD cần trả về %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD cần trả về bằng giá trị"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr ""
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr ""
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr ""
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT được coi là %qs"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 msgid "%qT has a previous declaration here"
 msgstr "%q+T có một khai báo trước ở đây"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT được coi là enum"
@@ -64381,101 +64451,101 @@ msgstr "%qT được coi là enum"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr ""
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr ""
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "template-id %qD in declaration of primary template"
 msgid "class template %qD redeclared as non-template"
 msgstr "template-id %qD trong khai báo của mẫu nguyên gốc"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr ""
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT không phải một mẫu"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr ""
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr ""
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "%qT được định nghĩa với cơ sở đa trực tiếp"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, gcc-internal-format
 msgid "%qT defined with direct virtual base"
 msgstr "%qT được định nghĩa cơ sở trực tiếp ảo"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr ""
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr ""
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr ""
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "định nghĩa trước ở đây"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr ""
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "đối số %d của %qE phải là một địa chỉ"
@@ -64484,90 +64554,96 @@ msgstr "đối số %d của %qE phải là một địa chỉ"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr ""
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr ""
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr ""
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr ""
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 #| msgid "increment of enumeration value is invalid in C++"
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "phép gia tăng giá trị kiểu liệt kê là không hợp lệ trong C++"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr ""
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr ""
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "nhiều định nghĩa cho %q#T"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "kiểu trả về %q#T là một kiểu không hoàn toàn"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> cần trả về một tham chiếu đến %<*this%>"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr ""
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr ""
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "%<return%> (trả lại) không có giá trị, trong hàm trả lại non-void (không rỗng)"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD đã sẵn định nghĩa trong %qT"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 #| msgid "using %<%c%s%>"
 msgid "using %qs"
 msgstr "đang dùng %<%c%s%>"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D được dùng trước khai báo"
+
+#: cp/decl.cc:21341
 #, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr ""
@@ -65012,387 +65088,387 @@ msgstr "lệnh không thỏa những ràng buộc của nó:"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    trực tiếp từ %qs tại %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d%R"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    trực tiếp từ %qs tại %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    trực tiếp từ %qs"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In static member function %qD"
 msgstr "Trong hàm bộ phận tĩnh %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 #| msgid "In copy constructor %qs"
 msgid "In copy constructor %qD"
 msgstr "Trong cấu tử bản sao %qs"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 #| msgid "In constructor %qs"
 msgid "In constructor %qD"
 msgstr "Trong cấu tử %qs"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 #| msgid "In destructor %qs"
 msgid "In destructor %qD"
 msgstr "Trong bộ hủy %qs"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "Trong hàm λ"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "Trong hàm bộ phận tĩnh %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "Trong hàm bộ phận %qs"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "Trong hàm %qs"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "but %qE is a type"
 msgstr "%qE không phải là một kiểu"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "but %qE is an expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr ""
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD không phải là một biến"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is deprecated"
 msgid "but %qE is a parameter"
 msgstr "%qE đã lạc hậu"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "but %qE is a function"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "but %qE is a data member"
 msgstr "%q#T có thành viên dữ liệu con trỏ"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD không phải là một mẫu hàm"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class template"
 msgid "but %qE is a class template"
 msgstr "%qE không phải một lớp mẫu"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable template"
 msgid "but %qE is a variable template"
 msgstr "%qD không phải là một biến"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD là một namespace"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an enumerator-name"
 msgid "but %qE is an enumerator"
 msgstr "%qD không phải là một enumerator-name"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, gcc-internal-format
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr ""
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 #| msgid "%s: In substitution of %qS:\n"
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s: Trong thay thế của %qS:\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s: Trong minh dụ của %q#D:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from here\n"
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "yêu cầu đệ quy từ đây\n"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 msgid "recursively required by substitution of %qS\n"
 msgstr "yêu cầu đệ quy bởi thay thế của %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 msgid "required by substitution of %qS\n"
 msgstr "được yêu cầu bởi thay thế của %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "yêu cầu đệ quy từ %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "được yêu cầu từ %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "yêu cầu đệ quy từ đây\n"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "được yêu cầu từ đây\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%r%s:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "%r%s:%d:%R   [ bỏ qua %d ngữ cảnh minh dụ, dùng -ftemplate-backtrace-limit=0 để tắt ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 #| msgid "%r%s:%d:%R   in constexpr expansion of %qs"
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%r%s:%d:%R   trong khai triển constexpr của %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required by the constraints of %q#D\n"
 msgstr "được yêu cầu bởi thay thế của %qS\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 #| msgid "required by substitution of %qS\n"
 msgid "required for the satisfaction of %qE"
 msgstr "được yêu cầu bởi thay thế của %qS\n"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c required for gnat2scil"
 msgid "required for constraint satisfaction\n"
 msgstr "-c là cần cho gnat2scil"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "in requirements "
 msgstr "không có đối số nào"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "không có đối số nào"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "khởi tạo chụp lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 #| msgid "variable templates only available with -std=c++14 or -std=gnu++14"
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "mẫu biến chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 #| msgid "fold-expressions only available with -std=c++1z or -std=gnu++1z"
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 auto only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 auto inline chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 #| msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 #| msgid "ref-qualifiers only available with -std=c++11 or -std=gnu++11"
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-qualifiers chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "khởi tạo chụp lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 #| msgid "ref-qualifiers only available with -std=c++11 or -std=gnu++11"
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-qualifiers chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 #| msgid "C++11 auto only available with -std=c++11 or -std=gnu++11"
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 auto inline chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 #| msgid "ref-qualifiers only available with -std=c++11 or -std=gnu++11"
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "ref-qualifiers chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr ""
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr ""
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE; did you mean %qE?"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qT không có thành viên nào mang tên %qE; ý bạn là %qE?"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD không phải là thành viên của %qT"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE; did you mean %qE?"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qT không có thành viên nào mang tên %qE; ý bạn là %qE?"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD không phải là thành viên của %qD"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> chưa được khai báo"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> chưa được khai báo"
@@ -65620,7 +65696,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "tham số %qD được khởi tạo"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr ""
@@ -65736,7 +65812,7 @@ msgstr ""
 msgid "type %qT is not a direct base of %qT"
 msgstr "kiểu %qT không là cơ sở trực tiếp của %qT"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -65931,43 +66007,43 @@ msgstr ""
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "bộ khởi tạo kết thúc bất ngờ"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "kiểu trả về là một kiểu không hoàn toàn"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, gcc-internal-format
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr ""
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr ""
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr ""
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
@@ -66002,86 +66078,94 @@ msgstr ""
 msgid "captured structured bindings are a C++20 extension"
 msgstr ""
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr ""
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr ""
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "#pragma %s không hợp lệ"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable không còn được hỗ trợ nữa"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, gcc-internal-format
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr ""
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD chưa được định nghĩa"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 #| msgid "%<requires%> only available with -fconcepts"
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "%<requires%> chỉ sẵn sàng với -fconcepts"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD chưa được khai báo trong phạm vi này"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD chưa được khai báo trong phạm vi này"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr ""
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr ""
@@ -66091,64 +66175,57 @@ msgstr ""
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr ""
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr ""
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr ""
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -66558,7 +66635,7 @@ msgstr "khai báo trước đây của %qL là linkage"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "khai báo xung đột %q+#D"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting types for built-in function %q+D"
 msgid "conflicting type for imported declaration %#qD"
@@ -66576,452 +66653,452 @@ msgstr "xung đột với khai báo trước %q#D"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "xung đột kiểu cho hàm dựng sẵn %q+D"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specified for friend class declaration"
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "%<inline%> được chỉ định cho khai báo lớp bạn"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting types for built-in function %q+D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "xung đột kiểu cho hàm dựng sẵn %q+D"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "khai báo xung đột %q+#D"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "khai báo xung đột %q+#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "trong khai báo %q+D"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for %q#D"
 msgid "conflicting default argument for %#qD"
 msgstr "định nghĩa lại của đối số mặc định của %q#D"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 msgid "existing default declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "Missing actual argument for argument %qs at %L"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "Thiếu đối số đối thực tế cho đối số %qs tại %L"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of %q+D"
 msgid "definition of %qD does not match"
 msgstr "định nghĩa lại của %q+D"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "thiếu định nghĩa"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "quá nhiều đối số cho cho phương thức %qE"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr ""
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE không là kiểu %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is an enumeration template"
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%qD là một mẫu liệt kê"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "%qD declared with internal linkage"
 msgstr "%qD được khai báo ở đây"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr ""
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr ""
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD không phải là một hàm mẫu"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 #| msgid "missing template arguments after %qT"
 msgid "%qD has TU-local template argument %qT"
 msgstr "thiếu đối số mẫu sau %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD không phải là hàm thành viên mẫu"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared %<constexpr%> outside its class"
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD được khai báo %<constexpr%> ngoài lớp của nó"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr ""
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "module %qs declared here"
 msgstr "%qD được khai báo ở đây"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "  from definition of %q#D"
 msgid "macro definitions of %qE corrupted"
 msgstr "  từ định nghĩa của %q#D"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr ""
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr ""
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiled module is %sversion %s"
 msgstr "collect2 phiên bản %s\n"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 phiên bản %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 #| msgid "no %qs getter found"
 msgid "module %qs found"
 msgstr "không tìm thấy getter %qs"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr ""
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr ""
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 #| msgid "function attribute mismatch"
 msgid "fixed tree mismatch"
 msgstr "thuộc tính hàm không khớp"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "dwarf version %d is not supported"
 msgid "interface partition is not exported"
 msgstr "dwarf phiên bản %d không được hỗ trợ"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "failed to rename %s to state file %s [%s]"
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "gặp lỗi khi đổi tên %s thành tập tin thống kê %s [%s]"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "không tìm thấy lớp “%s”"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr ""
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %D"
 msgid "declaration %qD conflicts with builtin"
 msgstr "kiểu phần xung đột với %D"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "khai báo xung đột %q+#D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q+#D"
 msgid "conflicting declaration of %qD in global module"
 msgstr "khai báo xung đột %q+#D"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared in module %qs"
 msgstr "đã khai báo trước ở đây"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared in global module"
 msgstr "đã khai báo trước ở đây"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr ""
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration with %qL linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "khai báo trước đây của %qL là linkage"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "Creating '%s'\n"
 msgid "reading CMI %qs"
 msgstr "Đang tạo “%s”\n"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr ""
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 #| msgid "  declared here"
 msgid "module declared here"
@@ -67034,116 +67111,116 @@ msgstr "  đã được khai báo ở đây"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs already declared"
 msgid "module already declared"
 msgstr "Ký hiệu %qs đã sẵn được khai báo"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 #| msgid "module procedure"
 msgid "module already imported"
 msgstr "thủ tục mô-đun"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 #| msgid "module procedure"
 msgid "module %qs imported here"
 msgstr "thủ tục mô-đun"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown compiled module interface: %s"
 msgstr "không hiểu tên thanh ghi: %s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing."
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "Bật tiền xử lý theo kiểu cổ điển."
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param name %qs"
 msgid "invalid header name %qs"
 msgstr "sai tên cho tùy chọn --param %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param name %qs"
 msgid "invalid module name %qs"
 msgstr "sai tên cho tùy chọn --param %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "lỗi ghi %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 #| msgid "routine %qD declared here"
 msgid "first error in %qD appeared here"
 msgstr "%qD được khai báo ở đây"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "không tìm thấy lớp “%s”"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 #| msgid "unknown IRA region %qs"
 msgid "unknown header kind %qs"
@@ -67160,7 +67237,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "%+D đã khai báo weakref sau khi được dùng"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
@@ -67209,280 +67286,290 @@ msgstr ""
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "sự khai báo của các bóng %qD như là thành viên của %qT"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr ""
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "sự khai báo lại %q+D khác trong %<constexpr%>"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s(%E) %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D declared here"
 msgid "%q#D declared here with no linkage"
 msgstr "%q#D được khai báo ở đây"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here, later in the translation unit"
 msgid "%q#D declared here with internal linkage"
 msgstr "%+D đã khai báo weakref sau khi được dùng"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D declared here"
 msgid "%q#D declared here with module linkage"
 msgstr "%q#D được khai báo ở đây"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> tên hủy tử"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 #| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "inline namespaces chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%E%> is not a class, namespace, or enumeration"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%<::%E%> không phải là một lớp, namespace, hay enumeration"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr ""
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, gcc-internal-format
 msgid "using-declaration for member at non-class scope"
 msgstr ""
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "kiểu %qT không là cơ sở trực tiếp của %qT"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not declared in %qD"
 msgid "%qD has not been declared in %qD"
 msgstr "%qD chưa được khai báo trong %qD"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration of namespace %qD here"
 msgid "using-declaration may not name namespace %qD"
 msgstr "khai báo trước đây của không gian tên %qD ở đây"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> các tên cấu tử trong %qT"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not declared in %qD"
 msgid "%qD has not been declared within %qD"
 msgstr "%qD chưa được khai báo trong %qD"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D được khai báo là friend"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr ""
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr ""
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr ""
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr ""
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "các khả năng được gợi ý:"
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "%qD has already been defined"
 msgid "the macro %qs had not yet been defined"
 msgstr "%qD đã định nghĩa rồi"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "it was later defined here"
 msgstr "struct được định nghĩa ở đây"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "%<-fabi-version=1%> is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "%<-fabi-version=1%> không còn tiếp tục được hỗ trợ nữa"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, gcc-internal-format
 msgid "annotation on using directive"
 msgstr ""
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, gcc-internal-format, gfc-internal-format
 msgid "cannot nest more than %d namespaces"
 msgstr ""
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is ambiguous"
 msgid "%<namespace %E%> is ambiguous"
 msgstr "%qs tại %L phải là số nguyên"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr ""
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr ""
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, gcc-internal-format
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr ""
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "cần %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr ""
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "previous definition here"
 msgid "reachable %s definition here"
 msgstr "định nghĩa trước ở đây"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX vào pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -67513,7 +67600,7 @@ msgstr ""
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr ""
@@ -67560,7 +67647,7 @@ msgstr "%<::%E%> chưa được khai báo"
 msgid "request for member %qE in non-class type %qT"
 msgstr ""
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%> chưa được khai báo"
@@ -67630,7 +67717,7 @@ msgstr ""
 msgid "%qE is not a class template"
 msgstr "%qE không phải một lớp mẫu"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE không phải là một mẫu"
@@ -67950,1785 +68037,1796 @@ msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "%<requires%> only available with -fconcepts"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "%<requires%> chỉ sẵn sàng với -fconcepts"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "expected function name"
 msgid "expected a reflection of a type"
 msgstr "cần tên hàm"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD không phải là một mẫu hàm"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "non-class template %qT used without template arguments"
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "mẫu không phải lớp %qT được dùng mà không có đỗi số mẫu"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%E%> is not a class, namespace, or enumeration"
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%<::%E%> không phải là một lớp, namespace, hay enumeration"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "kiểu dấu chấm cố định không hỗ trợ trong C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr ""
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr ""
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 #| msgid "fold-expressions only available with -std=c++1z or -std=gnu++1z"
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "cần biểu thức cơ bản"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr ""
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr ""
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "hàm đa phương tiện chỉ sẵn có trên fr500"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "cần id-expression"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr ""
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr ""
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, gcc-internal-format
 msgid "template-id not allowed for destructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "phần khai báo của %<~%T%> là thành viên của %qT"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr ""
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "cần unqualified-id"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD không phải một mẫu"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr ""
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "expected nested-name-specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "cần nested-name-specifier"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr ""
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "cần nested-name-specifier"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr ""
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "sai số tham số cho %<__builtin_addressof%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "đối số sai số lượng cho %<__builtin_launder%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "sai số tham số cho %<__builtin_addressof%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "sai số tham số cho %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr ""
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "hàm chung dòng %q+D được khai báo yếu"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ cấm compound-literals"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "dùng %qD không hợp lệ"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%> không phải là thành viên lớp"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "kiểu không-scalar"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "expected nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "cần nested-name-specifier"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "%<_Atomic%> applied to a qualified type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "%<_Atomic%> áp dụng cho kiểu hạn định"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ không cho phép %<alignof%> với một non-type"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr ""
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD không thể có đối số mặc định"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in %qs expressions"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr ""
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr ""
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr ""
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr ""
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, gcc-internal-format
 msgid "expected expression-list or type-id"
 msgstr ""
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr ""
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr ""
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr ""
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "dùng áp kiểu theo cách cũ"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr ""
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "gợi ý bao quanh biểu thức %<>>%> bằng dấu ngoặc đơn"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow ?: with omitted middle operand"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ không cho phép ?: với toán hạng ở giữa bị bỏ qua"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 #| msgid "fold-expressions only available with -std=c++1z or -std=gnu++1z"
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mẫu lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "cần kết thúc của capture-list"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 #| msgid "%<*this%> capture only available with -std=c++1z or -std=gnu++1z"
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "chụp %<*this%> chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr ""
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 #| msgid "%<*this%> capture only available with -std=c++1z or -std=gnu++1z"
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "chụp %<*this%> chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "%<@synthesize%> can not be used in categories"
 msgid "%<this%> cannot be captured by reference"
 msgstr "%<@synthesize%> không thể được dùng trong các-ta-lốc"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 #| msgid "%<*this%> capture only available with -std=c++1z or -std=gnu++1z"
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "chụp %<*this%> chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "khởi tạo chụp lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate instance variable %q+D"
 msgid "capture of non-variable %qE"
 msgstr "trùng biến minh dụ %q+D"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr ""
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 #| msgid "too many %<if%> clauses"
 msgid "too many %<...%> in lambda capture"
 msgstr "quá nhiều mệnh đề %<if%>"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr ""
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr ""
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 #| msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mẫu lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr ""
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr ""
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr ""
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 #| msgid "deduced return type only available with -std=c++14 or -std=gnu++14"
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "kiểu trả về deduced chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%q#D declared here"
+msgid "%q#E declared here"
+msgstr "%q#D được khai báo ở đây"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr ""
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "cần labeled-statement"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr ""
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr ""
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%E%> names the constructor, not the type"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%> tên cấu tử, không phải kiểu"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "lệnh không phải biểu thức hằng"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp cancel%> may only be used in compound statements"
 msgid "%<if consteval%> requires compound statement"
 msgstr "%<#pragma omp cancel%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "cần selection-statement"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "hàm trả về một mảng"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qE declared as a function"
 msgid "condition declares a function"
 msgstr "trường %qE được khai báo như là một hàm"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr ""
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "cần bộ khởi tạo"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 #| msgid "range-based %<for%> loops only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "vòng lặp range-based %<for%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "Loop variable at %C cannot be a coarray"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "Biến vòng lặp tại %C không thể là một coarray"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr ""
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr ""
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "cần iteration-statement"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 #| msgid "range-based %<for%> loops only available with -std=c++11 or -std=gnu++11"
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "vòng lặp range-based %<for%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in vector initializer"
 msgid "designators in %<template for%> initializer"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo véc-tơ"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr ""
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ cấm tính toán gotos"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "cần jump-statement"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration"
 msgid "expected module-partition"
 msgstr "cần khai báo"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-name"
 msgid "expected module-name"
 msgstr "cần template-name"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, gcc-internal-format
 msgid "module-declaration not permitted in header-unit"
 msgstr ""
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, gcc-internal-format
 msgid "module-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "scope opened here"
 msgstr "struct được định nghĩa ở đây"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 #| msgid "volatile argument"
 msgid "private module fragment"
 msgstr "đối số hay thay đổi"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, gcc-internal-format
 msgid "import-declaration must be at global scope"
 msgstr ""
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%qE may only occur once in an export declaration"
 msgstr "%<inline%> trong khai báo trống rỗng"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, gcc-internal-format
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "extra %<;%> outside of a function"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after class definition"
 msgid "extra %<;%> after in-class function definition"
 msgstr "cần %<;%> sau định nghĩa lớp"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "weakref is not supported in this configuration"
 msgid "attributes are not permitted in this position"
 msgstr "weakref không được hỗ trợ trong cấu hình này"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 #| msgid "attribute ignored"
 msgid "attributes may be inserted here"
 msgstr "thuộc tính bị bỏ qua"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, gcc-internal-format
 msgid "explicit specializations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, gcc-internal-format
 msgid "explicit instantiations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr ""
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%> không ở đầu của một khối"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr ""
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr ""
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr ""
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "%<typedef%> was ignored in this declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "%<typedef%> bị bỏ qua trong khai báo này"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "mẫu biến chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "khởi tạo chụp lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr ""
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 #| msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "mẫu biến chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "khai báo trống rỗng"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member function declaration"
 msgid "invalid initializer for structured binding declaration"
 msgstr "khai báo hàm thành viên không hợp lệ"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 #| msgid "Coarray declaration at %C"
 msgid "for-range-declaration cannot be %qs"
 msgstr "Khai báo Coarray tại %C"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of type %<void%> in parameter declaration"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "không thể dùng %<::%> trong khai báo đối số"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> được dùng bên ngoài lớp"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr ""
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %D"
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "kiểu phần xung đột với %D"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> thay đổi ý nghĩa trong C++11; hãy bỏ nó đi"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "%qD invalid in lambda"
 msgid "%qD invalid in condition"
 msgstr "%qD không hợp lệ trong lambda"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, gcc-internal-format
 msgid "%qD invalid in lambda"
 msgstr "%qD không hợp lệ trong lambda"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 #| msgid "%qD invalid in lambda"
 msgid "type-specifier invalid in lambda"
 msgstr "%qD không hợp lệ trong lambda"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr ""
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "các mẫu không thể là %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in explicit-specifier"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "đặc tả linkage không hợp lệ"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 #| msgid "static_assert without a message only available with -std=c++1z or -std=gnu++1z"
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "static_assert không có lời nhắn chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 #| msgid "static_assert without a message only available with -std=c++1z or -std=gnu++1z"
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "static_assert không có lời nhắn chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr ""
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr ""
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr ""
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr ""
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr ""
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "cannot expand initializer for member %qD"
 msgstr "thiếu bộ khởi tạo cho thành viên %qD"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr ""
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr ""
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr ""
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr ""
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr ""
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "cần định danh hậu tố"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr ""
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr ""
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "cần toán tử"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr ""
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated and has no effect"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "%qs đã lỗi thời và không có tác động gì"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr ""
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr ""
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr ""
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "dùng %<auto%> không hợp lệ trong đối số mẫu mặc định"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr ""
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "cần template-id"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr ""
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr ""
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr ""
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 #| msgid "invalid template-id"
 msgid "invalid template-argument-list"
 msgstr "template-id không hợp lệ"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "expected %<(%> after template-argument-list"
 msgstr "cần template-argument"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr ""
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "cần template-name"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr ""
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr ""
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "cần template-argument"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr ""
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 #| msgid "array notation expression cannot be used as a return value"
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "biểu thức không thể được dùng như một hàm"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr ""
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr ""
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, gcc-internal-format
 msgid "expected type specifier"
 msgstr "cần bộ chỉ định kiểu"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "việc dùng %<auto%> trong khai báo tham số chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "việc dùng %<auto%> trong khai báo tham số chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "việc dùng %<auto%> trong khai báo tham số chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in template argument"
 msgid "use of %<auto%> in template argument"
 msgstr "dùng %<auto%> không hợp lệ trong đối số mẫu"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "cần template-id cho kiểu"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "cần type-name (tên kiểu)"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE không phải tên một kiểu"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "concept defined here"
 msgstr "union được định nghĩa ở đây"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "dùng %qD không hợp lệ"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%> after %qE"
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "cần %<,%> hoặc %<)%> sau %qE"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr ""
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr ""
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr ""
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr ""
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD là một mẫu liệt kê"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD không phải tên một kiểu enumeration trong %qT"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr ""
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in enum-base"
 msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiểu"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "cần %<;%> hoặc %<{%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr ""
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, gcc-internal-format
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr ""
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr ""
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "không cho phép từ hạn định mở rộng"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ cấm kiểu liệt kê nặc danh không tên trống rỗng"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr ""
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr ""
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qE không phải tên một kiểu"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD không là một namespace-name"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "cần namespace-name"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 #| msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 #| msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "định nghĩa namespaces lồng nhau chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 #| msgid "expected namespace-name"
 msgid "nested namespace name required"
 msgstr "cần namespace-name"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, gcc-internal-format
 msgid "a nested namespace definition cannot have attributes"
 msgstr ""
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, gcc-internal-format
 msgid "a nested namespace definition cannot be inline"
 msgstr ""
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, gcc-internal-format
 msgid "namespace %qD entered"
 msgstr ""
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<namespace%> không cho phép định nghĩa ở đây"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr ""
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "fold-expressions chỉ sẵn sàng với -std=c++1z hay -std=gnu++1z"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr ""
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr ""
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qT không phải một kiểu enumeration"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "increment of pointer to an incomplete type %qT"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "tăng con trỏ tới loại không hoàn toàn %qT"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration here"
 msgid "opaque-enum-declaration here"
 msgstr "khai báo trước ở đây"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr ""
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 #| msgid "expected interface or pointer to interface"
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "cần giao diện hay con trỏ đến giao diện"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "trùng cv-qualifier"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT không phải là một namespace"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr ""
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 #| msgid "attribute declaration"
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "lời khai báo thuộc tính"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, gcc-internal-format
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr ""
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about implicit function declarations."
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "Cảnh báo về lời khai báo hàm ngầm."
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD redeclared as variable"
 msgid "add parentheses to declare a variable"
 msgstr "hàm %qD được định nghĩa lại thành một biến"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "cannot handle qualified name for variant function"
 msgstr "%qE không thể dùng như một hàm"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on constructors"
 msgstr ""
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on destructors"
 msgstr ""
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE argument not an identifier"
 msgid "cannot handle %s identifier name"
 msgstr "%qE đối số không phải là một định danh"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 #| msgid "implicit declaration of function %qE"
 msgid "no declaration of base function %qs in this scope"
 msgstr "khai báo ngầm của hàm %qE"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is ambiguous"
 msgid "base function is ambiguous"
 msgstr "%qs tại %L phải là số nguyên"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr ""
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr ""
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr ""
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, gcc-internal-format
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr ""
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "không cho phép định nghĩa hàm tại đây"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, gcc-internal-format
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr ""
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr ""
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "bộ khởi tạo được cung cấp cho hàm"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr ""
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr ""
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr ""
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr ""
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%> không phải một kiểu"
@@ -69737,283 +69835,283 @@ msgstr "%<%T::%E%> không phải một kiểu"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "bộ khai báo không hợp lệ"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "dùng cấu tử như là một mẫu là không hợp lệ"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "dùng %<%T::%D%> thay cho %<%T::%D%> cho tên của cấu tử trong tên hạn định"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "mã hạn định trong khai báo"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "cần câu khai báo"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD là một namespace"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr ""
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "cần ptr-operator"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "trùng cv-qualifier"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "đa ref-qualifiers"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, fuzzy, gcc-internal-format
 #| msgid "%E requires %<-fgnu-tm%>"
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "%E cần %<-fgnu-tm%>"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "trùng virt-specifier"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 #| msgid "missing template arguments after %qT"
 msgid "missing template arguments after %qE"
 msgstr "thiếu đối số mẫu sau %qT"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in template arguments"
 msgid "%qT not permitted in template argument"
 msgstr "các kiểu không nên được định nghĩa trong đối số mẫu"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "cách dùng không hợp lệ %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "các kiểu không nên được định nghĩa trong đối số mẫu"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "dùng %<auto%> không hợp lệ trong đối số mẫu"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "cần type-specifier"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "cần %<,%> hoặc %<…%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr ""
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specified for friend class declaration"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "%<inline%> được chỉ định cho khai báo lớp bạn"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr ""
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr ""
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr ""
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "%qD không thể có đối số mặc định"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "khởi tạo chụp lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow ?: with omitted middle operand"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ không cho phép ?: với toán hạng ở giữa bị bỏ qua"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr ""
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, gcc-internal-format
 msgid "%<...%> not allowed in designated initializer list"
 msgstr ""
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "cần class-name"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "cần %<;%> sau định nghĩa lớp"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "cần %<;%> sau định nghĩa cấu trúc"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "cần %<;%> sau định nghĩa kiểu hỗn hợp"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate virt-specifier"
 msgid "duplicate %qD specifier"
 msgstr "trùng virt-specifier"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "cần %<{%> hoặc %<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr ""
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr ""
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr ""
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr ""
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, gcc-internal-format
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr ""
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr ""
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr ""
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr ""
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 msgid "previous definition of %q#T"
 msgstr "khai báo trước đây của %q+#T"
@@ -70021,285 +70119,285 @@ msgstr "khai báo trước đây của %q+#T"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, gcc-internal-format
 msgid "expected class-key"
 msgstr "cần class-key"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "cần %<class%>, hoặc %<typename%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr ""
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 #| msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "việc dùng %<auto%> trong khai báo tham số chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr ""
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 #| msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "khởi tạo chụp lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "đã khởi tạo một bộ phận mảng dẻo"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "  non-static data member %qD has non-literal type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "  thành viên dữ liệu không-tĩnh %qD có kiểu không-văn-chương"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr ""
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr ""
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "cần %<;%> tại cuối khai báo thành viên"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr ""
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr ""
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 #| msgid "Warn whenever type qualifiers are ignored."
 msgid "attributes on base specifiers are ignored"
 msgstr "Cảnh báo khi nào đoạn điều kiện loại bị bỏ qua."
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr ""
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr ""
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr ""
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "ISO C++ không cho phép %<alignof%> với một non-type"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr ""
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "dùng %<auto%> không hợp lệ trong đặc tả ngoại lệ"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> chỉ sẵn sàng với -std=c++11 hay -std=gnu++11"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr ""
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> trong khai báo trống rỗng"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD không thể có đối số mặc định"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "cần %qT nhưng đối số là kiểu %qT"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr ""
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr ""
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr ""
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "cần %<:%> hoặc %<…%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, gcc-internal-format
 msgid "attribute with no arguments contains no parameter packs"
 msgstr ""
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected goto expression"
 msgid "expected conditional-expression"
 msgstr "cần điều lệnh goto"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %qs"
 msgid "%qs is only available with %qs"
 msgstr "%qs không tương thích với %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "thuộc tính %qE bị lờ đi cho %qE"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "Period required in format specifier"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "Bộ ghi rõ định dạng thì yêu cầu một dấu chấm"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 #| msgid "%<concept%> only available with -fconcepts"
 msgid "contracts are only available with %qs"
 msgstr "%<concept%> chỉ sẵn sàng với -fconcepts"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 #| msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "%<~auto%> chỉ sẵn sàng trên -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "mẫu biến chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 #| msgid "expression must be integral"
 msgid "expression must be enclosed in parentheses"
 msgstr "chỉ số phải là số nguyên"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "argument %qd is not a constant"
 msgid "result type is not a plain type-constraint"
 msgstr "đối số %qd không phải hằng số"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not constant"
 msgid "return-type-requirement is not a type-constraint"
 msgstr "yếu tố khởi tạo không phải hằng số"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr ""
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "khai báo không hợp lệ của %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr ""
@@ -70308,445 +70406,445 @@ msgstr ""
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr ""
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, gcc-internal-format
 msgid "template-id not allowed for constructor in C++20"
 msgstr ""
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr ""
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr ""
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr ""
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr ""
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr ""
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "đặc tả rõ ràng không hợp lệ"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr ""
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, gcc-internal-format
 msgid "a class template declaration must not declare anything else"
 msgstr ""
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr ""
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr ""
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr ""
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in template arguments"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "các kiểu không nên được định nghĩa trong đối số mẫu"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr "đối số cho %<sizeof…%> phải được bao quanh bởi dấu ngoặc đơn"
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr ""
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 #| msgid "section type conflict with %D"
 msgid "%qD specifier conflicts with %qs"
 msgstr "kiểu phần xung đột với %D"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%> trước %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 #| msgid "%qE used with %<typedef%>"
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%qE được dùng với %<typedef%>"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr ""
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "đã chỉ ra cả hai %<__thread%> và %<thread_local%>"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "trùng %qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "trùng %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "cần %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "cần %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "cần %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "cần %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "cần %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "cần %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "cần %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "cần %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "cần %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "cần %<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "cần %<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "cần %<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "cần %<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "cần %<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "cần %<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<data%>"
 msgid "expected %<auto%>"
 msgstr "cần %<data%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "cần %<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "cần %<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "cần %<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "cần %<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "cần %<__transaction_atomic%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "cần %<__transaction_relaxed%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<@end%>"
 msgid "expected %<co_yield%>"
 msgstr "cần %<@end%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "cần %<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "cần %<…%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "cần %<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "cần %<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "cần %<:%> hoặc %<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "cần %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr ""
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T trước đã khai báo ở đây"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "không thể khai báo tham chiếu đến %q#T"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr ""
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 #| msgid "expected class-key"
 msgid "replace the class-key with %qs"
 msgstr "cần class-key"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%qT defined as %qs here"
 msgstr "nhãn %qD được định nghĩa ở đây"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared here"
 msgid "%qT first declared as %qs here"
 msgstr "%qT được khai báo ở đây"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr ""
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr ""
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr ""
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr ""
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr ""
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr ""
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr ""
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr ""
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr ""
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr ""
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr ""
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "kiểu không hợp lệ cho biến instance (minh dụ)"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr ""
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr ""
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr ""
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, gcc-internal-format
 msgid "invalid type for property"
 msgstr "kiểu không hợp lệ cho thuộc tính"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "unknown property attribute %qE"
 msgstr "không hiểu thuộc tính tính chất"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected integer expression list"
 msgstr "cần biểu thức nguyên"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "biểu thức %<wait%> phải là số nguyên"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "cần %<class%>, %<typename%>, hoặc %<template%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "bộ khởi tạo sai"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in iterator type"
@@ -70756,185 +70854,185 @@ msgstr "các kiểu có lẽ không nên được định nghĩa trong áp kiể
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable không còn được hỗ trợ nữa"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr ""
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma omp section%> chỉ có thể sử dụng trong cấu trúc %<#pragma omp sections%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr ""
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qD is not a C pointer"
 msgstr "%qD không phải là một biến trỏ"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "cần %<target%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "mệnh đề khởi tạo không hợp lệ"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "cần id-expression (các đối số)"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr ""
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "%<#pragma omp declare reduction%> trước"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in template arguments"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "các kiểu không nên được định nghĩa trong đối số mẫu"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "cần %<=%>, %<,%>, %<;%>, %<asm%> hay %<__attribute__%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD không phải là hàm thành viên mẫu"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 #| msgid "an increment cannot appear in a constant-expression"
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "phép gia số không được phép xuất hiện trong biểu thức hằng"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "vòng ngoài hơn %<__transaction_cancel%> không nằm trong vòng ngoài hơn %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  hoặc một hàm %<transaction_may_cancel_outer%>"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "%<#pragma GCC pch_preprocess%> phải là đầu tiên"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp flush%> chỉ có thể sử dụng trong các biểu thức phức hợp"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma grainsize%> must be inside a function"
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "%<#pragma grainsize%> phải ở bên trong một hàm"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not implemented for -fPIC"
 msgid "multi-source compilation not implemented for C++"
 msgstr "-mnop-mcount không được thực hiện cho -fPIC"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "các mẫu ngầm không nên là %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -71419,507 +71517,512 @@ msgstr "đặc tả rõ ràng không hợp lệ"
 msgid "redeclaration of %qD with different constraints"
 msgstr "định nghĩa lại của typedef %q+D với kiểu khác"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr ""
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT không phải là một kiểu mẫu"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr ""
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] ""
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] ""
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "đối số mẫu %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "khai báo lại ở đây như là %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "redeclared here"
 msgstr "được khai báo ở đây"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of typedef %q+D with different type"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "định nghĩa lại của typedef %q+D với kiểu khác"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr ""
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of typedef %q+D with different type"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "định nghĩa lại của typedef %q+D với kiểu khác"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr ""
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr ""
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr ""
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qD không phải là thành viên của %qT"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 #| msgid "got %d template parameters for %q#D"
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "nhận được %d đối số mẫu cho %q#D"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr ""
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  kiểu không khớp %qT và %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr ""
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr ""
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE không tương đương với %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr ""
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr ""
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr ""
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr ""
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  kiểu hàm thành viên %qT không phải là một đối số mẫu hợp lệ"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  ứng cử cần ít nhất %d đối số, nhưng cung cấp %d"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  ứng cử cần %d đối số, %d được cung cấp"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  không thể chuyển đổi %qE (kiểu %qT) thành kiểu %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT là lớp cơ sở chưa rõ ràng của %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT không được dẫn xuất từ %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr ""
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "không thể giải mã địa chỉ"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "quá nhiều đối số cho cho phương thức %qE"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr ""
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr ""
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr ""
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 #| msgid "  member function type %qT is not a valid template argument"
 msgid "the address of %qD is not a valid template argument"
 msgstr "  kiểu hàm thành viên %qT không phải là một đối số mẫu hợp lệ"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 #| msgid "  member function type %qT is not a valid template argument"
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "  kiểu hàm thành viên %qT không phải là một đối số mẫu hợp lệ"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr ""
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr ""
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr ""
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 #| msgid "missing template arguments after %qT"
 msgid "in template argument for type %qT"
 msgstr "thiếu đối số mẫu sau %qT"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "quá nhiều đối số cho cho phương thức %qE"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr ""
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr ""
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr ""
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr ""
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "dùng %qE để thay thế"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr ""
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr ""
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "dùng %<auto%> không hợp lệ trong đối số mẫu"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr ""
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr ""
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr ""
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  cần hằng của kiểu %qT, nhưng lại nhận được %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr ""
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  cần mẫu lớp, nhưng lại nhận được %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  cần kiểu, nhưng lại nhận %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  cần một kiểu, nhưng lại nhận được %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  cần mẫu lớp, nhưng lại nhận được %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  cần mẫu kiểu %qD, nhưng lại nhận được %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, gcc-internal-format
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr ""
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  cần %qD nhưng lại nhận %qD"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "không thể chuyển đổi %qE từ %qT thành %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr ""
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "sai số lượng đối số hàm mẫu (%d, phải là %d)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "sai số lượng đối số mẫu (%d, cần ít nhất phải là %d)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, gcc-internal-format
 msgid "provided for %qD"
 msgstr "được cung cấp cho %qD"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr ""
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr ""
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D không phải là hàm mẫu"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr ""
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "cho khai báo hàm mẫu %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "template constraint failure"
 msgid "template constraint failure for %qD"
 msgstr "ràng buộc mẫu gặp lỗi nghiêm trọng"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "%qD không phải là một biến"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "score argument must be constant integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L must be nonnegative"
 msgid "score argument must be non-negative"
 msgstr "%s tại %L phải là số nguyên"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr ""
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "property must be constant integer expression"
 msgstr "cần biểu thức nguyên"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr ""
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "original definition appeared here"
 msgid "first error appeared here"
 msgstr "định nghĩa nguyên bản xuất hiện ở đây"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "cấu có không thành viên đã đặt tên"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE không ở đầu của khai báo"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr ""
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr ""
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, fuzzy, gcc-internal-format
 #| msgid "cannot find 'nm'"
 msgid "cannot index an empty pack"
 msgstr "không tìm thấy “nm”"
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of default argument for %q#D"
 msgid "  when instantiating default argument for call to %qD"
 msgstr "định nghĩa lại của đối số mặc định của %q#D"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mismatched arguments"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -71938,126 +72041,126 @@ msgstr "các đối số không tương ứng với nhau"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "biến %qD có kiểu hàm"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "kiểu đối số không hợp lệ %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "trong khai báo %q+D"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "hàm trả về một mảng"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "hàm trả về hàm"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "%qE is not usable in a splice type"
 msgstr "%qE không phải là một kiểu"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE không phải một biến trong mệnh đề %<aligned%>"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr ""
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr ""
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr ""
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr ""
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "đang tạo con trỏ đến thành viên của kiểu void"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "đang tạo mảng của %qT"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, gcc-internal-format
 msgid "%qD expanded to more than one element"
 msgstr ""
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT không phải có kiểu lớp, cấu trúc hay union"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr ""
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr ""
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected a reflection of a type template"
 msgstr "cần selection-statement"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "dùng %qs trong mẫu"
@@ -72065,213 +72168,213 @@ msgstr "dùng %qs trong mẫu"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<~%T%> as member of %qT"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "phần khai báo của %<~%T%> là thành viên của %qT"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr ""
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr ""
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr ""
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "yếu tố khởi tạo không phải là một biểu tượng hằng số"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr ""
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr ""
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr ""
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr ""
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "dùng %<this->%D%> thay thế"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "dùng %<%T::%D%> thay thế"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%+D đã khai báo weakref sau khi được dùng"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_choose_expr%>"
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "sai số lượng đối số cho %<__builtin_choose_expr%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments to %<__builtin_complex%>"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "đối số sai số lượng cho %<__builtin_complex%>"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT không phải là một lớp hay namespace"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD không phải là một lớp hay namespace"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "đang dùng trường không hợp lệ %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, gcc-internal-format
 msgid "%qT is/uses unnamed type"
 msgstr "%qT là/dùng kiểu nặc danh"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr ""
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr ""
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "biểu thức nguyên %qE không là hằng"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr ""
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr ""
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr ""
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 #| msgid "%s %#S"
 msgid "%s %#qS"
 msgstr "%s %#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr ""
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD không phải là một thành viên dữ liệu tĩnh của một mẫu lớp"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr ""
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr ""
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr ""
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr ""
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr ""
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr ""
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr ""
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr ""
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr ""
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr ""
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "previous specification in %q#D here"
 msgid "exception specification of %qD depends on itself"
 msgstr "sau đặc tả trước đây trong %q#D"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr ""
@@ -72283,539 +72386,599 @@ msgstr ""
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr ""
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr ""
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mẫu lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr ""
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mẫu lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr ""
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, gcc-internal-format
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr ""
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "a concept cannot be a member function"
 msgid "a concept cannot be constrained"
 msgstr "cấu tử không thể là hàm thành viên tĩnh"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace or unscoped enum"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT không phải là một namespace hay enum không hoạt vi"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, gcc-internal-format
 msgid "concept %qE has multiple template parameter lists"
 msgstr ""
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr ""
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "non-class template %qT used without template arguments"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "mẫu không phải lớp %qT được dùng mà không có đỗi số mẫu"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "mẫu lambda chỉ sẵn sàng với -std=c++14 hay -std=gnu++14"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "use #include instead"
 msgid "use %qD directly instead"
 msgstr "sử dụng #include để thay thế"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr ""
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo hợp"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "hàm không phải được tính để chèn vào trực tiếp"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo hợp"
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "hàm chung dòng %q+D được khai báo yếu"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr ""
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr ""
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr ""
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, gcc-internal-format
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, gcc-internal-format
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr ""
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, gcc-internal-format
 msgid "deduced expression type does not satisfy placeholder constraints"
 msgstr ""
 
 #: cp/reflect.cc:130
-#, fuzzy, gcc-internal-format
-#| msgid "%<_Atomic%> applied to a qualified type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "%<_Atomic%> áp dụng cho kiểu hạn định"
-
-#: cp/reflect.cc:137
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr ""
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr ""
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute applied to %s %s at %L"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "thuộc tính %s được áp dụng cho %s %s tại %L"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot be used for type declarations"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "%<constexpr%> không thể dùng cho khai báo kiểu"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr ""
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of %qE"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "kiểu không tương thích cho đối số %d của %qE"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%qT không phải là một namespace"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr ""
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn%'t understand version %s\n"
 msgid "couldn%'t throw %qs"
 msgstr "không thể hiểu phiên bản %s\n"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "cần %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not open dump file %qs: %m"
 msgid "couldn%'t look up %qs"
 msgstr "không thể mở tập tin dump %qs: %m"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  cần kiểu, nhưng lại nhận %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT không phải kiểu con trỏ đến đối tượng"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT must be a function type"
 msgstr "%qD không phải là một mẫu hàm"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "cần template-argument"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as an %<inline%> type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "%qD được khai báo là một kiểu %<inline%>"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "originally defined here"
 msgid "%<consteval%> block defined here"
 msgstr "định nghĩa lần đầu ở đây"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in template argument"
 msgid "invalid %<access_context%> argument"
 msgstr "dùng %<auto%> không hợp lệ trong đối số mẫu"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<decltype%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "cần %<decltype%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "gặp tham số thừa"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "incompatible type for argument %d of %qE"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "kiểu không tương thích cho đối số %d của %qE"
+
+#: cp/reflect.cc:7799
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr ""
+
+#: cp/reflect.cc:7802
+#, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr ""
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 #| msgid "unknown spec function %qs"
 msgid "unknown metafunction %qD"
 msgstr "không hiểu hàm đặc tả %qs"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "last argument must be an immediate"
 msgid "splice argument must be an expression of type %qs"
 msgstr "đối số cuối phải là giá trị trực tiếp"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot call function %qD"
+msgid "cannot splice a null reflection"
+msgstr "không thể gọi hàm %qD"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "không thể dùng %<::%> trong khai báo đối số"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared %<constexpr%>"
 msgid "add %<constexpr%>"
 msgstr "%qD chưa được khai báo %<constexpr%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "function definition declared %qs"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "định nghĩa hàm được khai báo là %qs"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "cần một biểu thức lôgíc"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, gcc-internal-format
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr ""
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 #| msgid "Factor complex constructors and destructors to favor space over speed."
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "Cảnh báo khi mọi bộ cấu trúc và bộ hủy cấu trúc đều là riêng"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, gcc-internal-format
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, gcc-internal-format
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr ""
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "invalid cast to abstract class type %qT"
+msgid "invalid class member access of type template %qE"
+msgstr "áp đổi kiểu trừu tượng cho kiểu lớp %qT không hợp lệ"
+
+#: cp/reflect.cc:9042
+#, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr ""
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr ""
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr ""
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD không phải là một mẫu hàm"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t specify %<-D%> without %<--main%>"
@@ -73162,613 +73325,613 @@ msgstr "định nghĩa không hợp lệ của kiểu hạn định %qT"
 msgid "invalid base-class specification"
 msgstr "đặc tả lớp-cơ-sở không hợp lệ"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "không thể chụp thành viên %qD trong hỗn hợp nặc danh"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD không bị bắt"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr ""
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 #| msgid "use of deleted function %qD"
 msgid "use of parameter outside function body"
 msgstr "dùng hàm bị xóa %qD"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "missing template arguments after %qT"
 msgid "missing template arguments"
 msgstr "thiếu đối số mẫu sau %qT"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr ""
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr ""
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr ""
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr ""
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "không hiểu kiểu của %qE"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT không phải một kiểu enumeration"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, gcc-internal-format
 msgid "pack index has non-integral type %qT"
 msgstr ""
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "pack index is not an integral constant"
 msgstr "kích cỡ mảng không phải là biểu thức hằng số nguyên"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "Đối số của hàm %s tại %L là âm"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr ""
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr ""
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr ""
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 #| msgid "a concept cannot be a member function"
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "cấu tử không thể là hàm thành viên tĩnh"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr ""
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "constructor priorities are not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "các quyền ưu tiên cấu tử là không được hỗ trợ"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr ""
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 #| msgid "%s %#D"
 msgid "%s %#qD"
 msgstr "%s %#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr ""
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr ""
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "biểu thức bước thẳng phải là số nguyên"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr ""
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD không phải một biến trong mệnh đề %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "biểu thức tĩnh %<gang%> phải nguyên"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 #| msgid "%<gang%> static value must bepositive"
 msgid "%<gang%> static value must be positive"
 msgstr "giá trị tĩnh %<gang%> phải dương"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "biểu thức số %<gang%> phải nguyên"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "chiều dài %<vector%> phải là số nguyên"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "biểu thức số %<worker%> phải là số nguyên"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<gang%> giá trị phải dương"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 #| msgid "%<vector%> length value must bepositive"
 msgid "%<vector%> length value must be positive"
 msgstr "chiều dài %<vector%> giá trị phải dương"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 #| msgid "%<worker%> num value must bepositive"
 msgid "%<worker%> num value must be positive"
 msgstr "%<worker%> giá trị phải dương"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr ""
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "%<async%> biểu thức phải nguyên"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "%<thread_limit%> biểu thức phải nguyên"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "chỉ số %<device%> phải là số nguyên"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD không phải một biến trong mệnh đề  %<aligned%>"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr ""
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %<depend%> clause"
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD không phải một biến trong mệnh đề %<depend%>"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not an argument in %<uniform%> clause"
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD không phải một đối số trong mệnh đề %<uniform%>"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in %<aligned%> clause"
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qE không phải một biến trong mệnh đề %<aligned%>"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %<aligned%> clause"
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD không phải một biến trong mệnh đề  %<aligned%>"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %<aligned%> clause"
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD không phải một biến trong mệnh đề  %<aligned%>"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr ""
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length traits arrays are not supported"
 msgstr "mảng có độ dài biến đổi được dùng"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable in %qs clause"
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD không phải một biến trong mệnh đề %qs"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "chỉ số %<device%> phải là số nguyên"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "chỉ số %<device%> phải là số nguyên"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 #| msgid "%<wait%> expression must be integral"
 msgid "%<hint%> expression must be integral"
 msgstr "biểu thức %<wait%> phải là số nguyên"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 #| msgid "%<wait%> expression must be integral"
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "biểu thức %<wait%> phải là số nguyên"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 #| msgid "%<wait%> expression must be integral"
 msgid "%<filter%> expression must be integral"
 msgstr "biểu thức %<wait%> phải là số nguyên"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "target is not pointer or reference to complete type"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "đích không phải là hàm trỏ hoặc tham chiếu đến loại hoàn toàn"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "%<tile%> value must be integral"
 msgid "%<tile%> argument needs integral type"
 msgstr "giá trị %<tile%> phải là số nguyên"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr ""
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr ""
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr ""
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr ""
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr ""
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "biểu thức %qE không phải là biểu thức hằng"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 #| msgid "static assertion failed: %s"
 msgid "static assertion failed: %.*s"
 msgstr "thẩm tra tĩnh gặp lỗi: %s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr ""
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "%<delete[]%> không phải biểu thức hằng"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 #| msgid "<unresolved overloaded function type>"
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "<chưa giải quyết loại hàm quá tải>"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT không phải là kiểu lớp"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT không phải là một kiểu mẫu"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "%<__builtin_next_arg%> được gọi mà không có đối số"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "%<__builtin_next_arg%> được gọi mà không có đối số"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "argument must be a field reference"
 msgid "%qs argument %qT is a reference"
 msgstr "đối số phải là một tham chiếu trường"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class template"
 msgid "%qD is not a class or alias template"
 msgstr "%qE không phải một lớp mẫu"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, gcc-internal-format
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr ""
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_call_with_static_chain%> must be a pointer type"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -73777,369 +73940,369 @@ msgstr "đối số 1 của __builtin_paired_predicate phải là một hằng"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "%<this%> có lẽ không nên được dùng trong ngữ cảnh này"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr ""
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 #| msgid "  declared here"
 msgid " declared here"
 msgstr "  đã được khai báo ở đây"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%qT is a floating-point type"
 msgstr "%qT không phải một kiểu enumeration"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "%qT không phải là một kiểu mẫu"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT không là cơ sở của %qT"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T có thành viên dữ liệu con trỏ"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "so sánh giữa %qT và %qT"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs không phải là tập tin dữ liệu gcov"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "  base class %qT of %q+T is non-literal"
 msgid "base class %qT is not public"
 msgstr "  lớp cơ sở %qT của %q+T là non-literal"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not captured"
 msgid "%qD is not public"
 msgstr "%qD không bị bắt"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qD is mutable"
 msgstr "%qD không phải là một biến"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD has a non-structural type"
 msgstr "%qD không phải là một kiểu"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "đối số thuộc tính phần không phải là một hằng chuỗi"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "thuộc tính %qE chỉ áp dụng cho các hàm"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%<typeof%> applied to a bit-field"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "%<typeof%> được áp dụng cho một bit-field"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 #| msgid "the %qE attribute requires arguments"
 msgid "%qE attribute takes no arguments"
 msgstr "thuộc tính %qE cần tham số"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute doesn't apply to functions"
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "Thuộc tính %qE không được áp dụng cho các hàm"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "khai báo hàm không hợp lệ"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an enumeration type"
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT không phải một kiểu enumeration"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "%<__alignof%> được áp dụng cho trường bít"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 #| msgid "<unnamed-fixed:"
 msgid "%qE on unnamed bit-field"
 msgstr "<không tên cố định:"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr ""
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "bộ khởi tạo chứa một chỉ mục mảng không phải là một biểu tượng hằng số nguyên"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr ""
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr ""
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, gcc-internal-format
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr ""
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as member of %qT"
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "sự khai báo của %qD như là thành viên của %qT"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "thuộc tính %qE cần tham số"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr ""
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr ""
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr ""
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr ""
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr ""
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr ""
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr ""
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr ""
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr ""
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr ""
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 #| msgid "Warn if a comparison always evaluates to true or false."
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "Cảnh báo khi so sánh luôn ước lượng là đúng hoặc là sai."
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, gcc-internal-format
 msgid "annotation on a type other than class or enumeration definition"
 msgstr ""
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "Thuộc tính %qE chỉ được áp dụng cho các biến"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr ""
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as parameter"
 msgid "annotation on void parameter"
 msgstr "khai báo của %qD như là đối số"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have structural type"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "hàm không trả về kiểu chuỗi"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -74345,833 +74508,839 @@ msgstr "%q#T không có thành viên nào mang tên %qE; ý bạn là %qE?"
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%q#T không có thành viên nào mang tên %qE; ý bạn là %qE?"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> không phải là thành viên của %qT"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD không phải là thành viên của %qT"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD không phải là hàm thành viên mẫu"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT không phải kiểu con trỏ đến đối tượng"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr ""
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr ""
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr ""
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr ""
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "Generate default single-precision SH4 code."
 msgid "no default version in scope"
 msgstr "Tạo ra mã SH4 chính xác đơn mặc định."
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ cấm gọi %<::main%> từ bên trong chương trình"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr ""
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE không thể dùng như một hàm"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE không thể dùng như một hàm"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD không thể được dùng như một hàm"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "biểu thức không thể được dùng như một hàm"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "quá nhiều đối số cho cấu tử %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "quá ít đối số cho hủy tử %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "quá nhiều đối số cho hàm thành viên %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "quá ít đối số cho hàm thành viên %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "quá nhiều đối số cho hàm %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "quá ít đối số cho hàm %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "quá nhiều đối số cho phương thức %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "quá ít đối số cho phương thức %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "quá nhiều đối số cho hàm"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "quá ít đối số cho hàm"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 #| msgid "the compiler can assume that the address of %qD will never be NULL"
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "trình biên dịch sẽ coi rằng địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "trình biên dịch sẽ coi rằng địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "các toán hạng ?: có kiểu khác %qT và %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "operands to ?: have different types %qT and %qT"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "các toán hạng ?: có kiểu khác %qT và %qT"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr ""
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "NULL được dùng trong số học"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr ""
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "các kiểu toán hạng là %qT và %qT"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr ""
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "Unrecognized option to floating-point init value: %qs"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "Không nhận ra tùy chọn để khởi tạo giá trị dấu chấm động: %qs"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr ""
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr ""
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr ""
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr ""
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of constructor %qE"
 msgid "taking address of constructor %qD"
 msgstr "lấy địa chỉ của cấu tử %qE"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "taking address of destructor %qD"
 msgstr "lấy địa chỉ của hủy tử %qE"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  cần qualified-id"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr ""
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr ""
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr ""
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr ""
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, gcc-internal-format
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr ""
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "đang lấy địa chỉ của mẫu"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr ""
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr ""
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 msgid "attempt to take address of bit-field"
 msgstr "không thể lấy địa chỉ của %qs"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 #| msgid "%<~%> on a boolean expression"
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "%<~%> trên một biểu thức lôgíc"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr ""
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr ""
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr ""
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr ""
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr ""
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr ""
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr ""
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr ""
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr ""
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr ""
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 #| msgid "useless cast to type %qT"
 msgid "useless cast to type %q#T"
 msgstr "trừ phi ép thành kiểu %qT"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "%E qualifier ignored on asm"
 msgid "type qualifiers ignored on cast result type"
 msgstr "từ hạn định %E bị bỏ qua trên asm"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "chuyển đổi từ %qT thành %qT không hợp lệ"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "kiểu lớp %qT chưa hoàn thiện"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "đang chuyển đổi từ %qT thành %qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "chuyển đổi từ %qT thành %qT không hợp lệ"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "áp đổi kiểu tử %qT thành %qT làm mất độ chính xác"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "áp đổi kiểu tử %qT thành %qT yêu cầu tăng cân chỉnh của kiểu đích"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr ""
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr ""
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, gcc-internal-format
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr ""
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "không thể chuyển đổi kiểu %qT thành %qT"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid conversion from %qT to %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "chuyển đổi từ %qT thành %qT không hợp lệ"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ cấm việc áp đổi kiểu của mảng %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr ""
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, gcc-internal-format
 msgid "moving %qE of type %qT to itself"
 msgstr ""
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  trong định giá %<%Q(%#T, %#T)%>"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "gán giá trị cho mảng từ một danh sách bộ khởi tạo"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "phép gán %qT cho %qT không tương thích kiểu"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "mảng được dùng như là bộ khởi tạo"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "gán mảng không hợp lệ"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr ""
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr ""
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 #| msgid "%qD cannot have default arguments"
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "%qD không thể có đối số mặc định"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 #| msgid "cannot convert %qT to %qT"
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "không thể chuyển đổi %qT thành %qT"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 #| msgid "cannot convert %qT to %qT"
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "không thể chuyển đổi %qT thành %qT"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 #| msgid "cannot convert %qT to %qT"
 msgid "cannot convert %qH to %qI in return"
 msgstr "không thể chuyển đổi %qT thành %qT"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 #| msgid "cannot convert %qT to %qT"
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "không thể chuyển đổi %qT thành %qT"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr ""
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, gcc-internal-format
 msgid "in passing argument %P of %qD"
 msgstr "trong đối số chuyển qua %P của %qD"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "trả về tham chiếu đến tạm thời (temporary)"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "trả về tham chiếu đến tạm thời (temporary)"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, gcc-internal-format
 msgid "reference to local variable %qD returned"
 msgstr "tham chiếu đến biến cục bộ %qD được trả về"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "địa chỉ của nhãn %qD được trả về"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, gcc-internal-format
 msgid "address of local variable %qD returned"
 msgstr "địa chỉ của biến cục bộ %q+D được trả về"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "too many values in return statement"
 msgid "redundant move in return statement"
 msgstr "quá nhiều giá trị trong lệnh trả về"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "<During initialization>\n"
 msgid "redundant move in initialization"
 msgstr "<Khi khởi tạo>\n"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "trả về một giá trị từ hủy tử"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "trả về một giá trị từ cấu tử"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr ""
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, gcc-internal-format
 msgid "returning initializer list"
 msgstr "trả về danh sách bộ khởi tạo"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr ""
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr ""
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with a value, in function returning 'void'"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "biểu thức trả về với một giá trị, trong hàm trả lại “void”"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, gcc-internal-format
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr ""
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr ""
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 #| msgid "using temporary as lvalue"
 msgid "using rvalue as lvalue"
@@ -75588,19 +75757,19 @@ msgstr "không thể mở tập tin nhật ký %<vtv_set_ptr_data.log%>: %m"
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr "không thể mở tập tin nhật ký %<vtv_count_data.log%>: %m"
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 #| msgid "unknown property attribute"
 msgid "unknown attribute %qs"
 msgstr "không hiểu thuộc tính tính chất"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%+D declared weak after being used"
 msgid "%q+D declared weak after being used"
 msgstr "%+D đã khai báo weak sau khi được dùng"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -75628,46 +75797,46 @@ msgstr "thiếu bộ khởi tạo cho thành viên %qD"
 msgid "the address of %qD will never be %<null%>"
 msgstr "địa chỉ của %qD sẽ không bao giờ là NULL"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "không thể khai báo con trỏ đến %q#T"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code."
 msgid "nested function missing body"
 msgstr "Lưu các tên hàm trong mã đối tượng."
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr ""
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "expression cannot be used as a function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "biểu thức không thể được dùng như một hàm"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "Array reference out of bounds"
 msgid "forward reference to frame of %qs"
@@ -75753,36 +75922,36 @@ msgstr "đối số hợp lệ cho cho %qs là: %s"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "đối số hợp lệ cho cho %qs là: %s"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "can%'t mở %s để ghi: %m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "mở tập tin kết xuất %s: %m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "can%'t mở %s để ghi: %m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "mở tập tin phụ thuộc %s: %m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -75889,7 +76058,7 @@ msgstr "không hiểu mô hình TLS %qs"
 msgid "%qs is not an associative array"
 msgstr "%qD không phải là một biến trỏ"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -75906,25 +76075,25 @@ msgstr "%qD thường không phải là hàm non-static"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs không hợp lệ cho %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 #| msgid "recursively required from %q#D\n"
 msgid "recursive reference %qs"
 msgstr "yêu cầu đệ quy từ %q#D\n"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "tràn trong biểu thức hằng"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%qs is not an expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "type %qs is not an expression"
@@ -76018,17 +76187,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -76358,8 +76527,8 @@ msgstr ""
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -76642,7 +76811,7 @@ msgstr "Danh sách tên “%s” không thể là đối số tại %L"
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là hằng"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr ""
@@ -76724,7 +76893,7 @@ msgstr "đối số %qs của %qs intrinsict tại %L phải là THỰC hay PH
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là NGUYÊN hay THỦ TỤC"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là hằng"
@@ -76868,7 +77037,7 @@ msgstr ""
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr ""
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr ""
@@ -76883,7 +77052,7 @@ msgstr ""
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr ""
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr ""
@@ -77025,8 +77194,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr ""
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr ""
@@ -77127,9 +77296,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr ""
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr ""
@@ -77144,12 +77313,12 @@ msgstr ""
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr ""
@@ -77246,633 +77415,633 @@ msgstr "Đối số %qs của hạn chế %qs tại %L phải là thực thể d
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr ""
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr ""
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Different character kinds at %L"
 msgstr "Tên có chứa ký tự không hợp lệ tại %C"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr ""
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr ""
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là NGUYÊN hay THỦ TỤC"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr ""
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "Đối số %qs của hạn chế %qs tại %L phải là khoảng 1 hay 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là hằng"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là NGUYÊN hay THỰC"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "Tham số %qs của hạn chế %qs tại %L phải là SỐ-NGUYÊN"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr ""
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr ""
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr ""
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr ""
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là NGUYÊN hay THỰC"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr ""
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr ""
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr ""
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr ""
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a scalar"
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là tuyến tính"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a logical array"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là mảng lôgíc"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr ""
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr ""
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr ""
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr ""
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr ""
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr ""
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr ""
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr ""
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr ""
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr ""
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr ""
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr ""
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr ""
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr ""
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr ""
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr ""
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr ""
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD is not a function returning a pointer"
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "%qD không phải là một hàm trả về con trỏ"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr ""
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr ""
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr ""
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr ""
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr ""
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr ""
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr ""
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr ""
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr ""
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a scalar"
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là tuyến tính"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr ""
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr ""
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "Quá nhiều đối số cho %s tại %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr ""
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "STAT= argument to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "STAT= đối số cho %s tại %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be %s"
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be %s"
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr ""
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr ""
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr ""
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr ""
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr ""
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr ""
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "Quá nhiều đối số cho %s tại %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, gcc-internal-format, gfc-internal-format
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr ""
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr ""
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr ""
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr ""
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr ""
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a scalar"
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là tuyến tính"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là hằng"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr ""
@@ -77938,12 +78107,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr ""
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr ""
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr ""
@@ -77994,2089 +78163,2089 @@ msgstr ""
 msgid "Simplification error"
 msgstr "gimplification gặp lỗi"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs cannot appear in a constant-expression"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%qs không thể xuất hiện trong biểu thức hằng"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr ""
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "Sự khởi tạo kiểu cũ tại %C"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo vô hướng"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "chiều dài véc-tơ phải là một hằng nguyên"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected data constant after repeat spec at %C"
 msgstr "Cần tham chiếu thành phần tại %C"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, gcc-internal-format, gfc-internal-format
 msgid "End of scalar initializer expected at %C"
 msgstr ""
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Not enough elements in array initializer at %C"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo mảng"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Too many elements in array initializer at %C"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo mảng"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "Lỗi trong khởi tạo con trỏ tại %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr ""
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr ""
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr ""
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, gcc-internal-format
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "Tên “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "sự khai báo lại %q+D khác trong %<constexpr%>"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr ""
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr ""
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr ""
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "Ký hiệu “%qs” tại %C đã sẵn được khai báo tại %L"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "chiều dài véc-tơ phải là một hằng nguyên"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr ""
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr ""
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr ""
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr ""
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr ""
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs at %L already is initialized at %L"
 msgid "Bad shape of initializer at %L"
 msgstr "“%qs” tại %L đã được khởi tạo tại %L rồi"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot determine shape of initializer at %L"
 msgstr "gặp yếu tố thừa trong bộ khởi tạo mảng"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is incompatible with %s %s"
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "%qs không tương thích với %s %s"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr ""
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "Đối số %qs của %qs với PASS(%s) tại %L phải là vô hướng"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, gcc-internal-format
 msgid "Component %qs at %C already declared at %L"
 msgstr "Thành phần “%qs” tại %C đã sẵn được khai báo tại %L"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr ""
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr ""
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, gcc-internal-format
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr ""
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr ""
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "Lỗi trong khởi tạo con trỏ tại %C"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "Khởi tạo con trỏ khác KHÔNG tại %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr ""
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %C is not a member of the %qs structure"
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%qs tại %C không phải là thành viên của cấu trúc %qs"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "%qs function cannot have arguments"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%qs hàm không có đối số"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "Tên có chứa ký tự không hợp lệ tại %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr ""
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr ""
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Function %qs at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate %s specification at %C"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "Trùng đặc tả %s tại %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set pointee array spec."
 msgstr "không thể chuyển đổi thành kiểu con trỏ"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "Sự khởi tạo kiểu cũ tại %C"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr ""
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "Lỗi trong khởi tạo con trỏ tại %C"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr ""
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr ""
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr ""
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr ""
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr ""
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function %qs at %L cannot have an initializer"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr ""
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr ""
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr ""
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr ""
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr ""
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr ""
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr ""
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr ""
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr ""
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr ""
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr ""
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr ""
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr ""
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parametrized derived type argument"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "đối số kiểu được dẫn suất tham số hóa"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "kiểu BYTE tại %C"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr ""
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr ""
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "Giả định kiểu tại %C"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr ""
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid type-spec at %C"
 msgid "Malformed type-spec at %C"
 msgstr "type-spec không hợp lệ tại %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr ""
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr ""
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "câu lệnh CLASS tại %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr ""
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr ""
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr ""
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr ""
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr ""
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr ""
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "câu lệnh IMPORT tại %C"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, gcc-internal-format
 msgid "import-name %qs at %C is in the local scope"
 msgstr ""
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr ""
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr ""
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr ""
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr ""
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr ""
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr ""
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "Trùng thuộc tính %s tại %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "Tham số %qs của hạn chế %qs tại %L phải là SỐ-NGUYÊN"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected :: in TYPE definition at %C"
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Cần :: trong định nghĩa KIỂU tại %C"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "Tham số %qs của hạn chế %qs tại %L phải là SỐ-NGUYÊN"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr ""
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr ""
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "thuộc tính ASYNCHRONOUS tại%C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "thuộc tính CONTIGUOUS tại %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "thuộc tính BẢO VỆ tại %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "thuộc tính VALUE tại %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "thuộc tính VOLATILE tại %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr "match_attr_spec(): Thuộc tính sai"
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr ""
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr ""
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr ""
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "Return value %qs of function %qs declared at %L not set"
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "Trả lại giá trị %sq của hàm %qs khai báo tại %L chưa đặt"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr ""
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, gcc-internal-format
 msgid "Missing symbol"
 msgstr "Thiếu ký hiệu"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "BIND(C) tại %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr ""
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "Tiền tố MODULE tại %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr ""
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "thủ tục IMPURE tại %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr ""
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Left parenthesis required after %<*%>"
 msgid "A type parameter list is required at %C"
 msgstr "Đẳng sau “%<*%>” thì yêu cầu một dấu ngoặc đơn mở"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr ""
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Left parenthesis required after %<*%>"
 msgid "A parameter name is required at %C"
 msgstr "Đẳng sau “%<*%>” thì yêu cầu một dấu ngoặc đơn mở"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr ""
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a nameless interface at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "Cần một giao diện không tên tại %C"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr ""
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol %qs in formal argument list at %C"
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "Trùng ký hiệu %qs trong danh sách đối số hình thức tại %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "Trùng ký hiệu %qs trong danh sách đối số hình thức tại %C"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr ""
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr ""
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr ""
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr ""
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr ""
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "Thủ tục “%qs” tại %L đã sẵn có kiểu cơ bản của %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr ""
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr ""
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr ""
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr ""
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "câu lệnh ENTRY tại %C"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr ""
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr ""
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr ""
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr ""
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "Hàm khai báo tại %L không phải xuất hiện trong một GIAO DIỆN"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr ""
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr ""
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr ""
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr ""
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr ""
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr ""
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr ""
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "Không cần câu lệnh ENTRY tại %C"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr ""
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr ""
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr ""
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr ""
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr ""
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr ""
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "Không cần câu lệnh END tại %C"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr ""
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "cần lệnh %s tại %L"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "Cần câu lệnh %s tại %L"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr ""
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "Cần tên chấm dứt tại %C"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr ""
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr ""
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr ""
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr ""
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "Cần %<(%> tại %C"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "Cần tên biến tại %C"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr ""
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr ""
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "Cần \",\" tại %C"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
 msgstr "không thể chuyển đổi thành kiểu con trỏ"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr ""
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "Cần \")\" tại %C"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "cần %<,%> hoặc kết thúc câu lệnh tại %C"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr ""
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "câu lệnh CONTIGUOUS tại %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr ""
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr ""
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr ""
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "Không cần câu lệnh %s tại %C"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "Không cần câu lệnh %s tại %C"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in STATIC statement at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr ""
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr ""
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr ""
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "câu lệnh VALUE tại %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "câu lệnh VOLATILE tại %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr ""
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "câu lệnh ASYNCHRONOUS tại %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr ""
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr ""
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr ""
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr ""
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr ""
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr ""
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr ""
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "Kiểu TRỪU TƯỢNG tại %C"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr "gặp lỗi khi đóng tập tin thống kê %s [%s]"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "câu lệnh IMPORT tại %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "Không cần câu lệnh END tại %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %C is not a member of the %qs structure"
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "%qs tại %C không phải là thành viên của cấu trúc %qs"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "Không cần câu lệnh CASE tại %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "Cần :: trong định nghĩa KIỂU tại %C"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "derived type declaration"
 msgid "Mangled derived type definition at %C"
 msgstr "lời khai báo loại có hướng"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr ""
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr ""
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs at %L already has basic type of %s"
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "Thủ tục “%qs” tại %L đã sẵn có kiểu cơ bản của %s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "thẻ %s tại %L phải là kiểu %s"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr ""
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, gcc-internal-format, gfc-internal-format
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr ""
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "ENUM và ENUMERATOR tại %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr ""
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr ""
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr ""
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr ""
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr ""
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr ""
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr ""
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr ""
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "Trùng DEFERRED tại %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "Cần access-specifier tại %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "Cần thuộc tính ràng buộc tại %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr ""
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr ""
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "cần %<)%> tại %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "Cần tên ràng buộc tại %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "danh sách PROCEDURE tại %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr ""
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr ""
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr ""
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "Cần %<::%> tại %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr ""
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "Cần %<=>%> tại %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr ""
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown procedure name %qs at %C"
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "Không rõ tên thủ tục “%qs” tại %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr ""
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected access-specifier at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "Cần access-specifier tại %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "Không cần câu lệnh END tại %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr ""
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr ""
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr ""
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr ""
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr ""
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr ""
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "FINAL trống rỗng tại %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr ""
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "Cần %<,%> tại %C"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "Không rõ tên thủ tục “%qs” tại %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs at %C is already defined at %L"
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr ""
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in expression at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in expression at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in expression at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in expression at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -80226,411 +80395,411 @@ msgstr "thủ tục IMPURE tại %C"
 msgid "IM part_ref at %C"
 msgstr "Tiền tố MODULE tại %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr ""
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr ""
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr ""
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr ""
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr ""
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr ""
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr ""
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr ""
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr ""
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr ""
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr ""
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr ""
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr ""
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "Function %qs at %L must be PURE"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "Hàm %qs tại %L phải là PURE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr ""
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr ""
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr ""
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "Biến %qs không thể xuất hiện trong biểu thức tại %L"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "check_restricted(): không hiểu kiểu biểu thức"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "Hàm %qs tại %L phải là PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "Biểu thức tại %L phải thuộc kiểu scalar"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "Vùng không tương thích nhau trong %s (%d và %d) tại %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr ""
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, gcc-internal-format
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr ""
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr ""
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal assignment to external procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr ""
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr ""
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr ""
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr ""
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr ""
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 #| msgid "Expected a procedure for argument %qs at %L"
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "Cần một thủ tục cho đối số %qs tại %L"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr ""
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "an assignment cannot appear in a constant-expression"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "phép gán không thể được xuất hiện trong biểu thức hằng"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr ""
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr ""
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr ""
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr ""
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr ""
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr ""
@@ -80638,202 +80807,202 @@ msgstr ""
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr ""
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr ""
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "bổ từ %qE không phải là biểu thức hằng"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr ""
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr ""
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr ""
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr ""
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr ""
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr ""
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure %qs is used as actual argument at %L"
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Thủ tục nội tại %qs được dùng làm đối số thật tại %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 #| msgid "Error in pointer initialization at %C"
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "Lỗi trong khởi tạo con trỏ tại %C"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr ""
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr ""
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs cannot appear in the expression at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "Biến %qs không thể xuất hiện trong biểu thức tại %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs cannot appear in the expression at %L"
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "Biến %qs không thể xuất hiện trong biểu thức tại %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "Biến %qs không thể xuất hiện trong biểu thức tại %L"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr ""
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr ""
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr ""
@@ -80854,7 +81023,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -80918,43 +81087,43 @@ msgstr ""
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "containing loop"
 msgid "Interchanging loops at %L"
 msgstr "chứa vòng lặp"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "%s between %L and %L"
@@ -81083,12 +81252,12 @@ msgstr ""
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr ""
@@ -81521,310 +81690,315 @@ msgstr ""
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr ""
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr ""
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr ""
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "Thiếu đối số đối thực tế cho đối số %qs tại %L"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr "compare_actual_expr(): Mã thành phần sai"
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr "check_some_aliasing(): Danh sách không khớp"
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr "check_intents(): Danh sách không khớp"
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr ""
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr ""
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr ""
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr ""
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs called at %L is not explicitly declared"
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "Thủ tục %qs được gọi tại %L không được khai báo rõ ràng"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "Thủ tục %qs được gọi tại %L không được khai báo rõ ràng"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr ""
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr ""
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected a procedure for argument %qs at %L"
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "Cần một thủ tục cho đối số %qs tại %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr ""
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr ""
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr ""
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr ""
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr ""
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr ""
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "không thể tìm thấy ký hiệu %qs"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr ""
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr "gfc_add_interface(): Kiểu giao diện sai"
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 #| msgid "Can't overwrite GENERIC %qs at %L"
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "không thể đè GENERIC %qs tại %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr ""
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr ""
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr ""
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr ""
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr ""
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr ""
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr ""
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr ""
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr ""
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr ""
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr ""
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "thẻ %s tại %L phải là kiểu %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là các loại %d"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "Đối số giả chưa dùng %qs tại %L"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Quá nhiều đối số cho %s tại %L"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "Quá nhiều đối số cho %s tại %L"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr ""
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "Tham số %qs của thủ tục cơ bản tại %L phải là vô hướng"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "Quá nhiều đối số trong cuộc gọi đến %qs tại %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "Quá nhiều đối số trong cuộc gọi đến %qs tại %L"
@@ -82022,7 +82196,7 @@ msgstr "Chuyển đổi từ %s sang %s tại %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -82597,7 +82771,7 @@ msgstr ""
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr ""
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr ""
@@ -82774,12 +82948,12 @@ msgstr "Tràn số nguyên"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -83299,7 +83473,7 @@ msgstr ""
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr ""
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s at %L must be a scalar"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -83828,95 +84002,95 @@ msgstr ""
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "%qD chưa được khai báo trong phạm vi này"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr ""
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C"
 msgid "SELECT RANK statement at %C"
 msgstr "câu lệnh ENTRY tại %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "Không cần câu lệnh CASE tại %C"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr ""
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr ""
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr ""
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "Không cần câu lệnh END tại %C"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr ""
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in expression at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "Gặp lỗi cú pháp trong biểu thức tại %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr ""
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr ""
@@ -84950,7 +85124,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr ""
@@ -84986,12 +85160,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr ""
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -85496,7 +85670,7 @@ msgstr ""
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr ""
@@ -85518,7 +85692,7 @@ msgstr "Con trỏ Cray %qs trong mệnh đề %s tại %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Con trỏ Cray %qs trong mệnh đề %s tại %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr ""
@@ -85550,17 +85724,17 @@ msgstr ""
 msgid "POINTER object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr ""
@@ -85681,8 +85855,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr ""
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr ""
@@ -85763,7 +85937,7 @@ msgstr "Đối tượng %qs không phải là một biến tại %L"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "Đối tượng %qs không phải là một biến tại %L"
@@ -85786,7 +85960,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr ""
@@ -85828,7 +86002,7 @@ msgstr "Ký hiệu “%qs” tại %C đã sẵn được khai báo tại %L"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr ""
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -86153,607 +86327,617 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "biến LINEAR %qs tại %L phải là SỐ-NGUYÊN"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr ""
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "%qE không phải là biểu thức hằng"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, gcc-internal-format
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, gcc-internal-format
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, gcc-internal-format
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "Vùng không tương thích nhau trong %s (%d và %d) tại %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "SIZES requires constant expression at %L"
 msgstr "TILE cần biểu thức hằng tại %L"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The event variable at %L shall not be coindexed "
 msgid "The event handle at %L must not be an array element"
 msgstr "Biến sự kiện tại %L sẽ không thể là coindexed "
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The event variable at %L shall not be coindexed "
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "Biến sự kiện tại %L sẽ không thể là coindexed "
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "!$OMP ATOMIC phân bổ bên trong phải là MIN, MAX, IAND, IOR hay IEOR tại %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "cần biểu thức"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "cần biểu thức nguyên"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 #| msgid "%<priority%> value must be non-negative"
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%<priority%> giá trị phải dương"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer value too large in expression at %C"
 msgid "property must be a logical expression at %L"
 msgstr "Giá trị số nguyên quá lớn trong biểu thức tại %C"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "chiều dài véc-tơ phải là một hằng nguyên"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "property must be a constant logical expression at %L"
 msgstr "TILE cần biểu thức hằng tại %L"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ordered argument needs positive constant integer expression"
 msgid "property must be a constant integer expression at %L"
 msgstr "cần biểu thức nguyên"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "TILE cần biểu thức hằng tại %L"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr ""
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -87424,64 +87608,64 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr ""
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr ""
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr ""
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "Hàm khai báo tại %L không phải xuất hiện trong một GIAO DIỆN"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr ""
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr ""
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs at %C is already defined at %L"
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure %qs at %C is already defined at %L"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "Thủ tục “%qs” tại %C đã được định nghĩa trước tại %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr ""
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr ""
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr ""
@@ -87489,7 +87673,7 @@ msgstr ""
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr ""
@@ -87952,1113 +88136,1113 @@ msgstr ""
 msgid "%qs at %C is not a variable"
 msgstr "%qs tại %C không phải là một biến"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "%qs tại %L phải là kiểu ABSTRACT %s"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "Kiểu TRỪU TƯỢNG tại %qs được dùng tại %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr ""
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr ""
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "Giao diện %qs tại %L không thể là hàm khai báo"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr ""
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr ""
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr ""
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr ""
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr ""
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr ""
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr ""
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr ""
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "Tham số %qs của thủ tục cơ bản tại %L phải là vô hướng"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr ""
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "Tham số %qs của thủ tục cơ bản tại %L phải là vô hướng"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr ""
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr ""
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 #| msgid "Return value of function %qs at %L not set"
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Trả lại giá trị của hàm %qs tại %L chưa đặt"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr ""
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr ""
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr ""
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Namelist '%s' can not be an argument at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Danh sách tên “%s” không thể là đối số tại %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Namelist '%s' can not be an argument at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "Danh sách tên “%s” không thể là đối số tại %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "Ký hiệu %qs tại %C đã có trong khối COMMON"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "Ký hiệu %qs tại %C đã có trong khối COMMON"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr ""
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr ""
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 #| msgid "Variable %qs cannot appear in the expression at %L"
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Biến %qs không thể xuất hiện trong biểu thức tại %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr ""
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr ""
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr ""
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr ""
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr ""
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "%qs tại %L phải là số nguyên"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr ""
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr ""
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr ""
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr ""
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr ""
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr ""
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 #| msgid "Internal procedure %qs is used as actual argument at %L"
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Thủ tục nội tại %qs được dùng làm đối số thật tại %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Thủ tục nội tại %qs được dùng làm đối số thật tại %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "Ký hiệu “%qs” tại %L chưa rõ ràng"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr ""
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr ""
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr ""
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr ""
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr ""
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr ""
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr ""
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr ""
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "Không thể phân giải hàm đặc tả %qs tại %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "%qE không phải tên một kiểu"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr ""
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr ""
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr ""
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected intrinsic type %qs at %L"
 msgid "Unexpected junk after %qs at %L"
 msgstr "Gặp kiểu hạn chế không cần %qs tại %L"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "ABSTRACT INTERFACE %qs phải không tham chiếu tại %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "resolve_function(): kiểu hàm sai"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr ""
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "Using function %qs at %L is deprecated"
 msgstr "%qs đã lạc hậu"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr ""
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr ""
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr ""
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "resolve_subroutine(): kiểu hàm sai"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 #| msgid "protocol %qE is deprecated"
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "giao thức %qE đã lạc hậu"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr ""
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, fuzzy, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "resolve_operator(): intrinsic sai"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "Return value of function %qs at %L not set"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "Trả lại giá trị của hàm %qs tại %L chưa đặt"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr ""
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, gcc-internal-format, gfc-internal-format
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr ""
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "Gặp ngữ cảnh sai cho hàm trỏ NULL() tại %%L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "Tại %%L có một toán tử thuộc số nguyên phân “%s” với toán hạng %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "Tại %%L có một toán tử thuộc số nhị phân “%s” với các toán hạng %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "Tại %%L và %%L có một toán tử với các phân hàng mâu thuẫn nhau"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "Tại %%L có một toán tử ghép nối chuỗi với các toán hạng %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "Tại %%L có một toán tử hợp lý “%s” với các toán hạng %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .not. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "Tại %%L có một toán tử .not. với toán hạng %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "Không thể so sánh các số lượng PHỨC TẠP tại %L"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "Tại %%L và %%L có một toán tử với các phân hàng mâu thuẫn nhau"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "loại không hợp lệ cho %s tại %L"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "loại không hợp lệ cho %s tại %L"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "Tại %%L thì các bộ hợp lý phải được so sánh với %s thay cho %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "Tại %%L có một toán tử so sánh “%s” với các toán hạng %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "unknown type name %qE; did you mean %qs?"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "không hiểu kiểu tên %qE; ý bạn là %qs?"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator %%<%s%%> at %%L"
 msgid "Unknown operator %qs at %L"
 msgstr "Không rõ toán tử %%<%s%%> tại %%L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator %%<%s%%> at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "Toán hạng của toán tử người dùng %%<%s%%> tại %%L là %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator %%<%s%%> at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "Các toán hạng của toán tử người dùng %%<%s%%> tại %%L là %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "resolve_operator(): intrinsic sai"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr ""
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr ""
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr ""
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr ""
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr ""
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr ""
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "thẻ %s tại %L phải là scalar"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "thẻ %s tại %L phải là kiểu %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "thẻ %s tại %L phải là scalar"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "thẻ %s tại %L phải là scalar"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "thẻ %s tại %L phải là kiểu %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "Biểu thức tại %L phải thuộc kiểu scalar"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr ""
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr ""
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 #| msgid "illegal operand "
 msgid "Illegal coarray index"
 msgstr "toán hạng không hợp lệ"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr ""
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -89067,12 +89251,12 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr ""
@@ -89081,422 +89265,422 @@ msgstr ""
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr ""
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_variable_attr(): Bad array reference"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "gfc_variable_attr(): Tham chiếu mảng sai"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr ""
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr ""
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is deprecated"
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%qs đã lạc hậu"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid array reference at %L"
 msgstr "Tên có chứa ký tự không hợp lệ tại %C"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Error in type-spec at %L"
 msgid "Error in typebound call at %L"
 msgstr "Sai trong type-spec tại %L"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr ""
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%qs tại %L phải là THỦ TỤC CON"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "%qs tại %L phải là HÀM"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "gfc_resolve_expr(): sai kiểu biểu thức"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s tại %L phải là một scalar"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s tại %L phải là số nguyên"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s tại %L phải là SỐ-NGUYÊN"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr ""
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "Cần tên biến tại %C"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, gcc-internal-format
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr ""
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer %qs in %s clause at %L"
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Con trỏ Cray %qs trong mệnh đề %s tại %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 #| msgid "Unexpected intrinsic type %qs at %L"
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "Gặp kiểu hạn chế không cần %qs tại %L"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr ""
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "biến %qD được đặt nhưng lại chưa được dùng"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr ""
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr ""
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr ""
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr ""
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr ""
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, gcc-internal-format, gfc-internal-format
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr ""
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr ""
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr ""
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 #| msgid "Expected %<,%> or end of statement at %C"
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "cần %<,%> hoặc kết thúc câu lệnh tại %C"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr ""
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr ""
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr ""
@@ -89505,318 +89689,318 @@ msgstr ""
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr ""
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr ""
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr ""
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr ""
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr ""
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr ""
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr ""
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr ""
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unable to resolve the specific function %qs at %L"
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "Không thể phân giải hàm đặc tả %qs tại %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr ""
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "Danh sách tên “%s” không thể là đối số tại %L"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr ""
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr ""
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "parameter %u has void type"
 msgid "Selector at %L has no type"
 msgstr "tham số %u có kiểu void"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr ""
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr ""
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "Gặp kiểu hạn chế không cần %qs tại %L"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr ""
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "Ngữ cảnh sai cho hạn chế NULL() tại %L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "Tham số %qs của thủ tục cơ bản tại %L phải là vô hướng"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr ""
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr ""
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr ""
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr ""
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr ""
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr ""
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr ""
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be a character string of default kind"
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "thẻ %s tại %L phải là chuỗi ký tự của kiểu mặc định"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be a character string of default kind"
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "thẻ %s tại %L phải là chuỗi ký tự của kiểu mặc định"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr ""
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr ""
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr ""
@@ -89824,216 +90008,216 @@ msgstr ""
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr ""
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr ""
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "BLOCK construct at %C"
 msgid "FORALL construct at %L"
 msgstr "cấu trúc BLOCK tại %C"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr ""
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr ""
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "Cần tên biến tại %C"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr ""
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr "gfc_resolve_blocks(): Kiểu khối sai"
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr ""
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "Không thể chuyển đổi %s thành %s tại %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr ""
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr ""
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr ""
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr ""
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr ""
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr ""
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr ""
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid NULL at %L"
 msgstr "NULL không hợp lệ %L"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr ""
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr "gfc_resolve_code(): Không có biểu thức trên DO WHILE"
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr ""
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_resolve_code(): Mã câu lệnh sai"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 #| msgid "Unused parameter %qs declared at %L"
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "Đối số chưa dùng %qs được khai báo tại %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -90041,62 +90225,62 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "Chiều dài chuỗi tại %L là quá lớn"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr ""
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr ""
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr ""
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr ""
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 #| msgid "Function %qs at %L cannot have an initializer"
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
@@ -90104,1003 +90288,1003 @@ msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, gcc-internal-format
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr ""
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr ""
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr ""
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr ""
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s tại %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr ""
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr ""
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr ""
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr ""
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr ""
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr ""
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr ""
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr ""
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 #| msgid "Interface %qs at %L may not be a statement function"
 msgid "Interface of %qs at %L must be explicit"
 msgstr "Giao diện %qs tại %L không thể là hàm khai báo"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr ""
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "Đối số của thủ tục FINAL tại %L phải là kiểu %qs"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr ""
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr ""
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr ""
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr ""
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr ""
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr ""
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr ""
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "Đối số %qs của %qs với PASS(%s) tại %L phải là kiểu dẫn xuất %qs"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 #| msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "Đối số %qs của %qs với PASS(%s) tại %L phải là kiểu dẫn xuất %qs"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr ""
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr ""
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr ""
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr ""
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr ""
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr ""
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "Đối số của %s tại %L phải là của một độ dài"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr ""
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "Đối số %qs của %qs với PASS(%s) tại %L phải là dẫn xuất kiểu %qs"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "Đối số %qs của %qs với PASS(%s) tại %L phải là vô hướng"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr ""
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr ""
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr ""
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr ""
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr ""
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "Derived type %qs at %L has not been declared"
 msgstr "%qE chưa được khai báo"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr ""
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr ""
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "TILE requires constant expression at %L"
 msgid "Expecting constant expression near %L"
 msgstr "TILE cần biểu thức hằng tại %L"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr ""
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr ""
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr ""
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr ""
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr ""
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr ""
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr ""
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr ""
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr ""
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "Đối số của %s tại %L phải là của một độ dài"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr ""
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr ""
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr ""
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr ""
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr ""
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr ""
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist '%s' can not be an argument at %L"
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "Danh sách tên “%s” không thể là đối số tại %L"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "Function %qs at %L cannot have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "Hàm %qs tại %L không thể có bộ khởi tạo"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %L"
 msgid "Expecting definable entity near %L"
 msgstr "Cần câu lệnh %s tại %L"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr ""
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr ""
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr ""
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr ""
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr ""
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr ""
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr ""
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr ""
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "Nhãn %d tại %L đã định nghĩa nhưng chưa được dùng"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr ""
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr ""
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr ""
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr ""
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, gcc-internal-format
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr ""
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "Chuỗi con tại %L có độ dài là không"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, gcc-internal-format
 msgid "Self reference in character length expression for %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr ""
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr ""
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr ""
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr ""
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr ""
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr ""
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr ""
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr ""
@@ -91120,101 +91304,101 @@ msgstr "Không phải là thư mục bao gồm sẵn có %qs"
 msgid "%qs is not a directory"
 msgstr "%qs không phải là một thư mục"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr ""
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "Dòng bị cắt cụt tại %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "Thiếu %<&%> trong hằng ký tự tiếp tục tại %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Có ký tự tab không phù hợp tại %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character 0x%s at %C"
 msgstr "Tên có chứa ký tự không hợp lệ tại %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr ""
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr ""
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, gcc-internal-format
 msgid "file %qs left but not entered"
 msgstr "tập tin còn %qs nhưng không vào được"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, gcc-internal-format
 msgid "Illegal preprocessor directive"
 msgstr "Chỉ thị tiền xử lý không hợp lệ"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file %qs"
 msgid "Cannot open file %qs"
 msgstr "Không thể mở tập tin %qs"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot open profile file %s."
 msgid "Cannot open included file %qs"
 msgstr "Không thể mở tập tin hồ sơ %s"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot open profile file %s."
 msgid "Cannot open pre-included file %qs"
 msgstr "Không thể mở tập tin hồ sơ %s"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "input file %qs is the same as output file"
 msgid "Included file %qs is not a regular file"
@@ -91386,221 +91570,221 @@ msgstr ""
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim(): Kiểu sai"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "in gfc_simplify_exp(): Kiểu sai"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor(): Kiểu sai"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr ""
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr ""
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr ""
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr ""
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr ""
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr ""
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr ""
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr "gfc_simplify_log: Kiểu sai"
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr ""
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "Đối số của %s tại %L phải là của một độ dài"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "Đối số của %s tại %L phải là của một độ dài"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr ""
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr ""
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs argument of %qs intrinsic at %L must be of kind %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "đối số %qs của %qs intrinsict tại %L phải là các loại %d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr ""
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr "in gfc_simplify_sin(): Kiểu sai"
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr ""
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr ""
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr ""
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "đối số của SQRT tại %L không hợp lệ"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr ""
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr ""
@@ -91940,74 +92124,74 @@ msgstr ""
 msgid "Labeled DO statement at %L"
 msgstr "Không cần câu lệnh END tại %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr ""
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr ""
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr ""
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr ""
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr ""
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr ""
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr ""
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr ""
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr ""
@@ -92037,29 +92221,35 @@ msgstr ""
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr ""
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "initializer element is not a constant expression"
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "yếu tố khởi tạo không phải là một biểu tượng hằng số"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr ""
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr ""
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr ""
@@ -92161,115 +92351,115 @@ msgstr ""
 msgid "non-constant initialization expression at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "%s at %L has no default type"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr ""
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "Trả lại giá trị của hàm %qs tại %L chưa đặt"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr ""
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr ""
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr ""
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr ""
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr ""
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr ""
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "Đối số giả chưa dùng %qs tại %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "Biến số chưa dùng %qs được khai báo tại %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "Đối số chưa dùng %qs được khai báo tại %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "Trả lại giá trị %sq của hàm %qs khai báo tại %L chưa đặt"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "sorry, unimplemented"
 msgid "Unsigned not yet implemented"
 msgstr "tiếc là chưa thực hiện"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol %qs at %C is already in a COMMON block"
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
@@ -92300,12 +92490,12 @@ msgstr ""
 msgid "Unknown intrinsic op"
 msgstr "Không hiểu intrinsic op"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr ""
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -92321,12 +92511,12 @@ msgstr ""
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The event variable at %L shall not be coindexed "
 msgid "The event variable at %L shall not be coindexed"
@@ -92353,192 +92543,192 @@ msgstr "-fprefetch-loop-arrays không được hỗ trợ bởi đích này"
 msgid "implicit mapping of assumed size array %qD"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "optional argument"
 msgid "optional class parameter"
 msgstr "đối số tùy chọn"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "Mong đợi một loại biểu thức"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "cần biểu thức"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "Used here"
 msgstr "được khai báo ở đây"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr ""
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "Tham số %qs của thủ tục cơ bản tại %L phải là vô hướng"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "Unable to find symbol %qs"
 msgid "Cannot find symbol %qs at %L"
 msgstr "không thể tìm thấy ký hiệu %qs"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %L is not a function"
 msgid "variant %qs at %L is the same as base function"
 msgstr "“%qs” tại %L không phải là một hàm"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when there is a conversion between pointers that have incompatible types."
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "Cảnh báo khi chuyển đổi giữa một con trỏ tới kiểu không tương thích."
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "Cần danh sách đối số tại %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "Đối số của %s tại %L phải là của một độ dài"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, gcc-internal-format
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, gcc-internal-format
 msgid "%<need_device_addr%> not yet supported"
 msgstr ""
@@ -92892,7 +93082,7 @@ msgstr "close: %s"
 msgid "two or more sections for %s"
 msgstr "cần thiết ít nhất hai phần cho %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -93238,33 +93428,33 @@ msgstr "mảng được dùng như là bộ khởi tạo"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "argument %qd is not a constant"
 msgid "requested alignment is not a constant"
 msgstr "đối số %qd không phải hằng số"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "-falign-labels=%d không được hỗ trợ"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 msgid "alignment may not be specified for %qD"
 msgstr "không hiểu hàm đặc tả %qs"
@@ -96289,10 +96479,6 @@ msgstr ""
 #~ msgid "taking address of temporary array"
 #~ msgstr "lấy địa chỉ của mảng tạm"
 
-#, gcc-internal-format
-#~ msgid "cannot call function %qD"
-#~ msgstr "không thể gọi hàm %qD"
-
 #, gcc-internal-format
 #~ msgid "right rotate count is negative"
 #~ msgstr "số lượng quay phải bị âm"
@@ -96804,9 +96990,6 @@ msgstr ""
 #~ msgid "bad method signature"
 #~ msgstr "tín hiệu phương thức sai"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D được dùng trước khai báo"
-
 #~ msgid "method '%s' not found in class"
 #~ msgstr "không tìm thấy phương thức “%s” trong lớp"
 
@@ -96864,6 +97047,9 @@ msgstr ""
 #~ msgid "verification failed at PC=%d: %s"
 #~ msgstr "thẩm tra gặp lỗi tại PC=%d: %s"
 
+#~ msgid "%qD is not a constant"
+#~ msgstr "%q#D không là const"
+
 #~ msgid "array subscript out of bound"
 #~ msgstr "chỉ số mảng nằm ngoài phạm vi"
 
--- a/src/gcc/po/zh_CN.po
+++ b/src/gcc/po/zh_CN.po
@@ -35,7 +35,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc-16.1-b20260329\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2026-04-08 19:22+0800\n"
 "Last-Translator: Zhanhaoxiang Zhang <zzhx2006@outlook.com>\n"
 "Language-Team: Chinese (simplified) <i18n-zh@googlegroups.com>\n"
@@ -1333,12 +1333,12 @@ msgstr "别名："
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "已知 MIPS ISA 等级 (用于 -mips 选项)："
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, no-c-format
 msgid "Specify the PTX ISA version to use."
 msgstr "指定要使用的 PTX ISA 版本。"
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, no-c-format
 msgid "Initialize ptx registers."
 msgstr "初始化 ptx 寄存器。"
@@ -2228,13 +2228,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, fuzzy, no-c-format
 msgid "Use given stack-protector guard."
 msgstr "使用 propolice 来保护堆栈"
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 #| msgid "Valid arguments to -mfloat-gprs=:"
@@ -2729,7 +2729,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "假定目标 CPU 被配置为大端在前"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 #| msgid "Assume target CPU is configured as little endian"
 msgid "Assume target CPU is configured as little endian."
@@ -2815,7 +2815,7 @@ msgstr "使用子程序完成函数前言/尾声"
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 msgid "Specify the code model."
@@ -2855,7 +2855,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 #| msgid "Omit the frame pointer in leaf functions"
 msgid "Omit the frame pointer in leaf functions."
@@ -2969,7 +2969,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -3015,7 +3015,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5446,7 +5446,7 @@ msgstr "支持 RAOINT 内建函数及代码生成。"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5831,7 +5831,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "为跳转指令设定的开销"
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, fuzzy, no-c-format
 msgid "Use branch-protection features."
 msgstr "使用 propolice 来保护堆栈"
@@ -6171,219 +6171,224 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "The register used to access the thread pointer:"
 msgstr "指定如何访问线程指针"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 msgid "Specify the thread pointer register."
 msgstr "使用给定的线程局部存储模式"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 #| msgid "Specify bit size of immediate TLS offsets"
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "指定线程局部存储偏移量立即数的位大小"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 #| msgid "-march=ARCH\tUse features of architecture ARCH"
 msgid "Use features of architecture ARCH."
 msgstr "-march=ARCH\t使用指定架构 ARCH 的特性"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 #| msgid "-mcpu=CPU\tUse features of and optimize for CPU"
 msgid "Use features of and optimize for CPU."
 msgstr "-mcpu=CPU\t使用指定 CPU 的特性并为之优化"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr "为 CPU 优化。"
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "-mabi=ABI\tGenerate code that conforms to the specified ABI"
 msgid "Generate code that conforms to the specified ABI."
 msgstr "-mabi=ABI\t生成遵循指定 ABI 的代码"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "已知 AArch64 ABI (用于 -mabi= 选项)："
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, fuzzy, no-c-format
 #| msgid "Known address mode (for use with the -maddress-mode= option):"
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "已知寻址模式 (用于 -mcmodel= 选项)："
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, fuzzy, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr "假定大的线程局部存储段"
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate a call to abort if a noreturn function returns"
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "当 noreturn 函数返回时调用 abort"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "This option is deprecated and has no effect."
 msgid "This option is deprecated."
@@ -12157,7 +12162,7 @@ msgstr "在树上进行循环向量化"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -19638,91 +19643,91 @@ msgstr "遵循 ISO 2014 C++ 标准。"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "遵循 ISO 202Y C 标准草案（试验性质的不完全支持）。"
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 msgid "argument must be passed by copying"
 msgstr "实参 1 必须是一个 5 位有符号字面量"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 #| msgid "caller edge frequency is negative"
 msgid "callee returns twice"
 msgstr "调用边频率为负"
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 msgid "callee does not return"
 msgstr "调用边频率 %i 与基本块频率 %i 不匹配"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 #| msgid "variable %qD has function type"
 msgid "volatile function type"
 msgstr "变量%qD有函数类型"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 #| msgid "expected function"
 msgid "nested function"
 msgstr "需要函数"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 #| msgid "different number of parameters"
 msgid "inconsistent number of popped arguments"
 msgstr "形参数量不同"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s 不支持 split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 msgid "variable size arguments"
 msgstr "%L处按值传递的实参不能是数组或数组段"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 msgid "hidden string length argument passed on stack"
 msgstr "栈帧太大"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 #| msgid "static assertion failed"
 msgid "tail call production failed"
@@ -19841,12 +19846,12 @@ msgstr "‘%%l’操作数不是一个标号"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "错误地使用了浮点常量"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -21173,12 +21178,12 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "这是指令："
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 msgid "unable to reload address in "
 msgstr "fr30_print_operand：未处理的指针"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "无法生成重新载入，为："
 
@@ -21410,7 +21415,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC 准则：--param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<匿名>"
@@ -21799,20 +21804,20 @@ msgstr "代码‘%c’的操作数无效"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, fuzzy, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "无效的操作数代码‘%c’"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 msgid "invalid vector constant"
 msgstr "%<#pragma pack%>中有无效常量 - 已忽略"
@@ -21858,100 +21863,100 @@ msgstr "‘%%%c’不是一个有效的操作数前缀"
 msgid "invalid address mode"
 msgstr "无效寻址模式"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "从%<__fpreg%>的转换无效"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "到类型%qT的转换无效，从类型%qT"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "negation operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "plus operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "minus operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "multiply operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "divide operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "shift operation not permitted on svbool_t"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 msgid "subscript operation not supported on svbool_t"
 msgstr "堆栈限制在此目标机上不受支持"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 #, fuzzy
 #| msgid "method declaration not in @interface context"
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "方法声明不在@interface 上下文中"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 #| msgid "invalid operands in binary operation"
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "二元操作中中操作数无效"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -21968,13 +21973,13 @@ msgid "invalid %%r value"
 msgstr "无效 %%r 值"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "无效 %%R 值"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "无效 %%N 值"
@@ -21989,7 +21994,7 @@ msgstr "无效 %%P 值"
 msgid "invalid %%h value"
 msgstr "无效 %%h 值"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "无效 %%L 值"
@@ -22004,7 +22009,7 @@ msgstr "无效 %%m 值"
 msgid "invalid %%M value"
 msgstr "无效 %%M 值"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "无效 %%U 值"
@@ -22361,7 +22366,7 @@ msgstr "非预期的操作数"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -22608,140 +22613,140 @@ msgstr "%<#pragma pack%>中有无效常量 - 已忽略"
 msgid "Expected register or constant integer."
 msgstr "%C 需要一个无名接口"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "无效的 UNSPEC 用作操作数"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "错误地使用了%<restrict%>"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 msgid "invalid use of asm flag output"
 msgstr "向函数类型%qT的转换无效"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "fr30_print_operand：%%A 代码操作数无效"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "‘z’修饰符的操作数无效"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "操作数代码‘%c’的操作数类型无效"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "fr30_print_operand：%%A 代码操作数无效"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘Y’"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘D’"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘D’"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘D’"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘Y’"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘Y’"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘Y’"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 #| msgid "operand is not a condition code, invalid operand code 'Y'"
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘Y’"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "操作数不是一个条件码，无效的操作数代码‘D’"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "无效的操作数代码‘%c’"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "操作数的约束无效"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 #| msgid "invalid controlling predicate"
 msgid "invalid vector immediate"
 msgstr "无效的控制谓词"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "未知的指令模式"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "从%<__fpreg%>的转换无效"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 #| msgid "invalid conversion from %<__fpreg%>"
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "从%<__fpreg%>的转换无效"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "到类型%qT的转换无效，从类型%qT"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 #| msgid "invalid conversion to type %qT from type %qT"
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "到类型%qT的转换无效，从类型%qT"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -22820,9 +22825,9 @@ msgstr "‘%%%c’不是一个有效的操作数前缀"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, c-format
 msgid "invalid use of '%%%c'"
 msgstr "对‘%%%c’的使用无效"
@@ -22887,7 +22892,7 @@ msgid "insn contains an invalid address !"
 msgstr "指令包含无效地址！"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "无效地址"
 
@@ -22964,7 +22969,7 @@ msgstr "无效的声明"
 msgid "invalid %%H value"
 msgstr "无效 %%J 值"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "无效的 %%d 值"
@@ -23017,34 +23022,34 @@ msgstr "不支持的组合：%s"
 msgid "unsupported memory expression:"
 msgstr "整点转换中类型无效"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 msgid "invalid vector operand"
 msgstr "%%R 的操作数无效"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "‘b’修饰符的操作数无效"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "unsupported operand size for extended register"
 msgid "modifier 'H' is for integer registers only"
 msgstr "扩展的寄存器不支持的操作数大小"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -23114,7 +23119,7 @@ msgstr ""
 msgid "invalid %%A value"
 msgstr "无效 %%J 值"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "无效的 %%D 值"
@@ -23154,7 +23159,7 @@ msgstr "无效 %%J 代码"
 msgid "invalid %%k value"
 msgstr "无效 %%k 值"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "无效 %%K 值"
@@ -23184,17 +23189,17 @@ msgstr "无效 %%T 值"
 msgid "invalid %%u value"
 msgstr "无效 %%u 值"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "无效 %%v 值"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, c-format
 msgid "invalid %%V value"
 msgstr "无效 %%V 值"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "无效 %%x 值"
@@ -23422,28 +23427,28 @@ msgstr "无效的 %%s 操作数"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "浮点常量不是一个有效的立即数操作数"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "‘B’操作数不是一个常量"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "‘B’操作数设置了多个位"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "‘o’操作数不是一个常量"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "‘B’操作数不是一个常量"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand：未知代码"
@@ -23504,24 +23509,24 @@ msgstr "检测到无效的操作数"
 msgid "Unable to load DLL."
 msgstr "无法加载 DLL。"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "错误的测试"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "无效掩码"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "无效的 %%t/%%b 值"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "地址中无寄存器"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "地址偏移量不是一个常量"
 
@@ -23557,7 +23562,7 @@ msgstr "{错误}"
 msgid "aka"
 msgstr "或称"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 msgid "({anonymous})"
 msgstr "({anonymous})"
 
@@ -23582,8 +23587,8 @@ msgstr "({anonymous})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "需要%<;%>"
@@ -23611,7 +23616,7 @@ msgstr "需要 %<:%> 或 %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "需要%<)%>"
@@ -23619,7 +23624,7 @@ msgstr "需要%<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "需要%<]%>"
@@ -23639,13 +23644,13 @@ msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "需要%<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "需要%<[%>"
@@ -23654,7 +23659,7 @@ msgstr "需要%<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -23671,13 +23676,13 @@ msgstr "需要%<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "需要 %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "需要 %<while%>"
@@ -23687,7 +23692,7 @@ msgstr "需要 %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "需要 %<,%>"
@@ -23697,18 +23702,18 @@ msgid "expected %<.%>"
 msgstr "需要%<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "需要 %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "需要 %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "需要 %<,%> 或 %<)%>"
@@ -23718,45 +23723,45 @@ msgstr "需要 %<,%> 或 %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "需要%<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "需要 %<)%> 或 %<,%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "需要 %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "需要 %<else%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "需要%<#pragma omp section%>或%<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr "<编译时消息未知>"
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 msgid "(anonymous)"
 msgstr "(匿名)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "需要%<<%>"
@@ -23781,7 +23786,7 @@ msgstr "备选 %i:"
 msgid "  after user-defined conversion:"
 msgstr "  用户定义转换后："
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 msgid "candidate is:"
 msgid_plural "candidates are:"
 msgstr[0] "备选是:"
@@ -23880,7 +23885,7 @@ msgstr "<模板参数数错误>"
 msgid "<statement>"
 msgstr "<语句>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, gcc-internal-format
 msgid "<unknown>"
 msgstr "<未知>"
@@ -23907,252 +23912,304 @@ msgstr "<lambda>"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 msgid "<expression error>"
 msgstr "<表达式错误>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 msgid "<unknown operator>"
 msgstr "<未知的运算符>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 msgid "At global scope:"
 msgstr "在全局域："
 
-#: cp/reflect.cc:565
-msgid "array element not a constant integer"
-msgstr "数组元素不是整型常量"
+#: cp/reflect.cc:408
+#, fuzzy
+#| msgid "reflect_constant failed"
+msgid "reflect_constant_array failed"
+msgstr "reflect_constant失败"
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 msgid "reflect_constant failed"
 msgstr "reflect_constant失败"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+msgid "array element not a constant integer"
+msgstr "数组元素不是整型常量"
+
+#: cp/reflect.cc:1117
 msgid "reflection does not represent a type"
 msgstr "反射不代表一个类型"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 msgid "reflection does not have template arguments"
 msgstr "反射没有模板参数"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 msgid "reflection does not represent a function or function type"
 msgstr "反射未代表一个函数或函数类型"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr "反射未代表一个运算符函数或运算符函数模板"
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 msgid "operators argument is not a valid operator"
 msgstr "运算符参数不是一个有效的运算符"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 msgid "reflection does not have a type"
 msgstr "反射没有一个类型"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr "反射未代表一个具有静态存储期的对象，或对这样一个对象的引用"
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr "反射未代表一个注解(annotation)，或一个拼接表达式(splice-expression)的有效参数"
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 msgid "reflection does not represent an entity with parent"
 msgstr "反射未代表一个带有父实体的实体"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 msgid "reflection does not represent parameter of current function"
 msgstr "反射未代表当前函数的参数"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "反射未代表一个带有返回类型的函数或函数类型"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr "对具有抽象派生类的虚直接基类关系(virtual direct base relationship)的反射"
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr "反射不适用于offset_of"
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 msgid "non-constant offset for offset_of"
 msgstr "offset_of的偏移量非常量"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr "反射不适用于size_of"
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 msgid "reflection with incomplete type in size_of"
 msgstr "size_of中反射带有不完整的类型"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 msgid "reflection not suitable for alignment_of"
 msgstr "反射不适用于alignment_of"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 msgid "alignment_of on function type"
 msgstr "应用于函数类型的alignment_of"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 msgid "reflection with incomplete type in alignment_of"
 msgstr "alignment_of 中不完整类型的反射"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr "反射不适用于 bit_size_of"
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "bit_size_of 中不完整类型的反射"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr "has_identifier 的反射失败"
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr "identifier_of 在普通字面量编码中不可表示"
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr "u8identifier_of 在 UTF-8 中不可表示"
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+#, fuzzy
+#| msgid "identifier_of not representable in ordinary literal encoding"
+msgid "display_string_of not representable in ordinary literal encoding"
+msgstr "identifier_of 在普通字面量编码中不可表示"
+
+#: cp/reflect.cc:3782
+#, fuzzy
+#| msgid "u8identifier_of not representable in UTF-8"
+msgid "u8display_string_of not representable in UTF-8"
+msgstr "u8identifier_of 在 UTF-8 中不可表示"
+
+#: cp/reflect.cc:3922
+#, fuzzy
+#| msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
 msgstr "反射未表示类型、类型别名、变量、函数、命名空间、枚举项、直系基类关系或非静态数据成员"
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr "反射未表示完整类型或类型别名"
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr "reflect_object 失败"
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 msgid "reflect_function failed"
 msgstr "reflect_function 失败"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 msgid "value member missing"
 msgstr "缺少 value 成员"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 msgid "unexpected value of value member"
 msgstr "非预期的 value 成员的值"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr "缺少 type 成员"
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 msgid "reflection does not represent a complete enumeration type"
 msgstr "反射未表示完整枚举类型"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "反射未表示可枚举的枚举类型"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 msgid "reflection represents non-integral or bool type"
 msgstr "反射表示非整型或 bool 类型"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 msgid "reflection does not represent a template"
 msgstr "反射未表示模板"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 msgid "invalid argument to can_substitute"
 msgstr "传递给 can_substitute 的参数无效"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr "can_substitute 返回 false"
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 msgid "type is not object or reference type"
 msgstr "类型不是对象或引用类型"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr "从普通字面量编码到源代码字符集的转换失败"
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "从 UTF-8 到源代码字符集的转换失败"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 msgid "name is not a valid identifier"
 msgstr "名称不是有效的标识符"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr "名称是关键字"
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr "名称是内置特征(trait)"
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 msgid "neither name nor bit_width specified"
 msgstr "既未指定名称也未指定位宽"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr "为非整型且非枚举类型指定位宽"
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 msgid "both alignment and bit_width specified"
 msgstr "同时指定了对齐和位宽"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr "在 no_unique_address 为 true 时指定位宽"
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 msgid "bit_width 0 with specified name"
 msgstr "指定位宽 0 的同时指定了名称"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 msgid "bit_width is negative"
 msgstr "位宽为负数"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+msgid "name unspecified and type is const"
+msgstr "不能为%q+D指定对齐"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+msgid "name unspecified and type is volatile"
+msgstr "不能为%q+D指定对齐"
+
+#: cp/reflect.cc:6038
 msgid "alignment is not power of two"
 msgstr "对齐值不是 2 的幂"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 msgid "alignment is negative"
 msgstr "对齐值为负数"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 msgid "alignment is smaller than alignment_of"
 msgstr "对齐值小于 alignment_of"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+#| msgid "reflection does not have a type"
+msgid "reflection does not have non-array object type"
+msgstr "反射没有一个类型"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "reflection does not represent a type"
+msgid "current scope does not represent a function"
+msgstr "反射不代表一个类型"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "reflection does not represent parameter of current function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "反射未代表当前函数的参数"
+
+#: cp/reflect.cc:6685
 msgid "incomplete parent class"
 msgstr "父类不完整"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 msgid "neither complete class type nor namespace"
 msgstr "既不是完整的类类型也不是命名空间"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 msgid "not a complete class type"
 msgstr "不是完整的类类型"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr "闭包类型"
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 msgid "value cannot be extracted"
 msgstr "值无法提取"
 
@@ -24196,52 +24253,52 @@ msgstr "转换丢失了常量属性"
 msgid "source type is not polymorphic"
 msgstr "源类型不是多态的"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "备选为:"
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "单目减的操作数类型错误"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "单目加的操作数类型错误"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "按位取反的参数类型错误"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "不能对该类型的参数求绝对值"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "不能对该类型的参数求共轭"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 msgid "in argument to unary !"
 msgstr "单目 ! 的参数中"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 msgid "no pre-increment operator for type"
 msgstr "类型没有前自增运算符"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 msgid "no post-increment operator for type"
 msgstr "类型没有后自增运算符"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 msgid "no pre-decrement operator for type"
 msgstr "类型没有前自减运算符"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 msgid "no post-decrement operator for type"
 msgstr "类型没有后自减运算符"
 
@@ -24259,70 +24316,70 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "行在%L处被截断"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "‘a%d’和‘a%d’用作内建函数‘%s’的参数"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "‘%s’和‘%s’用作内建函数‘%s’的参数"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "‘%s’和‘%s’用作内建函数‘%s’的参数"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 #| msgid "%qD is not a pointer variable"
 msgid "NULL() is not interoperable"
 msgstr "%qD 不是一个指针变量"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 msgid "BOZ literal constant"
 msgstr "%<#pragma pack%>中有无效常量 - 已忽略"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 #| msgid "End expression in DO loop"
 msgid "Expression is polymorphic"
 msgstr "DO 循环中结束表达式"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 msgid "Expression is a noninteroperable derived type"
 msgstr "C++ 不允许在%qs表达式中定义类型"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 #| msgid "unexpected argument"
 msgid "Procedure unexpected as argument"
 msgstr "非预期的参数"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 msgid "Type shall have a character length of 1"
 msgstr "%C处字符长度规格语法错误"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "类型不完全兼容"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 msgid "Assumed-size arrays are not interoperable"
 msgstr "%3$C处名字列表‘%2$s’中的假定大小数组‘%1$s’不被允许"
@@ -24401,7 +24458,7 @@ msgstr "删除的特性："
 msgid "Unsigned:"
 msgstr ""
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 msgid "array assignment"
 msgstr "数组赋值"
 
@@ -24410,17 +24467,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -24606,11 +24663,11 @@ msgstr "块 IF"
 msgid "implied END DO"
 msgstr "暗示的 END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "赋值"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "指针赋值"
 
@@ -24618,146 +24675,146 @@ msgstr "指针赋值"
 msgid "simple IF"
 msgstr "简单的 IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 msgid "elemental procedure"
 msgstr "基本过程"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 msgid "allocatable argument"
 msgstr "没有参数"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 msgid "asynchronous argument"
 msgstr "参数"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 msgid "optional argument"
 msgstr "可选参数"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 msgid "pointer argument"
 msgstr "对空指针指向内容的写操作(实参 %d)"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 msgid "target argument"
 msgstr "目标"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 msgid "value argument"
 msgstr "%L处按值传递的实参不能是数组或数组段"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 msgid "volatile argument"
 msgstr "重复的%<volatile%>"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 msgid "assumed-shape argument"
 msgstr "%L处的非标量 FINAL 过程应当有假定外形的参数"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 msgid "assumed-rank argument"
 msgstr "在调度器中启用秩启发"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 msgid "coarray argument"
 msgstr "无效的参数"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 #, fuzzy
 msgid "parametrized derived type argument"
 msgstr "%L处 PARAMETER 中派生类型不兼容"
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 msgid "polymorphic argument"
 msgstr "源类型不是多态的"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr "NO_ARG_CHECK 属性"
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 msgid "assumed-type argument"
 msgstr "该类型不支持自增"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr "数组结果"
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 #, fuzzy
 msgid "pointer or allocatable result"
 msgstr "%3$L 处“%1$s”分句对象“%2$s”有 ALLOCATABLE 组件"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 #, fuzzy
 msgid "result with non-constant character length"
 msgstr "变量‘%s’在%L处上下文中字符长度必须为常量"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 #, fuzzy
 msgid "bind(c) procedure"
 msgstr "%C处带有 NAME 的 BIND(C)过程不能有 POINTER 属性"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 msgid "Loop variable"
 msgstr "循环变量"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 msgid "iterator variable"
 msgstr "变量"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 msgid "Start expression in DO loop"
 msgstr "DO 循环中的开始表达式"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 msgid "End expression in DO loop"
 msgstr "DO 循环中结束表达式"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 msgid "Step expression in DO loop"
 msgstr "DO 循环中的步进表达式"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 #, fuzzy
 msgid "DEALLOCATE object"
 msgstr "试图 DEALLOCATE 未分配的‘%s’"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 #, fuzzy
 msgid "ALLOCATE object"
 msgstr "%L处的源表达式和%L处的分配对象必须有相同的外形"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 #, fuzzy
 msgid "STAT variable"
 msgstr "%1$L处的统计变量不能在同一个 %3$s 语句中被 %2$s"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 #, fuzzy
 msgid "ERRMSG variable"
 msgstr "%1$L处的错误信息变量不能在同一 %3$s 语句中被 %2$s"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 #, fuzzy
 msgid "item in READ"
 msgstr "读取概要："
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 #, fuzzy
 msgid "ACQUIRED_LOCK variable"
 msgstr "无法锁定新归档文件"
@@ -24767,32 +24824,32 @@ msgstr "无法锁定新归档文件"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "数组构造函数中 CHARACTER 长度不同(%ld/%ld)"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 #, fuzzy
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "试图分配负数大小的内存。可能有整数溢出"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "字符串的实际长度不匹配其虚参声明‘%s’(%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "字符串的实际长度短于其虚参声明‘%s’(%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, fuzzy, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "目标的分级重新映射太小 (%ld<%ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -24857,27 +24914,27 @@ msgstr "内建函数 REPEAT 的 NCOPIES 参数为负(其值是 %lld)"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "内建函数 REPEAT 的 NCOPIES 参数太大"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -24977,7 +25034,7 @@ msgid "expected boolean type"
 msgstr "需要布尔类型"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, gcc-internal-format
 msgid "expected integer"
 msgstr "需要整数"
@@ -25046,7 +25103,7 @@ msgstr "实参太少"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, gcc-internal-format
 msgid "too many arguments"
 msgstr "实参太多"
@@ -25493,7 +25550,7 @@ msgstr "对 VxWorks 的取样支持"
 msgid "target OS does not support unaligned accesses"
 msgstr "目标操作系统不支持未对齐的访问"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "侧写档不是未实现的用于这个架构"
@@ -25756,13 +25813,13 @@ msgstr "正在创建 '%s'\n"
 msgid "Global declarative %s for %s"
 msgstr "%q#D的声明"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -25933,12 +25990,12 @@ msgstr "%qs 已弃用；请换用 -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs 已弃用；请换用 -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "未知的堆栈检查参数“%s”"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown LDP/STP policy %qs"
@@ -26388,8 +26445,8 @@ msgstr "%qE属性与 %s 属性冲突"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "%q+T先前在此处有过声明"
@@ -26406,7 +26463,7 @@ msgstr "%qE属性指定被忽略"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%qE属性指定被忽略"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "为%qE属性给定的实参数目错误"
@@ -26417,7 +26474,7 @@ msgstr "为%qE属性给定的实参数目错误"
 msgid "expected %i or more, found %i"
 msgstr "需要%<(%>或行尾"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected %<(%> or end of line"
 msgid "expected %i, found %i"
@@ -26501,12 +26558,12 @@ msgstr "类型属性在定义后被忽略"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -26624,138 +26681,138 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 #| msgid "edge %s->%s has no corresponding call_stmt"
 msgid "corresponding call"
 msgstr "边 %s->%s 没有对应的 call_stmt"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 #| msgid "creating run-time relocation"
 msgid "corresponding source location"
 msgstr "生成运行时重定位"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, fuzzy, gcc-internal-format
 #| msgid "callee refers to comdat-local symbols"
 msgid "location of the first call"
 msgstr "被调用者是指 comdat 本地符号"
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, fuzzy, gcc-internal-format
 #| msgid "no previous declaration for %qD"
 msgid "location of the second call"
 msgstr "%qD先前没有声明"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "creating array of functions"
 msgid "location is after end of function"
 msgstr "创建函数的数组"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "字节码流：需要标记 %s 而非 %s"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "无法打开输出文件“%s”"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "给%qD的模板实参不匹配原先的模板%qD"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "无法从“%s”中读入头"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "无法从“%s”中读入头"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "无法从 “%s” 中读取 LTO decls"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "无法从 “%s” 中读取 LTO decls"
@@ -26766,7 +26823,7 @@ msgstr "无法从 “%s” 中读取 LTO decls"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "偏移量越过字符串常量界"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qE在此声明"
@@ -26874,7 +26931,7 @@ msgstr "常量实参超过%qs的范围"
 msgid "illegal argument 0 to %qs"
 msgstr "%qs缺少参数"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -26955,12 +27012,12 @@ msgstr "%K%D 的最后一个实参不是一个 0 到 3 之间的整常量"
 msgid "cannot tail-call: %s"
 msgstr "无法尾调用：%s"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "函数调用有聚合类型"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "passing too large argument on stack"
 msgstr "栈帧太大"
@@ -27617,347 +27674,347 @@ msgstr "基本块不连贯"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "指令链中记录的基本块数 (%d) != n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 #| msgid "caller edge count is negative"
 msgid "caller edge count invalid"
 msgstr "调用边计数为负"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "函数‘%s’在%C处缺少参数列表"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing barrier after block %i"
 msgid "missing ref for speculation %i"
 msgstr "块 %i 后缺少屏障"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "为边 %s->%s 设定辅助域"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, fuzzy, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "节点是单独在中 comdat 群组"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "需要内联克隆"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "%<num_threads%>值必须为正"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 msgid "local symbols must be defined"
 msgstr "强制公共符号必须定义"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, fuzzy, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "为外部可见的名字添加下划线"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, fuzzy, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "已取地址，但是 ADDRESSABLE 位未被设置"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "需要内联克隆"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr "需要内联克隆"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "在有返回值的的函数中，%<return%>不带返回值"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 #| msgid "target specific option mismatch"
 msgid "semantic interposition mismatch"
 msgstr "目标相关的选项不匹配"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "为边 %s->%s 设定辅助域"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "edge count is not compatible with function count"
 msgstr "-mnop-mcount 与此目标不兼容"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "edge count is not compatible with inlined to function count"
 msgstr "-mnop-mcount 与此目标不兼容"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "间接边缘从 %s 未被标记为间接或已关联的 indirectinfo(_I)，相应叙述是："
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "inlined_to pointer 错误"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "多个内联调用者"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "为非内联的调用者设定了 inlined_to pointer"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "调用边频率 %i 与基本块频率 %i 不匹配"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "调用边频率 %i 与基本块频率 %i 不匹配"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "设定了 inlined_to 指针却找不到前驱"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "inlined_to pointer 指向自身"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "节点有错误的 clone_of"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "节点的克隆列表不正确"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "节点在克隆列表中，但并不是克隆"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "节点的 prev_clone 指针错误"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "双向克隆链接列表已损坏"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, fuzzy, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "基本块 %i 有多个 EH 边"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, fuzzy, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "别名有 non-alias 参考"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, fuzzy, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "别名有超过一个别名参考"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, fuzzy, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "%qE有%qs的引用类型"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, fuzzy, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "没有边缘超出 thunk 节点"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, fuzzy, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "超过一个边缘超出 thunk 节点"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, fuzzy, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "广义常表达式构造函数体不为空"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "共享的 call_stmt："
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "边指向错误的声明："
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, fuzzy, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "间接边缘与未知被调用端相应到 callstmt 与已知声明(_S)："
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "调用语句缺少 callgraph 边："
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "reference to dead statement"
 msgstr "删除死存储"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "边 %s->%s 没有对应的 call_stmt"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "边 %s->%s 没有对应的 call_stmt"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "将一个指针转换为大小不同的整数"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node 失败"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "在 %s %s 中有缺失的“%s”\n"
@@ -28757,17 +28814,17 @@ msgstr "局部对象的总大小太大"
 msgid "impossible constraint in %<asm%>"
 msgstr "%<asm%>中不可能的约束"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "变量%q+D能为%<longjmp%>或%<vfork%>所篡改"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "实参%q+D可能为%<longjmp%>或%<vfork%>所篡改"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "函数返回一个聚合"
@@ -29479,7 +29536,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "可变数组成员没有出现在结构的末尾"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -29520,7 +29577,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, gcc-internal-format
 msgid "%qD defined here"
 msgstr "%qD 不是 %<const char *%> 类型"
@@ -29542,24 +29599,24 @@ msgstr "空指针"
 msgid "function may return address of local variable"
 msgstr "函数可能返回局部变量的地址"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "函数返回局部变量的地址"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, gcc-internal-format
@@ -30459,7 +30516,7 @@ msgstr ""
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 msgid "returned from %qD"
 msgstr "与先前的声明%q+D不同"
@@ -30537,222 +30594,222 @@ msgstr "内联函数%q+D声明过但从未定义"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "未知的架构‘%s’"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "%2$qE的第 %1$d 个实参类型不兼容"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "%2$qE的第 %1$d 个实参类型不兼容"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 msgid "valid models are %e"
 msgstr "%qs对%qs而言无效"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "%2$qE的第 %1$d 个实参类型不兼容"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "%qT没有名为%qE的成员"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, fuzzy, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "失败内存式样无法 stronger 比成功内存式样用于 %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, fuzzy, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "失败内存式样无法 stronger 比成功内存式样用于 %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE attribute only applies to variables and functions"
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "%qE属性只能为变量或函数所使用"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of %s function at %L is negative"
 msgid "argument %i value %s is negative"
 msgstr "%2$L处 %1$s 函数的参数是负的"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "referencing argument %u of type %qT"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "内联函数%q+D声明过但从未定义"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "in a call with type %qT and attribute %qs"
 msgstr "属性%qs的元素类型无效"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "内建函数实参无效"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "in a call with type %qT"
 msgstr "在调用%qD时"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, gcc-internal-format
 msgid "%qD called on unallocated object %qD"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "assigned here"
 msgstr "联合在此定义"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "#pragma GCC optimize 不允许用在函数中"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "%3$L处 %2$s 分句中的 Cray 指针‘%1$s’"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "%3$L处 %2$s 分句中的 Cray 指针‘%1$s’"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "不能为%q+D指定对齐"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %q+D"
 msgid "pointer used after %qD"
 msgstr "未使用的参数%q+D"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "call to %qD here"
 msgstr "%qD在此声明"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "无效的指针模式%qs"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "假定是成员指针%qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "无效的指针模式%qs"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD在此声明"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 #| msgid "plugin cannot register an unnamed pass"
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "插件不能注册一趟无名处理"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "%B：警告：在此定义\n"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "调用非函数的%qD"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "调用非函数的%qD"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "在调用%qD时"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -31580,340 +31637,340 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "错误地使用了%<auto%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, fuzzy, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr "先前的定义在这里"
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, fuzzy, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr "在指定 -fno-rtti 的情况下不能使用 typeid"
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 msgid "contains additional virtual method %qD"
 msgstr "为非虚方法%q+D指定了初始值设定项"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, fuzzy, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "C++ 静态虚拟方法 %qD"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, fuzzy, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr "先前的定义在这里"
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, fuzzy, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr "先前的定义在这里"
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, fuzzy, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, fuzzy, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr "限定类型%qT不匹配析构函数名 ~%qT"
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "枚举类型在此定义"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 msgid "array types have different bounds"
 msgstr "?: 的操作数类型不一致，分别为%qT和%qT"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, gcc-internal-format
 msgid "return value type mismatch"
 msgstr "返回值类型不匹配"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, gcc-internal-format
 msgid "implicit this pointer type mismatch"
 msgstr ""
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "非类型参数包中类型不匹配"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "形参类型不同"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, fuzzy, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr "先前的定义在这里"
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 msgid "type %qT should match type %qT"
 msgstr "限定类型%qT不匹配析构函数名 ~%qT"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, fuzzy, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, fuzzy, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 msgid "memory layout mismatch"
 msgstr "<返回值>"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "未定义 C++ 基类"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, fuzzy, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr "先前的定义在这里"
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%qE未声明(不在函数内)"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, gcc-internal-format
 msgid "mismatching definition"
 msgstr "不匹配的定义"
@@ -31934,7 +31991,7 @@ msgstr "ipa 内联概要缺少在中输入文件"
 msgid "IPA modref summary is missing in input file"
 msgstr "ipa 内联概要缺少在中输入文件"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function in gimple call"
 msgid "invalid jump function in LTO stream"
@@ -32177,12 +32234,12 @@ msgstr "最大值条件保存对数量该可以是 sunk"
 msgid "unable to find a register to spill"
 msgstr "在类%qs中找不到可溢出的寄存器"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "%<asm%>中操作数约束不一致"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "最大值条件保存对数量该可以是 sunk"
@@ -32569,7 +32626,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr "返回值的数量不匹配值的数量"
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -34035,25 +34092,25 @@ msgstr "隐式弹栈的寄存器必须集中在栈顶"
 msgid "output operand %d must use %<&%> constraint"
 msgstr "输出操作数 %d 必须使用%<&%>约束"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data：[%u]  空链(%u) 的 next_regno 错误"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: Loop in regno chain (%u)"
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data：在 regno 链(%u)中的循环"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Bad oldest_regno (%u)"
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data：[%u] 错误的 oldest_regno (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 #| msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
@@ -35028,180 +35085,180 @@ msgstr "外异动作业在中 %<transaction_safe%> 函数"
 msgid "ignoring loop annotation"
 msgstr "循环变量"
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 #| msgid "constant not recomputed when ADDR_EXPR changed"
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "ADDR_EXPR 变化时常量未被重新计算"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 #| msgid "side effects not recomputed when ADDR_EXPR changed"
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "ADDR_EXPR 变化时副作用未被重新计算"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 #| msgid "address taken, but ADDRESSABLE bit not set"
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "已取地址，但是 ADDRESSABLE 位未被设置"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 #| msgid "non-scalar type"
 msgid "non-scalar %qs"
 msgstr "非标准类型"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size operand to %qs"
 msgstr "BIT_FIELD_REF 位置或大小操作数无效"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, fuzzy, gcc-internal-format
 #| msgid "integral result type precision does not match field size of BIT_FIELD_REF"
 msgid "integral result type precision does not match field size of %qs"
 msgstr "整体结果类型精度不匹配 BIT_FIELD_REF 字段尺寸"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, fuzzy, gcc-internal-format
 #| msgid "mode precision of non-integral result does not match field size of BIT_FIELD_REF"
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "非整体结果的模式精度不匹配 BIT_FIELD_REF 的字段尺寸"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "无效的移位操作数"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, fuzzy, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "BIT_FIELD_REF 位置或大小操作数无效"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 #| msgid "type mismatch in array reference"
 msgid "type mismatch in %qs reference"
 msgstr "数组引用类型不匹配"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "在左操作数边转化 SSA_NAME。"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "将一个指针转换为大小不同的整数"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "%%R 的操作数无效"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "非类型参数包中类型不匹配"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "BIT_FIELD_REF 位置或大小操作数无效"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "BIT_FIELD_REF 位置或大小操作数无效"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "BIT_FIELD_REF 位置或大小操作数无效"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "错误地使用了%qD"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "简单的 IF"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "需要标量时使用了结构类型"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "无效的最小左值表达式"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, fuzzy, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "gimple 调用有两目标"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "gimple 调用无目标"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "gimple 调用中有非法函数"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "gimple 调用了非函数"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "纯常函数状态无效"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "gimple 调用中左操作数无效"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, fuzzy, gcc-internal-format
 #| msgid "LHS in noreturn call"
 msgid "LHS in %<noreturn%> call"
 msgstr "不返回的调用中有左值"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "gimple 调用中转换无效"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "gimple 调用中静态链无效"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, fuzzy, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "静态调用链中有不使用静态调用的函数"
@@ -35212,626 +35269,626 @@ msgstr "静态调用链中有不使用静态调用的函数"
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "调用%<__builtin_next_arg%>时没有给定实参"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "gimple 调用中参数无效"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "gimple 比较中操作数无效"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "在类型%qT和%qT间比较"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, fuzzy, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "函数返回了一个函数"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, fuzzy, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "向量值的加法中有无效的非向量操作数"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "无效类型%qT被用作类型为%qT的向量的初始值设定"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "对不同枚举类型之间的比较给出警告"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "非寄存器作为单目操作的左操作数"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "单目操作中操作数无效"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in nop conversion"
 msgid "invalid vector types in nop conversion"
 msgstr "空转换中类型无效"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "空转换中类型无效"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "地址空间转换中类型无效"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "整点转换中类型无效"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 #| msgid "invalid types in conversion to floating point"
 msgid "invalid types in conversion to floating-point"
 msgstr "向浮点转换时类型无效"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "向整数转换时类型无效"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "移位表达式类型不匹配"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "无效的操作数代码‘%c’"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "无效的操作数代码‘%c’"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "单目操作时不平凡的转换"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "非寄存器作为二元操作的左操作数"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "二元操作中中操作数无效"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 #| msgid "invalid non-vector operands to vector valued plus"
 msgid "invalid non-vector operands to %qs"
 msgstr "向量值的加法中有无效的非向量操作数"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "无效的指针模式%qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "需要整数表达式"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "二元表达式中类型不匹配"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "非寄存器作为单目操作的左操作数"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "二元操作中中操作数无效"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "需要整数表达式"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "矢量与不同的组件号码找到在中矢量 permute 运算式"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 msgid "invalid mask type in %qs"
 msgstr "表格类型   ：%s\n"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "not allowed type combination in %qs"
 msgstr "不支持的组合：%s"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 #| msgid "invalid position or size operand to BIT_FIELD_REF"
 msgid "invalid position or size in %qs"
 msgstr "BIT_FIELD_REF 位置或大小操作数无效"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "无效的移位操作数"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for %qs"
 msgid "insertion out of range in %qs"
 msgstr "常量实参超过%qs的范围"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a directory"
 msgid "%qs not at element boundary"
 msgstr "%qs 不是目录"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion at assignment"
 msgid "non-trivial conversion in %qs"
 msgstr "赋值时不平凡的转换"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "%s：无效的目的：%s\n"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 #| msgid "in statement"
 msgid "%qs LHS in clobber statement"
 msgstr "在语句中"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr ""
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "%%R 的操作数无效"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs size argument in load"
 msgstr "%<...%>作为实参。)"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rhs for gimple memory store"
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "gimple 内存存储中右操作数无效"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr "非寄存器作为单目操作的左操作数"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "incorrect type of vector %qs elements"
 msgstr "左移次数大于或等于类型宽度"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "提供给函数%qE的实参太多"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, fuzzy, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr "PHI 参数不是 GIMPLE 变量"
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "向量初始值设定项中有多余元素"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "非形参%qs不能是一个参数包"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "返回语句操作数无效"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "返回语句转换无效"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "goto 的目标既非标号亦非指针"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "开关语句操作数无效"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "位段%qD非整型"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "case 标号出现在开关语句外"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "gimple 调用中静态链无效"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "case 标号出现在开关语句外"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "case 标号出现在开关语句外"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "case 标号出现在开关语句外"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "case 标号出现在开关语句外"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "case 标号未排序： "
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 msgid "label context is not the current function declaration"
 msgstr "make_local_variable: 当前作用域中没有函数上下文"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect entry in label_to_block_map"
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "label_to_block_map 中条目不正确"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "着陆场号码设置不正确"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "gimple 条件中比较代码无效"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "gimple 条件中的标号无效"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI result"
 msgid "invalid %<PHI%> result"
 msgstr "无效的 PHI 结果"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<PHI%> def"
 msgstr "缺少 PHI 定义"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI argument"
 msgid "invalid %<PHI%> argument"
 msgstr "无效的 PHI 实参"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "PHI 实参 %u 类型不兼容"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 #| msgid "verify_gimple failed"
 msgid "%<verify_gimple%> failed"
 msgstr "verify_gimple 失败"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, fuzzy, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "在 EH 表中死了的 STMT"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "implicit declaration of function %qE"
 msgid "local declaration from a different function"
 msgstr "隐式声明函数%qE"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimple_bb (phi) 设置为一个错误的基本块"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, fuzzy, gcc-internal-format
 msgid "PHI node with location"
 msgstr " (位置列表)"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "对树结节的共享不正确"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, fuzzy, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr "PHI 参数不是 SSA_NAME 或不变量"
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimple_bb (stmt) 设置为一个错误的基本块"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "语句被标记为抛出异常，但实际上并未抛出"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "语句在块中被标记为抛出"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verify_gimple 失败"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK 有与之关联的 IL"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK 有与之关联的 IL"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "直通边从基本块 %d 退出"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "初始值设定项末尾有多余的花括号组"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "初始值设定项末尾有多余的花括号组"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "exit block count is not compatible with entry block count"
 msgstr "-mnop-mcount 与此目标不兼容"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE is not initialized"
 msgid "count of bb %d not initialized"
 msgstr "%qE未经初始化"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "verify_flow_info: Wrong probability of edge %i->%i %i"
 msgid "probability of edge %d->%d not initialized"
 msgstr "verify_flow_info：边 %i->%i %i 概率错"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "-mnop-mcount 与此目标不兼容"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 msgid "label %qD to block does not match in bb %d"
 msgstr "%C处 ENDDO 中的语句标号与 DO 标号不匹配"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 msgid "label %qD has incorrect context in bb %d"
 msgstr "%qD类型不完全"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "基本块 %d 中出现流程控制"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "control flow in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "基本块 %d 中出现流程控制"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "在基本块 %d 中控制语句后的直通边"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "基本块 %d 中非 GIMPLE_COND 后的真假边"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "基本块 %d 结尾处有错误的出边标记"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "基本块 %d 末尾显式的 goto"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "基本块 %d 中，返回边并不指向退出"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "默认 case 不在 case 向量的开头"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "case 标号未排序： "
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "多余的出边 %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "缺少边 %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%>函数返回了"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "在有返回值的函数中，控制流程到达函数尾"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "忽略声明有 warn_unused_result 属性的%qD的返回值"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of function declared with attribute warn_unused_result"
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
@@ -36017,13 +36074,13 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid element type for attribute %qs"
 msgid "invalid fn spec attribute \"%s\""
 msgstr "属性%qs的元素类型无效"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid fn spec attribute \"%s\" arg %i"
@@ -36544,7 +36601,7 @@ msgstr "矢量作业将被展开 piecewise"
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "矢量随机播放作业将被展开 piecewise"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -36980,30 +37037,30 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, fuzzy, gcc-internal-format
 #| msgid "%qE incompatible attribute ignored"
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr "%qE不兼容的属性已被忽略"
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
 msgid "previous declaration of %qD"
 msgstr "%qD先前没有声明"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q+D的节与早先的声明冲突"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 msgid "%qD conflicts for version %qB"
 msgstr "与先前此处的声明冲突"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "%q+D的节与早先的声明冲突"
@@ -37083,7 +37140,7 @@ msgstr "只有未初始化的变量才能放在 .bss 节中"
 msgid "no initializers are allowed in section %qs"
 msgstr "只有未初始化的变量才能放在 .bss 节中"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "%q+D的寄存器名无效"
@@ -37238,7 +37295,7 @@ msgstr "weakref%q+D最终指向其自身"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "弱引用%q+D必须有静态链接"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "别名定义在此配置下不受支持"
@@ -37284,62 +37341,62 @@ msgstr "使用紧实的堆栈布局"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "模板第 %d 个参数无效"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "模板第 %d 个参数无效"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "%qE attribute argument has type %qT"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "%qE属性需要一个整常量作为实参"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "%qE属性需要一个整常量作为实参"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "默认参数只允许出现在函数参数中"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "默认参数只允许出现在函数参数中"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "默认参数只允许出现在函数参数中"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -37356,12 +37413,12 @@ msgstr "%qE属性只能为变量或函数所使用"
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "%qE属性在类型上被忽略"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "%qE属性在类型上被忽略"
@@ -37584,12 +37641,12 @@ msgstr "无法为枚举类型使用模式%qs"
 msgid "mode %qs applied to inappropriate type"
 msgstr "对不合适的类型应用模式%qs"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "此目标机不支持节属性"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "%q+D不能有 section 属性"
@@ -37600,18 +37657,18 @@ msgstr "%q+D不能有 section 属性"
 msgid "section attribute argument not a string constant"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "不能为局部变量指定节属性"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "%q+D的节与早先的声明冲突"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "节%q+D无法被重载"
@@ -37707,7 +37764,7 @@ msgstr "cleanup 实参不是一个标识符"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr "%q+D的数据区域与先前的声明冲突"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "内联函数%q+D声明过但从未定义"
@@ -37755,13 +37812,13 @@ msgstr "%qs(有%qT)的实参类型无效"
 msgid "%qE attribute is only applicable on functions"
 msgstr "%qE属性只能用于函数"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "%qs属性只能应用于函数"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to functions"
 msgid "%<symver%> attribute is only applicable to symbols"
@@ -37773,12 +37830,12 @@ msgstr "%qE属性只能用于函数"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -37875,23 +37932,23 @@ msgstr "%qE属性被忽略，因为%qT已被定义"
 msgid "visibility argument not a string"
 msgstr "visibility 的实参不是一个字符串"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "%qE属性在类型上被忽略"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD重声明时有不同的可见性"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD声明为有默认可见性的%qs"
@@ -37909,7 +37966,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "%qE属性只能用于函数"
@@ -37987,7 +38044,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "%qE属性在类型上被忽略"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -38070,7 +38127,7 @@ msgstr "%qD 与 %qD 不兼容"
 msgid "%qE argument is not a function"
 msgstr "属性%qE的参数无效"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "过时消息不是一个字符串"
@@ -38141,7 +38198,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "%qE属性在类型上被忽略"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute requires a string constant argument"
 msgid "%qE attribute requires a string argument"
@@ -38311,15 +38368,15 @@ msgid "requested position is less than zero"
 msgstr "要求的位置小于 0"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "嵌套函数在此目标机上不受支持"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "%qE属性需要一个字符串常量作为实参"
@@ -38608,7 +38665,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "建议在用作真值的赋值语句前后加上括号"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "错误地使用了%<restrict%>"
@@ -38783,8 +38840,8 @@ msgstr "变量实参太少，不足以填满一个哨兵"
 msgid "missing sentinel in function call"
 msgstr "函数调用中缺少哨兵"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, fuzzy, gcc-internal-format
 #| msgid "bad option %s to pragma attribute"
 msgid "bad option %qs to attribute %<optimize%>"
@@ -39847,7 +39904,7 @@ msgstr "不受支持的非标准字面字符串毗连"
 msgid "traditional C rejects string constant concatenation"
 msgstr "传统 C 不接受字符串常量毗连"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -39904,7 +39961,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr "%<void%>作为仅有的参数时不能被限定"
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "迭代变量%qE类型无效"
@@ -39920,17 +39977,17 @@ msgstr "迭代变量%qE类型无效"
 msgid "%qE is not initialized"
 msgstr "%qE未经初始化"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "缺少控制谓词"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "无效的控制谓词"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, gcc-internal-format
 msgid "missing increment expression"
 msgstr "缺少自增语句"
@@ -39940,7 +39997,7 @@ msgstr "缺少自增语句"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "无效的自增语句"
@@ -40043,18 +40100,18 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, gcc-internal-format
 msgid "%qD is not a function argument"
 msgstr "%qD 不是一个函数参数"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr "字段%qE的类型不完全"
@@ -40064,8 +40121,8 @@ msgstr "字段%qE的类型不完全"
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qD在子句%qs中不是一个变量"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "字段%qE的类型不完全"
@@ -40624,7 +40681,7 @@ msgstr "%<pragma %s%>位置错误，已忽略"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "%<#pragma %s%>格式错误，已忽略"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "%<#pragma %s%>末尾有垃圾"
@@ -40697,8 +40754,8 @@ msgstr "在这里不允许使用%<#pragma%>"
 msgid "wrong type argument to %s"
 msgstr "不能对该类型的参数求绝对值"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -41209,17 +41266,17 @@ msgstr "令函数%qD自减"
 msgid "function %qD used as %<asm%> output"
 msgstr "函数%qD用作%<asm%>的输出"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "向只读位置%qE赋值"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "令只读位置%qE自增"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "令只读位置%qE自减"
@@ -41493,7 +41550,7 @@ msgid "passing argument %i to %qs-qualified parameter aliases with argument %Z"
 msgid_plural "passing argument %i to %qs-qualified parameter aliases with arguments %Z"
 msgstr[0] "传递%2$qE的第 %1$d 个实参时丢弃了指针目标类型的限定"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -42480,7 +42537,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "内建函数%q+D未被声明为函数"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -43171,7 +43228,7 @@ msgstr "传递%2$qE的第 %1$d 个参数时将指针赋给整数，未作类型
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 #| msgid "deleted definition of %qD"
 msgid "duplicate definition of %qs"
@@ -43221,7 +43278,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "类型 %qT 大小未知"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored because %qT is already defined"
 msgid "variables of type %qT cannot have thread-local storage duration"
@@ -43278,7 +43335,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -43378,19 +43435,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "传递 AltiVec 参数给无原型的函数"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -43436,215 +43493,215 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "忽略%qs属性"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "invalid format for %<sve_width%>"
 msgstr "操作无效的对象"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%h value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "无效 %%h 值"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "%s: 不适用的选项 -- %c\n"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "spec 函数名格式错误"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, gcc-internal-format
 msgid "specify a system register with a small string length"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not valid for %qs"
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs对%qs而言无效"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, fuzzy, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr "全局构造函数在此目标机上不受支持"
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, fuzzy, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, fuzzy, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "%<...%>作为实参。)"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "内建函数实参无效"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 #| msgid "switch -mcpu=%s conflicts with -march=%s switch"
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "开关 -mcpu=%s 与 -march=%s 冲突"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "Assembler does not support -mabi=ilp32"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "汇编器不支持 -mabi=ilp32"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 #| msgid "builtin %qF is deprecated"
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "内建的 %qF 已被弃用"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr "代码模式%qs在 %s 位模式下不受支持"
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "代码模式%qs在 %s 位模式下不受支持"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, fuzzy, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "%qs后断言"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "%qs后缺少宏名"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "%qs后断言"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "%qs后缺少宏名"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "%qs后断言"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "%qs后断言"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "异常的 URL"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr "%s 只接受 2 个参数"
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr "目标系统不支持调试输出"
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 #| msgid "attribute(target(\"%s\")) is unknown"
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "attribute(target(\"%s\"))未知"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -43652,207 +43709,207 @@ msgstr "attribute(target(\"%s\"))未知"
 msgid "attribute %<target%> argument not a string"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 #| msgid "attribute(target(\"%s\")) is unknown"
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "attribute(target(\"%s\"))未知"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, fuzzy, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr "异常的 URL"
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "只能为类定义应用%qE属性"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "%qs后断言"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "%qs后缺少宏名"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, fuzzy, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "%qs后缺少宏名"
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "联合成员函数%qD被声明为虚函数"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was previously declared here"
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%qD以前在此声明过"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, fuzzy, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "操作数号超出范围"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 msgid "unsupported simdlen %wd"
 msgstr "不支持的真理哈希类型 %d。\n"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "%<operator new%>必须返回%qT"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, fuzzy, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr "%<operator new%>必须返回%qT"
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "-shared 选项目前在 VAX ELF 下不受支持"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "-shared 选项目前在 VAX ELF 下不受支持"
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 #| msgid "type attributes ignored after type is already defined"
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "类型属性在定义后被忽略"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%q+D defined here"
 msgstr "标号%qD在此定义"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "%K%D 的第一个实参必须是一个指针，第二个必须是整常量"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "根据原型，实参 %d (%qE) 将以不同的宽度传递"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be in the range %d...%d"
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr "%2$qE的第 %1$d 个参数必须是在 %3$d 和 %4$d 之间"
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "根据原型，实参 %d (%qE) 将以不同的宽度传递"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "根据原型，实参 %d (%qE) 将以不同的宽度传递"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "根据原型，实参 %d (%qE) 将以不同的宽度传递"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "%qs后缺少宏名"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 #, fuzzy
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "%qs后缺少宏名"
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "%qs后缺少宏名"
@@ -44055,12 +44112,12 @@ msgstr "%qE属性的实参不是“ilink1”或“ilink2”"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -44201,23 +44258,23 @@ msgid "argument of %qE attribute ignored"
 msgstr "%qE属性的实参不是“ilink1”或“ilink2”"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "属性%qE只能用于变量"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L is not allowed in this context"
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "%L处上下文中不允许使用按值传递的实参"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "未知的 TLS 模型%qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "向函数类型%qT的转换无效"
@@ -44791,12 +44848,12 @@ msgstr "不支持 %<-fpie%>"
 msgid "%<-fPIE%> is not supported"
 msgstr "不支持 %<-fPIE%>"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "-flto and -fwhopr 互斥"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "%qs 函数不能有参数"
@@ -44806,7 +44863,7 @@ msgstr "%qs 函数不能有参数"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "%qs 函数不能有返回值"
@@ -45154,7 +45211,7 @@ msgstr "嵌套函数在此目标机上不受支持"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "内建函数实参无效"
@@ -45493,7 +45550,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -45670,174 +45727,174 @@ msgstr ""
 "\n"
 "错误：“%s”并非有效新闻群组！\n"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 #| msgid "interrupt Service Routines cannot be coded in Thumb mode"
 msgid "interrupt service routine cannot be called directly"
 msgstr "Thumb 模式中不能编码中断服务进程"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "最后一个实参必须是一个 2 位立即数"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "最后一个实参必须是一个 8 位立即数"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "最后一个实参必须是一个 8 位立即数"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "最后一个实参必须是一个 1 位立即数"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "最后一个实参必须是一个 3 位立即数"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "最后一个实参必须是一个 4 位立即数"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "最后一个实参必须是一个 1 位立即数"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qE needs isa option %s"
 msgid "'%s' needs isa option %s"
 msgstr "%qE需要 ISA 选项 %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "最后一个实参必须是一个 5 位立即数"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "倒数第二个实参必须是一个 8 位立即数"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "最后一个实参必须是一个 8 位立即数"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "%<__builtin_prefetch%>的第三个实参必须是一个常量"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, gcc-internal-format
 msgid "incorrect comparison mode"
 msgstr "不正确的比较模式"
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 msgid "incorrect rounding operand"
 msgstr "控制生成的浮点舍入模式"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "最后一个实参必须是一个 4 位立即数"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "最后一个实参必须是一个 5 位立即数"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "最后一个实参必须是一个 8 位立即数"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "左实参必须是一个切片"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "选择子必须是 0 到 %wi 间的整常量"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE需要未知的 ISA 选项"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE需要 ISA 选项 %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "%<__builtin_prefetch%>的第三个实参必须是一个常量"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%>的第二个实参无效；使用 0"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 msgid "invalid third argument"
 msgstr "%<...%>作为实参。)"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%>的第三个实参无效；使用 0"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%>的第三个实参无效；使用 0"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "左实参必须是一个切片"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "最后一个参数必须是一个 32 位立即数"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "最后一个实参必须是一个立即数"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "最后一个实参必须是一个 4 位立即数"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 #| msgid "the next to last argument must be an 8-bit immediate"
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
@@ -46269,8 +46326,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%<-fcf-protection%> 与此目标不兼容"
@@ -46526,7 +46583,7 @@ msgstr "在 GCC 4.4 中传递带有复数浮点成员结构的 ABI 有了改变"
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "在 GCC 4.4 中传递带有复数浮点成员结构的 ABI 有了改变"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -46553,12 +46610,12 @@ msgstr "已禁用 SSE 却在 SSE 寄存器中传递参数"
 msgid "x87 register return with x87 disabled"
 msgstr "已禁用 x87 却在 x87 寄存器中返回"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, fuzzy, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "带属性 sseregparm 调用%qD却没有启用 SSE/SSE2"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -46568,41 +46625,41 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "在 GCC 4.4 中传递有 long double 的联合的 ABI 有改变"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "assert：%s 与 %s 赋值兼容"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "ms_hook_prologue 与嵌套函数不兼容"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "%qE属性在此平台上不受支持"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support fastcall with nested function"
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "-fsplit-stack 不支持对嵌套函数使用 fastcall"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support 2 register parameters for a nested function"
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
@@ -46610,96 +46667,96 @@ msgstr "-fsplit-stack 不支持在嵌套函数中使用 2 个寄存器参数"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 #| msgid "-fsplit-stack does not support 3 register parameters"
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "-fsplit-stack 不支持 3 个寄存器参数"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr "为每个函数使用堆栈保护机制"
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "2 byte cop instructions are not allowed in 64-bit VLIW mode"
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "2 字节 cop 指针不允许被用在 VLIW 模式中"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported operand size for extended register"
 msgid "unsupported size for integer register"
 msgstr "扩展的寄存器不支持的操作数大小"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "扩展的寄存器没有高半部分"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "扩展的寄存器不支持的操作数大小"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "非整数操作数使用了操作数代码‘%c’"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr ""
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "高寄存器弹栈时没有可用的低寄存器"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 #| msgid "-mcmodel= is not supported on 32 bit systems"
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "32 位系统不支持 -mcmodel="
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "未知的架构特定的内存模型"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 #| msgid "-fdirectives-only is incompatible with -traditional"
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
@@ -46754,7 +46811,7 @@ msgstr "gp_offset (%ld) 或 end_offset (%ld) 小于 0"
 msgid "argument %qd is not a constant"
 msgstr "实参%qd不是一个常数"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -46766,7 +46823,7 @@ msgstr "PRINT_OPERAND_ADDRESS，空指针"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND：未知的标点‘%c’"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -46929,50 +46986,50 @@ msgstr "attribute(target(\"%s\"))未知"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, fuzzy, gcc-internal-format
 #| msgid "version attribute is not a string"
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr "版本属性不是一个字符串"
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 #| msgid "readonly property can not be set"
 msgid "in attribute %qs priority cannot be empty"
 msgstr "不能设置只读属性"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "堆栈限制在此目标机上不受支持"
@@ -47751,7 +47808,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, gcc-internal-format
 msgid "bad builtin code"
 msgstr "错误的内建代码"
@@ -47980,84 +48037,84 @@ msgstr "无法打开中间的 ptx 文件"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, fuzzy, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "给出了两个不同的操作选项"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "不兼容的地址空间限定符%qs和%qs"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a void return type"
 msgstr "%qE属性在类型上被忽略"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "__BELOW100__ 属性不允许用于自动存储类"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "%<num_threads%>值必须为正"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "%qs必须与%qs一起使用"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "weak alias definitions not supported in this configuration"
 msgstr "别名定义在此配置下不受支持"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 #| msgid "alias definitions not supported in this configuration"
 msgid "non-function alias definitions not supported in this configuration"
@@ -48296,339 +48353,339 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, fuzzy, gcc-internal-format
 #| msgid "argument %d of %qE must be in the range %d...%d"
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr "%2$qE的第 %1$d 个参数必须是在 %3$d 和 %4$d 之间"
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a fixed size"
 msgstr "类型 %qT 大小未知"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT does not have a known size"
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "类型 %qT 大小未知"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "在指向不完全类型的指针上执行算术运算"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, fuzzy, gcc-internal-format
 #| msgid "function parameters cannot have __fp16 type"
 msgid "member variables cannot have RVV type %qT"
 msgstr "函数形参不能有 __fp16 类型"
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 msgid "fields cannot have RVV type %qT"
 msgstr "%qD类型不完全"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "function parameters cannot have __fp16 type"
 msgid "array elements cannot have RVV type %qT"
 msgstr "函数形参不能有 __fp16 类型"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "无法为有抽象类型%qT的对象分配内存"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "无法为有抽象类型%qT的对象分配内存"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "无法为有抽象类型%qT的对象分配内存"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "向 void 的类型转换不会访问具有不完全类型%qT的对象"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "无法识别的宽子指令"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, gcc-internal-format
 msgid "no matching function call to %qE with empty arguments"
 msgstr "没有与 %qE 匹配的函数调用，参数为空"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 #| msgid "unknown value %qs for -mtune"
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "-mtune 参数的值 %qs 未知"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, fuzzy, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "不使用位段指令"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, fuzzy, gcc-internal-format
 #| msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "在 GCC 4.4 中传递带有复数浮点成员结构的 ABI 有了改变"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, fuzzy, gcc-internal-format
 #| msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "在 GCC 4.4 中传递带有复数浮点成员结构的 ABI 有了改变"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "传递 AltiVec 参数给无原型的函数"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "目标属性或 pragma 改变了 SPE ABI"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "目标属性或 pragma 改变了 SPE ABI"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "目标属性或 pragma 改变了 SPE ABI"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "目标属性或 pragma 改变了 SPE ABI"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "目标属性或 pragma 改变了 SPE ABI"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, fuzzy, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "内建函数%q+D未被声明为函数"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "%qE属性的实参不是一个字符串常量"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE属性在不是类的类型上被忽略"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 #| msgid "case label is not an integer constant expression"
 msgid "%qs requires an integer constant"
 msgstr "case 标号不是一个整数常量表达式"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, fuzzy, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "不使用位段指令"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 #| msgid "target CPU does not support ARM mode"
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "目标 CPU 不支持 ARM 模式"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 msgid "code model %qs with %qs"
 msgstr "代码模式%qs在 %s 位模式下不受支持"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr "rv32e 需要 ilp32e ABI"
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr "rv64e 需要 lp64e ABI"
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 不支持复数类型"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, fuzzy, gcc-internal-format
 #| msgid "%<-mfpxx%> requires %<-mlra%>"
 msgid "ABI requires %<-march=rv%d%>"
 msgstr "%<-mfpxx%> 需要 %<-mlra%>"
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 #| msgid "-mpreferred-stack-boundary=%d is not between %d and %d"
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d 的值不在 %d 和 %d 之间"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs没有指定类名"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "在 %2$qs 中，%1$qs 不是一个有效的数字"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qs 函数不能有不同类型的中断"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, fuzzy, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr "堆栈限制在此目标机上不受支持"
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 #| msgid "bad value (%s) for %stune=%s %s"
 msgid "invalid version %qB for %<target_clones%> attribute"
@@ -49694,23 +49751,23 @@ msgstr "局部变量内存需求超过容量限制"
 msgid "%<function_profiler%> support"
 msgstr "function_profiler 支持"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "不能为中断函数使用 va_start"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "switch 语句太大(%lu 个条目)"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "属性%<__BELOW100__%>只对变量类型起作用"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -49949,34 +50006,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D定义后未使用"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "浮点选项需要布尔寄存器"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "CONST16 指令不支持 -f%s"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "需要 PIC，但 CONST16 指令不支持"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "只有未初始化的变量才能放在 .bss 节中"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -50069,7 +50126,7 @@ msgstr "%qs属性需要带有名参数的原型"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "%qs属性只能用于带可变参数函数"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -50157,8 +50214,8 @@ msgstr "%qs 不是目录"
 msgid "could not get size of source file"
 msgstr "无法写入响应文件 %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "void 值未如预期地被忽略"
@@ -50656,7 +50713,7 @@ msgstr "开关跳转至语句表达式中"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE定义为类型错误的标记"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "%qE属性在类型上被忽略"
@@ -50813,7 +50870,7 @@ msgstr "ISO C90 不支持在形参数组声明中使用%<static%>或类型限定
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 不支持%<[*]%>数组声明"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -50824,7 +50881,7 @@ msgstr "%<this%>不能用在此上下文中"
 msgid "%q+D is usually a function"
 msgstr "%q+D通常是一个函数"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "%qD先前没有声明"
@@ -50905,7 +50962,7 @@ msgstr "不能将带有 volatile 字段的对象放入寄存器"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "未初始化的常量%qD在C++中是无效的"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -51113,7 +51170,7 @@ msgstr "为形参%qE指定了存储类"
 msgid "storage class specified for unnamed parameter"
 msgstr "为无名形参指定了存储类"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "为类型名指定了存储类"
@@ -51291,7 +51348,7 @@ msgstr "类型名声明为返回一个数组的函数"
 msgid "function definition has qualified void return type"
 msgstr "函数定义有限定的 void 返回类型"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "忽略函数返回类型的类型限定"
@@ -51418,7 +51475,7 @@ msgstr "ISO C 不允许使用 const 或 volatile 限定函数类型"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "结构或联合成员不能具有可变类型"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "变量或字段%qE声明为 void"
@@ -51635,7 +51692,7 @@ msgstr "C++ 不允许在%qs表达式中定义类型"
 msgid "%qT defined in underspecified object initializer"
 msgstr "初始值设定项里有未知的字段%qE"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "没有声明任何东西"
@@ -51701,7 +51758,7 @@ msgstr "结构不包含任何有名成员"
 msgid "struct has no members"
 msgstr "结构体没有成员"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member in union is a GCC extension"
@@ -51771,7 +51828,7 @@ msgstr "%<enum %E%>重声明"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -51830,7 +51887,7 @@ msgstr "枚举值 %E 对其类型%<%T%>而言太大了"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C 将枚举值限制在%<int%>范围内"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 #| msgid "inline function %qD given attribute noinline"
 msgid "inline function %qD given attribute %qs"
@@ -51984,12 +52041,12 @@ msgstr "实参%qD与内建原型不符"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "实参%qD与原型不符"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "在有返回值的函数中未发现 return 语句"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "形参%qD被设定但未被使用"
@@ -52073,7 +52130,7 @@ msgstr "无效的协寄存器%qE"
 msgid "two or more data types in declaration specifiers"
 msgstr "声明指定了两个以上的数据类型"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%>对 GCC 来说太长了"
@@ -52184,7 +52241,7 @@ msgstr "ISO C90 不支持布尔类型"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C 不支持 %<__int%d%> 类型"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "嵌套函数在此目标机上不受支持"
@@ -52346,12 +52403,12 @@ msgstr "固定格式的行长至少为七。"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++ 对 %2$qs 不支持 %<__int%1$d%>"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -52419,39 +52476,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs 不支持与 %qs 一起使用"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "左移次数为负"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "左移次数为负"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "右移次数为负"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "左移次数大于或等于类型宽度"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "右移次数大于或等于类型宽度"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "左移次数大于或等于类型宽度"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -52472,7 +52529,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr "为了匹配这个%qs"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, gcc-internal-format
 msgid "expected end of line"
 msgstr "需要行尾"
@@ -52482,7 +52539,7 @@ msgstr "需要行尾"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C 不允许翻译单元为空"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -52531,8 +52588,8 @@ msgid "unknown type name %qE"
 msgstr "未知的类型名%qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "需要指定声明"
@@ -52570,7 +52627,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "需要标识符或%<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "属性在未初始化类型上被忽略"
@@ -52585,13 +52642,13 @@ msgstr "属性在模板实例化上被忽略"
 msgid "unexpected attribute"
 msgstr "非预期的属性"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "%q+D不能有 section 属性"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -52635,7 +52692,7 @@ msgstr "文件作用域中出现%<auto%>空声明"
 msgid "%qs may only be used with a single declarator"
 msgstr "%<auto%> 只能被指定的用于变量或函数声明"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "需要%<,%>或%<;%>"
@@ -52672,7 +52729,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "函数%qs不能被声明为%<mutable%>"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "需要字面字符串"
@@ -52703,7 +52760,7 @@ msgstr "静态断言中出现非常量条件"
 msgid "static assertion failed: %E"
 msgstr "静态断言错误：%E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, gcc-internal-format
 msgid "static assertion failed"
 msgstr "静态断言错误"
@@ -52759,8 +52816,8 @@ msgstr "无法为枚举类型使用模式%qs"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "需要标识符"
@@ -52793,12 +52850,12 @@ msgstr "对未定义类型%<%s %E%>的使用无效"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "%q+D的节与早先的声明冲突"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "枚举表以逗号结尾"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -52882,24 +52939,24 @@ msgstr "需要指定声明或%<...%>"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected OpenMP directive name"
 msgstr "需要函数"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%qE属性需要带有名实参的原型"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "%qE属性需要带有名实参的原型"
@@ -52910,7 +52967,7 @@ msgstr "%qE属性需要带有名实参的原型"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 不支持%<[*]%>数组声明"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -52942,18 +52999,18 @@ msgstr "ISO C90 不允许指定子对象的初始值"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "过时的用法，应使用%<=%>来指定元素初始值"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 #| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "有序区域必须紧密嵌套在一个有次序分句的循环内"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -52964,45 +53021,45 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr "有序区域必须紧密嵌套在一个有次序分句的循环内"
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, fuzzy, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr "%qE属性需要带有名实参的原型"
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, fuzzy, gcc-internal-format
 #| msgid "unrecognized address"
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr "无法识别的地址"
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "%qE属性需要带有名实参的原型"
@@ -53033,7 +53090,7 @@ msgstr "ISO C90 不允许混合使用声明和代码"
 msgid "expected %<}%> before %<else%>"
 msgstr "%<else%>前需要%<}%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%>之前没有%<if%>"
@@ -53048,7 +53105,7 @@ msgstr "标号位于复合语句末尾"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "需要语句"
@@ -53084,27 +53141,27 @@ msgstr "ISO C 不支持十进制浮点数"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "%s 表达式列表被看作复合表达式"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, gcc-internal-format
 msgid "expected declaration"
 msgstr "需要声明"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "建议在空的%<if%>语句体周围加上花括号"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "建议在空的%<else%>语句体周围加上花括号"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "建议显式地使用花括号以避免出现有歧义的%<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -53124,12 +53181,12 @@ msgstr "不允许多个中断属性"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "此指令中寄存器无效"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -53145,8 +53202,8 @@ msgstr "快速枚举在 Objective-C 1.0 里不可用"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "重复的 cv 限定"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, gcc-internal-format
 msgid "first seen here"
 msgstr ""
@@ -53169,12 +53226,12 @@ msgstr "ISO C 不允许省略 ?: 表达式中的第二项"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was declared here"
 msgid "first %<sizeof%> operand was declared here"
@@ -53362,7 +53419,7 @@ msgstr "ISO C90 不支持 %<__func__%> 预定义标识符"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "需要表达式"
@@ -53377,13 +53434,13 @@ msgstr "表达式中的花括号组只允许出现在函数中"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C 不允许在表达式中使用花括号组"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "%<va_start%>的第二个参数不是最后一个有名参数"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -53539,7 +53596,7 @@ msgstr "%<__builtin_prefetch%>的第三个实参必须是一个常量"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "%<__builtin_prefetch%>的第三个实参必须是一个常量"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "给函数%<__builtin_next_arg%>的参数数目不对"
@@ -53580,7 +53637,7 @@ msgstr "数组 new 的大小必须有整数类型"
 msgid "rotate count is negative"
 msgstr "循环左移次数为负"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -53694,7 +53751,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -53734,12 +53791,12 @@ msgstr "%C处数组声明需要另外一维"
 msgid "no type or storage class may be specified here,"
 msgstr "为%qs指定了存储类"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "不能设置只读属性"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -53750,61 +53807,61 @@ msgstr "缺少 Code 属性"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "不能设置只读属性"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "不能设置只读属性"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "位置错误的%<@%D%>Objective-C++ 构造"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected %qE selector name"
 msgstr "需要选择语句"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, fuzzy, gcc-internal-format
 #| msgid "setter name must terminate with %<:%>"
 msgid "setter method names must terminate with %<:%>"
 msgstr "setter 的名字必须以%<:%>结尾"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp flush%> may only be used in compound statements"
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<#pragma omp flush%>只能用在复合语句中"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "Objective-C 声明只能出现在全局作用域中"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<#pragma omp section%>只能用在%<#pragma omp sections%>结构中"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<#pragma omp section%>只能用在%<#pragma omp sections%>结构中"
@@ -53815,12 +53872,12 @@ msgstr "%<#pragma omp section%>只能用在%<#pragma omp sections%>结构中"
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<#pragma omp barrier%>只能用在复合语句中"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "需要语句"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<#pragma GCC pch_preprocess%>必须是第一个"
@@ -53830,11 +53887,11 @@ msgstr "%<#pragma GCC pch_preprocess%>必须是第一个"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "太多的%qs子句"
@@ -53849,65 +53906,65 @@ msgstr "调度块大小表达式必须为整型"
 msgid "%qD is not a variable"
 msgstr "%qD不是一个变量"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD 不是一个指针变量"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "折叠参数需要正整常量表达式"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<none%> or %<present%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected constant logical expression"
 msgstr "需要表达式"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<data%>"
 msgstr "需要%<catch%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<if%> clauses"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<if%> clauses without modifier"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -53930,23 +53987,23 @@ msgstr "%<num_threads%>值必须为正"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "需要整数表达式"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "启用最小/最大值指令"
@@ -53957,107 +54014,107 @@ msgstr "启用最小/最大值指令"
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "%qs 表达式必须是整型"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "太多 %<static%> 参数"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, gcc-internal-format
 msgid "unexpected argument"
 msgstr "非预期的参数"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%qE属性需要一个整常量作为实参"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<self%> clauses"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<new%>"
 msgid "expected %<concurrent%>"
 msgstr "需要%<new%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "ordered argument needs positive constant integer expression"
 msgstr "折叠参数需要正整常量表达式"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, fuzzy, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "需要标识符或%<(%>"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, gcc-internal-format
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr ""
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "调度%<runtime%>不接受一个%<chunk_size%>参数"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "调度%<auto%>不接受一个%<chunk_size%>参数"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "无效的调度类型"
@@ -54067,40 +54124,40 @@ msgstr "无效的调度类型"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, fuzzy, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %<allocator%> or %<align%>"
 msgstr "需要 %<,%> 或 %<)%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "重复的%qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "%H折叠变量需要正整常数表达式"
@@ -54115,22 +54172,22 @@ msgstr "需要%<class%>、%<typename%>或%<template%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 msgid "multiple linear modifiers"
 msgstr "%q+D的类型限定冲突"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "multiple %<step%> modifiers"
@@ -54141,7 +54198,7 @@ msgstr "太多的%qs子句"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "调度块大小表达式必须为整型"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -54156,334 +54213,334 @@ msgstr "%H折叠变量需要正整常数表达式"
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "%qs必须与%qs一起使用"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "无效的调度类型"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 msgid "invalid doacross kind"
 msgstr "无效的实型种别 %d，在%C处"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "{ 预期于运算式中 ? 之后"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "%<num_threads%>值必须为正"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 msgid "illegal comma"
 msgstr "不合法的算子"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<always%> modifiers"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<close%> modifiers"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<iterator%> modifiers"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<mapper%> modifiers"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "需要标识符或%<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<present%> modifiers"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, fuzzy, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 msgid "invalid map kind"
 msgstr "无效的实型种别 %d，在%C处"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, fuzzy, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "调度块大小表达式必须为整型"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "无效的调度类型"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "无效的调度类型"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, fuzzy, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "折叠参数需要正整常量表达式"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "%<asm%>中出现宽字面字符串"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "spec 函数名格式错误"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "%C 需要一个无名接口"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "duplicated %<fr%> preference selector"
 msgstr "重复的%<const%>"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, fuzzy, gcc-internal-format
 #| msgid "%<-march=%s%> is not compatible with the selected ABI"
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr "%<-march=%s%>与所选 ABI 不兼容"
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "需要字面字符串"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "重复的%qs"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %<target%> modifier"
 msgstr "重复的%qs"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "重复的%qs"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected an OpenACC clause"
 msgstr "需要指针"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs对%qs而言无效"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qE在子句%qs中不是一个变量"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected an OpenMP clause"
 msgstr "需要指针"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "%qD的声明隐藏了一个全局声明"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr "指定链接时使用%qD无效"
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 #| msgid "variably modified field at file scope"
 msgid "invalid OpenACC clause at file scope"
 msgstr "文件域中的动态可变字段"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %<extern%> variable %qD in %<for%> loop initial declaration"
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "在%<for%>循环初始声明中声明了%<extern%>变量%qD"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "指定链接时使用%qD无效"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "指定链接时使用%qD无效"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "%<#pragma message%>后需要一个字符串"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -54499,7 +54556,7 @@ msgstr "%qE未声明"
 msgid "expected function name"
 msgstr "需要函数"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, gcc-internal-format
 msgid "%qD does not refer to a function"
 msgstr "%qD 不引用一个函数"
@@ -54509,22 +54566,22 @@ msgstr "%qD 不引用一个函数"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr "#pragma GCC optimize 不允许用在函数中"
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "#pragma GCC optimize 不允许用在函数中"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
@@ -54552,7 +54609,7 @@ msgstr ""
 msgid "modified here"
 msgstr "联合在此定义"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "%H折叠变量需要正整常数表达式"
@@ -54589,117 +54646,117 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "需要标识符或%<(%>"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many atomic clauses"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many memory order clauses"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "%qT referred to as %qs"
 msgid "%qs clause requires %qs clause"
 msgstr "%qT作为%qs被引用"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after union definition"
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "联合定义后需要%<;%>"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "%<#pragma omp atomic%>运算符无效"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<else%>"
 msgstr "需要%<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "%<#pragma omp atomic%>运算符无效"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "%<#pragma omp atomic%>运算符无效"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "%<#pragma omp atomic%>运算符无效"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<# pragma omp 基元的 capture%>使用两不同的变量用于内存"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "整型表达式%qE不是常量"
@@ -54709,30 +54766,30 @@ msgstr "整型表达式%qE不是常量"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "整型表达式%qE不是常量"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -54742,34 +54799,34 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "需要%<(%>或行尾"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<#pragma omp flush%>只能用在复合语句中"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<#pragma omp%> clause"
 msgid "expected %<#pragma omp scan%>"
 msgstr "需要%<#pragma omp%>子句"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<#pragma omp flush%>只能用在复合语句中"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, gcc-internal-format
 msgid "for statement expected"
 msgstr "需要 for 语句"
@@ -54777,70 +54834,70 @@ msgstr "需要 for 语句"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 #| msgid "for statement expected"
 msgid "loop nest expected"
 msgstr "需要 for 语句"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "需要迭代声明或初始化"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 #| msgid "not enough perfectly nested loops"
 msgid "not enough nested loops"
 msgstr "不够完美的嵌套循环"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "迭代变量%qD不应当是 firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "{ 预期于运算式中 ? 之后"
@@ -54851,7 +54908,7 @@ msgstr "{ 预期于运算式中 ? 之后"
 msgid "expected a function name"
 msgstr "需要函数"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected target-function call"
@@ -54862,47 +54919,47 @@ msgstr "需要函数"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "需要%<;%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
@@ -54917,62 +54974,62 @@ msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected trait selector name"
 msgstr "需要选择语句"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "%3$L处哑过程‘%1$s’不能出现在基本过程‘%2$s’中"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "%s 只接受 2 个参数"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%>只能在类中指定"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression"
 msgstr "折叠参数需要正整常量表达式"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "%qs必须与%qs一起使用"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "需要字面字符串"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be integer expression"
 msgstr "需要整数表达式"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, fuzzy, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "内容 %qs 已经指定的在中 %<@synthesize%>"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> selector is not supported yet"
 msgstr "尚未支持代码模式 %<large%>"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 #| msgid "expected selection-statement"
 msgid "expected context selector set name"
@@ -54983,29 +55040,29 @@ msgstr "需要选择语句"
 msgid "variant %qD is not a function"
 msgstr "在函数%qs中"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "在函数%qs中"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<match%> clauses"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 msgid "%qD is specified more than once"
 msgstr "在基类限定中指定了多于一次的%<virtual%>"
@@ -55016,7 +55073,7 @@ msgstr "在基类限定中指定了多于一次的%<virtual%>"
 msgid "%qD is not of pointer type"
 msgstr "%qD 不是一个指针变量"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<nothing%> or %<need_device_ptr%>"
@@ -55028,18 +55085,18 @@ msgstr "需要%<none%>或%<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs对%qs而言无效"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "需要%<;%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%> clause"
@@ -55061,12 +55118,12 @@ msgstr "尚未支持代码模式 %<large%>"
 msgid "base function %qD declared here"
 msgstr "%qD在此声明"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "%2$qE的实参 %1$d 必须是地址"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 #| msgid "-I- specified twice"
 msgid "%<append_args%> specified here"
@@ -55078,7 +55135,7 @@ msgstr "-I- 指定了两次"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "-f%s 和 -msdata=%s 互不兼容"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "variant %qD and base %qD have incompatible types"
@@ -55089,7 +55146,7 @@ msgstr "-f%s 和 -msdata=%s 互不兼容"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
@@ -55105,90 +55162,90 @@ msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 msgid "no declaration of base function %qs"
 msgstr "隐式声明函数%qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 #| msgid "function definition does not declare parameters"
 msgid "variant function definition does not match declaration of %qE"
 msgstr "函数定义未声明形参"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "使用了变长数组"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<match%>"
 msgstr "需要%<catch%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<target%> or %<variant%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<none%> or %<shared%>"
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "需要%<none%>或%<shared%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<#pragma GCC pop_options%>缺少相应的%<#pragma GCC push_options%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute with %s attribute at %L"
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%s 属性与 %s 属性共存在 %L"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<#pragma GCC pop_options%>缺少相应的%<#pragma GCC push_options%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute with %s attribute at %L"
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr "%s 属性与 %s 属性共存在 %L"
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
@@ -55214,12 +55271,12 @@ msgstr "%qD的声明隐藏了一个全局声明"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T之前在此声明过"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 msgid "unexpected clause"
 msgstr "需要%<class%>"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 #| msgid "missing PHI def"
 msgid "missing %<map%> clause"
@@ -55280,33 +55337,33 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "需要%<#pragma omp section%>或%<}%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, fuzzy, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
@@ -55321,171 +55378,171 @@ msgstr "使用了变长数组"
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "使用了变长数组"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "expected %<sizes%>"
 msgstr "需要%<delete%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not an integer constant"
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%qE属性需要一个整常量作为实参"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<,%> or %<)%>"
 msgid "expected %qs or %qs"
 msgstr "需要 %<,%> 或 %<)%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<#pragma omp barrier%>只能用在复合语句中"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<#pragma omp barrier%>只能用在复合语句中"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "%L处过程指针赋值中接口不匹配：%s"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected directive name"
 msgstr "需要函数"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "不能设置只读属性"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected assumption clause"
 msgstr "需要指针"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%>, %<,%> or %<)%>"
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "需要 %<;%>、%<,%> 或 %<)%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr "太多的%qs子句"
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, fuzzy, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "内容 %qs 已经指定的在中 %<@synthesize%>"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown argument list function at %L"
 msgid "unknown directive name"
 msgstr "%L处参数列表函数未知"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE在其首次使用后被声明为%<threadprivate%>"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "自动变量%qE不能是%<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%>%qE的类型不完全"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%>而无需 transactional 内存支持已启用"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%>而无需 transactional 内存支持已启用"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%>而无需 transactional 内存支持已启用"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%>在之内 %<__transaction_relaxed%>"
@@ -55495,7 +55552,7 @@ msgstr "%<__transaction_cancel%>在之内 %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "%<transaction_may_cancel_outer%> 函数调用无法在之内外异动作业或 %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%>无法在之内 %<__transaction_atomic%>"
@@ -55511,7 +55568,7 @@ msgstr "括入并行"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD类型不完全"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "对 void 表达式的使用无效"
@@ -55544,177 +55601,177 @@ msgstr "对不完全的 typedef%qD的使用无效"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT和%qT在不相交的有名地址空间里"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to variadic functions"
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "%qs属性只能用于带可变参数函数"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "函数类型与 ISO C 不完全兼容"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and vector types"
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "十进制浮点和向量类型不能同时作操作数"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and complex types"
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "十进制浮点和复数类型不能同时作操作数"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t mix operands of decimal float and other float types"
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "十进制浮点与其他浮点类型不能同时作操作数"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "指针目标类型在 C++ 中不兼容"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "类型不完全兼容"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "指针目标类型在 C++ 中不兼容"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "由于%<volatile%>，函数返回类型不兼容"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, fuzzy, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "C++ 不允许在组合字面常量中定义类型"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute cannot be specified for local variables"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "不能为局部变量指定%qE属性"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT没有名为%qE的成员"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT没有名为%qE的成员"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, fuzzy, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr "匿名联合中出现保护成员%q+#D"
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "在非结构或联合中请求成员%qE"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "提领%<void *%>指针"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "下标运算的左操作数既非数组也非指针"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "数组下标不是一个整数"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "下标运算的左操作数是函数指针"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "数组下标不是一个整数"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C 不允许按下标访问%<register%>数组"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 不允许非左值的数组作为下标运算的左操作数"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD声明为引用却未被初始化"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "C++ 禁止在初始化时进行枚举转换"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "枚举常量在此定义"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "被调用的对象%qE不是一个函数"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "被调用的对象%qE不是一个函数"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "被调用的对象%qE不是一个函数"
@@ -55722,1952 +55779,1952 @@ msgstr "被调用的对象%qE不是一个函数"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "函数经由不兼容的类型调用"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "调用了有限定 void 返回类型的函数"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "实参 %d 的类型不完全"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为整数而不是浮点数传递"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为整数而不是复数传递"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为复数而不是浮点数传递"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为浮点数而不是整数传递"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为复数而不是整数传递"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为浮点数而不是复数传递"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为%<float%>而不是%<double%>传递"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "根据原型，实参 %d (%qE)将作为%qT而不是%qT传递"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将以不同的宽度传递"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作用无符号数传递"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "根据原型，实参 %d (%qE) 将作为有符号数传递"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "提供给函数%qE的实参太多"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "提供给函数%qE的实参太多"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "提供给函数%qE的实参太多"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "内联函数%q+D声明过但从未定义"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "C++ 中不允许从%qT到%qT的隐式转换"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "提供给函数%qE的实参太少"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "提供给函数%qE的实参太少"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "提供给函数%qE的实参太少"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "与字面字符串比较的结构是不可预测的"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "比较指针和整数"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "casting %qT to %qT does not dereference pointer"
 msgid "did you mean to dereference the pointer?"
 msgstr "从%qT转换到%qT并未提领指针"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "PRINT_OPERAND 空指针"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "在%qT和%qT间比较"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "在减法中使用类型为%<void *%>的指针"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "函数指针不能相减"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "在指向不完全类型的指针上执行算术运算"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "在指向不完全类型的指针上执行算术运算"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "%<~%> on a boolean expression"
 msgstr "需要布尔表达式"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C 不支持用%<~%>求共轭复数"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "不能对该类型的参数求绝对值"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "单目 ! 的实参类型无效"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "C++ 中枚举自增操作无效"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "C++ 中枚举自减操作无效"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "increment of a boolean expression"
 msgstr "需要布尔表达式"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "decrement of a boolean expression"
 msgstr "需要布尔表达式"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C 不支持对复数类型进行%<++%>或%<--%>操作"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "该类型不支持自增"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "该类型不支持自减"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "指向不完全类型%qT的指针不能自增"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "指向不完全类型%qT的指针不能自减"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "取一个类型为%<void%>的表达式的地址"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "无法取得位段%qD的地址"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "无法取右值表达式%<this%>的地址"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "要求寄存器变量%qD的地址。"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "要求寄存器变量%qD的地址。"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "嵌套函数中使用了全局寄存器变量%qD"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "嵌套函数中使用了寄存器变量%qD"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "要求全局寄存器变量%qD的地址"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "要求寄存器变量 %qD 的地址"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "非左值数组出现在条件表达式中"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 #| msgid "defining a type in a compound literal is invalid in C++"
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "C++ 不允许在组合字面常量中定义类型"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "C++ 中不允许从%qT到%qT的隐式转换"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C 不允许条件表达式仅有一边为空"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "条件表达式中使用了指向不相交地址空间的指针"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "条件表达式指针类型不匹配"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "条件表达式指针类型不匹配"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C 不允许在条件表达式中同时使用%<void *%>和函数指针"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "条件表达式指针类型不匹配"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "需要表达式类型"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "需要表达式类型"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "条件表达式中指针/整数类型不匹配"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "条件表达式中类型不匹配"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "忽略声明有 warn_unused_result 属性的%qD的返回值"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "忽略声明有 warn_unused_result 属性的%qD的返回值"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "忽略声明有 warn_unused_result 属性的%qD的返回值"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 #| msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "忽略声明有 warn_unused_result 属性的%qD的返回值"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "in call to %qD, declared here"
 msgstr "%qD在此声明"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "逗号表达式的左操作数不起作用"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 msgid "right-hand operand of comma expression has no effect"
 msgstr "逗号表达式的左操作数不起作用"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 msgid "cast adds %q#v qualifier to function type"
 msgstr "类型转换为函数类型添加了新的限定"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "类型转换丢弃了指针目标类型的限定"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, fuzzy, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "要是安全所有中介指标在中演员阵容从 %qT 到 %qT 必须是 %<const%> 经资格修饰"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "类型转换指定了数组类型"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "类型转换指定了函数类型"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C 不允许将非标量转换为其自身类型"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "向函数类型%qT的转换无效"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C 不允许转换为联合类型"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "类型转换的源类型未出现在联合中"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 #| msgid "cast to %s address space pointer from disjoint generic address space pointer"
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "将不相交的普通地址空间指针转换为 %s 地址空间指针"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 #| msgid "cast to generic address space pointer from disjoint %s address space pointer"
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "将不相交的 %s 地址空间指针转换为普通地址空间指针"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 #| msgid "cast to %s address space pointer from disjoint %s address space pointer"
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "将不相交的 %2$s 地址空间指针转换为 %1$s 地址空间指针"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "类型转换增大了目标类型的对齐需求"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "将一个指针转换为大小不同的整数"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "从类型为%qT的函数调用转换到不匹配的类型%qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "将一个整数转换为大小不同的指针"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C 不允许将一个函数指针转换为一个对象指针"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C 不允许将一个对象指针转换为一个函数指针"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t convert from incomplete type %qT to %qT"
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "无法从不完全类型%qT转换到%qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "C++ 禁止在类型转换中定义类型"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 msgid "assignment to expression with array type"
 msgstr "无效的数组赋值"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "C++ 禁止在赋值时进行枚举转换"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(在%qs的初始化附近)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "用括号中的字符串常量初始化数组"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %e but argument is of type %e"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared here"
 msgid "built-in %qD declared here"
 msgstr "%qD在此声明"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 #| msgid " declared here"
 msgid "%e declared here"
 msgstr "在此声明"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "C++ 禁止在传递%2$qE的第 %1$d 个参数时进行枚举转换"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in assignment is invalid in C++"
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "C++ 禁止在赋值时进行枚举转换"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in initialization is invalid in C++"
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "C++ 禁止在初始化时进行枚举转换"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 #| msgid "enum conversion in return is invalid in C++"
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "C++ 禁止在返回时进行枚举转换"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %q#T to %q#T"
 msgid "implicit conversion from %qT to %qT"
 msgstr "从%q#T到%q#T的转换"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "传递%2$qE的第 %1$d 个实参时从未限定的函数指针构造了限定的函数指针"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "将未限定的函数指针赋予限定的函数指针"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "返回时将未限定的函数指针赋给限定的函数指针"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "返回时将未限定的函数指针赋给限定的函数指针"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "传递%2$qE的第 %1$d 个实参时丢弃了指针目标类型的限定"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "赋值丢弃了指针目标类型的限定"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "初始化丢弃了指针目标类型的限定"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "返回时丢弃了指针目标类型的限定"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C 不允许将实参转换为联合"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "C++ 中不允许从%qT到%qT的隐式转换"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "传递%2$qE的第 %1$d 个参数时从指针转换为未被包围的地址空间"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "将指针赋值给未被包围的地址空间"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "从指针向未被包围的地址空间初始化"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "返回时将指针赋值给未被包围的地址空间"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected %qT but pointer is of type %qT"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "%2$qE的第 %1$d 个实参可能是 format 属性的备选"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "赋值的左手边可能是 format 属性的备选时"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "初始化的左手边可能是 format 属性的备选时"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "返回类型可能是 format 属性的备选"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "传递%2$qE的第 %1$d 个参数时在不兼容的指针类型间转换"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "指向不完全类型%qT的指针不能自增"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "从不兼容的指针类型初始化"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "在无返回值的函数中，%<return%>带返回值"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C 不允许将%2$qE的第 %1$d 个实参在函数指针和%<void *%>间传递"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C 不允许在函数指针和%<void *%>间赋值"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C 不允许在函数指针和%<void *%>间初始化"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C 不允许在函数指针和%<void *%>间返回"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "传递%2$qE的第 %1$d 个参数给指针时，目标与指针符号不一致"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "对指针赋值时目标与指针符号不一致"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in initialization differ in signedness"
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "初始化指针时目标与指针符号不一致"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "传递%2$qE的第 %1$d 个参数给指针时，目标与指针符号不一致"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "传递%2$qE的第 %1$d 个参数时在不兼容的指针类型间转换"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "指向不完全类型%qT的指针不能自增"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "从不兼容的指针类型赋值"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "从不兼容的指针类型初始化"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "从不兼容的指针类型初始化"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "成员指针类型%qT与对象类型%qT不兼容"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "在无返回值的函数中，%<return%>带返回值"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "传递%2$qE的第 %1$d 个参数时将整数赋给指针，未作类型转换"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes pointer from integer without a cast"
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "赋值时将整数赋给指针，未作类型转换"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes pointer from integer without a cast"
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "初始化时将整数赋给指针，未作类型转换"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "传递%2$qE的第 %1$d 个参数时将整数赋给指针，未作类型转换"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "传递%2$qE的第 %1$d 个参数时将指针赋给整数，未作类型转换"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes integer from pointer without a cast"
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "赋值时将指针赋给整数，未作类型转换"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes integer from pointer without a cast"
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "初始化将指针赋给整数，未作类型转换"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "传递%2$qE的第 %1$d 个参数时将指针赋给整数，未作类型转换"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "%2$qE的第 %1$d 个实参类型不兼容"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "将%2$qT赋值给%1$qT时类型不兼容"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "用%2$qT初始化%1$qT时类型不兼容"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "将%qT返回为%qT时类型不兼容"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "传统 C 不接受自动的聚合初始化"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "初始值设定中数组索引不是整型常量表达式"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 #| msgid "array index in initializer is not an integer constant expression"
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "初始值设定中数组索引不是整型常量表达式"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "对可变数组成员的初始化"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "用以初始化字符数组的字符串太长"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "用以初始化字符数组的字符串太长"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "用字符串常量初始化的数组类型不合适"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "对非左值数组的使用无效"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "无效的初始值设定"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "初始值设定元素不是常量"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "用非常量的数组表达式初始化数组"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "初始值设定中元素不是常量表达式"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "从%qT到%qT的转换丢失了限定信息"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "初始值设定中的元素在载入时无法被计算出"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "不透明的向量类型不能被初始化"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "初始值设定项末尾有多余的花括号组"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "标量初始化带花括号"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "在嵌套的上下文中初始化可变数组成员"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "初始值设定周围缺少花括号"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "成员%qD缺少初始值设定"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "标量初始值设定中有多余元素"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "在非数组初始值设定项中出现数组索引"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "字段名不在记录或联合初始值设定中"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "初始值设定中数组索引不是整型"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "初始值设定中数组索引不是整型常量表达式"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "初始值设定中数组索引不是常数"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "初始化时数组索引越界"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "初始值设定项中索引范围为空"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "初始值设定中数据索引范围超出数组边界"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "已初始化的字段被覆盖"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "带副作用的字段初始值设定被覆盖"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "C++ 禁止在初始化时进行枚举转换"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "联合初始值设定项中有多余元素"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "结构初始值设定项中有多余元素"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "对可变数组成员非静态地初始化"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "联合初始值设定项中有多余元素"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "传统 C 不接受对联合的初始化"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "数组初始值设定项中有多余的元素"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "向量初始值设定项中有多余元素"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "标量初始值设定项中有多余元素"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C 不支持在函数外使用多余的%<;%>"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in output operand outside of a function"
 msgstr "ISO C 不支持在函数外使用多余的%<;%>"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "输出操作数 %d 必须使用%<&%>约束"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "%<friend%>只能在类中指定"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr ""
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "side-effects in input operand outside of a function"
 msgstr "ISO C 不支持在函数外使用多余的%<;%>"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD在函数作用域外未被定义"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C++ 不允许%<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "%2$qE的实参 %1$d 必须是地址"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "被声明为%<noreturn%>的函数却有%<return%>语句"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "在有返回值的的函数中，%<return%>不带返回值"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "在无返回值的函数中，%<return%>带返回值"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C 不允许在无返回值的函数中%<return%>带返回值"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "function returns address of label"
 msgstr "函数返回局部变量的地址"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "函数返回局部变量的地址"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch 语句中的值不是一个整数"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "在 ISO C 中，%<long%>开关表达式不被转换为%<int%>"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "case 标号不是一个整数常量表达式"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case 标号出现在开关语句外"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "%<default%>标号未出现在 switch 语句内"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break 语句不在循环或开关语句内"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "OpenMP 结构块出口无效"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "OpenMP for 循环中使用了 break 语句"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue 语句出现在循环以外"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "语句不起作用"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "表达式语句类型不完全"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "比较将一律评估作为 %<false%> 用于地址的 %qD 将永不是空值"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "比较将一律评估作为 %<true%> 用于地址的 %qD 将永不是空值"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "比较将一律评估作为 %<false%> 用于地址的 %qD 将永不是空值"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "比较将一律评估作为 %<true%> 用于地址的 %qD 将永不是空值"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "对不同枚举类型之间的比较给出警告"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "形参数量不同"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "在类型%qT和%qT间比较"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, fuzzy, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "找不到类%qE的接口"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "使用 == 或 != 比较浮点数是不安全的"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "比较指向不相交的地址空间的指针"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C 不允许在%<void *%>和函数指针间比较"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "比较不相关的指针时缺少类型转换"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "比较指针和整数"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "在完全和不完全指针间比较"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C 不允许函数指针间比较大小"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "指针与整数 0 比较大小"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "指针与整数 0 比较大小"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "C++ 中不允许从%qT到%qT的隐式转换"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "需要标量时使用了不能被转换为指针的数组"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "需要标量时使用了结构类型"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "需要标量时使用了联合类型"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "需要标量时使用了联合类型"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "{ 预期于运算式中 ? 之后"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD 不是 %qs 子句中的变量"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE在子句%qs中不是一个变量"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "字段%qE的类型不完全"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD在子句%qs中不是一个变量"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 msgid "low bound %qE of array section does not have integral type"
 msgstr "数组 new 的大小必须有整数类型"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 msgid "length %qE of array section does not have integral type"
 msgstr "数组 new 的大小必须有整数类型"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "%L处过程指针赋值中接口不匹配：%s"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "使用了变长数组"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, fuzzy, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "使用了变长数组"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "for 循环増量表达式不起作用"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, fuzzy, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "for 循环増量表达式不起作用"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, fuzzy, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "在过程入口处将数组段复制到一个连续的块中"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qE不是一个类"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "抛出 NULL，它的类型是整数而不是指针"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr "%<#pragma omp atomic%>表达式类型无效"
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 #| msgid "parameter %qD has incomplete type"
 msgid "iterator %qD has const qualified type"
 msgstr "形参%qD类型不完全"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "iterator step with non-integral type"
 msgstr "位段%qD非整型"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "begin expression refers to outer iterator %qD"
 msgstr "迭代变量%qE类型无效"
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "end expression refers to outer iterator %qD"
 msgstr "迭代变量%qE类型无效"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "step expression refers to outer iterator %qD"
 msgstr "迭代变量%qE类型无效"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 #| msgid "expected pointer"
 msgid "expected pointer in %qs clause"
 msgstr "需要指针"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "尚未支持代码模式 %<large%>"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "尚未支持代码模式 %<large%>"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, fuzzy, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr "调用了有限定 void 返回类型的函数"
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "字段%qE的类型不完全"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "字段%qE的类型不完全"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE的类型对%<reduction(%s)%>无效"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr "用户定义的%qD总是计算所有两个参数"
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "使用了变长数组"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE必须是%<threadprivate%>方可%<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, fuzzy, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE在子句%qs中不是一个变量"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 #| msgid "%qD appears more than once in data clauses"
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE在数据子句中多次出现"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE在子句%<lastprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr "%qD在%<lastprivate%>子句中不是一个变量"
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE在数据子句中多次出现"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE在子句%<lastprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE在数据子句中多次出现"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE在数据子句中多次出现"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, fuzzy, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr "%2$qE的实参 %1$d 必须是地址"
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "名字‘%s’在%C处不能用作已定义的运算符"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 #| msgid "array must be initialized with a brace-enclosed initializer"
 msgid "traits array must be initialized with constants"
 msgstr "数组必须为一个由花括号包围的初始值设定所初始化"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "%qE在子句%<lastprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, fuzzy, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "在 %L 处的推迟数组“%1$s”在初始化表达式中不被允许"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "整点转换中类型无效"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD 在 %qs 子句中没有可映射的类型"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE在子句%qs中不是一个变量"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE在数据子句中多次出现"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD 不是 %<uniform%> 子句中的参数"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE在子句%<lastprivate%>中不是一个变量"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "source is not a pointer"
 msgid "%qs variable is not a pointer"
 msgstr "源不是一个指针"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %qs clauses on a task construct"
 msgstr "太多的%qs子句"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD必须有%<void%>类型"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not const"
 msgid "%qD shall not be const"
 msgstr "%q#D不是 const"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE可被预先确定为%qs，为%qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, fuzzy, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "使用了变长数组"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, gcc-internal-format
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "给%<va_arg%>的第一个参数的类型不是%<va_list%>"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "给%<va_arg%>的第一个参数的类型不是%<va_list%>"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "给%<va_arg%>的第一个参数的类型不是%<va_list%>"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "C++ 在%<va_arg%>中需要提升后的类型而不是枚举"
@@ -57966,259 +58023,254 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%q#D is not const"
 msgid "%s should not be null"
 msgstr "%q#D不是 const"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qD在子句%qs中不是一个变量"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid receiver type %qs"
 msgid "%s: Invalid field type %s:"
 msgstr "无效的接收者类型%qs"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for ACCEPT statement."
 msgstr "%C处 PROGRAM 语句格式无效"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for DISPLAY statement."
 msgstr "%C处 PROGRAM 语句格式无效"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 #| msgid "unknown TLS model %qs"
 msgid "unknown %<setop_t%> code %d"
 msgstr "未知的 TLS 模型 %qs"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT被解析到非类类型%qT"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "%C处期待模块过程名"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -58227,74 +58279,85 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "派生的类型声明"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "unknown type name %qE"
 msgid "Unknown type %d"
 msgstr "未知的类型名%qE"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qs is not supported with %qs"
+msgid "%s:%d: Must not call here with %s"
+msgstr "%qs 不支持与 %qs 一起使用"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -58304,13 +58367,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "输入文件太多"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "无法从“%s”中读入头"
@@ -58327,64 +58390,64 @@ msgstr "使用另一套寄存器名"
 msgid "%s exited with status %d"
 msgstr "%s 以返回值 %d 退出"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: data item %s #"
 msgstr ""
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%<num_threads%>值必须为正"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s%qs%s is invalid"
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s%qs%s 无效"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: could not add '%s'"
 msgstr ""
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: %s %lu %s %lu"
 msgstr "%s：%s：%s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: %s: %s"
 msgid "%s: regcomp: %s"
 msgstr "%s：%s：%s"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -58864,7 +58927,7 @@ msgstr "没有合适的%<operator %s%>给%qT"
 msgid "%q#D is private within this context"
 msgstr "在此上下文中"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "declared private here"
@@ -58876,7 +58939,7 @@ msgstr "在此声明"
 msgid "%q#D is protected within this context"
 msgstr "在此上下文中"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "declared protected here"
@@ -59225,7 +59288,7 @@ msgstr "%K%D 的第一个实参必须是一个指针，第二个必须是整常
 msgid "constructor delegates to itself"
 msgstr "inlined_to pointer 指向自身"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 msgid "cannot convert %qH to %qI"
 msgstr "不能将%qH转换为%qI"
 
@@ -59244,7 +59307,7 @@ msgstr "对%<%T::%s%E(%A)%#V%>的调用没有匹配的函数"
 msgid "call to non-function %qD"
 msgstr "调用非函数的%qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "不能直接调用构造函数%<%T::%D%>"
@@ -59871,7 +59934,7 @@ msgstr "可变数组是结构中的唯一成员"
 msgid "next member %q#D declared here"
 msgstr "%q+D已在此声明过"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "%q#T重定义"
@@ -59881,7 +59944,7 @@ msgstr "%q#T重定义"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -60018,7 +60081,7 @@ msgstr "函数%q+#D的抽象返回类型无效"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
@@ -60070,7 +60133,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%qD不是一个广义常函数"
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -60108,876 +60171,876 @@ msgstr "正在创建 '%s'\n"
 msgid "uncaught exception of type %qT"
 msgstr "不能声明指向限定函数类型%qT的指针"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must not have variable number of arguments"
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qD不能带可变数量的实参"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D声明时带有异常规范"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "‘o’操作数不是一个常量"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D声明时带有异常规范"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%qs does not support feature %qs"
 msgid "%qD called without supportable %qs"
 msgstr "%qs 不支持特性 %qs"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "%qD called with unexpected %qs argument"
 msgstr "非预期的参数"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "不能对该类型的参数求绝对值"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma message: %s"
 msgid "constexpr message: %.*s"
 msgstr "#pragma message：%s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "调用这些函数时给出警告"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E不是一个常量表达式"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "调用非函数的%qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer"
 msgstr "提领%<void *%>指针"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to %qE"
 msgid "the comparison reduces to %qE"
 msgstr "%qE实参太多"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, gcc-internal-format
 msgid "%qE evaluates to false"
 msgstr "%qE 总是评估为假"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 msgid "call to internal function %qE"
 msgstr "内部函数"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 #| msgid "originally defined here"
 msgid "originally declared %<const%> here"
 msgstr "原先在这里定义"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "类型%qT不是类型%qT的基类"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "虚拟表指针未初始化被使用"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "%qT是%qT的有歧义的基类"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "没有对象无法调用成员函数%qD"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "友元声明没有指定类或函数名"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "‘o’操作数不是一个常量"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, fuzzy, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr "-client_name 不能和 -dynamiclib 一起使用"
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 #| msgid "original definition appeared here"
 msgid "allocation performed here"
 msgstr "原始定义在此"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, fuzzy, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr "-client_name 不能和 -dynamiclib 一起使用"
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, fuzzy, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr "试图分配已经分配的数组‘%s’"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "%qD的声明隐藏了先前的一个局部变量"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD不能出现在常量表达式中"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD不能出现在常量表达式中"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "使用%qD时先前既没有原型也没有定义"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "调用存在循环依赖"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "在实例化%2$qD时模板实例化深度超过最大值 %1$d(使用 use -ftemplate-depth= 来增大最大值)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "pointer to %qD is not a constant expression"
 msgstr "%qE不是一个常量表达式"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is negative"
 msgstr "逗号表达式的左操作数不起作用"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "逗号表达式的左操作数不起作用"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "left operand of shift expression %q+E is negative"
 msgstr "逗号表达式的左操作数不起作用"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 msgid "shift expression %q+E overflows"
 msgstr "%q+E不是一个常量表达式"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "枚举值 %E 对其类型%<%T%>而言太大了"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "枚举值 %E 对其类型%<%T%>而言太大了"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "枚举值 %E 对其类型%<%T%>而言太大了"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "枚举值 %E 对其类型%<%T%>而言太大了"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized array element"
 msgstr "成员%qD是未初始化的引用"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "提领%<void *%>指针"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE不是一个常量表达式"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "%qD不能出现在常量表达式中"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 msgid "accessing uninitialized member %qD"
 msgstr "成员%qD是未初始化的引用"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "初始值设定中数组索引不是整型常量表达式"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "初始值设定中数组索引不是整型常量表达式"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 是一个联合体类型"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 包含了一个联合体类型"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 是一个指针类型"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 包含了一个指针类型"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 是一个引用类型"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 包含了一个引用类型"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 是一个指向成员类型的指针"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "%qs 不是一个常量表达式，因为 %qT 包含了一个指向成员类型的指针"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "%qs 不是一个常量表达式，因为 %qT 具有 volatile 属性"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qs 不是一个常量表达式，因为 %qT 包含了一个 volatile 子对象"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 #| msgid "nested functions not supported on this target"
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr ""
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "成员%qD是未初始化的引用"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr ""
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "%qE的枚举值不是一个整数常量"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 msgid "%qT object created here"
 msgstr "%B：警告：在此定义\n"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q#D在此声明"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in a constant expression"
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "常量表达式中的 Lambda 表达式"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 #| msgid "declared here"
 msgid "allocated here"
 msgstr "在此声明"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "%qD的枚举值不是一个整数常量"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "%qD的枚举值不是一个整数常量"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD用在其自身的初始值设定中"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D不是 const"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D是 volatile"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD不能出现在常量表达式中"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD在其类外被声明为%<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD 不是整型或枚举类型"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in a constant expression"
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "常量表达式中的 Lambda 表达式"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "扩展：从 %s 到 %s，位于 %L"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "扩展：从 %s 到 %s，位于 %L"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "在实例化%2$qD时模板实例化深度超过最大值 %1$d(使用 use -ftemplate-depth= 来增大最大值)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "inline assembly is not a constant expression"
 msgstr "初始值设定中元素不是常量表达式"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "错误地使用了%qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D声明时带有异常规范"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "%qE不是一个常量表达式"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "在实例化%2$qD时模板实例化深度超过最大值 %1$d(使用 use -ftemplate-depth= 来增大最大值)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, fuzzy, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "截取的变量 %qD 与 non-automatic 贮藏体持续时间"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "枚举和非枚举类型一起出现在条件表达式中"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "函数%q+#D的抽象返回类型无效"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "表达式%qE具有抽象类类型%qT，不能用于 throw 表达式中"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "%qT 无法类型的完成常数运算式因为它有可变的 sub-objects"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 msgid "pointed-to object declared here"
 msgstr "%q+D已在此声明过"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "typeid-expression 并非常数运算式因为 %qE 是的 polymorphic 类型"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "%<goto%> is not a constant expression"
 msgstr "%qE不是一个常量表达式"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "数组%qD的大小不是一个整数常表达式"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "KIND 参数 %s 在%L处必须是初始化表达式"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "‘B’操作数不是一个常量"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "break 语句不在循环或开关语句内"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> used outside of class"
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%>用在类外"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "jump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qT 无法类型的完成常数运算式因为它有可变的 sub-objects"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qT 无法类型的完成常数运算式因为它有可变的 sub-objects"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qT 无法类型的完成常数运算式因为它有可变的 sub-objects"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qT 无法类型的完成常数运算式因为它有可变的 sub-objects"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "取析构函数%qE的地址"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr "%qT 无法类型的完成常数运算式因为它有可变的 sub-objects"
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qs 不是一个常量表达式，因为 %qT 包含了一个指针类型"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "从具有类型%qT的右值表达式到类型%qT中的转换无效"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "赋值时将整数赋给指针，未作类型转换"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, fuzzy, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "address-of 对象 %qE 与线程本地或自动贮藏体并非常数运算式"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in a constant expression"
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "常量表达式中的 Lambda 表达式"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 #| msgid "lambda-expression in a constant expression"
 msgid "new-expression is not a constant expression before C++20"
 msgstr "常量表达式中的 Lambda 表达式"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "虚函数不能是友元"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "typeid-expression 并非常数运算式因为 %qE 是的 polymorphic 类型"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "常量表达式中类型错误"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "函数%qs的存储类%<__thread%>无效"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "非静态数据成员%qE被声明为%<constexpr%>"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "%L处被零除"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "%L处非常量初始化表达式"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "%2$L处 %1$s 种别无效"
@@ -61117,405 +61180,406 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy assignable"
 msgid "%qT is not nothrow copy assignable"
 msgstr "  %qT 无法进行nothrow复制赋值"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow default constructible"
 msgstr "  %qT 无法进行nothrow默认构造"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "%qT is not nothrow copy constructible"
 msgstr "  %qT 无法进行nothrow复制构造"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "%qT is not trivially copy assignable"
 msgstr "%qD不是一个变量"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not trivially default constructible"
 msgstr "%q#T没有用户提供的默认构造函数"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "基类%q#T有一个非虚析构函数"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "基类%q#T有一个非虚析构函数"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "%qT does not have unique object representations, because"
 msgstr "  %qT 没有唯一的对象表示"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have a virtual destructor"
 msgid "%qT does not have a virtual destructor"
 msgstr "  %qT 没有一个虚析构函数"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an abstract class"
 msgid "%qT is not an abstract class"
 msgstr "  %qT 不是一个抽象类"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an aggregate"
 msgid "%qT is not an aggregate"
 msgstr "  %qT 不是一个聚合体"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an array"
 msgid "%qT is not an array"
 msgstr "  %qT 不是一个数组"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not assignable from %qT"
 msgid "%qT is not assignable from %qT, because"
 msgstr "  %qT 不能从 %qT 赋值"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT不是%qT的基类"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a bounded array"
 msgid "%qT is not a bounded array"
 msgstr "  %qT 不是一个绑定的数组"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T is not a class"
 msgid "%qT is not a class"
 msgstr "%q#T不是一个类"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT is not a const type"
 msgstr " %qT 不是一个对象类型"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not default constructible, because"
 msgstr "  %qT 无法默认构造"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not constructible from %qE"
 msgid "%qT is not constructible from %qT, because"
 msgstr "  %qT 不能从 %qE 构造"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "在%q#T和%q#T间比较"
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an empty class"
 msgid "%qT is not an empty class"
 msgstr "  %qT 不是一个空类"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an enum"
 msgid "%qT is not an enum"
 msgstr "  %qT 不是一个枚举"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a final class"
 msgid "%qT is not a final class"
 msgstr "  %qT 不是一个最终类"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "%qT is not a function"
 msgstr "  %qT 不是一个函数"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT不是一个模板类型"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "在%q#T和%q#T间比较"
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not assignable from %qT"
 msgid "%qT is not invocable by %qT, because"
 msgstr "  %qT 不能从 %qT 赋值"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not layout compatible with %qT"
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "  %qT 与 %qT 的内存布局不兼容"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a literal type"
 msgid "%qT is not a literal type"
 msgstr "  %qT 不是一个字面类型"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member function pointer"
 msgid "%qT is not a member function pointer"
 msgstr "  %qT 不是一个成员函数指针"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member object pointer"
 msgid "%qT is not a member object pointer"
 msgstr "  %qT 不是一个成员对象指针"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member pointer"
 msgid "%qT is not a member pointer"
 msgstr "  %qT 不是一个成员指针"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow assignable from %qT"
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "  %qT 无法从 %qT 进行nothrow赋值"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow default constructible, because"
 msgstr "  %qT 无法进行nothrow默认构造"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow constructible from %qE"
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "  %qT 无法从 %qE 进行nothrow构造"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow convertible from %qE"
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "  %qT 无法从 %qE 进行nothrow转换"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow default constructible"
 msgid "%qT is not nothrow destructible, because"
 msgstr "  %qT 无法进行nothrow默认构造"
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy assignable"
 msgid "%qT is not nothrow invocable, because"
 msgstr "  %qT 无法进行nothrow复制赋值"
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow assignable from %qT"
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "  %qT 无法从 %qT 进行nothrow赋值"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT is not an object type"
 msgstr " %qT 不是一个对象类型"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "  %qT 不是 %qT 的指针可互转基类"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a POD type"
 msgid "%qT is not a POD type"
 msgstr "  %qT 不是一个POD类型"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a member pointer"
 msgid "%qT is not a pointer"
 msgstr "  %qT 不是一个成员指针"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a polymorphic type"
 msgid "%qT is not a polymorphic type"
 msgstr "  %qT 不是一个多态类型"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference"
 msgid "%qT is not a reference"
 msgstr "  %qT 不是一个引用"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not the same as %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "  %qT 与 %qT 不相同"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a scoped enum"
 msgid "%qT is not a scoped enum"
 msgstr "  %qT 不是一个带作用域的枚举"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an standard layout type"
 msgid "%qT is not a standard layout type"
 msgstr "  %qT 不是一个标准布局类型"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a trivial type"
 msgid "%qT is not a trivial type"
 msgstr "  %qT 不是一个平凡类型"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "派生联合%qT无效"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has no user-provided default constructor"
 msgid "%qT is not trivially default constructible, because"
 msgstr "%q#T没有用户提供的默认构造函数"
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "派生联合%qT无效"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "在%q#T和%q#T间比较"
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "基类%q#T有一个非虚析构函数"
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a bounded array"
 msgid "%qT is not an unbounded array"
 msgstr "  %qT 不是一个绑定的数组"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a union"
 msgid "%qT is not a union"
 msgstr "  %qT 不是一个联合体"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "  %qT不是%qT的基类"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a literal type"
 msgid "%qT is not a volatile type"
 msgstr "  %qT 不是一个字面类型"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "实参%qd不是一个常数"
+#| msgid "  %qT is not a literal type"
+msgid "%qT is not a structural type"
+msgstr "  %qT 不是一个字面类型"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an array"
 msgid "%qT cannot yield a rank"
 msgstr "  %qT 不是一个数组"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "%qT and %qT cannot be ordered"
 msgstr "-f%s 和 -msdata=%s 互不兼容"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not default constructible"
 msgid "%qT is not destructurable"
 msgstr "  %qT 无法默认构造"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 #| msgid "  %qD is not deducible from %qT"
 msgid "%qD is not deducible from %qT"
 msgstr "  %qD 无法从 %qT 推导"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 msgid "invalid constraints"
 msgstr "%<#pragma pack%>中有无效常量 - 已忽略"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined %qD always evaluates both arguments"
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "用户定义的%qD总是计算所有两个参数"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 msgid "constraints not satisfied"
 msgstr "析构函数不能被 cv 限定"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -61547,51 +61611,51 @@ msgstr "asm 声明因与先前的 rename 冲突而被忽略"
 msgid "previous declaration with fewer contracts here"
 msgstr "原始定义在此"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "redeclared here"
 msgid "parameter declared here"
 msgstr "在这里又被声明"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 msgid "declaration adds contracts to %q#D"
 msgstr "%q#D的声明"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "first declared here"
 msgstr "在此声明"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "函数不返回字符串类型"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "函数不返回字符串类型"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -61667,7 +61731,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%<return_void%>在此声明"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, gcc-internal-format
 msgid "no member named %qE in %qT"
 msgstr "在%2$qT中没有名为%1$qE的成员"
@@ -61749,92 +61813,92 @@ msgstr "限定的类型%qT不匹配析构函数名 ~%qT"
 msgid "awaitable type %qT is not a structure"
 msgstr "限定的类型%qT不匹配析构函数名 ~%qT"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qE不能用作函数"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "被声明为%<noreturn%>的函数却有%<return%>语句"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%>的第三个实参必须是一个常量"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%>的第三个实参必须是一个常量"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 #| msgid "no previous prototype for %qD"
 msgid "no suspend point info for %qD"
 msgstr "%qD先前没有原型"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "重复的%qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "指针不能用作 case 常量"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr "使用了变长数组"
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "ms_hook_prologue is not compatible with nested function"
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "ms_hook_prologue 与嵌套函数不兼容"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -61861,74 +61925,80 @@ msgstr "%qD不是一个模板函数"
 msgid "%qs used outside of constant expressions"
 msgstr "%qE不是一个常量表达式"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+#| msgid "expected declaration"
+msgid "unexpected %<std::%s%> declaration"
+msgstr "需要声明"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "taking address of an immediate function %qD"
 msgstr "取析构函数%qE的地址"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "数组%qD的大小不是一个整数常表达式"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will always evaluate as %<true%>"
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "%qD的地址总是等价为%<true%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "析构函数不能是%<constexpr%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "忽略在其定义之后为%qT应用的属性"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 #| msgid "invalid argument of %qE attribute"
 msgid "pack expansion of %qE attribute"
 msgstr "属性%qE的参数无效"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in template argument list"
 msgid "use fold expression in the attribute argument instead"
 msgstr "模板实参表语法错误"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD不是一个类型"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qD 不是一个类"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qD 不是 %<const char *%> 类型"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qD 不是整型"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -61975,7 +62045,7 @@ msgstr "将类型为%2$qT的右值转换为非常量引用类型%1$q#T"
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "从%qT到%qT的转换丢失了限定信息"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "从%qT转换到%qT并未提领指针"
@@ -62380,7 +62450,7 @@ msgstr "从先前的声明%q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "对%qD的重声明在%<constexpr%>方面"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD"
 msgstr "先前的声明%q+D"
@@ -62612,13 +62682,13 @@ msgstr "为%2$q#D的第 %1$d 个形参指定了默认实参"
 msgid "previous specification in %q#D here"
 msgstr "%q+D的上一个定义在此"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "相互冲突的声明%q#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 #| msgid "previously declared here"
 msgid "previously declared here without exporting"
@@ -62831,7 +62901,7 @@ msgstr "  跳过了%q+#D的初始化"
 msgid "  enters %<template for%> statement"
 msgstr "  需要语句"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -62879,563 +62949,563 @@ msgstr "%<typename %T::%D%>指定了%q#T，但后者不是一个类型"
 msgid "template parameters do not match template %qD"
 msgstr "给%qD的模板实参不匹配原先的模板%qD"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "-falign-labels=%d is not supported"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "不支持 -falign-labels=%d"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D invalid; an anonymous union can only have non-static data members"
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q+#D无效；匿名联合只能有非静态的数据成员"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr ""
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "匿名结构不在有名类型内"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "有构造函数的成员%q+#D不允许在匿名聚合中出现"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "有构构函数的成员%q+#D不允许在匿名聚合中出现"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "有拷贝赋值运算符的成员%q+#D不能用在联合中"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, fuzzy, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "%q+#T的属性必须跟在%qs关键字后面"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "一个声明指定了多个类型"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "对 C++ 内建类型%qT的重声明"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "只能为函数指定%qs"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "typedef 声明中缺少类型名"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ 不允许匿名结构"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "只能为函数指定%qs"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "只能为函数指定%qs"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%>只能在类中指定"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "只能为构造函数指定%<explicit%>"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "只能为对象和函数指定存储类"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "只能为对象和函数指定类型限定"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "只能为对象和函数指定类型限定"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "只能为对象和函数指定类型限定"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "a storage class can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "只能为对象和函数指定存储类"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "此声明中的%<typedef%>被忽略"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot be used for type declarations"
 msgid "%qs cannot be used for type declarations"
 msgstr "%<constexpr%>不能被用作类型声明"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "对%q#T重复的显式实例化"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "只能为类定义应用%qE属性"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored"
 msgstr "忽略%qs属性"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, fuzzy, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr "类型在非前向声明的详尽类型限定符中被忽略"
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "忽略在定义之外为类类型%qT应用的属性"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "忽略在关联定义之外为依赖类类型%qT应用的属性"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 #| msgid "typedef %qD is initialized (use decltype instead)"
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef%qD被初始化(改用 decltype)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "%q#D声明有%<extern%>并被初始化"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "%q#D的定义被标记为 %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q#D不是%qT的非静态数据成员"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "non-member-template declaration of %qD"
 msgstr "无效的成员模板声明%qD"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 msgid "does not match member template declaration here"
 msgstr "无效的成员模板声明%qD"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ 不允许将%<%T::%D%>定义为%<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "ISO C++ 不允许成员%qD的初始化"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "出现在类外的%q#D的声明不是定义"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr "块作用域的 extern 声明 %q#D 不能附加到命名的模块上"
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "变量%q#D有初始值设定，但是类型不完全"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "数组%q#D的元素类型不完全"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "聚合%q#D类型不完全，无法被定义"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD声明为引用却未被初始化"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "名字被用在 GNU 风格的数组指定元素初始值设定中"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "名字%qD用在 GNU 风格的数组指定元素初始值设定中"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "不平凡的代理初始值设定不受支持"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "初始值设定无法决定%qD的大小"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "%qD缺少数组大小"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "大小为 0 的数组%qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "%qD的存储大小未知"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "%qD的存储大小不是常量"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "对不起：内联函数中静态数据%q+#D的语义是错的(您会得到此变量的多份复制)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "对不起：内联函数中静态数据%q+#D的语义是错的(您会得到此变量的多份复制)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr " 变通的作法是删除初始值设定"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "未初始化的常量%qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "对广义常变量%qD的声明不同时是定义"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "对广义常变量%qD的声明不同时是定义"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T没有用户提供的默认构造函数"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, fuzzy, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "建构子未被 user-provided 因为它是明确的缺席在中类别本体"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, fuzzy, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "和 implicitly-defined 建构子不初始化 %q+#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "无效类型%qT被用作类型为%qT的向量的初始值设定"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "%qT的初始值设定必须在花括号内"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, fuzzy, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "名字%qD用在 GNU 风格的数组指定元素初始值设定中"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "对成员%qD的请求有歧义"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT没有名为%qD的非静态数据成员"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, gcc-internal-format
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD 不是 %qT 的直接成员"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "初始值设定无法决定%q+D的大小"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "C99 指示项 %qE 外侧汇总初始设置式"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "%qT的初始值设定项太多"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "类型%qT的标量初始化带花括号"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "类型%qT的标量初始化带花括号"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "%qT的初始值设定周围缺少花括号"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "指向不完全类型%qT的指针不能自减"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "数组%q#T的元素类型不完全"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "变长复合字面量"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q+D类型不完全"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "标量对象%qD在初始值设定中需要一个元素"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "在 C++98 中%qD必须由构造函数而不是%<{...}%>初始化"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "数组%qD被有括号的字面字符串%qE所初始化"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "构造函数中对静态成员的初始化无效"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "类中对具有非整数类型%qT的静态数据成员的初始化无效"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "类中对具有非整数类型%qT的静态数据成员的初始化无效"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(需要一个类外的初始化)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "要求显式寄存器变量%qD的地址"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "%qD声明为引用却未被初始化"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "%2$qE的实参 %1$d 必须是地址"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "could not find variant declaration"
 msgstr "%<[*]%>不在声明中"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "给 %qE 的实递参数太少"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "%<declare variant%> on destructor %qD"
 msgstr "取析构函数%qE的地址"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "赋值(不是初始化)出现在声明中"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ 不允许指定元素初始值设定"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %qs"
 msgid "%<register%> storage class specifier used"
 msgstr "为%qs指定了存储类"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "%q#D声明有缺少初始值设定"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "对成员的使用无效(您是否遗忘了%<&%>？)"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -63443,1966 +63513,1977 @@ msgstr "返回值类型%q#T不完全"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be defaulted"
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD不能被默认化"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "隐藏了早先的类型声明%q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables and functions"
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%qE属性只能为变量或函数所使用"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "函数%q#D像变量一样被初始化"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decompose address"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "无法分解地址"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 #| msgid " declared here"
 msgid "lambda declared here"
 msgstr "在此声明"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at %q+D because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "不能在%q+D使用过时的绑定，因为它有析构函数"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an inaccessible base of %qT"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "%qT是%qT不可访问的基类"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT不是%qT的嵌套类"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "指向不完全类型%qT的指针不能自减"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "形参%qD包含了指向具有未知边界数组%qT的指针"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 forbids variable length array %qE"
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 不允许变长数组%qE"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot decompose variable length vector %qT"
 msgstr "无法声明指向%q#T的指针"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "数组大小不是一个整数常表达式"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to qualified function type %qT"
 msgid "cannot decompose union type %qT"
 msgstr "不能声明指向限定函数类型%qT的指针"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "生成非类类型%qT的成员指针"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 #| msgid "source is of incomplete class type"
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "源有不完全的类类型"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for member function %qD"
 msgid "array initializer for structured binding declaration in condition"
 msgstr "成员函数%qD的初始值设定无效"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qs specified for structure field"
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "为结构字段指定了%qs"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "in initialization of structured binding pack %qD"
 msgstr "迭代变量%qE类型无效"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "in initialization of structured binding variable %qD"
 msgstr "迭代变量%qE类型无效"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to static data member %qD"
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "不能对静态数据成员%qD取%<offsetof%>"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, fuzzy, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "  %q+T 有 non-trivial 解构式"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "初始值设定无法决定%qD的大小"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "%qD缺少数组大小"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "大小为 0 的数组%qD"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "其他类%qT的析构函数不能用作成员"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "其他类%qT的构造函数不能用作成员"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD声明为%<virtual%>变量"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "为%qD指定的%<const%>和%<volatile%>在 %s 声明中无效"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD声明为%<virtual%>参数"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD声明为%<inline%>参数"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "为%qD指定的%<const%>和%<volatile%>在 %s 声明中无效"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD声明为%<virtual%>类型"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD声明为%<inline%>类型"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "为%qD指定的%<const%>和%<volatile%>在 %s 声明中无效"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD声明为%<virtual%>字段"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD声明为%<inline%>字段"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "为%qD指定的%<const%>和%<volatile%>在 %s 声明中无效"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D声明为友元"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D声明时带有异常规范"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "%qD的定义不在包含%qT的命名空间中"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "静态成员函数%q#D的声明带有类型限定符"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "有名返回值不再被支持"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD不是一个模板函数"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "友元声明不在类定义内"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "在友元声明中定义显式特例化%qD"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "在基本模板的声明中对模板标识符%qD的使用无效"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "友元模板特例化%qD中不允许出现默认参数"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%>不允许用于友元模板特例化%qD的声明"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "出现在类外的%q#D的声明不是定义"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "不能将%<::main%>声明为一个模板"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "不能将%<::main%>声明为 inline"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "不能将%<::main%>声明为 static"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "不能将%<::main%>声明为 static"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "不能将%<::main%>声明为 static"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "不能将%<::main%>声明为一个模板"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "非成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 #| msgid "static member function %qD cannot have cv-qualifier"
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "非成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "explicit object parameter declared here"
 msgstr "模板形参类型%qT声明为%<friend%>"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "%qD的特例化必须出现在命名空间内"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, gcc-internal-format
 msgid "  declared here"
 msgstr "在此声明"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "%qD的特例化必须出现在命名空间内"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "%qD没有声明为一个函数"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "特例化模板有 C 链接"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD 带有无效参数列表"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, fuzzy, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "整数字尾 %<%s%>带阴影由实现"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, fuzzy, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "浮点数字尾 %<%s%>带阴影由实现"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, fuzzy, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "实字运算符后缀无法前继的由 %<_%>被保留的用于未来标准化"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD必须是一个非静态的成员函数"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%>必须返回%<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "隐式声明的%qD的定义"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "默认化声明%q+D"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "默认化声明%q+D"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "成员函数%q#D未在类%qT中声明"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "不能将%<::main%>声明为一个模板"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 #| msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "自动变量%qE不能是%<threadprivate%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "concept must be defined at namespace scope"
 msgstr "%qD的特例化必须出现在命名空间内"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "有名返回值不再被支持"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "类中对具有非整数类型%qT的静态数据成员的初始化无效"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "类中对具有非整数类型%qT的静态数据成员的初始化无效"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "类中对具有非整数类型%qT的静态数据成员的初始化无效"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "类中对具有非整数类型%qT的静态数据成员的初始化无效"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ 不允许在类内初始化非常量静态成员%qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ 不允许初始化成员常量%qD，因为它有非整数的类型%qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "数组%qD的大小具有非整数类型%qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "数组%qT的大小的类型不是整数"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "数组%qD的大小不是一个整数常表达式"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "数组大小不是一个整数常表达式"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C 不允许大小为 0 的数组%qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ 不允许大小为 0 的数组"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++ 不允许变长数组%qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++ 不允许变长数组"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "使用了变长数组%qD"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, gcc-internal-format
 msgid "variable length array is used"
 msgstr "使用了变长数组"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "数组维数溢出"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, gcc-internal-format
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%qD 被声明为模板占位符类型 %qT 的数组"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "生成引用类型%qT的成员指针"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "%qD声明为 void 的数组"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, gcc-internal-format
 msgid "creating array of void"
 msgstr "创建 void 数组"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "%qD声明为函数的数组"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, gcc-internal-format
 msgid "creating array of functions"
 msgstr "创建函数的数组"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "%qD声明为引用的数组"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, gcc-internal-format
 msgid "creating array of references"
 msgstr "创建引用的数组"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "%qD声明为函数成员的数组"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, gcc-internal-format
 msgid "creating array of function members"
 msgstr "创建函数成员的组织"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "多维数组%qD的声明必须至少指定除第一维以外所有维的大小"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "声明多维数组必须至少指定除第一维以外所有维的大小"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable-length array of %<auto%>"
 msgstr "使用了变长数组"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "为构造函数指定返回值无效"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "%<operator %T%>的声明中不能使用限定符"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "指定析构函数的返回类型无效"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "%<operator %T%>的声明中不能使用限定符"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "为%<operator %T%>指定了返回值"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "%<operator %T%>的声明中不能使用限定符"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "指定析构函数的返回类型无效"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "%<operator %T%>的声明中不能使用限定符"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 #| msgid "too many template parameter lists in declaration of %qD"
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "%qD声明时模板参数表太多"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting specifiers in declaration of %qs"
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "%qs的声明中有相互冲突的限定符"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "无名变量或字段声明为 void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "变量或字段声明为 void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "在全局作用域外为函数%qs指定%<inline%>无效"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "type is not C-compatible because it has a base class"
 msgstr "-mnop-mcount 与此目标不兼容"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 #| msgid "-mnop-mcount is not compatible with this target"
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "-mnop-mcount 与此目标不兼容"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "析构函数不能被 cv 限定"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 #| msgid "%<signed%> and %<unsigned%> specified together for %qs"
 msgid "%e and %e specified together"
 msgstr "为%qs同时给定了%<signed%>和%<unsigned%>"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "对限定名%<::%D%>的使用无效"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "对限定名%<%T::%D%>的使用无效"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "对限定名%<%D::%D%>的使用无效"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT既不是类也不是命名空间"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "%qD没有声明为一个函数"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "%qD未声明为成员"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "缺少声明标识符：使用了保留字%qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "函数定义未声明形参"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "%qD没有声明为一个函数"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "形参声明中出现的 typedef 声明无效"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "声明的形参%qD不存在"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, gcc-internal-format
 msgid "both %qs and %qs specified"
 msgstr ""
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 #| msgid "%<constexpr%> cannot appear in a typedef declaration"
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%<constexpr%>不能被用于 typedef 声明"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "%qs的声明指定了两个以上的数据类型"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, gcc-internal-format
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C++ 不支持单独以 %<complex%> 表示 %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ 不允许声明无类型的%qs"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "嵌套函数在此目标机上不受支持"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++ 对 %2$qs 不支持 %<__int%1$d%>"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %qT"
 msgstr "%qE可被预先确定为%qs，为%qs"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with typedef-name %qD"
 msgstr "%qE不是一个 typedef 类型，也不是一个内建类型"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "%qE不是一个 typedef 类型，也不是一个内建类型"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<typeof%>"
 msgstr "%qE不是一个 typedef 类型，也不是一个内建类型"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "对%qs而言无效的复数"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "成员%qD不能既被声明为虚函数，又被声明为静态函数"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "成员%qD不能既被声明为虚函数，又被声明为静态函数"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "形参声明中出现的 typedef 声明无效"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "为模板参数%qs指定了存储类"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "为形参%qs指定了存储类"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "a parameter cannot be declared %qs"
 msgstr "形参不能被声明为%<constexpr%>"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%>用在类声明以外"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "无效的函数声明"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "%qs的声明指定了多个存储类"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "为%qs指定了存储类"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "嵌套函数%qs被声明为%<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "在文件层将%qs声明为%<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "函数作用域的%qs隐式为 auto，却被声明为%<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "为友元函数声明指定了无效的存储类"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "%qs的声明指定了多个存储类"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "需要左圆括号"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "函数‘%s’在%L处不能有初始值设定"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, fuzzy, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "虚函数不能是友元"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "%qE不是类型%qT的有效模板实参，因为它的类型是%qT"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "类型不能定义在条件表达式中"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "valid explicit object parameter declared here"
 msgstr "模板形参类型%qT声明为%<friend%>"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr "%qE属性在类型上被忽略"
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "%qs 函数使用了 %<auto%> 类型说明符，但没有后续的返回类型"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 msgid "virtual function cannot have deduced return type"
 msgstr "虚函数不能是友元"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "%qs函数使用迟返回类型%qT作为它的类型，而不是%<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "%qs函数使用迟返回类型%qT作为它的类型，而不是%<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%>"
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "错误地使用了%<auto%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "%qs函数使用迟返回类型%qT作为它的类型，而不是%<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "将构造函数用作模板无效"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "忽略函数返回类型的类型限定"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, fuzzy, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr "虚函数不能是友元"
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "%qs函数使用了迟返回类型却未用%<auto%>类型限定声明"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "虚函数不能是友元"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr "调用了有限定 void 返回类型的函数"
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs声明为返回一个函数的函数"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs声明为返回一个数组的函数"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%L处 CASE 语句中的逻辑范围是不被允许的"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "析构函数不能是静态成员函数"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, fuzzy, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "析构函数不能是静态成员函数"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "析构函数不能被 cv 限定"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "析构函数不能被 cv 限定"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 msgid "destructors may not be ref-qualified"
 msgstr "析构函数不能被 cv 限定"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 msgid "constructors may not be ref-qualified"
 msgstr "析构函数不能被 cv 限定"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "构造函数不能被声明为虚函数"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "虚函数不能是友元"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "友元声明不在类定义内"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "局部类定义中不能定义友元函数%qs"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 #| msgid "non-member function %qD cannot have cv-qualifier"
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "非成员函数%qD不能拥有 cv 限定符"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "模板不能是%<virtual%>的"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, gcc-internal-format
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD 不能是一个显式的对象成员函数"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "析构函数不能有参数"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "无法声明指向%q#T的指针"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "无法声明对%q#T的引用"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "无法声明指向%q#T成员的指针"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "不能声明指向限定函数类型%qT的引用"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "不能声明指向限定函数类型%qT的指针"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "无法声明对%q#T的引用，因为它不是 typedef 或者模板类型实参"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "模板标识符%qD用作声明"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "成员函数隐式地成为所属类的友元"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "有多余的限定%<%T::%>在成员%qs上"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot define member function %<%T::%s%> within %<%T%>"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "无法定义成员函数%<%T::%s%>，在%<%T%>中"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "无法声明成员%<%T::%s%>，在%qT中"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "无法声明成员%<%T::%s%>，在%qT中"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "非形参%qs不能是一个参数包"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "数据成员不能具有可变类型%qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "参数不能具有可变类型%qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<virtual%>用在类声明以外"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%>用于空声明中"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "只有构造函数才能被声明为%<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "非成员%qs不能被声明为%<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "非对象成员%qs不能被声明为%<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "函数%qs不能被声明为%<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "静态%qs不能被声明为%<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "常量%qs不能被声明为%<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "常量%qs不能被声明为%<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "typedef may not be a function definition"
 msgstr "类型不能定义在条件表达式中"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "typedef may not be a member function definition"
 msgstr "类型不能定义在条件表达式中"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 #| msgid "%<[*]%> not in a declaration"
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%>不在声明中"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef%q+D声明为%<inline%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "typedef 名不能是嵌套名指定"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ 不允许嵌类的类型%qD与其所属的类重名"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "友元函数声明中出现了%<inline%>"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "模板参数不能是友元"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "友元声明需要 class，即%<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "友元声明需要 class，即%<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "试图让%qT成为全局域的友元"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "非成员函数类型上的限定符无效"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "抽象声明%qT被用作声明"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "在返回%qT的函数中，返回语句不带返回值"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "不能在参数声明中使用%<::%>"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "不能将形参%q+D声明为具有抽象类型%qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr "%qD不是一个函数模板"
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "形参声明为%<auto%>"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "形参声明为%<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "使用模板名%qE时不带实参表无效"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "非静态数据成员%qE被声明为%<constexpr%>"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array %qD"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C 不允许大小为 0 的数组%qD"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 不允许可变数组成员"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "错误地使用了%<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "%qD模板声明无效"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "联合成员函数%qD被声明为虚函数"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, gcc-internal-format
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD 不能被声明为 %<virtual%>，因为它总是静态的"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "在析构函数%qD中的友元声明需要限定名"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "%qD声明为%qT的一个成员"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "a destructor cannot be %qs"
 msgstr "析构函数不能是%<constexpr%>"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "在构造函数%qD中的友元声明需要限定名"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "a constructor cannot be %<concept%>"
 msgstr "析构函数不能是%<constexpr%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be a member function"
 msgstr "析构函数不能是静态成员函数"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, gcc-internal-format
 msgid "%qD cannot be %qs"
 msgstr "%qD 不能是 %qs"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "模板声明%q#D"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "%q+D已在此声明过"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 msgid "field %qD has incomplete type %qT"
 msgstr "%qD类型不完全"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "名字%qT类型不完全"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE既不是函数也不是成员函数；不能声明为友元"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE既不是函数也不是成员函数；不能声明为友元"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "%qE属性只能用于函数"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "在友元声明中定义显式特例化%qD"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, fuzzy, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr "类型在非前向声明的详尽类型限定符中被忽略"
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member %qE declared %<constexpr%>"
 msgid "static data member %qE declared %qs"
 msgstr "非静态数据成员%qE被声明为%<constexpr%>"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "非静态数据成员%qD具有 Java 类类型"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 #| msgid "non-static data member %qE declared %<constexpr%>"
 msgid "non-static data member %qE declared %qs"
 msgstr "非静态数据成员%qE被声明为%<constexpr%>"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "函数%qs的存储类%<auto%>无效"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "函数%qs的存储类%<register%>无效"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "函数%qs的存储类%<__thread%>无效"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "函数%qs的存储类%<__thread%>无效"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "不能为%q+D指定对齐"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "函数定义中不允许出现 asm 指定"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "%<static%> specified invalid for function %qs declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "在全局作用域外为函数%qs指定%<static%>无效"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "在全局作用域外为函数%qs指定%<inline%>无效"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "虚函数%qs不是类成员"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs定义在在非类作用域中"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs 在非类作用域中声明"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "不能将成员函数%qD声明为有静态链接"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "不能在另一个函数中声明一个静态函数"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "与声明不同，定义静态数据成员时不能使用%<static%>"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "静态成员%qD声明为%<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "不能显式地将成员%q#D声明为有外部链接"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of constexpr variable %qD is not a definition"
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "对广义常变量%qD的声明不同时是定义"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter cannot be declared %<constexpr%>"
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "形参不能被声明为%<constexpr%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs已初始化，却又被声明为%<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs既有%<extern%>又有初始值设定"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "默认实参%qE使用了局部变量%qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "默认实参%qE使用了局部变量%qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "ISO C 不允许前向参数声明"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "对模板类型参数%qT的使用无效"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "不能将形参%q+D声明为具有抽象类型%qT"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "形参%qD被无效地被声明为具有方法类型"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "形参%qD包含了指向具有未知边界数组%qT的指针"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "形参%qD包含了指向具有未知边界数组%qT的引用"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "无效的构造函数：您要的可能是%<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD不能在命名空间声明"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD不能被声明为静态的"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD必须是一个非静态的成员函数"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD必须是一个非静态的成员函数"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD必须是一个非静态成员函数或非成员函数"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD的实参必须有类或枚举类型"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ 不允许重载 ?: 运算符"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD不能带可变数量的实参"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD必须带 0 或 1 个实参"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD必须带 1 或 2 个实参"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "后缀%qD必须使用%<int%>作为它的参数"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "后缀%qD必须使用%<int%>作为它的第二个参数"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD带且仅带 2 个实参"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD带且仅带 1 个实参"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD带且仅带 2 个实参"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD不能有默认参数"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to void will never use a type conversion operator"
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "向 void 的转换永远不会用到类型转换运算符"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a reference to the same type will never use a type conversion operator"
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "向具有相同类型的引用的转换永远不会用到类型转换运算符"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to the same type will never use a type conversion operator"
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "向相同类型的转换永远不会用到类型转换运算符"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a reference to a base class will never use a type conversion operator"
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "向指向基类的引用的转换永远不会用到类型转换运算符"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 #| msgid "conversion to a base class will never use a type conversion operator"
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "向基类的转换永远不会用到类型转换运算符"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "用户定义的%qD总是计算所有两个参数"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "前缀%qD应当返回%qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "后缀%qD应当返回%qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD应当返回值而非引用"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "使用模板类型形参%qT，在%qs后"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "使用模板类型形参%qT，在%qs后"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "使用 typedef 名%qD，在%qs后"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT作为%qs被引用"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%qT has a previous declaration here"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT作为枚举被引用"
@@ -65414,102 +65495,102 @@ msgstr "%qT作为枚举被引用"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "%<%s %T%>需要模板参数"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "对%qD的引用有歧义"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 #| msgid "function template %qD redeclared as a class template"
 msgid "class template %qD redeclared as non-template"
 msgstr "函数模板%qD重声明为类模板"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD与其声明所在的类重名"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT不是一个模板"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "使用枚举%q#D前没有给出声明"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "%qT重声明为非模板"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "派生联合%qT无效"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, fuzzy, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr "此函数中的%qD在使用前未初始化"
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct or virtual base of %qT"
 msgid "%qT defined with direct virtual base"
 msgstr "类型%qT不是%qT的直接或虚基类"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "基类型%qT不是结构或类"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "递归的类型%qT未定义"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "重复的基类型%qT无效"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, fuzzy, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "范围/unscoped 不匹配在中 enum %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, gcc-internal-format
 msgid "previous definition here"
 msgstr "先前的定义在这里"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, fuzzy, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "条件表达式中类型不匹配"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, fuzzy, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "不同的下层的输入 enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 #| msgid "underlying type %<%T%> of %<%T%> must be an integral type"
 msgid "underlying type %qT of %qT must be an integral type"
@@ -65519,89 +65600,95 @@ msgstr "%<%2$T%>的内在类型%<%1$T%>必须是整型"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "没有一个整数类型可以表示%qT的所有枚举值"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 #| msgid "enumerator value for %qD is not an integer constant"
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "%qD的枚举值不是一个整数常量"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "%qD的枚举值不是一个整数常量"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "对%<unsigned long%>类型而言整数常量太大"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "对%<unsigned long%>类型而言整数常量太大"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "%qD处枚举值溢出"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "枚举值 %E 对其类型%<%T%>而言太大了"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "%q#T多次定义"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "返回值类型%q#T不完全"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%>应当返回一个对%<*this%>的引用"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "在返回%qT的函数中，返回语句不带返回值"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "由于%<volatile%>，函数返回类型不兼容"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "在有返回值的函数中未发现 return 语句"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD已在类%qT中定义过"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 msgid "using %qs"
 msgstr "括入并行"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D在声明前使用"
+
+#: cp/decl.cc:21341
 #, fuzzy, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "%qD的类型默认为%<int%>"
@@ -66057,358 +66144,358 @@ msgstr "对%qD的重声明在%<constexpr%>方面"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr ""
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    内联自%qD于 %r%s:%d:%d%R"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    内联自%qD于 %r%s:%d%R"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, gcc-internal-format
 msgid "    inlined from %qD"
 msgstr "    内联自%qD"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In static member function %qD"
 msgstr "在静态成员函数%qs中"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "在复制构造函数%qD"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "在构造函数%qD中"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "在析构函数%qD中"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, gcc-internal-format
 msgid "In lambda function"
 msgstr "在 lambda 函数中"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 #| msgid "In static member function %qs"
 msgid "In explicit object member function %qD"
 msgstr "在静态成员函数%qs中"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "在成员函数%qs中"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, gcc-internal-format
 msgid "In function %qD"
 msgstr "在函数%qD中"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a type"
 msgid "but %qE is a type"
 msgstr "%qE不是一个类型"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "but %qE is an expression"
 msgstr "%qE不是一个常量表达式"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 #| msgid "%qs specified for structure field"
 msgid "but %qE is a structured binding"
 msgstr "为结构字段指定了%qs"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable"
 msgid "but %qE is a variable"
 msgstr "%qD不是一个变量"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of parameter %q+D"
 msgid "but %qE is a parameter"
 msgstr "形参%q+D重定义"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a function"
 msgid "but %qE is a function"
 msgstr "  %qT 不是一个函数"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a static data member"
 msgid "but %qE is a data member"
 msgstr "%qD 不是一个静态数据成员"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD不是一个函数模板"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "需要一个类模板，却给出了%qE"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a variable template"
 msgid "but %qE is a variable template"
 msgstr "%qD 不是一个变量模板"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD是一个命名空间"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is an enumeration template"
 msgid "but %qE is an enumerator"
 msgstr "%qD不是一个枚举模板"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "%s：在实例化 %q#D 时:\n"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "空动态字符串替换"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "%s: In instantiation of %q#D:\n"
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s：在实例化 %q#D 时:\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 msgid "%r%s:%d:%d:%R   "
 msgstr "%r%s:%d:%d:%R   "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 msgid "%r%s:%d:%R   "
 msgstr "%r%s:%d:%R   "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "从此处调用"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, fuzzy, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr "空动态字符串替换"
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 #, fuzzy
 msgid "recursively required by substitution of %qS\n"
 msgstr "递归必要项由替代的 %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 #, fuzzy
 msgid "required by substitution of %qS\n"
 msgstr "空动态字符串替换"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "与先前的声明%q+D不同"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "在 %q#D 中的要求\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "从此处调用"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, gcc-internal-format
 msgid "required from here\n"
 msgstr "在此处的要求\n"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "%s:%d:%d：[ 跳过 %d 个实例化上下文 ]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 #| msgid "%r%s:%d:%R   in %<constexpr%> expansion of %qs"
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%r%s:%d:%R   在 %<constexpr%> 展开中的 %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "空动态字符串替换"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "空动态字符串替换"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 #| msgid "-c required for gnat2scil"
 msgid "required for constraint satisfaction\n"
 msgstr "gnat2scil 需要 -c"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "requires"
 msgid "in requirements "
 msgstr "需要"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, gcc-internal-format
 msgid "(no argument)"
 msgstr "（没有参数）"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "扩展初始值设定列表只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "显式转换运算符只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "Lambda 表达式只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++11 auto 只在 %<-std=c++11%> 或 %<-std=gnu++11%> 下可用"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "显式转换运算符只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "扩展初始值设定列表只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "扩展初始值设定列表只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "显式转换运算符只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "嵌套名指定中使用了不完全的类型%qT"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "对%<%T::%D%>的引用有歧义"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, gcc-internal-format
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD 不是 %qT 的成员；你是说 %qs 吗？"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD不是%qT的成员"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, gcc-internal-format
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD 不是 %qD 的成员；你是说 %qs 吗？"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD不是%qD的成员"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%>未被声明"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%>未被声明"
@@ -66635,7 +66722,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "成员%qD未经初始化被使用"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "数组必须为一个由花括号包围的初始值设定所初始化"
@@ -66751,7 +66838,7 @@ msgstr "类型%qT不是%qT的直接或虚基类"
 msgid "type %qT is not a direct base of %qT"
 msgstr "类型%qT不是%qT的直接基类"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, gcc-internal-format
 msgid "%qT is not a class type"
@@ -66950,44 +67037,44 @@ msgstr "检测到调用 delete 运算符时可能出现的问题："
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "析构函数和类特定的 delete 运算符均不会被调用，即使它们在类定义时已经声明。"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "初始值设定在完成之前结束"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "delete 时数组大小未知"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "返回不完全的类型"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "检测到调用 delete 运算符时可能出现的问题："
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "析构函数和类特定的 delete 运算符均不会被调用，即使它们在类定义时已经声明。"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, fuzzy, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "删除对象的抽象类别类型 %qT 该项有 non-virtual 解构式将造成未定义的行为"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, fuzzy, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "删除对象的 polymorphic 类别类型 %qT 该项有 non-virtual 解构式也许造成未定义的行为"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "向量 delete 的实参类型既非指针也非数组"
@@ -67023,86 +67110,94 @@ msgstr "向 void 的类型转换不会访问具有不完全类型%qT的对象"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "无效的函数声明"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "lambda 函数中无法捕获%<this%>"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD的对齐"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD的对齐"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "无效的 #pragma %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable 不再受支持"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "文件在%qs的 #pragma implementation 出现前已被包含"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD未定义"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD在此作用域中尚未声明"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD在此作用域中尚未声明"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "%qD的实参不依赖模板参数，所以%qD的声明必须可用"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(如果您使用%<-fpermissive%>，G++ 会接受您的代码，但是允许使用未定义的名称是已弃用的风格)"
@@ -67112,65 +67207,58 @@ msgstr "(如果您使用%<-fpermissive%>，G++ 会接受您的代码，但是允
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, fuzzy, gcc-internal-format
 #| msgid "mangling typeof, use decltype instead"
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "修饰 typeof，请改用 decltype"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "修饰 %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "省略的%<?:%>中操作数不能被修饰"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "%qD修饰后的名字将在 GCC 的未来版本中有变化"
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr "%qD修饰后的名字将在 GCC 的未来版本中有变化"
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "%qD修饰后的名字将在 GCC 的未来版本中有变化"
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "%qD修饰后的名字将在 GCC 的未来版本中有变化"
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, fuzzy, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr "%qD修饰后的名字将在 GCC 的未来版本中有变化"
@@ -67570,7 +67658,7 @@ msgstr "此处已有不带标签的声明"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "导入的声明 %#qD 的语言链接冲突"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "导入的声明 %#qD 的类型冲突"
@@ -67585,424 +67673,424 @@ msgstr "导入的声明 %#qD 的参数列表冲突"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "导入的声明 %#qD 的参数类型冲突"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "导入的声明 %#qD 的 %<noexcept%> 说明符冲突"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, gcc-internal-format
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "导入的声明 %#qD 的推导返回类型冲突"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "导入的声明 %#qD 的 %<constexpr%> 冲突"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, gcc-internal-format
 msgid "conflicting imported declaration %q#D"
 msgstr "导入的声明 %q#D 冲突"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, gcc-internal-format
 msgid "existing declaration %#qD"
 msgstr "已有的声明 %#qD"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, gcc-internal-format
 msgid "conflicting default argument for %#qD"
 msgstr "%#qD 的默认实参冲突"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, gcc-internal-format
 msgid "existing default declared here"
 msgstr "此处已有的默认声明"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, gcc-internal-format
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "参数 %P 的默认实参与 %#qD 冲突"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "%qD 的定义不匹配"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, gcc-internal-format
 msgid "existing definition %qD"
 msgstr "已有的定义 %qD"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "枚举项 %qD 不匹配 ..."
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, gcc-internal-format
 msgid "... this enumerator %qD"
 msgstr "... 此枚举项 %qD"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr "以 %qD 开头的额外枚举项"
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr "枚举范围不同"
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, gcc-internal-format
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qD 是 TU 局部类型 %qT 的别名"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "%qD 是 TU 局部模板 %qD 的特化"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, gcc-internal-format
 msgid "%qD declared with internal linkage"
 msgstr "%qD 声明为内部链接"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD 无链接且在匿名命名空间中声明"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD 无链接且在 TU 局部实体 %qT 内声明"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD 无链接且在 TU 局部实体 %qD 内声明"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr "%qT 没有名称，无法与其他 TU 中的相似 lambda 区分"
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr "%qT 没有名称，且未在类、函数或初始化器内定义"
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD 具有 TU 局部的模板实参 %qD"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qD 具有 TU 局部的模板实参 %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr "%qD 引用 TU 局部对象 %qD"
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, gcc-internal-format
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD 引用 TU 局部函数 %qD"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, gcc-internal-format
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "实例化暴露了 TU 局部实体 %qD"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr "%qD 暴露了 TU 局部实体 %qD"
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr "%qD 也是 TU 局部的，但已在其他地方暴露"
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr "%qD 引用 TU 局部实体 %qD，这可能导致在其他 TU 中实例化时出现问题"
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr "%qD 引用 TU 局部实体 %qD，且无法在其他 TU 中实例化"
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr "%qD 声明为 %<constexpr%> 且被初始化为 TU 局部值"
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr "%qD 是声明为 %<inline%> 的引用，且被常量初始化为 TU 局部值"
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr "递归惰性加载"
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, gcc-internal-format
 msgid "module %qs depends on itself"
 msgstr "模块 %qs 依赖于自身"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "模块 %qs 在此声明"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr "间接导入 %qs 尚未加载"
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr "导入 %qs 的 CRC 不匹配"
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr "未导出 %<#define %E%>，因为它是一个关键字"
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, gcc-internal-format
 msgid "macro definitions of %qE corrupted"
 msgstr "%qE 的宏定义损坏"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "导入的宏定义 %qE 不一致"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr "%<#undef %E%>"
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr "%<#define %s%>"
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "编译后的模块文件是 %qs"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, gcc-internal-format, gfc-internal-format
 msgid "compiled module is %sversion %s"
 msgstr "编译后的模块是 %sversion %s"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, gcc-internal-format, gfc-internal-format
 msgid "compiler is %sversion %s%s%s"
 msgstr "编译器是 %sversion %s%s%s"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, gcc-internal-format
 msgid "module %qs found"
 msgstr "找到模块 %qs"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr "需要头文件模块，但找到了模块 %qs"
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr "需要模块 %qs，但找到了头模块"
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr "模块 %qs CRC 不匹配"
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr "目标与主机为 %qs:%qs，期望 %qs:%qs"
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr "语言方言不同于 %qs，期望 %qs"
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "模块包含 OpenMP，请使用 %<-fopenmp%> 启用"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr "模块包含 OpenMP，请使用 %<-fopenmp%> 或 %<-fopenmp-simd%> 启用"
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "模块包含 OpenACC，请使用 %<-fopenacc%> 启用"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "固定树不匹配"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, gcc-internal-format
 msgid "interface partition is not exported"
 msgstr "接口分区未导出"
 
 # 还有可能是：
 # 读取编译后的模块集群 %u: %s 失败
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "读取编译后的模块集群 %u 失败：%s"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "读取已编译模块失败：%s"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr "考虑使用 %<-fno-module-lazy%>，增加 %<-param-lazy-modules=%u%> 的值，或者提高每个进程的文件描述符限制"
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr "导入必须在被导入之前先被构建"
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, gcc-internal-format
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "在模块 %2$qs 中声明 %1$qD 与全局模块中的内建声明冲突"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, gcc-internal-format
 msgid "declaration %qD conflicts with builtin"
 msgstr "声明 %qD 与内建声明冲突"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, gcc-internal-format
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "在模块 %2$qs 中重声明 %1$qD 与导入冲突"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr "在全局模块中重声明 %qD 与导入冲突"
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr "导入声明附着于模块 %qs"
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr "导入声明在全局模块中"
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "在模块 %2$qs 中 %1$qD 的声明冲突"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, gcc-internal-format
 msgid "conflicting declaration of %qD in global module"
 msgstr "在全局模块中 %qD 的声明冲突"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "先前在模块 %qs 中声明"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "先前在全局模块中声明"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr "头文件模块中 %qD 的外部链接定义必须声明为 %<inline%>"
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, gcc-internal-format
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "导出在未命名命名空间中声明的声明 %qD"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, gcc-internal-format
 msgid "exporting declaration %qD with internal linkage"
 msgstr "导出具有内部链接的声明 %qD"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, gcc-internal-format
 msgid "reading CMI %qs"
 msgstr "正在读取 CMI %qs"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr "加载绑定 %<%E%s%E%> 失败"
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr "加载绑定 %<%E%s%E@%s%> 失败"
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr "在加载绑定 %<%E%s%E%> 期间"
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr "在加载绑定 %<%E%s%E@%s%> 期间"
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr "加载 %<%E%s%E%> 的待处理项失败"
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "在加载 %<%E%s%E%> 的待处理项期间"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, gcc-internal-format
 msgid "import of %qs within its own implementation unit"
 msgstr "在其自身实现单元内导入 %qs"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, gcc-internal-format
 msgid "module declared here"
 msgstr "模块在此声明"
@@ -68014,107 +68102,107 @@ msgstr "模块在此声明"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr "在语言链接块内导入命名模块 %qs"
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, gcc-internal-format
 msgid "module already declared"
 msgstr "模块已声明"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, gcc-internal-format
 msgid "module already imported"
 msgstr "模块已导入"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "模块 %qs 在此导入"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr "已编译模块接口不匹配：原为 %qs，得到 %qs"
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "未知的已编译模块接口：%s"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr "无法确定 %s 的 %<#include%> 转换：%s"
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr "include %qs 转换为导入"
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr "导入 %qs 失败，回退为 include"
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr "include %qs 按文本处理"
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr "C++ 模块与预编译头文件不兼容"
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, gcc-internal-format
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "C++ 模块与传统预处理不兼容"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, gcc-internal-format
 msgid "invalid header name %qs"
 msgstr "无效的头文件名 %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, gcc-internal-format
 msgid "invalid module name %qs"
 msgstr "无效的模块名 %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr "%<-fmodule-only%> 用于非接口"
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, gcc-internal-format
 msgid "writing CMI %qs"
 msgstr "正在写入 CMI %qs"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr "由于模板体中的错误，未写入模块 %qs"
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr "启用 %<-Wtemplate-body%> 以获取更多详情"
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "%qD 中的首个错误出现在此"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "写入已编译模块失败：%s"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "未知的头文件种类 %qs"
@@ -68129,7 +68217,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "new 声明中的表达式必须具有整数或枚举类型"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
@@ -68177,278 +68265,290 @@ msgstr "%q#D的声明隐藏了一个形参"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "%qD声明为%qT的一个成员"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to variables"
+msgid "annotation applied to block scope extern %qD"
+msgstr "属性%qE只能用于变量"
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+#| msgid "declaration for parameter %qD but no such parameter"
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "声明的形参%qD不存在"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration %qD in local class without prior declaration"
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "本地类中的友元声明%qD没有先前声明"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, gcc-internal-format
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %<%s(%E)%> %p %d"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, gcc-internal-format
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, fuzzy, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "new 声明中的表达式必须具有整数或枚举类型"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q+D已在此声明过"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "new 声明中的表达式必须具有整数或枚举类型"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q+D已在此声明过"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%>指定了析构函数"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "在类作用域使用非成员的 using 声明"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a class, namespace, or enumeration"
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qE不是一个类、命名空间或枚举"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "无效的成员模板声明%qD"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "在类作用域使用非成员的 using 声明"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "类型%qT不是%qT的直接基类"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has not been declared in %qD"
 msgstr "%qE未声明"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 msgid "using-declaration may not name namespace %qD"
 msgstr "不允许在 using 声明中使用命名空间%qD"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%>在%qT内指定了构造函数"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "%qD的声明不在包含%qD的命名空间中"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "%qD的声明中有显式的限定"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD应当先在%qD内声明"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has not been declared"
 msgid "%qD has not been declared within %qD"
 msgstr "%qE未声明"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D声明为友元"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%qD属性需要一个 NTBS 作为实参"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "%qD属性无意义，因为匿名命名空间的成员拥有局部符号"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "%qs(有%qT)的实参类型无效"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "%qs(有%qT)的实参类型无效"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "指定%qD属性被忽略"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, fuzzy, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "最大值限制的 %d 命名空间搜索的用于 %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "建议的替代："
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "静态成员函数中不能使用%<this%>"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "聚合%q#D类型不完全，无法被定义"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "it was later defined here"
 msgstr "结构在此定义"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr "从花括号中的初始化列表演绎需要 #include <initializer_list>"
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "switch %qs is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "开关%qs不再被支持"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<this%>不能用在此上下文中"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "annotation on using directive"
 msgstr "属性在未初始化类型上被忽略"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "cannot nest more than %d namespaces"
 msgstr "%qD不能在命名空间声明"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "‘%s’(位于 %L)有歧义"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "这里不允许命名空间别名%qD，假定为%qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 msgid "exporting namespace %qD with internal linkage"
 msgstr "new 声明中的表达式必须具有整数或枚举类型"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD不能在命名空间声明"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<namespace%>"
 msgid "exporting unnamed namespace"
 msgstr "需要%<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "方法属性必须被指定的于结束只有"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 #| msgid "%qD conflicts with used function"
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%qD与已用的函数冲突"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "previous definition here"
 msgid "reachable %s definition here"
 msgstr "先前的定义在这里"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX 进入 pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -68479,7 +68579,7 @@ msgstr "标识符%qE是C++26中的关键字"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr "%<LEXER_DEBUGGING_ENABLED_P%>未设置为true"
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<#pragma omp declare %s%> 后面未紧跟函数声明或定义"
@@ -68524,7 +68624,7 @@ msgstr "%<::%E%>尚未声明"
 msgid "request for member %qE in non-class type %qT"
 msgstr "在非类类型%2$qT中请求成员%1$qE"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%>尚未声明"
@@ -68594,7 +68694,7 @@ msgstr "(%qT的定义末尾可能缺少一个分号)"
 msgid "%qE is not a class template"
 msgstr "%qE不是一个类模板"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE不是一个模板"
@@ -68906,1772 +69006,1784 @@ msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, gcc-internal-format
 msgid "reflection is only available with %<-freflection%>"
 msgstr "反射仅在启用 %<-freflection%> 选项时可用"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "需要类型的反射"
 
-#: cp/parser.cc:6341
-#, gcc-internal-format
-msgid "expected a reflection of a function template"
-msgstr "需要函数模板的反射"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "非模板%qD用作模板"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "需要类、命名空间或枚举的反射"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "C++ 不支持定点类型"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ 不允许在表达式中使用花括号组"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "语句表达式只能用于函数或模板实参列表内"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "Lambda 表达式只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "需要 primary-expression"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%>不能用在此上下文中"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "Objective-C 声明只能出现在全局作用域中"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "local variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "局部变量%qD不应出现在此上下文中"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "局部变量%qD不应出现在此上下文中"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, gcc-internal-format
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "反射仅在 C++26 下启用 %<-freflection%> 时可用"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, gcc-internal-format
 msgid "expected id-expression"
 msgstr "需要标识符表达式"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "%<~%>前的作用域%qT不是一个类名"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "形参声明为%<auto%>"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "%<~auto%> 仅在 %<-std=c++14%> 或 %<-std=gnu++14%> 下可用"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "template-id not allowed for destructor in C++20"
 msgstr "关键字%<typename%>不能在模板以外使用"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr "移除 %qs"
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "%<~%T%>声明为%qT的一个成员"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef 名%qD用于析构函数声明"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "需要非限定标识符"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD不是一个模板"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, fuzzy, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "嵌套名指定中使用了不完全的类型%qT"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "%qT被解析到非枚举类型%qT"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "嵌套名指定中使用了不完全的类型%qT"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "嵌套名指定中使用了不完全的类型%qT"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "%C 期待访问指定符"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "需要嵌套名称说明符(nested-name-specifier)"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "类型不能定义在类型转换中"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "类型不能定义在%<typeid%>表达式中"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "给函数%<__builtin_next_arg%>的参数数目不对"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "给函数%<__builtin_next_arg%>的参数数目不对"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "给函数%<__builtin_next_arg%>的参数数目不对"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "给函数%<__builtin_next_arg%>的参数数目不对"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, fuzzy, gcc-internal-format
 #| msgid "destructor cannot be static member function"
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "析构函数不能是静态成员函数"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "内联函数%q+D声明过但从未定义"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ 不允许复合字面量"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "类型不能定义在条件表达式中"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "错误地使用了%qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%>不是%qT的成员"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, gcc-internal-format
 msgid "non-scalar type"
 msgstr "非标准类型"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 #| msgid "typedef name may not be a nested-name-specifier"
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "typedef 名不能是嵌套名指定"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new 不能用于引用类型"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "无效的移位操作数"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++ 不允许对非类型使用%<alignof%>"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "类型不能定义在%<decltype%>中"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD不能有默认参数"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "不能在返回类型中定义新类型"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "__builtin_saveregs 不为此目标所支持"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "不能在返回类型中定义新类型"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "括起的类型标识符后面不能出现数组边界"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "请尝试删除类型标识符两边的括号"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected expression-list or type-id"
 msgstr "需要表达式类型"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "类型不能定义在 new-type-id 中"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on template instantiation"
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "属性在模板实例化上被忽略"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "new 声明中的表达式必须具有整数或枚举类型"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "使用旧式的类型转换"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "%<>>%>运算符在 C++0x 中将被认为是两个右尖括号"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "建议%<>>%>表达式周围加上括号"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow ?: with omitted middle operand"
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++ 不允许省略 ?: 的中间操作数"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr "数组下标中的顶级逗号表达式已弃用"
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in conditions"
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "类型不能定义在条件表达式中"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "Lambda 表达式只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, fuzzy, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr "为 lambda 形参指定了默认参数"
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "捕获列表应在此结束"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, fuzzy, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "已经在 Lambda 表达式中捕获了%<this%>"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 #| msgid "cannot capture %qE by reference"
 msgid "%<this%> cannot be captured by reference"
 msgstr "无法通过引用捕获%qE"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "Lambda 表达式只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "%qD不是一个变量"
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, fuzzy, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "截取的变量 %qD 与 non-automatic 贮藏体持续时间"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "too many %<...%> in lambda capture"
 msgstr "太多的%qs子句"
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, fuzzy, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "明确的 by-copy 截取的 %qD 冗余与 by-copy 截取缺省"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, fuzzy, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "明确的 by-reference 截取的 %qD 冗余与 by-reference 截取缺省"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "为 lambda 形参指定了默认参数"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 #| msgid "default argument specified for lambda parameter"
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "为 lambda 形参指定了默认参数"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 #| msgid "default argument specified for lambda parameter"
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "为 lambda 形参指定了默认参数"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+#| msgid "%qE declared here"
+msgid "%q#E declared here"
+msgstr "%qE在此声明"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "属性在模板实例化上被忽略"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "需要标号语句"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case 标号%qE未出现在 switch 语句中"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "%qE之前需要%<typename%>，因为%qT是一个有依赖的作用域"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%E%> names the constructor, not the type"
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%>命名了一个构造函数而非类型"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "标号位于复合语句末尾"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, fuzzy, gcc-internal-format
 #| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr "有序区域必须紧密嵌套在一个有次序分句的循环内"
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, fuzzy, gcc-internal-format
 #| msgid "lvalue required in asm statement"
 msgid "%<if consteval%> requires compound statement"
 msgstr "asm 语句中需要左值"
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "需要选择语句"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "函数返回了一个数组"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "field %qE declared as a function"
 msgid "condition declares a function"
 msgstr "字段%qE声明为一个函数"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "类型不能定义在条件表达式中"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, gcc-internal-format
 msgid "expected initializer"
 msgstr "需要初始值设定"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "%C处的循环变量不能是一个子组件"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "表达式语句类型不完全"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, fuzzy, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "对%qT不一致的演绎：先是%qT然后是%qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "需要循环语句"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "带作用域的枚举只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr "C99 指示项 %qE 外侧汇总初始设置式"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "析构函数不能是%<constexpr%>"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ 不允许计算转移"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "需要跳转语句"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-name"
 msgid "expected module-partition"
 msgstr "需要模板名"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-name"
 msgid "expected module-name"
 msgstr "需要模板名"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "方法声明不在@interface 上下文中"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "在类作用域使用非成员的 using 声明"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "scope opened here"
 msgstr "联合在此定义"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 msgid "private module fragment"
 msgstr "重复的%<volatile%>"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr "模块声明只允许作为第一个声明，或者结束全局模块片段"
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "在类作用域使用非成员的 using 声明"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr "%qE 只能在模块接口声明之后出现"
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in exception-declarations"
 msgid "%qE may only occur once in an export declaration"
 msgstr "类型不能定义在异常声明中"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr "%<export%> 不是以下模块指令的一部分"
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C 不支持在函数外使用多余的%<;%>"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C 不支持在函数外使用多余的%<;%>"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<;%> after class definition"
 msgid "extra %<;%> after in-class function definition"
 msgstr "类定义后需要%<;%>"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 msgid "attributes are not permitted in this position"
 msgstr "形参声明为%<auto%>"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "忽略%qs属性"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "显式特例化非模板%qT"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "对非模板%q#D的显式实例化"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "export-declarations are not permitted here"
 msgstr "方法声明不在@interface 上下文中"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%>未出现在块起始"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "对%qT不一致的演绎：先是%qT然后是%qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "不能混合声明和函数定义"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in exception-declarations"
 msgid "types may not be defined in a for-range-declaration"
 msgstr "类型不能定义在异常声明中"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, fuzzy, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr "初始值设定项中索引范围为空"
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 msgid "structured binding pack outside of template"
 msgstr "指向不完全类型%qT的指针不能自减"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration"
 msgid "multiple packs in structured binding declaration"
 msgstr "需要声明"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "annotation on structured binding"
 msgstr "迭代变量%qE类型无效"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 #| msgid "expected declaration"
 msgid "empty structured binding declaration"
 msgstr "需要声明"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer for member function %qD"
 msgid "invalid initializer for structured binding declaration"
 msgstr "成员函数%qD的初始值设定无效"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "为形参声明指定了无效的存储类"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%>用在类外"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "%+D 导致一个节类型冲突"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%>的语义在 C++0x 中将被改变；请考虑删除它"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 msgid "%qD invalid in condition"
 msgstr "%s：无效的新列指定符号“%s”\n"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in lambda"
 msgstr "%q+D无效，在%q#T中"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "%s：无效的新列指定符号“%s”\n"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "类定义不能被声明为友元"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "模板不能是%<virtual%>的"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in an exception-specification"
 msgid "types may not be defined in explicit-specifier"
 msgstr "类型不能定义在异常规范中"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "指定链接时使用%qD无效"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "类型不能定义在%<decltype%>中"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "类型不能定义在 new-type-id 中"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "在转换运算符中使用%<auto%>无效"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "在转换运算符中使用%<auto%>无效"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "只有构造函数才能有基类初始值设定"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 #| msgid "cannot expand initializer for member %<%D%>"
 msgid "cannot expand initializer for member %qD"
 msgstr "无法从成员%<%D%>中扩展初始值"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "对%qD的静态声明出现在非静态声明之后"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, fuzzy, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "建构子 delegation 追随 mem-initializer 用于 %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "年代错误的旧式基类初始值设定"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "关键字%<typename%>不允许用在此上下文中(限定的初始值设定隐式地是一个类型)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "比较指针和整数"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, fuzzy, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "缺少空格介于 %<“”%>和后缀识别码"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "需要标识符或%<(%>"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, fuzzy, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "%<#pragma message%>后需要一个字符串"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "二元操作中中操作数无效"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, gcc-internal-format
 msgid "expected operator"
 msgstr "需要操作符"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "关键字%<export%>未实现，将被忽略"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "关键字%<export%>未实现，将被忽略"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 #| msgid "-mexr is used without -ms"
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "-mexr 未与 -ms 一起使用"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "对模板类型参数%qT的使用无效"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "对模板类型参数%qT的使用无效"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "模板参数包%qD不能有默认参数"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "模板参数包不能有默认参数"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, gcc-internal-format
 msgid "expected template-id"
 msgstr "需要模板 ID"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "不能以%<<::%>开始一个模板实参列表"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%>是%<[%>的另一种拼法。请在%<<%>和%<::%>间加上空格"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(如果您使用%<-fpermissive%>G++ 会接受您的代码)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "expected %<(%> after template-argument-list"
 msgstr "需要模板实参"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "模板实参表语法错误"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, gcc-internal-format
 msgid "expected template-name"
 msgstr "需要模板名"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "非模板%qD用作模板"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "使用%<%T::template %D%>来表示这是一个模板"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "%<...%>前需要形参包"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, gcc-internal-format
 msgid "expected template-argument"
 msgstr "需要模板实参"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "%qE 不能作为函数"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "显式实例化不应当使用%<inline%>限定符"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "显式实例化不应当使用%<constexpr%>限定符"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "显式实例化不应当使用%<constexpr%>限定符"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "特例化模板有 C 链接"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 msgid "expected type specifier"
 msgstr "需要类型限定"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "需要模板 ID"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, gcc-internal-format
 msgid "expected type-name"
 msgstr "需要类型名"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE不是一个类型名"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "concept defined here"
 msgstr "联合在此定义"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "错误地使用了%qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "{ 预期于运算式中 ? 之后"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, fuzzy, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "elaborated-type-specifier 用于范围的 enum 必须不使用 %<%D%>关键字"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "声明%qD没有声明任何东西"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "属性在未初始化类型上被忽略"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "属性在模板实例化上被忽略"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "类型在非前向声明的详尽类型限定符中被忽略"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD不是一个枚举模板"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD 在 %qT 中不是一个枚举的名称"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 #| msgid "%<namespace%> definition is not allowed here"
 msgid "unnamed scoped enum is not allowed"
 msgstr "在这里不允许使用%<namespace%>定义"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in casts"
 msgid "types may not be defined in enum-base"
 msgstr "类型不能定义在类型转换中"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "需要 %<;%> 或 %<{%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "启用模板自动实例化"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "友元声明没有指定类或函数名"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "%qD声明出现在命名空间%qD中，而后者并不包含%qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "%qD声明出现在%qD中，而后者并不包含%qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "不允许有多余的限定"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++ 不允许枚举自减"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "opaque-enum-specifier 而无需名称"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "opaque-enum-specifier 必须使用简单的识别码"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, gcc-internal-format
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD 不是一个命名空间名；你是说 %qs 吗？"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD不是一个命名空间名"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "需要命名空间名"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 #| msgid "expected namespace-name"
 msgid "nested namespace name required"
 msgstr "需要命名空间名"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "namespace name required"
 msgstr "命名空间%qD被用作表达式"
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 #| msgid "%<namespace%> definition is not allowed here"
 msgid "a nested namespace definition cannot have attributes"
 msgstr "在这里不允许使用%<namespace%>定义"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "a nested namespace definition cannot be inline"
 msgstr "当内联函数无法被内联时给出警告"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "namespace %qD entered"
 msgstr "命名空间%qD被用作表达式"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "在这里不允许使用%<namespace%>定义"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "模板标识符不允许出现在 using 声明中"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "默认化和被删除的函数只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, fuzzy, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "访问声明被不宜用在中 favour 的 using-declarations；建议：加入 %<using%> 关键字"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of dependent type %qT"
 msgid "%<using enum%> of dependent type %qT"
 msgstr "对依赖类型%qT的使用无效"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qD不是一个枚举名"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of incomplete type %q#T"
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "对不完全的类型%q#T的非法使用"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "类型不能定义在异常声明中"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "%C 需要一个无名接口"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "重复的 cv 限定"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "忽略函数返回类型的类型限定"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT不是一个命名空间"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "%<asm%> qualifier outside of function body"
 msgstr "%qD在函数作用域外未被定义"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "%q+T先前在此处有过声明"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "函数声明中出现形参名却未指定类型"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "括起的初始值设定后出现的属性被忽略"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "函数声明中出现形参名却未指定类型"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD redeclared as variable"
 msgid "add parentheses to declare a variable"
 msgstr "函数%qD重声明为变量"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "cannot handle qualified name for variant function"
 msgstr "%qE不能用作函数"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "%<operator %T%>的声明中不能使用限定符"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "declare variant directives are not allowed on destructors"
 msgstr "%<operator %T%>的声明中不能使用限定符"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "cannot declare %qD to be a bit-field type"
 msgid "cannot handle %s identifier name"
 msgstr "不能将%qD声明为位段类型"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "%qD模板声明无效"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "对%qD的引用有歧义"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr "%qD的特例化必须出现在命名空间内"
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, fuzzy, gcc-internal-format
 #| msgid "specialization of %qD must appear at namespace scope"
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr "%qD的特例化必须出现在命名空间内"
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "函数定义中不允许有属性"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "函数定义中不允许有属性"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "函数定义中不允许有属性"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "函数定义中不允许有属性"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "在这里不允许使用%<namespace%>定义"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "函数定义中不允许出现 asm 指定"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "函数定义中不允许有属性"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, fuzzy, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "预期的建构子、解构式，或类型转换"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "为函数提供了初始值设定"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "括起的初始值设定后出现的属性被忽略"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 msgid "non-function %qD declared as implicit template"
 msgstr "函数%q+D重声明为内联的"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "数组边界不是一个整数常量"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "生成引用类型%qT的成员指针"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%>不是一个类型"
@@ -70680,286 +70792,286 @@ msgstr "%<%T::%E%>不是一个类型"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, gcc-internal-format
 msgid "invalid declarator"
 msgstr "无效的声明"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "将构造函数用作模板无效"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "使用%<%T::%D%>而不是%<%T::%D%>来以限定名指定构造函数"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "需要一个限定的标识符"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, gcc-internal-format
 msgid "expected declarator"
 msgstr "需要声明"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD是一个命名空间"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "生成非类类型%qT的成员指针"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "需要%<operator%>"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "重复的 cv 限定"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 msgid "multiple ref-qualifiers"
 msgstr "%q+D的类型限定冲突"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, fuzzy, gcc-internal-format
 #| msgid "%<-mfpxx%> requires %<-mlra%>"
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr "%<-mfpxx%> 需要 %<-mlra%>"
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "%C处重复访问限定符"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched arguments"
 msgid "%qT not permitted in template argument"
 msgstr "参数不匹配"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "对%qT的使用非法"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "不能在模板实参中定义类型"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "需要类型限定"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr "比较指针和整数"
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "需要%<,%>或%<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "类型不能定义在参数类型中"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "为形参声明指定了无效的存储类"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr "为形参声明指定了无效的存储类"
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 #| msgid "non-parameter %qs cannot be a parameter pack"
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "非形参%qs不能是一个参数包"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "默认参数只允许出现在函数参数中"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "模板参数包%qD不能有默认参数"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "模板参数包不能有默认参数"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "模板参数包不能有默认参数"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter pack cannot have a default argument"
 msgid "an explicit object parameter may not have a default argument"
 msgstr "模板参数包不能有默认参数"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "扩展初始值设定列表只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ 不允许指定元素初始值设定"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++ 不允许指定元素初始值设定"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ 不允许指定元素初始值设定"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, gcc-internal-format
 msgid "expected class-name"
 msgstr "需要类名"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "类定义后需要%<;%>"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "结构定义后需要%<;%>"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "联合定义后需要%<;%>"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "%C处重复访问限定符"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "需要%<{%>或%<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, fuzzy, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "%qD的声明中类名无效"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "友元声明没有指定类或函数名"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "关键字%<typename%>不能在模板以外使用"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "%qD的声明中类名无效"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "在友元声明中定义显式特例化%qD"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "显式特例化前必须有%<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "函数模板%qD重声明为类模板"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, fuzzy, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "缺少用以解析%qE类型的上下文"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+#T"
 msgid "previous definition of %q#T"
@@ -70968,281 +71080,281 @@ msgstr "%q+#T的前一个定义"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 msgid "expected class-key"
 msgstr "需要%<class%>"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, fuzzy, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "声明友元时必须使用 class 关键字"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "友元声明没有指定类或函数名"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "扩展初始值设定列表只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "为无名形参指定了%qs"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 #| msgid "bit-field %qD with non-integral type"
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "位段%qD非整型"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "函数定义上有 pure 指定"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "可变数组成员没有出现在结构的末尾"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "需要声明"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, fuzzy, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "指定了无效的 AE 类型(%s)\n"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, fuzzy, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "%qT的初始值设定必须在花括号内"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "不能为局部变量指定节属性"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, fuzzy, gcc-internal-format
 #| msgid "%<virtual%> specified more than once in base-specified"
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "在基类限定中指定了多于一次的%<virtual%>"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, fuzzy, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "超过一个访问说明符在中 base-specified"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "关键字%<typename%>不允许用在此上下文中(基类隐式地是一个类型)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "类型不能定义在异常规范中"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 #| msgid "due to different exception specifications"
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "因为异常规范不一致"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, fuzzy, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "动态异常规格被不宜用在中 C++0x; 使用 %<noexcept%> 作为替代"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<auto%> in conversion operator"
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "在转换运算符中使用%<auto%>无效"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "类型不能定义在异常声明中"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%>用于空声明中"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD不能有默认参数"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 #| msgid "expected %qT but argument is of type %qT"
 msgid "expected attribute argument as balanced token sequence"
 msgstr "需要类型%qT，但实参的类型为%qT"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "%qE属性与 %s 属性冲突"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "需要标识符"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "不能为局部变量指定节属性"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 #| msgid "expected parameter pack before %<...%>"
 msgid "expected attribute before %<...%>"
 msgstr "%<...%>前需要形参包"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "非空的属性在非原型中没有实参"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected conditional-expression"
 msgstr "需要表达式"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "%qs必须与%qs一起使用"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "%qE属性为%qE所忽略"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 #| msgid "attributes ignored on uninstantiated type"
 msgid "attributes are ignored on function contract specifiers"
 msgstr "属性在未初始化类型上被忽略"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, fuzzy, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr "C++0x %<constexpr%>只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x auto 只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "调度块大小表达式必须为整型"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "要求的位置不是一个整数常量"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "要求的位置不是一个整数常量"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "特例化成员%<%T::%E%>需要%<template<>%>语法"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "%<%T::%E%>声明无效"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "模板参数表太少"
@@ -71251,443 +71363,443 @@ msgstr "模板参数表太少"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "模板参数表太多"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "template-id not allowed for constructor in C++20"
 msgstr "关键字%<typename%>不能在模板以外使用"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "有名返回值不再被支持"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, fuzzy, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "实字运算符模板 %qD 有无效的参数清单。 预期 non-type 模板参数包装 <char...>"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, fuzzy, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "实字运算符模板 %qD 有无效的参数清单。 预期 non-type 模板参数包装 <char...>"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "局部类中对成员模板的声明无效"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "模板有 C 链接"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "显式特例化前必须有%<template <>%>"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "%<typedef%>的模板声明"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "没有声明任何东西"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "显式特例化不能有存储类型"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "在嵌套模板实参列表中应当使用%<> >%>而非%<>>%>"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "可疑的%<>>%>，使用%<>%>来结束模板实参列表"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "可疑的%<>>%>，使用%<>%>来结束模板实参列表"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "指定链接时使用%qD无效"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "%+D 导致一个节类型冲突"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%>出现在%qD之前"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%qE不是一个 typedef 类型，也不是一个内建类型"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++ 1998 不支持%<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "线程局部的 COMMON 数据没有实现"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "重复的标号%qD"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "重复的%qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "需要%<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "需要%<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "需要%<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "需要%<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "需要%<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "需要%<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "需要%<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "需要%<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "需要%<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "需要%<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "需要%<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "需要%<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "需要%<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "需要%<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "需要%<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<catch%>"
 msgid "expected %<auto%>"
 msgstr "需要%<catch%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "需要%<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "需要%<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "需要%<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "需要%<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "对 rpmtxn 数据库异动作业进行除错"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "于 %s 等待异动作业锁定\n"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<@end%>"
 msgid "expected %<co_yield%>"
 msgstr "需要 %<@end%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "需要%<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "需要%<...%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "需要%<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "需要%<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "需要%<:%>或%<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>"
 msgid "expected %<:]%>"
 msgstr "需要 %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "使用了%qs标记，在命名%q#T时"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T之前在此声明过"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "无法声明对%q#T的引用"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 #| msgid "%qT declared with greater visibility than its base %qT"
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT被声明为比其基类%qT有更高的可见性"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "需要%<class%>"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 #| msgid "label %qD defined here"
 msgid "%qT defined as %qs here"
 msgstr "标号%qD在此定义"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "在此声明"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD重声明时有不同的可访问性"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, fuzzy, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "用作消歧义的%<template%>只能用于模板内"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "文件在默认参数处结束"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "位置错误的%<@%D%>Objective-C++ 构造"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "需要指定声明"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "objective-c++ 消息参数被预期"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%>必须指定一个类型作为实参"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "无效的 Objective-C++ 选择子名"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "%C处数组声明需要另外一维"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "不能为局部变量指定节属性"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, fuzzy, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "零星的 %qs 介于 Objective-C++ 方法"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "不一致的实例变量指定"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "%<@protocol%>需要标识符"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, fuzzy, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "属性可能无法被指定的之前 %<@%D%>Objective-C++ 关键字"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "%qE属性为%qE所忽略"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 msgid "invalid type for property"
 msgstr "不能设置只读属性"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "不能设置只读属性"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected integer expression list"
 msgstr "需要整数表达式"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "需要%<class%>、%<typename%>或%<template%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, gcc-internal-format
 msgid "invalid reduction-identifier"
 msgstr "无效还原标识符"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in parameter types"
 msgid "types may not be defined in iterator type"
@@ -71697,182 +71809,182 @@ msgstr "类型不能定义在参数类型中"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable 不再受支持"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "括起的初始化不允许使用在 OpenMP %<for%>循环中"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, fuzzy, gcc-internal-format
 #| msgid "%<void%> as only parameter may not be qualified"
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr "%<void%>作为仅有的参数时不能被限定"
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "迭代变量%qD不应当是 reduction"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<#pragma GCC pop_options%>缺少相应的%<#pragma GCC push_options%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<#pragma align%>必须出现在 %D 的声明之前，忽略"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qD is not a C pointer"
 msgstr "%qD 不是一个指针变量"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "需要%<;%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer clause"
 msgstr "无效的初始值设定"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "? 预期于运算式中"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in declare reduction type list"
 msgstr "不能在返回类型中定义新类型"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr "上一个声明"
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 #| msgid "types may not be defined in parameter types"
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "类型不能定义在参数类型中"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "需要%<#pragma omp section%>或%<}%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, gcc-internal-format
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD 不引用命名空间范围内的函数"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "标号位于复合语句末尾"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, fuzzy, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "外 %<__transaction_cancel%>无法在之内外 %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, fuzzy, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  或 %<transaction_may_cancel_outer%> 函数"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 #| msgid "malformed #pragma GCC coprocessor"
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "#pragma GCC coprocessor 格式错误"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%>只能用在复合语句中"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 #| msgid "%<#pragma omp barrier%> may only be used in compound statements"
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<#pragma omp barrier%>只能用在复合语句中"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "#pragma GCC memregs 必须出现在所有函数声明之前"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "模块间优化未为 C++ 实现"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "此上下文中不允许标准转换"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, fuzzy, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "模板不能是%<virtual%>的"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -72361,23 +72473,28 @@ msgstr "使用 template<> 来显式特例化"
 msgid "redeclaration of %qD with different constraints"
 msgstr "对%qD的重声明在%<constexpr%>方面"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "为 lambda 形参指定了默认参数"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT不是一个模板类型"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "%qD的声明中没有 template 限定"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "重声明为具有 %d 个模板参数"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D used %d template parameter"
 #| msgid_plural "previous declaration %q+D used %d template parameters"
@@ -72385,488 +72502,488 @@ msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "先前的声明%q+D使用了 %d 个模板参数"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "模板形参%q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "在这里又被声明为%q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, gcc-internal-format
 msgid "redeclared here"
 msgstr "在这里又被声明"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration %qD differs in %<constexpr%>"
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "对%qD的重声明在%<constexpr%>方面"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 #| msgid "original definition appeared here"
 msgid "original declaration appeared here"
 msgstr "原始定义在此"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration %qD differs in %<constexpr%>"
 msgid "redeclaration of %q#D with different constraints"
 msgstr "对%qD的重声明在%<constexpr%>方面"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE不是类型%qT的有效模板参数"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "它必须是一个具有外部链接函数的地址"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, fuzzy, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "它必须是一个具有外部链接函数的地址"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE不是类型%qT的有效模板实参，因为对象%qD没有外部链接"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE不是类型%qT的有效模板实参，因为函数%qD没有外部链接"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, fuzzy, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "它必须是格式为‘&X::Y’的成员指针"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qD不是%qT的成员"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  无法推导模板参数 %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, fuzzy, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  类型 %qT 和 %qT 有不兼容的 cv-qualifiers"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "在类型%qT和%qT间比较"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "模板参数包%qD不能有默认参数"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "给%qD的模板实参不匹配原先的模板%qD"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE 与 %qE 不等价"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  使用 %qT 和 %qT 进行参数包推导时出现不一致"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  对于参数 %qT 推导出了相互冲突的类型（%qT 和 %qT）"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  对于非类型参数 %qE 推导出了相互冲突的值（%qE 和 %qE）"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "%qE不是类型%qT的有效模板实参，因为它的类型是%qT"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  备选需要至少 %d 个实参，但提供了 %d 个"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] " 备选需要 %d 个实参，但提供了 %d 个"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  无法将 %qE (类型为 %qT) 转换为类型 %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT 是 %qT 的一个模糊的基类"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT 不是从 %qT 派生的"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, fuzzy, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  模板参数的模板模板参数是不一致与其他 deduced 模板参数"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "指向不完全类型%qT的指针不能自减"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "给%qD的模板实参不匹配原先的模板%qD"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE不是类型%qT的有效模板实参，因为函数%qD没有外部链接"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE不是类型%qT的有效模板实参，因为对象%qD没有外部链接"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qE不是类型%qT的有效模板实参，因为函数%qD没有外部链接"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD不是一个有效模板实参，因为%qD是一个变量，而非变量的地址"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE不是类型%qT的有效模板实参，因为字面字符串不能用在此上下文中"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "%qE不是类型%qT的有效模板实参，因为%qE不是一个变量"
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE不是类型%qT的有效模板实参，因为 cv 限定冲突"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE不是类型%qT的有效模板实参，因为它不是一个左值"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D不是类型%qT的有效模板参数，因为一个引用变量没有常量地址"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE不是类型%qT的有效模板实参，因为它是一个指针"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "尝试使用%qE代替"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE不是类型%qT的有效模板实参，因为它的类型是%qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "忽略在其定义之后为%qT应用的属性"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "忽略在其定义之后为%qT应用的属性"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "注入的类名%qD被用作模板的模板参数"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "将析构函数%qD用作类型无效"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "需要使用某个模板参数的类型成员时，请使用%<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "实参 %d 的类型/值不匹配，在%qD的模板参数列表中"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "需要一个%qT类型的常量，却给出了%qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for template parameter for class enclosing %qD"
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "包含%qD的类的模板参数有默认参数"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "需要一个类模板，却给出了%qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "需要一个类型，却给出了%qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "需要一个类型，却给出了%qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "需要一个类模板，却给出了%qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "需要有%qD类型的模板，却得到了%qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "实参 %d 的类型/值不匹配，在%qD的模板参数列表中"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, gcc-internal-format
 msgid "  expected %qD but got %qD"
 msgstr "  需要%qD，却给出了%qD"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument %qE to %qT"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "不能将模板参数从%qE转换到%qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "模板参数数目不对(不应是 %d 个而应是 %d 个)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "模板参数数目不对(不应是 %d 个而应是 %d 个)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "提供给%q+D"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "包含%qD的类的模板参数有默认参数"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "包含%qD的类的模板参数有默认参数"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D声明为模板"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "非模板类型%qT用作模板"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "对于模板声明%q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "internal consistency failure"
 msgid "template constraint failure for %qD"
 msgstr "内部一致性错误"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 msgid "use of invalid variable template %qE"
 msgstr "%qD不是一个模板"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "在实例化%2$qD时模板实例化深度超过最大值 %1$d(使用 use -ftemplate-depth= 来增大最大值)"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "score argument must be constant integer expression"
 msgstr "折叠参数需要正整常量表达式"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "%qs必须与%qs一起使用"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be constant integer expression"
 msgstr "需要整数表达式"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 msgid "instantiating erroneous template"
 msgstr "显式实例化非模板类型%qT"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "originally specified here"
 msgid "first error appeared here"
 msgstr "原先在这里定义"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 #| msgid "flexible array member in union"
 msgid "flexible array member %qD in union"
 msgstr "联合和可变数组成员"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE没有出现在声明的开头"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%T%>"
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "展开%<%T%>时参数包长度不匹配"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%E%>"
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "展开%<%E%>时参数包长度不匹配"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "重定义%q#D的默认参数"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "生成非类类型%qT的成员函数指针"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "mismatched argument pack lengths while expanding %<%T%>"
 msgid "mismatched argument pack lengths (%d vs %d)"
@@ -72885,128 +73002,128 @@ msgstr "展开%<%T%>时参数包长度不匹配"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "变量%qD有函数类型"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "无效的参数类型%qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "在声明%q+D中"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "函数返回了一个数组"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "函数返回了一个函数"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not defined as a type"
 msgid "%qE is not usable in a splice type"
 msgstr "%qs 没有被定义为一个类型"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a variable in clause %qs"
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE在子句%qs中不是一个变量"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "形成对 void 的引用"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "生成指向引用类型%qT的指针"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "生成指向引用类型%qT的引用"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "不能声明指向限定函数类型%qT的指针"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "不能声明指向限定函数类型%qT的引用"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "生成非类类型%qT的成员指针"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "生成引用类型%qT的成员指针"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "创建指向 void 类型的成员指针"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "生成%qT的数组"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "假定数组%q+D有一个元素"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT不是类、结构或联合类型"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT被解析到非枚举类型%qT"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT被解析到非类类型%qT"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT被解析到非枚举类型%qT"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 #| msgid "expected function"
 msgid "expected a reflection of a type template"
 msgstr "需要函数"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "在模板中使用%qs"
@@ -73014,211 +73131,211 @@ msgstr "在模板中使用%qs"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "在初次使用后显式特例化%qD"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "限定类型%qT不匹配析构函数名 ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "依赖名%qE被解析为非类型，但实例化却产生了一个类型"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "如果您想指定类型，请使用%<typename %E%>"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 #| msgid "initializer element is not a constant expression"
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "初始值设定中元素不是常量表达式"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "对集展开表达式的无效使用"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "使用%<...%>来展开实参集"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr ""
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD 未被声明在中这个范围，而找不到任何声明是由 argument-dependent 查找于点的实体化"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, fuzzy, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "声明在中附属基底 %qT 找不到由资格不符的查找"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, fuzzy, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "使用%<%T::%D%>而不是%<%T::%D%>来以限定名指定构造函数"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "使用%<%T::%D%>而不是%<%T::%D%>来以限定名指定构造函数"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%qD 在此声明，稍后在翻译单元中"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "给函数%<__builtin_next_arg%>的参数数目不对"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 #| msgid "wrong number of arguments specified for %qE attribute"
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "为%qE属性给定的实参数目错误"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT既不是类也不是命名空间"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD既不是类也不是命名空间"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "使用无效字段%qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is/uses anonymous type"
 msgid "%qT is/uses unnamed type"
 msgstr "%qT是/使用了匿名类型"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "%qD的模板实参使用了局部类型%qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT是一个可变类型"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "整型表达式%qE不是常量"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  试图实例化%qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#T"
 msgstr "%q#T的显式实例化出现在模板定义之前"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 msgid "ambiguous template instantiation for %q#D"
 msgstr "有歧义的模板特例化%qD(为%q+D)"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 msgid "%s %#qS"
 msgstr "%s %#qS"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "对非模板%q#D的显式实例化"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD不是类模板的非静态数据成员"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "没有找到与%qD匹配的模板"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "类型%qT用于显式实例化%qD时不匹配声明的类型%qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "对%q#D的显式实例化"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "对%q#D重复的显式实例化"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++ 1998 不允许在显式实例化时使用%<extern%>"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "为模板实例化化应用了存储类型%qD"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "显式实例化非模板类型%qT"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "显式实例化非模板类型%qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "%q#T的显式实例化出现在模板定义之前"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ 不允许在显式实例化时使用%qE"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "对%q#T重复的显式实例化"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "在初次使用后显式特例化%qD"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "函数定义中不允许出现 asm 指定"
@@ -73230,167 +73347,167 @@ msgstr "函数定义中不允许出现 asm 指定"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "显式实例化%qD时没有可用的定义"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 #| msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)"
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "在实例化%2$q+D时模板实例化深度超过了最大值 %1$d，可能是由于生成虚函数表所致(使用 -ftemplate-depth= 来增大最大值)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T不是一个有效的模板常量参数类型"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "对模板类型参数%qT的使用无效"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T不是一个有效的模板常量参数类型"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "关键字%<typename%>不能在模板以外使用"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 msgid "a concept cannot be constrained"
 msgstr "析构函数不能是静态成员函数"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 msgid "concept %qE not in namespace scope"
 msgstr "%qT作为枚举被引用"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "在模板参数列表中定义了%q#T"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, fuzzy, gcc-internal-format
 #| msgid "deducing from brace-enclosed initializer list requires #include <initializer_list>"
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "从花括号中的初始化列表演绎需要 #include <initializer_list>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "非模板%qD用作模板"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "可变参数模板只在 -std=c++0x 或 -std=gnu++0x 下可用"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "use #include instead"
 msgid "use %qD directly instead"
 msgstr "改用 #include"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "%qE不是类型%qT的有效模板实参，因为对象%qD没有外部链接"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "不考虑内联函数"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 #| msgid "indirect function %q+D cannot be declared weakref"
 msgid "explicit deduction guide declared here"
 msgstr "内联函数%q+D不能声明为有弱链接"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "模板第 %d 个参数无效"
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "无法从%2$qE推导出%1$qT"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "无法从%2$qE推导出%1$qT"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "指令不满足其约束："
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "指令不满足其约束："
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -73398,378 +73515,439 @@ msgstr "指令不满足其约束："
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new 不能用于引用类型"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new 不能用于函数类型"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "%qE属性在不是类的类型上被忽略"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "%qE属性在不是类的类型上被忽略"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new 不能用于函数类型"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new 不能用于函数类型"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+#| msgid "passing argument %d of %qE from distinct Objective-C type"
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "从不同的 Objective-C 类型传递%2$qE的第 %1$d 个参数"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%E%> is not a class or namespace"
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<::%E%>既不是类也不是命名空间"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, fuzzy, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "%qT被解析到非枚举类型%qT"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, fuzzy, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr "%qT被解析到非枚举类型%qT"
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, gcc-internal-format
 msgid "couldn%'t throw %qs"
 msgstr ""
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<operator%>"
 msgid "unexpected %<std::meta::operators%>"
 msgstr "需要%<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "could not find specs file %s\n"
 msgid "couldn%'t look up %qs"
 msgstr "找不到 specs 文件 %s\n"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "需要一个类型，却给出了%qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an object type"
 msgid "%qT must be an object type"
 msgstr " %qT 不是一个对象类型"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "%qT must be a function type"
 msgstr "%qD必须是一个非静态的成员函数"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 #| msgid "expected template-argument"
 msgid "unexpected %<data_member_options%> argument"
 msgstr "需要模板实参"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "不能将位段%qD声明为函数类型"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 #| msgid "struct defined here"
 msgid "%<consteval%> block defined here"
 msgstr "结构在此定义"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
-#, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
-msgstr ""
+#: cp/reflect.cc:6472
+#, fuzzy, gcc-internal-format
+#| msgid "%qE is not a constant expression"
+msgid "%qs used outside of manifestly constant-evaluation"
+msgstr "%qE不是一个常量表达式"
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 #| msgid "invalid PHI argument"
 msgid "invalid %<access_context%> argument"
 msgstr "无效的 PHI 实参"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<delete%>"
 msgid "unexpected %<access_context::scope()%>"
 msgstr "需要%<delete%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 #| msgid "unexpected argument"
 msgid "unexpected argument to %qs"
 msgstr "非预期的参数"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+#| msgid "passing argument %d of %qE from distinct Objective-C type"
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "从不同的 Objective-C 类型传递%2$qE的第 %1$d 个参数"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "需要整数表达式"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "需要整数表达式"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "spec 函数名格式错误"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "splice argument must be an expression of type %qs"
 msgstr "折叠参数需要正整常量表达式"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot disable built-in function %qs"
+msgid "cannot splice a null reflection"
+msgstr "无法禁用内建函数%qs"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "Warn about overflow in arithmetic expressions"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "算术表示式溢出时给出警告"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "无效的协寄存器%qE"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 #| msgid "built-in function %qD takes one argument only"
 msgid "function of consteval-only type must be declared %qs"
 msgstr "内建函数%qD只需要一个实参"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "expected boolean expression"
 msgid "expected a reflection of an expression"
 msgstr "需要布尔表达式"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "关键字%<typename%>不能在模板以外使用"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "预期的建构子、解构式，或类型转换"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "命名空间%qD被用作表达式"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "不能显式地将成员%q#D声明为有外部链接"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+msgid "invalid class member access of type template %qE"
+msgstr "生成抽象类型%qT的数组"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+#| msgid "can%'t use %qs as a call-used register"
+msgid "cannot use %qE to access a class member"
+msgstr "无法将%qs用作调用者使用寄存器"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "在包含函数中使用%<auto%>变量"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "数组%qD的大小不是一个整数常表达式"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about overflow in arithmetic expressions"
 msgid "cannot use a data member specification in a splice expression"
 msgstr "算术表示式溢出时给出警告"
 
+#: cp/reflect.cc:9114
+#, gcc-internal-format
+msgid "expected a reflection of a function template"
+msgstr "需要函数模板的反射"
+
+#: cp/reflect.cc:9130
+#, fuzzy, gcc-internal-format
+#| msgid "expected a reflection of a function template"
+msgid "expected a reflection of a function or variable template"
+msgstr "需要函数模板的反射"
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -74121,601 +74299,601 @@ msgstr "对限定类型%qT的定义无效"
 msgid "invalid base-class specification"
 msgstr "无效的基类"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 msgid "cannot capture member %qD of anonymous union"
 msgstr "匿名联合中出现保护成员%q+#D"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD未被捕获"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, fuzzy, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr "为 lambda 形参指定了默认参数"
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "在包含函数中使用%<auto%>变量"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, fuzzy, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "已弃用为非函数指定默认参数"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "已弃用为非函数指定默认参数"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 #| msgid "mismatched arguments"
 msgid "missing template arguments"
 msgstr "参数不匹配"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "模板参数%qD(类型为%qT)不允许出现在整数表达式中，因为它的类型不是整数或枚举"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "将类模板%qT用作表达式"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "在多继承网格中对%qD的访问有歧义"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD不能出现在常量表达式中"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "%qE的类型未知"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qD不是一个枚举名"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "数组%qT的大小的类型不是整数"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 msgid "pack index is not an integral constant"
 msgstr "要求的位置不是一个整数常量"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 #| msgid "execution count is negative"
 msgid "pack index %qE is negative"
 msgstr "执行次数为负"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr "类型索引编号 %d 超出范围\n"
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "为形参声明指定了无效的存储类"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "不能为析构函数%<~%T%>使用%<offsetof%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "不能为成员函数%qD应用%<offsetof%>"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "不能为成员函数%qD应用%<offsetof%>"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 #| msgid "cannot apply %<offsetof%> to member function %qD"
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "不能为成员函数%qD应用%<offsetof%>"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, fuzzy, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr "不能通过%<...%>接受不能平凡复制的类型%q#T；"
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 #| msgid "constructor priorities are not supported"
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "不支持构造函数优先级"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 msgid "user defined reduction lookup is ambiguous"
 msgstr "对%qD的引用有歧义"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %#qD"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "%qE has invalid type for %<reduction%>"
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE的类型对%<reduction%>无效"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "指定链接时使用%qD无效"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 #| msgid "expected integer expression"
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "需要整数表达式"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD在子句%qs中不是一个变量"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD在%<firstprivate%>子句中不是一个变量"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD在%<lastprivate%>子句中不是一个变量"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "%<num_threads%>值必须为正"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "调度块大小表达式必须为整型"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "调度块大小表达式必须为整型"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, fuzzy, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "调度块大小表达式必须为整型"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD 不是 %<aligned%> 子句中的变量"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, fuzzy, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "调度块大小表达式必须为整型"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD 不是 %<nontemporal%> 子句中的变量"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD 不是 %<allocate%> 子句中的变量"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD在数据子句中多次出现"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr "%qE在子句%<firstprivate%>中不是一个变量"
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "名字‘%s’在%C处不能用作已定义的运算符"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 #| msgid "variable length array is used"
 msgid "variable length traits arrays are not supported"
 msgstr "使用了变长数组"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "%qD 不是 %qs 子句中的左值表达式或数组段"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 #| msgid "too many %qs clauses"
 msgid "template %qE in clause %qs"
 msgstr "太多的%qs子句"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "num_threads 表达式必须是整型的"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs integral type"
 msgstr "调度块大小表达式必须为整型"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%>%qD不是一个文件、命名空间或块作用域变量"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%<threadprivate%>%qE指示不在%qT定义中"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "%qE和%qD之间的差不具有整数类型"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<# pragma omp 基元的 update%>使用两不同的变量用于内存"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<# pragma omp 基元的 update%>使用两不同的变量用于内存"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "跳转至语句表达式中"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "%K%D 的第一个实参必须是一个指针，第二个必须是整常量"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "静态断言错误：%.*s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "静态断言中出现非常量条件"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 #| msgid "argument to decltype must be an expression"
 msgid "argument to %<decltype%> must be an expression"
 msgstr "decltype 的实参必须是一个表达式"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "%s 无法解析重载的函数地址"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class type"
 msgid "%qT is not a non-union class type"
 msgstr "%qT不是一个类"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not an standard layout type"
 msgid "%qT is not a standard-layout type"
 msgstr "  %qT 不是一个标准布局类型"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "调用%<__builtin_next_arg%>时没有给定实参"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "调用%<__builtin_next_arg%>时没有给定实参"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not a reference"
 msgid "%qs argument %qT is a reference"
 msgstr "  %qT 不是一个引用"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qD 不是一个类模板或别名模板"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "逗号表达式的左操作数不起作用"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "模板实参%qE混杂了模板形参"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
 msgstr "%<__builtin_prefetch%>的第二个实参必须是一个常量"
@@ -74723,372 +74901,372 @@ msgstr "%<__builtin_prefetch%>的第二个实参必须是一个常量"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "new 不能用于函数类型"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV限定符不能应用到%qT上"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, gcc-internal-format
 msgid " declared here"
 msgstr "在此声明"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT is a floating-point type"
 msgstr "%qD不是一个函数模板"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a pointer variable"
 msgid "%qT is a fixed-point type"
 msgstr "%qD 不是一个指针变量"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT不是%qT的基类"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr "  %qT 没有唯一的对象表示"
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T有指针数据成员"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "base %qT does not have unique object representations"
 msgstr "  %qT 没有唯一的对象表示"
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT does not have unique object representations"
 msgid "%qD with type %qT does not have unique object representations"
 msgstr "  %qT 没有唯一的对象表示"
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "padding occurs between %qD and %qD"
 msgstr "在%qT和%qT间比较"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %q+D"
 msgid "padding occurs after %qD"
 msgstr "未使用的参数%q+D"
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs不是一个 gcov 数据文件"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 msgid "base class %qT is not public"
 msgstr "%3$L处 CLASS 变量‘%2$s’的类型‘%1$s’不能被扩展"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not captured"
 msgid "%qD is not public"
 msgstr "%qD未被捕获"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD 是可变的"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a type"
 msgid "%qD has a non-structural type"
 msgstr "%qD不是一个类型"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "只能为类定义应用%qE属性"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not a string constant"
 msgid "%qE attribute argument must be a string constant"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "只能为类定义应用%qE属性"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "只能为类定义应用%qE属性"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "只能为类定义应用%qE属性"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "%qE属性需要带有名实参的原型"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "不能向类型添加属性%qE"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "无效的函数声明"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%qD不是一个枚举名"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "将%<__alignof%>用于位段"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qD 不是整型或枚举类型"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "为无名形参指定了%qs"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 #| msgid "declaration for parameter %qD but no such parameter"
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "声明的形参%qD不存在"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "请求的 init_priority 不是一个整数常数"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "只能将%qE属性用于某个类的对象的文件作用域定义"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "请求的 init_priority 越界"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "请求的 init_priority 保留为内部使用"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "%qD声明为%qT的一个成员"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "%qE属性需要带有名实参的原型"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "%qE属性的实参不是一个字符串常量"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "%qE属性的实参不是一个字符串常量"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%T::%D%>不是一个有效的声明"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "请输入有效字符"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "%qE属性在不是类的类型上被忽略"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "忽略在其定义之后为%qT应用的属性"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "忽略在其定义之后为%qT应用的属性"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "忽略在其定义之后为%qT应用的属性"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%qE属性只能用于函数"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "%qE属性只能用于函数"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute argument not a string constant"
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "%qE属性需要一个字符串常量作为实参"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral or enumeration type"
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "%qD 不是整型或枚举类型"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute only applies to variables"
 msgid "annotation applied to a label"
 msgstr "属性%qE只能用于变量"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "为无名形参指定了%qs"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "redefinition of parameter %q+D"
 msgid "annotation on void parameter"
 msgstr "形参%q+D重定义"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 #| msgid "%qD does not have integral type"
 msgid "annotation does not have structural type"
 msgstr "%qD 不是整型"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "  %qT is not nothrow copy constructible"
 msgid "annotation does not have copy constructible type"
 msgstr "  %qT 无法进行nothrow复制构造"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -75296,843 +75474,849 @@ msgstr "%qT没有名为%qE的成员"
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT没有名为%qE的成员"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%>不是%qT的成员"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD不是%qT的成员"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD不是一个成员模板函数"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT不是一个指向对象的类型"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "对成员指针数组索引的使用无效"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "对成员指针使用一元%<*%>非法"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "隐式转换成员指针用法无效"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "数组引用缺少下标"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "按下标访问声明为%<register%>的数组"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "下标运算的左操作数既非数组也非指针"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "使用%qE时缺少对象"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 #| msgid "non-trivial conversion at assignment"
 msgid "no default version in scope"
 msgstr "赋值时不平凡的转换"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ 不允许在程序里调用%<::main%>"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "必须用%<.*%>or%<->*%>调用%<%E (...)%>中的成员函数指针，例如%<(... ->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE不能用作函数"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE不能用作函数"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qD 不能用作函数"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "%qE不能用作函数"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "给予函数 %s 的参数太多，于 %L"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "给 %qE 的实递参数太少"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "提供给函数%qE的实参太多"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "提供给函数%qE的实参太少"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "给予函数的实参太多"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "给予函数的实参太少"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "给予函数 %s 的参数太多，于 %L"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "给 %qE 的实递参数太少"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "给予函数的实参太多"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "给予函数的实参太少"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "%2$qD的第 %1$P 个形参的类型%3$qT不完全"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "形参 %P 的类型%qT不完全"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 #| msgid "the address of %qD will never be NULL"
 msgid "the address %qE will never be NULL"
 msgstr "%qD的地址永远不会为 NULL"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "%qD的地址永远不会为 NULL"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "比较将一律评估作为 %<true%> 用于地址的 %qD 将永不是空值"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "比较将一律评估作为 %<true%> 用于地址的 %qD 将永不是空值"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 #| msgid "conversion between distinct pointer types %qT and %qT lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "在不同的指针类型%qT和%qT之间的转换要一个类型转换"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 #| msgid "conversion between distinct pointer types %qT and %qT lacks a cast"
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "在不同的指针类型%qT和%qT之间的转换要一个类型转换"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "在不同的指针类型%qT和%qT之间的比较需要一个类型转换"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "在不同的指针类型%qT和%qT之间的比较需要一个类型转换"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 #| msgid "conditional expression between distinct pointer types %qT and %qT lacks a cast"
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "不同的指针类型%qT和%qT组成的条件表达式中需要一个类型转换"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "表达式%qE具有抽象类类型%qT，不能用于 throw 表达式中"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "表达式%qE具有抽象类类型%qT，不能用于 throw 表达式中"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, fuzzy, gcc-internal-format
 #| msgid "conditional expression between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr "不同的指针类型%qT和%qT组成的条件表达式中需要一个类型转换"
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 #| msgid "conditional expression between distinct pointer types %qT and %qT lacks a cast"
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "不同的指针类型%qT和%qT组成的条件表达式中需要一个类型转换"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "假定从重载函数转换到类型%qT"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "算术表达式中使用了 NULL"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ 不允许比较指针和整数的值"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "在类型%qT和%qT间比较"
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "指针与整数 0 比较大小"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "非浮点实参间的无效比较"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "C++ 中不允许从%qT到%qT的隐式转换"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "操作数类型%qT和%qT对双目%qO而言无效"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ 不允许在减法中使用类型为%<void *%>的指针"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ 不允许在减法中使用函数指针"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ 不允许在减法中使用指向方法的指针"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "在指针算术中使用指向不完全类型的指针无效"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of constructor %qE"
 msgid "taking address of constructor %qD"
 msgstr "取构造函数%qE的地址"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of destructor %qE"
 msgid "taking address of destructor %qD"
 msgstr "取析构函数%qE的地址"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "用%qE形成成员函数指针的用法无效"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "需要一个限定的标识符"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "%qE两边的括号不能用来构造一个成员函数指针"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ 不允许通过提取一个未限定的或带括号的非静态成员函数的地址来形成一个成员函数指针。请使用%<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 #| msgid "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%>"
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ 不允许通过提取一个未限定的或带括号的非静态成员函数的地址来形成一个成员函数指针。请使用%<&%T::%D%>"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ 不允许通过取已绑定的成员函数的地址来构造成员函数指针。请改用%<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ 不允许通过取已绑定的成员函数的地址来构造成员函数指针。请改用%<&%T::%D%>"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(成员指针只能用%<&%E%>构成)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "取临时变量的地址"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ 不允许取函数%<::main%>的地址"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "不能创建指向引用成员%qD的指针"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field %qD"
 msgid "attempt to take address of bit-field"
 msgstr "无法取得位段%qD的地址"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of expression of type %<void%>"
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "取一个类型为%<void%>的表达式的地址"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++ 不允许枚举自增"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++ 不允许枚举自减"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "指向不完全类型%qT的指针不能自增"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "指向不完全类型%qT的指针不能自减"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++ 不允许对类型为%qT的指针自增"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++ 不允许对类型为%qT的指针自减"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "无法取右值表达式%<this%>的地址"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "请求声明为%<register%>的%qD的地址"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "%qT的初始值设定必须在花括号内"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "%s 表达式列表被看作复合表达式"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "%s 表达式列表被看作复合表达式"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "%s 表达式列表被看作复合表达式"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "%s 表达式列表被看作复合表达式"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "缺少用以解析%qE类型的上下文"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "从类型%qT到类型%qT的类型转换丢失了限定符"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 #| msgid "static_cast from type %qT to type %qT casts away qualifiers"
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "从类型%qT到类型%qT的 static_cast 丢失了限定符"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 #| msgid "reinterpret_cast from type %qT to type %qT casts away qualifiers"
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "从类型%qT到类型%qT的 reinterpret_cast 丢失了限定符"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "向函数类型%qT的转换无效"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "忽略函数返回类型的类型限定"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "从类型%qT到类型%qT中的 static_cast 无效"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 msgid "class type %qT is incomplete"
 msgstr "源有不完全的类类型"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "从%qT转换到%qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "从具有类型%qT的右值表达式到类型%qT中的转换无效"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "从%qT到%qT的转换损失精度"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 #| msgid "comparison between distinct pointer-to-member types %qT and %qT lacks a cast"
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "在不同的成员指针类型%qT和%qT之间的比较需要一个类型转换"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "从%qT到%qT的转换增大了目标类型的对齐需求"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ 不允许在函数指针和对象指针间进行转换"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "从类型%qT到类型%qT的转换无效"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "在类型%qT上使用 const_cast 无效，因为它既不是指针，也不是引用，也不是数据成员指针"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "在类型%qT上使用 const_cast 无效，因为它是一个指针函数类型的指针或引用"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "从类型%qT到类型%qT中的 const_cast 无效"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "从类型%qT到类型%qT中的 const_cast 无效"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ 不允许转换为数组类型%qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "向函数类型%qT的转换无效"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "无法将%qE从类型%qT转换到类型%qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "在求%<%Q(%#T, %#T)%>值时"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "初始值设定中数组索引不是常数"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "将%qT赋值给%qT时类型不兼容"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, gcc-internal-format
 msgid "array used as initializer"
 msgstr "数组被用作初始值设定"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "无效的数组赋值"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "在成员函数指针转换中"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "成员指针转换经由虚基类%qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "在成员指针转换中"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "到类型%qT的转换无效，从类型%qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "不能在参数默认时将%qH转换为%qI"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "不能在传参时将%qH转换为%qI"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "不能在初始化时将%qH转换为%qI"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 msgid "cannot convert %qH to %qI in return"
 msgstr "不能在返回时将%qH转换为%qI"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "不能在赋值时将%qH转换为%qI"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "%2$qE的第 %1$d 个实参可能是 format 属性的备选"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "返回类型可能是 format 属性的备选"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "函数的实参可能是 format 属性的备选"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "初始化的左手边可能是 format 属性的备选时"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "赋值的左手边可能是 format 属性的备选时"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of %q+D"
 msgid "in passing argument %P of %qD"
 msgstr "在传递%2$q+D的第 %1$P 个实参时"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "返回临时变量的引用"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "返回临时变量的引用"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable %q+D returned"
 msgid "reference to local variable %qD returned"
 msgstr "返回了对局部变量的%q+D的引用"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 msgid "address of label %qD returned"
 msgstr "返回了局部变量的%q+D的地址"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of local variable %qD returned"
 msgstr "返回了局部变量的%q+D的地址"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 #| msgid "too many values in return statement"
 msgid "redundant move in return statement"
 msgstr "返回语句中值太多"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 #| msgid "too many values in return statement"
 msgid "redundant move in initialization"
 msgstr "返回语句中值太多"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "析构函数返回值"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "不能从构造函数的异常处理中返回"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "构造函数返回值"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "在返回%qT的函数中，返回语句不带返回值"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 msgid "returning initializer list"
 msgstr "<花括号内的初始值列表>"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "Lambda 返回类型演绎得到不一致的类型%qT和%qT"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, fuzzy, gcc-internal-format
 #| msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "对%qT不一致的演绎：先是%qT然后是%qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with no value, in function returning %qT"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "在返回%qT的函数中，返回语句不带返回值"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%>不能返回 NULL，除非它被声明为%<throw()%>(或 -fcheck-new 起作用)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 msgid "not eliding copy on return from %qD"
 msgstr "%q+#D的协变返回类型无效"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "右值的引用用作左值"
@@ -76551,17 +76735,17 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "不能设置只读属性"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 msgid "%q+D declared weak after being used"
 msgstr "%q+D声明为友元"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -76589,48 +76773,48 @@ msgstr "成员%qD缺少初始值设定"
 msgid "the address of %qD will never be %<null%>"
 msgstr "%qD的地址永远不会为 NULL"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "无法声明指向%q#T的指针"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "在目标文件中存储函数名"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "%qE既不是函数也不是成员函数；不能声明为友元"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, fuzzy, gcc-internal-format
 #| msgid "a destructor cannot be %<constexpr%>"
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr "析构函数不能是%<constexpr%>"
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qD used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "嵌套函数中使用了寄存器变量%qD"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 #| msgid "forming reference to reference type %qT"
 msgid "forward reference to frame of %qs"
@@ -76718,36 +76902,36 @@ msgstr "内建函数实参无效"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "内建函数实参无效"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "无法打开 %s 并写入：%m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "打开输出文件 %s：%m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "无法打开 %s 并写入：%m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "打开输出文件 %s：%m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -76852,7 +77036,7 @@ msgstr "未知的 TLS 模型 %qs"
 msgid "%qs is not an associative array"
 msgstr "%qs 不是一个关联数组"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -76868,23 +77052,23 @@ msgstr "%qD通常不是一个静态函数"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs 不是一个字段，而是一个 %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "与先前的声明%q+D不同"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "常量表达式溢出"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%qs 不是一个表达式"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not a constant expression"
 msgid "type %qs is not an expression"
@@ -76982,18 +77166,18 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "%<dynamic_cast%> not permitted with -fno-rtti"
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "在指定 -fno-rtti 的情况下不能使用%<dynamic_cast%>"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -77326,8 +77510,8 @@ msgstr "%C处的任何引用都不能多于 %d 维"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, fuzzy, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "集合数组在%C处被禁用，使用 -fcoarray= 来启用"
@@ -77611,7 +77795,7 @@ msgstr "名字列表 %s 不能为对 %s 的 USE 关联来更名"
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "‘我’于 %L 和‘J’于 %L 无法两者是 BOZ 实字常数"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "%2$C处 DATA 语句初始值设定 %1$s 无效"
@@ -77686,7 +77870,7 @@ msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须为实数型或复
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "实参‘%s’(属于内建函数‘%s’，位于 %L)必须为 INTEGER 或 PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
@@ -77828,7 +78012,7 @@ msgstr "%C处的 ENTRY 语句不能出现在嵌套的子程序中"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "%4$L处‘%3$s’内建函数的‘%1$s’和‘%2$s’实参类型必须相同"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "%L处指针赋值时秩不同"
@@ -77843,7 +78027,7 @@ msgstr "%L 的 NULL 指针不能用作内建函数‘%s’的实参"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须具有种别 %4$d"
@@ -77985,8 +78169,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, fuzzy, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "集合数组在%C处被禁用，使用 -fcoarray= 来启用"
@@ -78086,9 +78270,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "%C处的 ENTRY 语句不能出现在嵌套的子程序中"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "%L处内建 REPEAT 的 NCOPIES 实参是负的"
@@ -78103,12 +78287,12 @@ msgstr "%3$L处‘%2$s’内建函数的实参‘%1$s’在维数 %4$d (%5$ld/%6
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须有 %4$d 的秩或者是一个标量"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须为数字或 LOGICAL 型"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "%2$L处内建‘%1$s’的参数必须匹配(%3$s/%4$s)"
@@ -78204,625 +78388,625 @@ msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个常量"
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "%2$L处的内建函数‘%1$s’必须至少有两个实参"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "%3$L处内建‘%2$s’内建函数的‘%1$s’实参为空"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "‘%s’和‘%s’用作内建函数‘%s’的参数"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "‘%s’和‘%s’用作内建函数‘%s’的参数"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "%L处指针赋值时秩不同"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "%3$L处内建函数‘%2$s’的实参‘a%1$d’必须是 %4$s(%5$d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "%L处内建 REPEAT 的 NCOPIES 实参是负的"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "%2$L处‘%1$s’内建函数的‘a1’实参必须是 INTEGER、REAL 或 CHARACTER"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "%2$L处‘%1$s’内建函数的‘a1’实参必须是 INTEGER、REAL 或 CHARACTER"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "%3$L处矩阵乘法的两个参数‘%1$s’和‘%2$s’第一维的外形不相同"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "用作%3$L处矩阵乘法参数的‘%1$s’的第二维和‘%2$s’的第一维的外形不相同"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’的秩必须为 1 或 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个数组"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须为整数型或实数型"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "到参数在中 MOVE_ALLOC 于 %L 必须是 polymorphic 如果从是 polymorphic"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "%4$L处‘%3$s’内建函数的‘%1$s’和‘%2$s’实参必须有相同的秩 %5$d/%6$d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "%4$L处‘%3$s’内建函数的‘%1$s’和‘%2$s’实参必须有相同的秩 %5$d/%6$d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须为 ALLOCATABLE"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "Fortran 2003:空值 intrinsic 与 allocatable 铸型于 %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "%3$L处内建函数‘%2$s’的‘%1$s’实参类型必须为 REAL 或 INTEGER"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须至少具有与‘%4$s’(%5$ld/%6$d)中 .TRUE. 值一样多的元素"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个哑元"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个 OPTIONAL 哑元"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个变量"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "‘reshape’内建函数的‘shape’实参在%L处必须是大小为常量的数组"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "‘reshape’内建函数的‘shape’实参在%L处有多于 %d 个的元素"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "%3$L处内建‘%2$s’内建函数的‘%1$s’实参有负的元素(%4$d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "%3$L处‘%2$s’内建函数的‘%1$s’实参的元素数错误(%4$d/%5$d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "%3$L处内建‘%2$s’内建函数的‘%1$s’实参维数越界(%4$d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "%3$L处‘%2$s’内建函数的‘%1$s’实参维数置换无效(维数%4$d重复)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "若没有填充，%L处内建 ESHAPE 源中没有足够的元素去与外形匹配"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是 %4$s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须具有可扩展类型"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, fuzzy, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "Fortran 2008:SELECTED_REAL_KIND 与 neither‘P’nor‘R’参数于 %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "%L处内建 REPEAT 的 NCOPIES 实参是负的"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "‘shape’内建函数的‘source’实参在%L处不能是假定大小的数组"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个标量"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’不能是 INTENT(IN)"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "‘shape’内建函数的‘source’实参在%L处不能是假定大小的数组"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个数组"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD is not a function template"
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "%qD不是一个函数模板"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "缺少参数“%s”，在调用“%s”时，位于 %L"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "实际参数到‘%s’于 %L 必须是 polymorphic"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "实际参数到‘%s’于 %L 必须是 polymorphic"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "%2$L处的函数返回值‘%1$s’处没有隐式类型"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "%2$C处的过程‘%1$s’已经在%3$L处被定义"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "%C处的组件必须有 POINTER 属性"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "参数‘S’的最近的于 %L 不应该是零"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "缺少参数“%s”，在调用“%s”时，位于 %L"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "%C处 EQUIVALENCE 中的数组引用不能是个数组段"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "%2$L处 %1$s 内建函数缺少实参"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’秩必须小于 %4$d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "%3$L处‘%2$s’内建函数的‘%1$s’实参不是一个有效的维数索引"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "%3$L处内建函数‘%2$s’的‘%1$s’实参类型必须为默认实型"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "数组元素数量的子参数到 IMAGE_INDEX 于 %L 应该是 %d (corank) 无法 %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "给予函数 %s 的参数太多，于 %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, fuzzy, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "DIM 参数而无需数组参数不允许用于 THIS_IMAGE intrinsic 于 %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "无法检验状态：%s：%s\n"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "%L处‘TRANSER’内建函数的‘MOLD’参数不能是 %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "%L处‘TRANSER’内建函数的‘MOLD’参数不能是 %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "%L处‘TRANSER’内建函数的‘MOLD’参数不能是 %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 #, fuzzy
 #| msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld"
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "%L处内建 TRANSFER 有部分未定义的结果：源尺寸 %ld < 结果尺寸 %ld"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是标量或者具有与‘%4$s’一样的秩"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "%4$L处‘%3$s’内建函数的‘%1$s’和‘%2$s’实参必须有相同的外形。"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "%L处 ATANH 的参数必须在 -1 和 1 之间"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’的大小太小(%4$i/%5$i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "给予函数 %s 的参数太多，于 %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "模板参数数目不对(不应是 %d 个而应是 %d 个)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’的种别必须不能比默认种别(%4$d)宽"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "实参‘%s’(属于内建函数‘%s’，位于 %L)必须为 INTEGER 或 LOGICAL"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, fuzzy, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "%2$L处类型‘%1$s’达到了最大的扩展级别"
@@ -78890,12 +79074,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "初始化字符串被截断，以匹配%L处的变量"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "%L处的子字符串起始索引小于 1"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "%L处的子字符串终止索引超过了字符串长度"
@@ -78948,2124 +79132,2124 @@ msgstr "%2$C处有初始值设定的变量‘%1$s’已经出现在一个 DATA 
 msgid "Simplification error"
 msgstr "gimplification 失败"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "%2$C处主机相关的变量‘%1$s’不能出现在 DATA 语句中"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "扩展：DATA 语句中对公共块变量‘%s’在%C处初始化"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "%2$C处 DATA 语句中符号‘%1$s’必须是一个 PARAMETER"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "%2$C处 DATA 语句初始值设定 %1$s 无效"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%C处 ENTRY 语句不能出现在被包含的过程中"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "初始化不允许出现在%C处的 PURE 过程中"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "%C处的 ENTRY 语句不能出现在 INTERFACE 中"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid initializer %s in Data statement at %C"
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "%2$C处 DATA 语句初始值设定 %1$s 无效"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "%C处 ENTRY 语句不能出现在被包含的过程中"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "DATA 语句不允许出现在%C处的 PURE 过程中"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "创建旧风格表格"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array component of structure at %C must have an explicit shape"
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "%C处结构的数组组件必须有显式的外形"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "标量初始值设定中有多余元素"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "数组边界不是一个整数常量"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Expected data constant after repeat spec at %C"
 msgstr "%C处需要替代的返回标号"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "End of scalar initializer expected at %C"
 msgstr "%C处需要标量初始化表达式"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "数组初始值设定项中有多余的元素"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "数组初始值设定项中有多余的元素"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in OpenMP variable list at %C"
 msgid "Syntax error in old style initializer list at %C"
 msgstr "%C处的 OpenMP 变量列表语法错误"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "%C处错误的 INTENT 规格"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "%C处重复的 DEFERRED 语句"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "%C处字符长度规格语法错误"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "%C处字符长度规格语法错误"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "%2$C处的过程‘%1$s’已经在%3$L处被定义"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "%2$C处的过程‘%1$s’已经在%3$L处被定义"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is already defined as a generic interface at %L"
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "%2$C处的名字‘%1$s’已经在%3$L处被定义为泛型接口"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "过程‘%s’在%C处具有显式接口，因此不能有在%L处声明的属性"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "%2$L处的过程‘%1$s’必须有属性才能与 C 互操作"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "%2$L 处类型“%1$s”是去到 BIND(C) 过程“%3$s”的参数，但不能与 C 互操作，因为派生类型“%4$s”不是与 C 可互操作的"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "%2$L处变量‘%1$s’是 BIND(C) 过程‘%3$s’的参数，但它不能与 C 互操作"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "%2$L处变量‘%1$s’是 BIND(C) 过程‘%3$s’的参数，但它不能与 C 互操作"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "%2$L处变量‘%1$s’不能有 OPTIONAL 属性，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "%L处的哑过程不允许出现在 ELEMENTAL 过程中"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "%2$L处字符参数‘%1$s’长度必须为 1，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "%2$L处字符参数‘%1$s’长度必须为 1，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, fuzzy, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "%2$L处字符参数‘%1$s’长度必须为 1，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "%2$L处字符参数‘%1$s’长度必须为 1，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, fuzzy, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "%2$L处字符参数‘%1$s’长度必须为 1，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "%2$L处变量‘%1$s’不能有 ALLOCATABLE 属性，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "%2$L处变量‘%1$s’不能有 POINTER 属性，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "%2$L处变量‘%1$s’不能有 OPTIONAL 属性，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "%2$L处变量‘%1$s’不能有 OPTIONAL 属性，因为过程‘%3$s’是 BIND(C)"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "%2$L处假定外形数组‘%1$s’不能是%4$L处过程‘%3$s’的参数，因为该过程是 BIND(C)"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "符号‘%s’在%L处已经有了基本类型 %s"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "%3$C处公共块‘%2$s’中的变量‘%1$s’必须被声明为与 C 可互操作的种别，因为公共块‘%4$s’是 BIND(C)"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Different CHARACTER lengths (%d/%d) in array constructor at %L"
 msgid "CHARACTER length must be a constant at %L"
 msgstr "%3$L处数组构造函数中不同 CHARACTER 长度(%1$d/%2$d)"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CHARACTER expression at %L is being truncated (%d/%d)"
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "CHARACTER 表达式在%L处被截断(%d/%d)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The CHARACTER elements of the array constructor at %L must have the same length (%d/%d)"
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "%L处的数组构造函数的 CHARACTER 元素必须有相同的长度(%d/%d)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "PARAMETER‘%s’在%C处不允许有初始值设定"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "%L处 PARAMETER 缺少初始值设定"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "%2$C处有初始值设定的变量‘%1$s’已经出现在一个 DATA 语句中"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "不能用初始值设定项来初始化多维数组"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "%L处数组引用中秩不匹配(%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "不能用初始值设定项来初始化多维数组"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' at %L already is initialized at %L"
 msgid "Bad shape of initializer at %L"
 msgstr "%2$L处的‘%1$s’已于 %3$L处被初始化"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ISO C90 forbids variable length array %qE"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "ISO C90 不允许变长数组%qE"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "%C处数据声明语法错误"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "‘我’于 %L 和‘J’于 %L 无法两者是 BOZ 实字常数"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "%C处的组件必须有 POINTER 属性"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "%2$L处具有 CLASS 的组件‘%1$s’必须是可分配的或指针"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "%C处结构的数组组件必须有显式或延迟的外形"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "Component %qs at %C already declared at %L"
 msgstr "%2$C处的组件‘%1$s’已于 %3$L处被声明"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "%C处结构的指针数组组件必须有延迟的外形"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "%C处可分配的组件必须有延迟的外形"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "%C处结构的数组组件必须有显式的外形"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "带有省略号的形参列表无法与空形参名列表声明匹配"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "%C处的 NULL() 初始化有歧义"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "%C处的 NULL() 初始化有歧义"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "%C处对指针的初始化不允许出现在 PURE 过程中"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "%C处对指针的初始化不允许出现在 PURE 过程中"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "%C处的 NULL() 初始化有歧义"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, fuzzy, gcc-internal-format
 #| msgid "VALUE is not allowed inside of BLOCK at %C"
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "VALUE 不能用在%C处 BLOCK 内"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "为结构字段%2$qE指定了%1$qs"
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, gcc-internal-format
 msgid "%qs entity cannot have attributes at %C"
 msgstr "%qs 实体在 %C 处不能有属性"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character %qc in variable name at %C"
 msgstr "%C处的名字中有非法字符"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "指定CHARACTER(*) 函数‘%s’在%L处不能为指针值"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Fortran 2008：%L处格式中的‘G0’"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, fuzzy, gcc-internal-format
 #| msgid "%qs at %C is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr "%qs 在 %C 处是对对应接口中 MODULE PROCEDURE %qs 声明的重新定义"
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "%qs entity cannot have an initializer at %C"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "%qs 实体在 %C 处不能有初始化器"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate array spec for Cray pointee at %C"
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "%C处 Cray 指针重复指定了数组"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 msgid "Cannot set pointee array spec."
 msgstr "%C处 Cray 指针重复指定了数组"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "创建旧风格表格"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "引用类型的非法值初始化"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "%C处对指针的初始化不允许出现在 PURE 过程中"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "%C处的初始化不是为指针变量准备的"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "%C处的初始化不是为指针变量准备的"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "%C处需要一个初始化表达式"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "%C处对变量的初始化不允许出现在 PURE 过程中"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "不允许在%C处初始化可分配的组件"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Initialization of allocatable component at %C is not allowed"
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "不允许在%C处初始化可分配的组件"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "%3$L处‘%2$s’的指针组件‘%1$s’类型尚未声明"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "外部‘%s’在%L处不能有初始值设定"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "%3$C处旧式的类型声明 %1$s*%2$d 不受支持"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "%3$C处的 %1$s*%2$d 类型声明不符合标准"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "%C处缺少右括号"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "%C处需要初始化表达式"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "%C处需要标量初始化表达式"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "种别 %1$d 不为类型%3$C处 %2$s 所支持"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "C 种别类型参数对应类型 %s 但%L处的类型却是 %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "%C处缺少右括号或逗号"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "种别 %d 在%C处不为 CHARACTER 所支持"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "%C处 CHARACTER 声明语法错误"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "%C 需要一个无名接口"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Kind type parameter for entity at %L differs from the kind type parameter of the typespec"
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "%L实体的种别类型参数与类型限定中的种别类型参数不同"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 #| msgid "the first parameter of %<operator new%> cannot have a default argument"
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "%<operator new%>的第一个形参不能有默认参数"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "%2$L处数组‘%1$s’是个变量，不能被归约为常量表达式"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "%L处 PARAMETER 中派生类型不兼容"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "扩展：%C处的 BYTE 类型"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "%C处使用到的 BYTE 类型在目标机上不可用"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "%C处 TYPE 中的组件必须先于 CONTAINS"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr "%C处非预期的 TYPE IS 语句"
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "%C处类型指定无效"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid type-spec at %C"
 msgid "Malformed type-spec at %C"
 msgstr "%C处类型指定无效"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "扩展：‘%s’重初始化于 %L"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C is ambiguous"
 msgstr "%C处 TYPE 定义中的歧义符号"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "未定义 C++ 基类"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "类型名称‘%s’于 %C 冲突与在之前声明的实体于 %L, 该项有同名"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "%C处 IMPLICIT NONE 语句重复"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate IMPLICIT NONE statement at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "%C处 IMPLICIT NONE 语句重复"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "%C处 IMPLICIT 缺少字符范围"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "%C处 IMPLICIT 语句中的字母必须按序排列"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "%C处 SAVE 语句跟随空白 SAVE 语句"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "%C处 IMPLICIT 语句为空"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "%C处 IMPORT 语句只允许出现在接口体中"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "%C处 IMPORT 语句只允许出现在接口体中"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "%C处 IMPORT 语句只允许出现在接口体中"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-name %qs at %C is in the local scope"
 msgstr "在类作用域使用非成员的 using 声明"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "不能从%2$C处主机作用域单元 IMPORT‘%1$s’- 不存在。"
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, fuzzy, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "‘%s’已经从%C处主机作用域单元导入。"
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "%C处的 IMPORT 语句语法错误"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "%C处 IMPORT 语句只允许出现在接口体中"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "%C处 IMPORT 语句只允许出现在接口体中"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "%C处需要有名实体列表"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "%C处没有维数规格"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "%C处没有维数规格"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "重复的 %s 属性，位于 %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%2$L处的 %1$s 属性不允许出现在模块规格说明以外"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Attribute at %L is not allowed in a TYPE definition"
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "%C处 ASYNCHRONOUS 语句语法错误"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "%C处需要绑定属性"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "%C处的 PROTECTED 仅允许出现在模块规格说明部分内"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "%C处 PROTECTED 语句语法错误"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "%L处指定了重复的 VALUE 属性"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "%C处的 VOLATILE 语句语法错误"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "%C处为单个 NAME= 指定了多个标识符"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, fuzzy, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "%2$L处隐式声明的 BIND(C) 函数‘%1$s’不能与 C 互操作"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "%3$L处的公共块‘%2$s’中的变量‘%1$s’可能不是 C 互操作种别，即使公共块‘%4$s’是 BIND(C)"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, fuzzy, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "%2$L处的类型声明‘%1$s’不是与 C 可互操作的，但它是个 BIND(C)"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "%2$L处的变量‘%1$s’无法与 C 互操作但被声明为 BIND(C)"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "%3$L处的公共块‘%2$s’中的变量‘%1$s’不能被声明为 BIND(C)，因为它不是全局的"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "%2$L处变量‘%1$s’不能既有 ALLOCATABLE 又有 BIND(C) 属性"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "%2$L处的BIND(C) 函数‘%1$s’不能返回一个数组"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "%2$L处的BIND(C) 函数‘%1$s’不能返回一个字符串"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "%2$L处符号‘%1$s’被标记为 PRIVATE 但是已经给定绑定标号‘%3$s’"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "%C处的属性规格说明语句需要实体或公共块名"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "%C处的属性规格说明语句缺少实体或公共块名"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 msgid "Missing symbol"
 msgstr "%s:%d: 缺少新的符号名称"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "%C处的 BIND(C) 中不允许有绑定名"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "%C处的派生类型以前尚未被定义，因此不能出现在派生类型定义中"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "%C处数据声明语法错误"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "%C处数据声明语法错误"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "初始化不允许出现在%C处的 PURE 过程中"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "%C处的 MODULE PROCEDURE 必须在一个泛型接口内"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "初始化不允许出现在%C处的 PURE 过程中"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE 和 IMPURE 必须不出现两者于 %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "%C处 PROCEDURE 语句语法错误"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "缺少前导左括号"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate-return argument at %C"
 msgstr "%L 不带 * 虚参的替代返回"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "缺少前导左括号"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "%C处期待模块过程名"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "%C处数组声明需要另外一维"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "%C处形参列表中有非预期的垃圾字符"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "重复的汇编操作数名%qs"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "符号‘%s’在%C处的形参列表中重复出现"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "%L处 PURE 过程不能指定 SAVE 属性"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr "MODULE PROCEDURE 的形式参数是替代返回值，并且与在 %2$C 处单独声明中的 %1$qs 发生冲突"
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "%C处 PROCEDURE 语句语法错误"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "%C处 RESULT 变量不能与函数重名"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "%C处的函数声明后有非预期的垃圾字符"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Fortran 2008：%L处的 BIND(C)属性对于内部过程不可以指定"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "%C处的 BIND(C) 属性要求一个具有 BIND(C)的接口"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "%C处带有 NAME 的 BIND(C)过程不能有 POINTER 属性"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "%C处的哑过程不能有带有 NAME 的 BIND(C) 属性"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "符号‘%s’在%L处已经有了基本类型 %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "%C处 PROCEDURE 语句语法错误"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "%C 处的泛型绑定后有垃圾字符"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "%C处需要 NOPASS 或显式接口"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "%C处需要一个类型限定的过程或过程指针组件"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "%C处过程指针组件语法错误"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "%C处的 PROCEDURE 必须在一个泛型接口内"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "%C处 PROCEDURE 语句语法错误"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "%C处 PROCEDURE 语句语法错误"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "函数定义在%C处需要形参列表"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "%L处的 BIND(C) 属性只能用于变量或公共块"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "%C处的 ENTRY 语句不能出现在 BLOCK DATA 中"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "%C处的 ENTRY 语句不能出现在 PROGRAM 中"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "%C处的 ENTRY 语句不能出现在 MODULE 中"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "%C处的 ENTRY 语句不能出现在 MODULE 中"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "%C处的 ENTRY 语句不能出现在 BLOCK DATA 中"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "%C处的 ENTRY 语句不能出现在 INTERFACE 中"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "%C处的 ENTRY 语句不能出现在 SELECT 块中"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "%C处的 ENTRY 语句不能出现在 DERIVED TYPE 块中"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "%C处的 ENTRY 语句不能出现在 IF-THEN 块中"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "%C处的 ENTRY 语句不能出现在 DO 块中"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "%C处的 ENTRY 语句不能出现在 SELECT 块中"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "%C处的 ENTRY 语句不能出现在 FORALL 块中"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "%C处的 ENTRY 语句不能出现在 WHERE 块中"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "%C处的 ENTRY 语句不能出现在嵌套的子程序中"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected ENTRY statement at %C"
 msgstr "%C处非预期的 CASE 语句"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "%C处 ENTRY 语句不能出现在被包含的过程中"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "%C 处 BIND(C) 前缺少要求的括号"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "%C处 ENTRY 语句不能出现在被包含的过程中"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Alternate return cannot appear in operator interface at %L"
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "替代返回不能出现在%L处的运算符接口中"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "%C处的名字中有非法字符"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "%C绑定标号的 NAME= 限定符语法错误"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "必须为%L处的 ASYNCHRONOUS= 指定一个初始化表达式"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "%C处绑定标号缺少右括号"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "%C处的 BIND(C) 中不允许有绑定名"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "对于哑过程 %s，%C 处的 BIND(C) 中不允许有绑定名"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "%C 处的 ABSTRACT INTERFACE 的 BIND(C)上不允许有 NAME"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "%C处非预期的 END 语句"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "%s 语句在%C处不能跟随 %s 语句在%L处"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "需要 %s 语句在%L处"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting %s statement at %L"
 msgstr "需要 %s 语句在%L处"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "需要块名‘%s’在‘%s’表达式中，于 %C"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "%C处需要结束名"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 msgid "Expected label %qs for %s statement at %C"
 msgstr "%2$C处需要 %1$s 语句"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "%L处的 DIMENSION 语句缺少数组规格"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dimensions specified for %s at %L after its initialisation"
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "%2$L处在初始化后为 %1$s 指定了维数"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "%L处的 DIMENSION 语句缺少数组规格"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "%L处数组规格必须延迟"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "%C处变量列表中有非预期的垃圾字符"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, gcc-internal-format
 msgid "Expected %<(%> at %C"
 msgstr "在%C处需要%<(%>"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "在%C处需要变量名"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "%C处 Cray 指针必须是一个整数"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "%C处的 Cray 指针精度为 %d；内存地址需要 %d 字节"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "在%C处需要“,”"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 msgid "Cannot set Cray pointee array spec."
 msgstr "%C处 Cray 指针重复指定了数组"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "%C处 Cray 指针重复指定了数组"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "在%C处需要“)”"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, gcc-internal-format
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "在%C处需要%<,%>或"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "INTENT 不能用在%C处 BLOCK 内"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "OPTIONAL 不能用在%C处 BLOCK 内"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 #| msgid "Cray pointer declaration at %C requires -fcray-pointer flag"
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "%C处的 Cray 指针声明需要 -fcray-pointer 标记"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "%C处的语句标号为零"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "%2$C处的 %1$s 运算符的访问规格说明已经被指定"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "%2$C处的 .%1$s. 运算符的访问规格说明已经被指定"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "%C处 PROTECTED 语句语法错误"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "%C处 PROTECTED 语句语法错误"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "%C处的 PRIVATE 语句仅允许出现在模块规格说明部分内"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "%C处的 PUBLIC 语句只不允许出现在模块规格说明部分内"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "%C处的 PARAMETER 语句需要变量名"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "%C 在 PARAMETER 语句中需要 = 符号"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "%C 在 PARAMETER 语句中需要表达式"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "%C处初始化已经初始化的变量"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "%C处 PARAMETER 语句中有非预期的字符"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "%C READ 语句需要变量"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in VOLATILE statement at %C"
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "%C处的 VOLATILE 语句语法错误"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "%C READ 语句需要变量"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "%C SAVE 语句语法错误"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "%C处覆盖 SAVE 语句跟随以前的 SAVE 语句"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "%C处 SAVE 语句跟随空白 SAVE 语句"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "Fortran 2003：%2$L处的 COMMON 块‘%1$s’也是一个函数返回值"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "%C SAVE 语句语法错误"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "VALUE 不能用在%C处 BLOCK 内"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "%C处 VALUE 语句语法错误"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "%C处 VALUE 语句语法错误"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "%C处的 VOLATILE 语句语法错误"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "指定易变的用于 coarray 变量‘%s’于 %C, 该项是 use-/ host-associated"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "%C处的 VOLATILE 语句语法错误"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "%C处 ASYNCHRONOUS 语句语法错误"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "%C处 ASYNCHRONOUS 语句语法错误"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "%C处需要实参列表"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "%C处的 MODULE PROCEDURE 必须在一个泛型接口内"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "%L处内建过程不能是 MODULE PROCEDURE"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "%C处 TYPE 定义中的歧义符号"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "%2$C处符号‘%1$s’已经与主机相关联"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, fuzzy, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "C++ 不允许在%qs表达式中定义类型"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "%2$C 处‘%1$s’不能被扩展，因为它是 BIND(C)"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "%2$C 处‘%1$s’不能被扩展，因为它是 SEQUENCE 类型"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "%C处的派生类型在模块规格说明部分内只能是 PRIVATE"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "%C处的派生类型在模块规格说明部分内只能是 PUBLIC"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "%q+D的抽象类型无效"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to create structure type '%s' at %C"
 msgstr ""
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "%2$C处的派生类型‘%1$s’定义已经被定义"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "%C处 ELSE 语句后有非预期的垃圾字符"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "%C处 ELSE 语句后有非预期的垃圾字符"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, fuzzy, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr "为结构字段%2$qE指定了%1$qs"
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "%C处的函数声明后有非预期的垃圾字符"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "%C处 ELSE 语句后有非预期的垃圾字符"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "类型‘%s’(位于 %C)不能与内建类型重名"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "%C 在 TYPE 定义中需要 ::"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "%C处的 GENERIC 必须是在派生类型 CONTAINS 内"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "类型‘%s’(位于 %C)不能与内建类型重名"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "%2$C处的派生类型名“%1$s”已经有一个基本类型 %3$s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "%2$C处的派生类型名“%1$s”已经有一个基本类型 %3$s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "%L处运算符接口的第一个参数不能是可选的"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "%2$C处的派生类型‘%1$s’定义已经被定义"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "%C处 CHARACTER 声明语法错误"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "%C处 Cray 指针不能指向假定外形数组"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "C++ 禁止在赋值时进行枚举转换"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "%C处：枚举量超过 C 整数类型"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "ENUMERATOR %L没有用整数表达式初始化"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "%C 前需要 ENUM 定义语句"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "%C处 ENUMERATOR 定义中语法错误"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "%C处重复访问限定符"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "捆绑属性已经指定传递，%C处 NOPASS 非法"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "捆绑属性已经指定传递， %C处 PASS 非法"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "%C处 POINTER 属性重复"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "%C处 NON_OVERRIDABLE 重复"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "%C处重复的 DEFERRED 语句"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "%C需要访问限定符"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "%C处需要绑定属性"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "NON_OVERRIDABLE and DEFERRED can't both appear at %C"
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE 和 DEFERRED 不能同时出现在%C处"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "%C处的过程指针组件需要 POINTER 属性"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "%C 需要一个无名接口"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "在%C处需要“,”"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "%C处必须为 DEFERRED 绑定指定接口"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "%C处的 PROCEDURE(接口) 需要声明为 DEFERRED"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "%C处需要绑定名"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "%C处需要实参列表"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, fuzzy, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "%C处必须为 DEFERRED 绑定指定接口"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, fuzzy, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "%C处与显式目标捆绑的 PROCEDURE 中需要‘::’"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "%C 处的泛型绑定后有垃圾字符"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, fuzzy, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "%2$C处包含 DEFERRED 绑定的类型‘%1$s’不能是 ABSTRACT"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, fuzzy, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "在 %3$C 处对于派生类型“%2$s”已经有一个非普通的过程用限定名“%1$s”"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "在%C处需要%<::%>"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "%C处需要泛型名或运算符描述子"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "%C处的 USE 语句缺少泛型规格"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "在%C处需要“,”"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Range specification at %L can never be matched"
 msgid "The access specification at %L not in a module"
 msgstr "%L处范围规格无法匹配"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, fuzzy, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr "%C处期待模块过程名"
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "%3$C处派生类型‘%2$s’已经有一个绑定名为‘%1$s’的非泛型过程"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "%2$C处的 %1$s 运算符的访问规格说明已经被指定"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 #| msgid "Access specification of the %s operator at %C has already been specified"
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "%2$C处的 %1$s 运算符的访问规格说明已经被指定"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "%C处的绑定必须有与已经定义的绑定‘%s’相同的访问权限"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected module procedure name at %C"
 msgid "Expected specific procedure name at %C"
 msgstr "%C处期待模块过程名"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "%3$C处‘%1$s’已经定义为泛型的‘%2$s’特定的限定"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "%C处 ELSE 语句后有非预期的垃圾字符"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "%C处的 GENERIC 必须是在派生类型 CONTAINS 内"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "%3$C处派生类型‘%2$s’已经有一个绑定名为‘%1$s’的非泛型过程"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, fuzzy, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "%C处的绑定必须有与已经定义的绑定‘%s’相同的访问权限"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "%C处需要特定的绑定名"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "%3$C处‘%1$s’已经定义为泛型的‘%2$s’特定的限定"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "%C 处的泛型绑定后有垃圾字符"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "%C处的 FINAL 声明必须在一个派生类型的 CONTAINS 节内"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "%C处带有 FINAL 的派生类型声明必须在 MODULE 的规格说明部分内"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "%C处的 FINAL 为空"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "%C处期待模块过程名"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, gcc-internal-format
 msgid "Expected %<,%> at %C"
 msgstr "在%C处需要%<,%>"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "未知的 C++ 编码名称"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "%2$C处的过程‘%1$s’已经在%3$L处被定义"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "%C处 !GCC$ ATTRIBUTES 语句中有未知的属性"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "%C处 !GCC$ ATTRIBUTES 语句中的语法错误"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "%C处 FORALL 游标语法错误"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "%C处 FORALL 游标语法错误"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "%C处 FORALL 游标语法错误"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -81211,412 +81395,412 @@ msgstr "初始化不允许出现在%C处的 PURE 过程中"
 msgid "IM part_ref at %C"
 msgstr "初始化不允许出现在%C处的 PURE 过程中"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "%C处基本函数的实参不兼容"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "%L处的表达式中需要数字或 CHARACTER 操作数"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "%L处表达式中的毗连运算符必须有两个 CHARACTER 操作数"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "%L处的毗连运算符必须毗连同一种别的字符串"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "%L处的表达式中的 .NOT. 运算符必须带 LOGICAL 操作数"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "%L处的表达式需要 LOGICAL 操作数"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "%L处只有内建运算符才能用于表达式中"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "%L处的表达式需要数字操作数"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "%2$L处结构构造函数中 ALLOCATABLE 组件‘%1$s’的初始化表达式无效"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "%2$L处常量表达式中有假定字符长度变量‘%1$s’"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "必须为%L处的 ASYNCHRONOUS= 指定一个初始化表达式"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "%2$L处 PARAMETER‘%1$s’在其定义完全之前被使用"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L处的假定大小数组‘%1$s’不能用在初始化表达式中"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L处假定外形数组‘%1$s’不能用在初始化表达式中"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L处假定外形数组‘%1$s’不能用在初始化表达式中"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L处的延迟数组‘%1$s’不允许出现在初始化表达式中"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "%2$L处数组‘%1$s’是个变量，不能被归约为常量表达式"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "%2$L处假定外形数组‘%1$s’不能用在初始化表达式中"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "参数’%s在%L处尚未声明或者是一个不能被归约为常量表达式的变量"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 msgid "check_init_expr(): Unknown expression type"
 msgstr "需要表达式类型"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "%2$L处规格函数‘%1$s’不能是一个语句函数"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "%2$L处规格函数‘%1$s’不能是一个内部函数"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L must be PURE"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "%2$L处规格函数‘%1$s’不能是 RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "虚参‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "%L处运算符接口的第一个参数不能是可选的"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "%2$L处的‘%1$s’虚参不能是 INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "变量‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 msgid "check_restricted(): Unknown expression type"
 msgstr "需要表达式类型"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "%L处内建运算符接口必须是一个 FUNCTION"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "%L处的表达式必须具有标量类型"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "%4$L%1$s 中秩(%2$d 和 %3$d)不兼容"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "%2$L处 %1$s 在第 %3$d 维上外形不同(%4$d 和 %5$d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "使用模板类型形参%qT，在%qs后"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr "不能在%2$C处的 PURE 过程中读取变量‘%1$s’"
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "%2$L 处的 %1$qs 不是一个 VALUE"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "%L 零间隔非法"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "赋值中有不兼容的秩 %d 和 %d，位于 %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "%L处赋值中的变量类型是 UNKNOWN"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "%L处赋值右手边出现 NULL"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "%L处赋值右手边出现值为 POINTER 的函数"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr "%L处指针赋值时参数种别类型不同"
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "%L处 DATA 语句中类型不兼容；试图从 %s 转换到 %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "%L处指针赋值的目标不是一个 POINTER"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, fuzzy, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "%2$L处指针赋值中的‘%1$s’不能是一个左值，因为它是一个过程"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "%2$L处‘%1$s’需要边界规格"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Fortran 2003：%2$L处指针赋值语句中‘%1$s’的边界规格"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "%L 零间隔非法"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "外部对象‘%s’在%L处不能有初始值设定"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "%L处过程指针赋值非法"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "语句函数‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "抽象接口‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "语句函数‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "内部过程‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "%L处过程指针赋值非法"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "内部过程‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "%L处过程指针赋值不匹配：调用约定不匹配"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 #| msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "%L处过程指针赋值中接口不匹配：%s"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "%C处需要 NOPASS 或显式接口"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "%C处需要 NOPASS 或显式接口"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "%L处过程指针赋值中接口不匹配：%s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment target is not a POINTER at %L"
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "%L处指针赋值的目标不是一个 POINTER"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "%L处指针赋值时类型不同；试图将 %s 赋值给 %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "%L处指针赋值时参数种别类型不同"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "%L处指针赋值时秩不同"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "分级重新映射目标是小于大小的指标 (%ld<%ld) 于 %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "分级重新映射目标必须是分级 1 或仅需 contiguous 于 %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Fortran 2008：%L处格式中的‘G0’"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
@@ -81624,197 +81808,197 @@ msgstr "%L处数据传输元素不能有 POINTER 组件"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "%L处计算转移 GOTO 语句的选择表达式必须是一个标量整数表达式"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "%L 处指针赋值目标对象有 PROTECTED 属性"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "必须为%L处的 ASYNCHRONOUS= 指定一个初始化表达式"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "%L处指针赋值的目标既不是 TARGET 也不是 POINTER"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "%L处 PURE 过程中指针赋值目标错误"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "%L处指针赋值的右手边带有向量下标"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "%L处指针赋值目标对象有 PROTECTED 属性"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "%L处指针赋值的目标既不是 TARGET 也不是 POINTER"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "%L处的分配对象必须是 ALLOCATABLE 或 POINTER"
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "%L 处指针赋值目标对象有 PROTECTED 属性"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "%2$L 处的对象“%1$s”对于成分的默认初始化必须有 SAVE 属性，"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "%L处 PURE 过程中指针赋值目标错误"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "内部过程‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "内部过程‘%s’在%L处的过程指针赋值中是非法的"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2003：%L处初始化表达式中非整数指数"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Non-variable 运算式在中变量定义语境 (%s) 于 %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "变量‘%s’在%L处上下文中必须是常量"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "%L处的属性不允许出现在 TYPE 定义中"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Non-POINTER 在中指标关联语境 (%s) 于 %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "变量‘%s’在%L处上下文中必须是常量"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "变量‘%s’在%L处上下文中必须是常量"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "变量‘%s’在%L处上下文中必须是常量"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "变量‘%s’在%L处上下文中必须是常量"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "虚参‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "虚参‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "变量‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "变量‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "变量‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "变量‘%s’在%L处上下文中必须是常量"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "变量‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "变量‘%s’不能出现在%L处的表达式中"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Associate-name‘%s’无法出现在中变量定义语境 (%s) 于 %L 因为它的目标于 %L 无法，还是"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "‘%s’于 %L 关联的到运算式无法已用于变量定义语境 (%s)"
@@ -81837,7 +82021,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -81900,42 +82084,42 @@ msgstr "变量‘%s’(位于 %C)不能在从 %L 开始的循环的内部重定
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "变量‘%s’(位于 %C)不能在从 %L 开始的循环的内部重定义"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "%1$L处数组引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "%1$L处数组引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "变量‘%s’(位于 %C)不能在从 %L 开始的循环的内部重定义"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "变量‘%s’(位于 %C)不能在从 %L 开始的循环的内部重定义"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr "循环变量"
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison between %qT and %qT"
 msgid "%s between %L and %L"
@@ -82061,12 +82245,12 @@ msgstr "%L处定义赋值的第一个参数必须是 INTENT(OUT) 或 INTENT(INOU
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "%L处定义赋值的第二个参数必须是 INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "%L处运算符接口的第一个参数必须是 INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "%L处运算符接口的第二个参数必须是 INTENT(IN)"
@@ -82496,311 +82680,316 @@ msgstr "%L处 FINAL 过程的参数必须不是 ALLOCATABLE"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, fuzzy, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "%L处带有向量下标的数组节实际参数与虚参‘%s’的 INTENT(OUT)、INTENT(INOUT) 或 VOLATILE 属性不兼容"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "%L处假定外形的实参由于 VOLATILE 属性而与非假定外形虚参‘%s’不兼容"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, fuzzy, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "%L处数组节实参由于 VOLATILE 属性而与非假定外形虚参‘%s’不兼容"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "%L处指针数组的实参由于 VOLATILE 属性要求一个假定外形或指针数组虚参‘%s’"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, fuzzy, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "%L处假定外形的实参由于 VOLATILE 属性而与非假定外形虚参‘%s’不兼容"
+
+#: fortran/interface.cc:4181
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "%L处子进程调用缺少替代返回限定"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "%C处的实参数列中缺少关键字名"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, fuzzy, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "%5$L处同样的实际参数与 INTENT(%1$s) 实参‘%2$s’和 INTENT(%3$s)实参‘%4$s’相关联"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "%L处的过程参数对于 PURE 过程是局部的，但是有 POINTER 属性"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "%L处的过程参数对于 PURE 过程是局部的而被传递给一个 INTENT(%s) 参数"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "%L处的过程参数对于 PURE 过程是局部的而被传递给一个 INTENT(%s) 参数"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, fuzzy, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "%L处的过程参数对于 PURE 过程是局部的而被传递给一个 INTENT(%s) 参数"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "%2$L处调用的过程‘%1$s’不是显式声明的"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "%2$L处调用的过程‘%1$s’不是显式声明的"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "调用过程‘%s’带隐式接口，位于 %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, fuzzy, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "过程‘%s’在%C处具有显式接口，因此不能有在%L处声明的属性"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, fuzzy, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "过程‘%s’在%C处具有显式接口，因此不能有在%L处声明的属性"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "%2$L处的自动字符长度函数‘%1$s’必须有一个显式的接口"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "%C处需要 NOPASS 或显式接口"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "%2$L处过程‘%1$s’的关键字参数要求显式的接口"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "符号‘%s’在%L处已经有了显式接口"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, fuzzy, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "%3$L处‘%2$s’的虚参‘%1$s’应该命名为‘%4$s’以匹配被覆盖过程的相应参数"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, fuzzy, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "%3$L处‘%2$s’的虚参‘%1$s’应该命名为‘%4$s’以匹配被覆盖过程的相应参数"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "铸型参数到空值必要项于 %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "符号‘%s’在%L处已经有了显式接口"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "%2$L处过程‘%1$s’的关键字参数要求显式的接口"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "%2$L调用过程指针组件‘%1$s’时有隐式接口"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "%2$L处过程指针组件‘%1$s’的关键字实参需要显式接口"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "铸型=必要项在中空值() 参数于 %L:模棱两可介于特定的函数 %s 和 %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "在类%qs中找不到可溢出的寄存器"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "%2$C处实体‘%1$s’已经出现在接口中"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "不能覆盖%2$L处的 GENERIC‘%1$s’"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "%2$L处的‘%1$s’覆盖了一个绑定声明为 NON_OVERRIDABLE 的过程"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "%2$L处的‘%1$s’不能被 DEFERRED，因为它覆盖了一个非 DEFERRED 绑定"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "%2$L处的‘%1$s’覆盖了一个 PURE 过程因此必须也是 PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "%2$L处的‘%1$s’覆盖了一个 ELEMENTAL 过程因此也必须是 ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "%2$L处的‘%1$s’覆盖了一个非 ELEMENTAL 过程因此必须也不是 ELEMENTAL"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "%2$L处的‘%1$s’覆盖了一个 SUBROUTINE 因此也必须是 SUBROUTINE"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "哑过程‘%s’接口在%L处不匹配：%s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "%2$L处的‘%1$s’覆盖了一个 PUBLIC 过程因此必须不是 PRIVATE"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "%3$L处‘%2$s’的虚参‘%1$s’应该命名为‘%4$s’以匹配被覆盖过程的相应参数"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, fuzzy, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "哑过程‘%s’接口在%L处不匹配：%s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "%2$L处的‘%1$s’必须有与被覆盖的过程相同数量的形式参数"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "%2$L处的‘%1$s’覆盖了一个 NOPASS 绑定因此必须也是 NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "%2$L处的‘%1$s’覆盖了一个具有 PASS 的绑定因此也必须是 PASS"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "%2$L处的‘%1$s’的传递对象虚参必须与被覆盖的过程传递对象的虚参位置相同"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "%s 标记在%L处必须具有类型 %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "%L处实参维数必须具有 INTEGER 类型"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr "%L处内建运算符接口必须是一个 FUNCTION"
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "%3$L处有字符值的 %1$s‘%2$s’不能是假定长度的"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "%2$L处的‘%1$s’虚参不能是 INTENT(OUT)"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "DATA 语句不允许出现在%C处的 PURE 过程中"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "过程‘%s’(在 %s 中，位于 %L) 既不是函数也不是子进程"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "给予函数 %s 的参数太多，于 %L"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
 msgstr "给予函数 %s 的参数太多，于 %L"
@@ -82991,7 +83180,7 @@ msgstr "从 %s 转换到 %s，位于 %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -83568,7 +83757,7 @@ msgstr "名称表列‘%s’在中读取叙述于 %L 含有符号‘%s’该项
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "%3$L处 NAMELIST 数组对象‘%1$s’在名字列表‘%2$s’不能有 POINTER 组件"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "%3$L处 NAMELIST 数组对象‘%1$s’在名字列表‘%2$s’必须有 ALLOCATABLE 组件"
@@ -83748,12 +83937,12 @@ msgstr "整数溢出"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -84271,7 +84460,7 @@ msgstr "停止编码于 %L 必须是缺省字符 KIND=%d"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "%C处 Cray 指针必须是一个整数"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
@@ -84798,95 +84987,95 @@ msgstr "%2$C处需要 SELECT 构造的块名‘%1$s’"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "%C处的 ENTRY 语句不能出现在嵌套的子程序中"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "%C处 PROTECTED 语句语法错误"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "%C处 SELECT TYPE 中的选择子不是一个有名变量；请使用 associate-name=>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "%C处的语句标号为零"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, gcc-internal-format, gfc-internal-format
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr ""
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "%C处 PROTECTED 语句语法错误"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "%C处非预期的 CASE 语句"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "%C处 CASE 规格语法错误"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "%C处非预期的 TYPE IS 语句"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "%C处 TYPE IS 规格语法错误"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "%C处 CLASS IS 规格语法错误"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "%C处非预期的 END 语句"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL stride expression at %L must be a scalar %s"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "%L处 FORALL 间隔表达式必须是一个标量 %s"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CASE specification at %C"
 msgid "Syntax error in RANK specification at %C"
 msgstr "%C处 CASE 规格语法错误"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "%C处的 ELSEWHERE 语句不在 WHERE 块中"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "%2$C处的标号‘%1$s’不匹配 WHERE 标号‘%3$s’"
@@ -85911,7 +86100,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "%L处的 NUM_THREADS 分句需要一个标量 INTEGER 表达式"
@@ -85947,12 +86136,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "%C处 ELSE IF 语句后有非预期的垃圾字符"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -86449,7 +86638,7 @@ msgstr "%C处 ELSE 语句后有非预期的垃圾字符"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "%L处的 NUM_THREADS 分句需要一个标量 INTEGER 表达式"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
@@ -86469,7 +86658,7 @@ msgstr "%3$L处 %2$s 分句中的 Cray 指针‘%1$s’"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "%3$L处 %2$s 分句中 的Cray 指针目标‘%1$s’"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, fuzzy, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "%3$L处 %2$s 分句中的 POINTER 对象‘%1$s’"
@@ -86499,17 +86688,17 @@ msgstr "%3$L处 %2$s 分句中假定大小的数组‘%1$s’"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "%3$L处 %2$s 分句中的 POINTER 对象‘%1$s’"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "%3$L处 %2$s 分句中的 Cray 指针‘%1$s’"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "%3$L处 %2$s 分句中 的Cray 指针目标‘%1$s’"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "%3$L处 %2$s 分句中的 POINTER 对象‘%1$s’"
@@ -86631,8 +86820,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
@@ -86715,7 +86904,7 @@ msgstr "可变大小的对象不能被初始化"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "可变大小的对象不能被初始化"
@@ -86738,7 +86927,7 @@ msgstr ""
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "%2$L处符号‘%1$s’出现在多个分句上"
@@ -86779,7 +86968,7 @@ msgstr "%2$L处符号‘%1$s’出现在多个分句上"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE在数据子句中多次出现"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -87097,612 +87286,622 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, fuzzy, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, fuzzy, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, fuzzy, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr "向量 delete 的实参类型既非指针也非数组"
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "%qD的枚举值不是一个整数常量"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "%L处的 SCHEDULE 分句的 chunk_size 需要一个标量 INTEGER 表达式"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "-frepo 必须与 -c 一起使用"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "%4$L%1$s 中秩(%2$d 和 %3$d)不兼容"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr "%<#pragma omp taskwait%>只能用在复合语句中"
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "外部对象‘%s’在%L处不能有初始值设定"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "外部对象‘%s’在%L处不能有初始值设定"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, gcc-internal-format
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "%C处需要标量初始化表达式"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr "%L处 !$OMP ATOMIC 内建函数的实参必须是标量"
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值“变量 = 变量 运算符 表达式”中的“表达式”必须是标量并且不能引用“变量”"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "!$OMP 基元的截取截取叙述读取从不同的变量比更新叙述写入进入于 %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, fuzzy, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "!$OMP 基元的截取截取叙述读取从不同的变量比更新叙述写入进入于 %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值“变量 = 变量 运算符 表达式”中的“表达式”必须是标量并且不能引用“变量”"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值运算符必须是 +、*、-、/、.AND.、.OR.、.EQV. 或 .NEQV."
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值形式必须为“变量 = 变量 运算符 表达式”或“变量 = 表达式 运算符 变量”"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "%L处 !$OMP ATOMIC“变量 = 变量 运算符 表达式”与“变量 = 变量 运算符 (表达式)”在数学上不等价"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值“变量 = 变量 运算符 表达式”中的“表达式”必须是标量并且不能引用“变量”"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值内建函数 IAND、IOR 或 IEOR 必须带两个实参"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "%L处!$OMP ATOMIC 赋值内建函数必须是 MIN、MAX、IAND、IOR 或 IEOR"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, fuzzy, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "!$OMP ATOMIC 内建函数的实参除一个以外不能在%2$L处引用‘%1$s’"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "%L处 !$OMP ATOMIC 内建函数的实参必须是标量"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, fuzzy, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "第一个或最后一个 !$OMP ATOMIC 内建函数实参在%2$L处必须是‘%1$s’"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "%L处 !$OMP ATOMIC 赋值的右手边必须有一个运算符或内建函数"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "%C处 ELSE IF 语句后有非预期的垃圾字符"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%L处 !$OMP DO 不能是一个 DO WHILE 或不带循环控制的 DO"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr "%L处的 DO 循环中的步进表达式不能为零"
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "%L处 !$OMP DO 迭代变量不能是 THREADPRIVATE"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "%L处 !$OMP DO 迭代变量出现在非 PRIVATE 或 LASTPRIVATE 分句中"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "%L处 !$OMP DO 迭代变量出现在非 PRIVATE 或 LASTPRIVATE 分句中"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "iteration variable %qE should not be reduction"
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "迭代变量%qE不应当是 reduction"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "invalid type for iteration variable %qE"
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "迭代变量%qE类型无效"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "%L处折叠的 !$OMP DO 没有足够的 DO 循环"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "折叠的 !$OMP DO 循环没有完美的嵌套于%L处"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "折叠的 !$OMP DO 循环没有完美的嵌套于%L处"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 #| msgid "collapse argument needs positive constant integer expression"
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "折叠参数需要正整常量表达式"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "%2$L处 %1$s 函数的参数是负的"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be an integer expression at %L"
 msgstr "需要整数表达式"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected integer expression"
 msgid "property must be a constant integer expression at %L"
 msgstr "需要整数表达式"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr "%H折叠变量需要正整常数表达式"
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "%L处 !$OMP DO 不能是一个 DO WHILE 或不带循环控制的 DO"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr "%L处的 DO 循环中的步进表达式不能为零"
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "%L处 !$OMP DO 迭代变量必须具有整数类型"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "%L处 !$OMP DO 折叠的循环不形成矩形迭代空间"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "折叠的 !$OMP DO 循环没有完美的嵌套于%L处"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "%L处折叠的 !$OMP DO 没有足够的 DO 循环"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, fuzzy, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "可变大小的对象不能被初始化"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, fuzzy, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "%L过程参数无效"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, fuzzy, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "%C处公共块名语法错误"
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, fuzzy, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr "%C处公共块名语法错误"
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "expected expression"
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "需要表达式"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "%C处数组声明需要另外一维"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -88379,64 +88578,64 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "%2$C处包含的过程‘%1$s’已经有歧义"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "非预期的 %s 语句出现在%C处的 CONTAINS 段中"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Fortran 2008：%C处 CONTAINS 语句没有 FUNCTION 或 SUBROUTINE 语句"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "%L处 FORMAT 语句没有语句标号"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "%C处的 CONTAINS 语句已经在包含的程序单元中"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "%2$L处的名字‘%1$s’已经在%4$L处被用作 %3$s"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "%2$L处的名字‘%1$s’已经在%4$L处被用作 %3$s"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "%2$L处的名字‘%1$s’已经在%4$L处被用作 %3$s"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 #| msgid "Global name '%s' at %L is already being used as a %s at %L"
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "%2$L处的名字‘%1$s’已经在%4$L处被用作 %3$s"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "%C处空白 BLOCK DATA 与%L处先前的 BLOCK DATA 冲突"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "非预期的 %s 语句出现在%C处的 BLOCK DATA 块中"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "非预期的 %s 语句出现在%C处的 MODULE 中"
@@ -88444,7 +88643,7 @@ msgstr "非预期的 %s 语句出现在%C处的 MODULE 中"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "%L 和%C处有两个主 PROGRAM"
@@ -88914,1122 +89113,1122 @@ msgstr "%2$C处有初始值设定的变量‘%1$s’已经出现在一个 DATA 
 msgid "%qs at %C is not a variable"
 msgstr "为 auto 变量%2$qE指定了%1$qs"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "属性%qs的元素类型无效"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "%2$L处使用了 ABSTRACT 类型‘%1$s’"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "为过程‘%2$s’在%3$L处使用的接口‘%1$s’是在之后的 PROCEDURE 语句中声明的"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "%2$C处的接口‘%1$s’不能是泛型"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "%2$C处的接口‘%1$s’不能是个语句函数"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "内建过程‘%s’不允许在 %C 的 PROCEDURE 语句中"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "%L处的运算符接口必须是一个 SUBROUTINE"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "%2$L处的 PROCEDURE‘%1$s’不能被用作其自身的接口"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "元素子进程‘%s’中的替代返回限定符在%L处不被允许"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "函数‘%s’中的替代返回限定符在%L处不被允许"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "%2$L处关键字实参‘%1$s’不在过程里"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "%2$L处 PURE 过程的哑过程‘%1$s’必须也是 PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "%3$L处纯函数‘%2$s’的实参‘%1$s’必须是 INTENT(IN)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "%3$L处纯函数‘%2$s’的实参‘%1$s’必须是 INTENT(IN)"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "%3$L处纯子进程‘%2$s’的参数‘%1$s’必须指定其 INTENT"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "%3$L处纯子进程‘%2$s’的参数‘%1$s’必须指定其 INTENT"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "%L处赋值中的变量类型不能是多态的"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "%2$L处关键字实参‘%1$s’不在过程里"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "元素过程的实参‘%s’在%L处必须是标量"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "在 %2$L 处基本过程的参数“%1$s”不能有 POINTER 属性"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "%2$L处基本过程的参数‘%1$s’不能有 POINTER 属性"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "%3$L处哑过程‘%1$s’不能出现在基本过程‘%2$s’中"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "%3$L处纯子进程‘%2$s’的参数‘%1$s’必须指定其 INTENT"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "%L处 SELECT 语句中的实参必须为标量"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "%2$L处语句函数有字符值的参数‘%1$s’必须有常量长度"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "%2$L处 INTERFACE 过程‘%1$s’有与外围过程相同的名字"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "%2$L处的包含函数‘%1$s’没有隐式类型"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "%3$L处包含函数‘%2$s’的结果‘%1$s’没有 IMPLICIT 类型"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "%3$L处有字符值的 %1$s‘%2$s’不能是假定长度的"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "%3$L处有字符值的 %1$s‘%2$s’不能是假定长度的"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "%2$L处函数‘%1$s’有不匹配的数组规格说明"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Function %s at %L has entries with mismatched array specifications"
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "%2$L处函数‘%1$s’有不匹配的数组规格说明"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "扩展：%2$L处函数 %1$s 有返回不同字符串长度的变量的表项"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "%3$L处函数 %2$s 的返回值 %1$s 不能是一个数组"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "%3$L处函数 %2$s 中入口返回值 %1$s 不能是一个数组"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "%3$L处函数 %2$s 的返回值 %1$s 不能是一个指针"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "%3$L处函数 %2$s 中入口返回值 %1$s 不能是一个指针"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "%3$L处函数 %2$s 的返回值 %1$s 不能是一个指针"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "%3$L处函数 %2$s 中入口返回值 %1$s 不能是一个指针"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "%4$L处函数 %2$s 的返回值 %1$s 不能具有 %3$s 具型"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "%4$L处函数 %2$s 中入口返回值 %1$s 不能具有 %3$s 具型"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "符号‘%s’在%C处已经在一个 COMMON 块中"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "符号‘%s’在%C处已经在一个 COMMON 块中"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "COMMON block /%s/ not found at %C"
 msgid "COMMON block at %L"
 msgstr "%2$C处未发现 COMMON 块 /%1$s/"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "%2$L处变量‘%1$s’是在 COMMON 中, 但初始化仅允许出现在 BLOCK DATA 中"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, fuzzy, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "%2$L处被初始化的变量‘%1$s’是在一个空白 COMMON 中，但是初始化仅容许出现在有名公用块中"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "符号‘%s’在%C处已经在一个 COMMON 块中"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "%2$L处 COMMON 中的派生类型变量‘%1$s’既没有 SEQUENCE 也没有 BIND(C) 属性"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "%2$L处 COMMON 中的派生类型变量‘%1$s’有一个可分配的最终组件"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "%2$L处 COMMON 中的派生类型变量‘%1$s’不能有默认的初始值设定"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "%2$L处的 COMMON 块‘%1$s’在%3$L处被用作 PARAMETER"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, fuzzy, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲突"
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, fuzzy, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲突"
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 #| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "%2$L处的 COMMON 块‘%1$s’在%3$L处被用作 PARAMETER"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "%2$L处的 COMMON 块‘%1$s’也是一个内建过程"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "Fortran 2003：%2$L处的 COMMON 块‘%1$s’也是一个函数返回值"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "Fortran 2003：%2$L处的 COMMON 块‘%1$s’也是一个全局过程"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "%L处的派生类型构造函数中元素的秩与该组件(%d/%d)的不匹配"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "%L处指针组件‘%s’的派生类型构造函数中的元素是 %s 但应该是 %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 #| msgid "Unequal character lengths (%ld/%ld) in %s at %L"
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "%4$L处 %3$s 中字符长度不相等 (%1$ld/%2$ld)"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, fuzzy, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "%L处派生类型构造函数中的 NULL 被用在既不是一个指针也不是 ALLOCATABLE 的组件‘%s’上"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "%C处结构构造函数中组件太多！"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "%C处结构构造函数中组件太多！"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "%L处的派生类型构造函数中元素的秩与该组件(%d/%d)的不匹配"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "%L处指针组件‘%s’的派生类型构造函数中的元素应该是 POINTER 或 TARGET"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Pointer assignment with vector subscript on rhs at %L"
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "%L处指针赋值的右手边带有向量下标"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "%2$L处指针组件‘%1$s’的派生类型构造函数中表达式无效"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, fuzzy, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "最后一维的上限必须出现在对在%2$L处假定大小数组‘%1$s’的引用中"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "‘%s’(位于 %L)有歧义"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "GENERIC 过程‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "%2$L处为内建函数‘%1$s’指定的类型被忽略"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "%2$L处的内建子例程‘%1$s’不应该有类型限定符"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "在 %2$L 声明的内联函数 %1$qs 不存在"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, fuzzy, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "在%2$L处由内建函数‘%1$s’声明的 INTRINSIC 在当前的标准设置中是不可用的，但在 %3$s 下可用。使用一个适当的 -std=* 选项或启用 -fall-intrinsics 以便使用它。"
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, fuzzy, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "%2$L处非 RECURSIVE 过程‘%1$s’可能递归地调用它自己。请将它声明为 RECURSIVE 或使用 -frecursive"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, fuzzy, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "%2$L处非 RECURSIVE 过程‘%1$s’可能递归地调用它自己。请将它声明为 RECURSIVE 或使用 -frecursive"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "标号 %d(引用自 %L)从未被定义"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "内部过程‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "语句函数‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "内建函数‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "内部过程‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL 非 INTRINSIC 过程‘%s’不允许在%L处作为实际参数"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "%2$L处对‘%1$s’的引用找不到特定的 INTRINSIC 过程"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "%C处 TYPE 定义中的歧义符号"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "%L处按值传递的实参不具有数字类型"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "%L处按值传递的实参不能是数组或数组段"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "%L处上下文中不允许使用按值传递的实参"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "不允许按位置传递%L处的内部过程"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL 非 INTRINSIC 过程‘%s’不允许在%L处作为实际参数"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Coindexed 实际参数于 %L 与 ultimate 指标成分"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "%2$L处的‘%1$s’是个数组且是可选的；如果它缺失, 它不能是一个 ELEMENTAL 过程的实际参数，除非有一个具有相同秩的非可选的参数(12.4.1.5)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "%1$L处 ELEMENTAL 子程序‘%4$s’的 INTENT(%2$s) 哑‘%3$s’的实际参数是一个标量，但是另一个实际参数是一个数组"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "函数不能返回函数"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "%L处过程指针赋值中接口不匹配：%s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "%2$L处的泛型‘%1$s’没有指定的函数"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "%2$L处泛型函数‘%1$s’与特定的内建接口不一致"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "不能解析 %2$L处的函数‘%1$s’"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "%2$L处的函数‘%1$s’没有隐式类型"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "%2$L处的函数‘%1$s’没有隐式类型"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "%2$L处对非 PURE 函数‘%1$s’的引用出现在 FORALL %3$s 中"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "%2$L处对非 PURE 函数‘%1$s’的引用出现在 FORALL %3$s 中"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "%2$L处对非 PURE 函数‘%1$s’的引用出现在 FORALL %3$s 中"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "%2$L处对非 PURE 函数‘%1$s’的引用出现在 FORALL %3$s 中"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "%C处 ELSE 语句后有非预期的垃圾字符"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "在函数%qs中"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "%2$L处的 ABSTRACT INTERFACE‘%1$s’不能被引用"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, fuzzy, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "函数‘%s’被声明为 CHARACTER(*)从而不能被使用在%L处，因为它不是一个虚参"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "%C处的实参数列中缺少关键字名"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "不良的 C++ 方法函数类型"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, fuzzy, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "%2$L处用户定义的非 ELEMENTAL 函数‘%1$s’不允许出现在 WORKSHARE 构造中"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "%2$L处 ENTRY‘%1$s’不能递归调用，因为函数‘%3$s’并非 RECURSIVE"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "%2$L处的函数‘%1$s’不能被递归调用，因为它并非 RECURSIVE"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "已弃用%qE"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "%2$L处 FORALL 块内对‘%1$s’子例程的调用不是 PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "%2$L处 FORALL 块内对‘%1$s’子例程的调用不是 PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "%2$L处 FORALL 块内对‘%1$s’子例程的调用不是 PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "%L处子进程调用缺少替代返回限定"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "泛型‘%s’在%L处没有特定的子进程"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "%2$L处泛型子进程‘%1$s’与一个内建子进程接口不一致"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "%2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "不能解决%2$L处的指定子例程‘%1$s’"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "%2$L处的‘%1$s’的类型与%3$L处 CALL 的类型不一致"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "%2$L处 ENTRY‘%1$s’不能被递归调用，因为子进程‘%3$s’并非 RECURSIVE"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "%2$L处 SUBROUTINE‘%1$s’不能递归调用，因为它并非 RECURSIVE"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "不良的 C++ 方法函数类型"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "已弃用%qE"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "%L和%L处的操作数外形不相容"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, fuzzy, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr "%L处内建运算符接口必须是一个 FUNCTION"
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "指定CHARACTER(*) 函数‘%s’在%L处不能为指针值"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "当内联函数无法被内联时给出警告"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 #| msgid "By-value argument at %L cannot be an array or an array section"
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "%L处按值传递的实参不能是数组或数组段"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "无符号表达式永远大于或等于 0"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid context for NULL() pointer at %%L"
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "%%L处 NULL() 指针上下文无效"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator '%s' at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "单目数值运算符‘%s’(位于 %%L)的操作数为 %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "二元数值运算符‘%s’(位于 %%L)的操作数为 %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "%%L和%%L处的操作数的秩不一致"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr "二元数值运算符‘%s’(位于 %%L)的操作数为 %s/%s"
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "字符串毗连运算符(位于 %%L)的操作数为 %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator '%s' at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "逻辑运算符‘%s’(位于 %%L)的操作数为 %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operand of .not. operator at %%L is %s"
 msgid "Operand of .not. operator at %L is %s"
 msgstr "%%L处的 .not. 运算符的操作数为 %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "%L处复数不能比较大小"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr ""
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Inconsistent ranks for operator at %%L and %%L"
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "%%L和%%L处的操作数的秩不一致"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "%2$L处 %1$s 种别无效"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "%2$L处 %1$s 种别无效"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "%%L处逻辑值必须与 %s 比较，而不是 %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "比较运算符‘%s’(位于 %%L)的操作数为 %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator '%s' at %%L"
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "未知的运算符‘%s’在 %%L处"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 #| msgid "Unknown operator '%s' at %%L"
 msgid "Unknown operator %qs at %L"
 msgstr "未知的运算符‘%s’在 %%L处"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator '%s' at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "用户运算符‘%s’(位于 %%L)的操作数为 %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator '%s' at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "用户运算符‘%s’(位于 %%L)的操作数为 %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, fuzzy, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr "%L处内建运算符接口必须是一个 FUNCTION"
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个标量"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "%4$L处‘%3$s’内建函数的‘%1$s’和‘%2$s’实参类型必须相同"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "%L处的分配对象和%L处的源表达式应该有相同的种别类型参数"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "%L处的源表达式和%L处的分配对象必须有相同的外形"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "%1$L处数组引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "%1$L处数组引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "%1$L处数组引用在第 %4$d 维中越界(%2$ld > %3$ld)"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "%1$L处数组引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "%L 零间隔非法"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "%1$L处数组下限引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "%1$L处数组下限引用在第 %4$d 维中越界(%2$ld > %3$ld)"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "%1$L处数组上限引用在第 %4$d 维中越界(%2$ld < %3$ld)"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "%1$L处数组上限引用在第 %4$d 维中越界(%2$ld > %3$ld)"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, gcc-internal-format
 msgid "check_dimension(): Bad array reference"
 msgstr "check_dimension()：不当的数组引用"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "%L处未指定假定大小数组段的最右端上限"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "%L处数组引用中秩不匹配(%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "%L处数组引用中秩不匹配(%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’必须是一个标量"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "%L处数组索引必须是标量"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "%L处数组索引必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "%L处数组索引是一个秩为 %d 的数组"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "%L处实参维数必须具有 INTEGER 类型"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "%C处数组引用形式无效"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "%L处数组索引是一个秩为 %d 的数组"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "%L 实参维数必须是标量"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "%L处的表达式必须具有标量类型"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "%L处的子字符串起始索引类型必须为 INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "%L处的子字符串起始索引必须是标量"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "%L处的子字符串终止索引类型必须为 INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "%L处的子字符串终止索引必须是标量"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "%L处子串结束索引太大"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 msgid "resolve_ref(): Bad array reference"
 msgstr "%L处数组引用错误"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "%L处对有非零秩的部分引用的右侧的组件不能有 POINTER 属性"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "%L处对有非零秩的部分引用的右侧的组件不能有 ALLOCATABLE 属性"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "%L处不能指定两个或以上秩不为零的部分引用"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "不合法的算子"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "假定外形的数组在 %L 处必须是哑参数"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "%L处假定外形的数组必须是一个虚参"
@@ -90038,12 +90237,12 @@ msgstr "%L处假定外形的数组必须是一个虚参"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "%L处假定外形的数组必须是一个虚参"
@@ -90052,421 +90251,421 @@ msgstr "%L处假定外形的数组必须是一个虚参"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "“%s”是必须是一个模块过程或有显式接口的外部过程于 %L 处"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "数组‘%s’在%L处不能有延迟的外形"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "数组‘%s’在%L处不能有延迟的外形"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_variable_attr(): Bad array reference"
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "gfc_variable_attr()︰不当的数组引用"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "用在一个规格说明表达式中的变量‘%s’在%L处的引用出现在该变量是其参数的 ENTRY 语句之前"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "变量‘%s’在%L处的使用出现在该变量是其参数的 ENTRY 语句之前"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "%2$L处非多态的传递对象哑元实参‘%1$s’"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Coindexed 对象与 polymorphic allocatable subcomponent 于 %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "已弃用%qE"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "%L处数组引用错误"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "%C处类型指定无效"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "%L处传递的对象必须是标量"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, fuzzy, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "%L处类型限定过程调用的基类型是 ABSTRACT 类型‘%s’"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, fuzzy, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "%L处 NOPASS 类型限定过程调用的基对象必须是标量"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "%L处 NOPASS 类型限定过程调用的基对象必须是标量"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, fuzzy, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "%2$L处对 GENERIC‘%1$s’的调用没有找到匹配特别的限定"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "%L处的运算符接口必须是一个 SUBROUTINE"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "在函数%qs中"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "需要表达式类型"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s (%L处)必须是一个标量"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "%s (%L处)必须是 INTEGER"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s (%L处)必须是 INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "%L处的 DO 循环中的步进表达式不能为零"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "%L处的 DO 循环中的步进表达式不能为零"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "在%C处需要变量名"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "变量‘%s’在 %L 尚未分配到格式标号"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "%L处 PURE 过程不能指定 SAVE 属性"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "%3$L处 %2$s 分句中假定大小的数组‘%1$s’"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "%3$L处 %2$s 分句中的 POINTER 对象‘%1$s’"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "%3$L处 %2$s 分句中 的Cray 指针目标‘%1$s’"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "对子进程名‘%s’非预期的使用，在%C处"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "需要块名‘%s’在‘%s’表达式中，于 %C"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 #| msgid "variable %qD set but not used"
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "变量%qD被设定但未被使用"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "%L处 FORALL 索引名必须是一个标量整数"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "%L处 FORALL 起始表达式必须是一个标量整数"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "%L处 FORALL 结束表达式必须是一个标量整数"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "%L处 FORALL 间隔表达式必须是一个标量 %s"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "%L处 FORALL 间隔表达式不能是零"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "FORALL 索引‘%s’不能出现在%L处的三元组规格说明中"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "%L处的分配对象必须是 ALLOCATABLE 或 POINTER"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "%L处的分配对象必须是 ALLOCATABLE 或 POINTER"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Allocate-object at %L also appears at %L"
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "%L处分配的对象也出现在%L处"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "%L处的源表达式必须是标量或者与%L处的分配对象有相同的秩"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "%L处的源表达式和%L处的分配对象必须有相同的外形"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "%L处只有内建运算符才能用于表达式中"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "%L处实体的类型与%L处的源表达式类型不兼容"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "%L处的分配对象和%L处的源表达式应该有相同的种别类型参数"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "source-expr 于 %L 应该 neither 是的类型 LOCK_TYPE nor 有 LOCK_TYPE 成分如果 allocate-object 于 %L 是 coarray"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "source-expr 于 %L 应该 neither 是的类型 LOCK_TYPE nor 有 LOCK_TYPE 成分如果 allocate-object 于 %L 是 coarray"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "%2$L处分配具有 ABSTRACT 基类型的 %1$s 需要一个类型指定或 SOURCE="
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "配置 %s 于 %L 与 type-spec 需求相同 character-length 参数作为在中声明"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "%L处的 ALLOCATE 语句中需要数组规格说明"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Array specification required in ALLOCATE statement at %L"
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "%L处的 ALLOCATE 语句中需要数组规格说明"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "%L处的 ALLOCATE 语句中需要数组规格说明"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "%L处的 ALLOCATE 语句中有错误的数组规格"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "%L处的 ALLOCATE 语句中有错误的数组规格"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, fuzzy, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "‘%s’不能出现在%L处其自身被分配的 ALLOCATE 语句的数组规格说明中"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "%L处的 ALLOCATE 语句中需要数组规格说明"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "%1$L处的统计变量不能在同一个 %3$s 语句中被 %2$s"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "%L处的 ERRMSG 没有 STAT 标记所以不起作用"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "%L处错误信息变量必须是一个标量 CHARACTER 变量"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "%1$L处的错误信息变量不能在同一 %3$s 语句中被 %2$s"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "%L处分配的对象也出现在%L处"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "%L处的分配对象必须是 ALLOCATABLE 或 POINTER"
@@ -90475,316 +90674,316 @@ msgstr "%L处的分配对象必须是 ALLOCATABLE 或 POINTER"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "%L处的 CASE 标号与%L处的 CASE 标号重叠"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "%L处 CASE 语句中的表达式必须具有 %s 类型"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "%L 处 CASE 语句中的表达式种别必须为 %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "%L处 CASE 语句中的表达式必须为标量"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "%L处计算转移 GOTO 语句的选择表达式必须是一个标量整数表达式"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "%L处 SELECT 语句的实参不能是 %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "%L处 SELECT 语句中的实参必须为标量"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "%L处 CASE 语句中的表达式必须具有 %s 类型"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "%L处的 DEFAULT CASE 为%L处的第二个 DEFAULT CASE 所跟随"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "%L处 CASE 语句中的逻辑范围是不被允许的"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "%L 处 CASE 语句中的常量逻辑值被重复了"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "%L处范围规格无法匹配"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "%L处逻辑 SELECT CASE 块有多于两个的情况"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "不能解析 %2$L处的函数‘%1$s’"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "%L处过程指针赋值非法"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "名字‘%s’在%C处不能用作已定义的运算符"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "%2$L 处的名字“%1$s”已经在 %4$L 处被用作 %3$s"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "选择子必须是立即数"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "选择子必须是立即数"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "%2$L 处的名字“%1$s”已经在 %4$L 处被用作 %3$s"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "%C处 SELECT TYPE 语句中的选择子应该是多态的"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "选择子必须是立即数"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "CASE label at %L overlaps with CASE label at %L"
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "%L处的 CASE 标号与%L处的 CASE 标号重叠"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "%2$L处派生类型‘%1$s’必须是可扩展的"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "%2$L处派生类型‘%1$s’必须是‘%3$s’的一个扩展"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "对子进程名‘%s’非预期的使用，在%C处"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "数组‘%s’在%L处不能有延迟的外形"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "%L处 SELECT TYPE 语句中有双重的 CLASS IS 块"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "%%L处 NULL() 指针上下文无效"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "%L处的表达式必须具有标量类型"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "数据转移组件于 %L 无法 polymorphic 除非它被处理由定义的输入/输出进程"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "%L处数据传输元素不能有 PRIVATE 组件"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "%L处数据传输元素不能有 ALLOCATABLE 组件"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "%L处数据传输元素不能有 PRIVATE 组件"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "%L处数据传输元素不能有 POINTER 组件"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "%L处数据传输元素不能是对一个假定大小数组的全引用"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "%L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "‘%s’的实参在%L处必须是一个指针"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "%L处错误信息变量必须是一个标量 CHARACTER 变量"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "%L处 SELECT 语句中的实参必须为标量"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr "%L处 SELECT 语句中的实参必须为标量"
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "%L处的毗连运算符必须毗连同一种别的字符串"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "%L处 SELECT 语句中的实参必须为标量"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "%L处 ACOS 的参数必须在 -1 和 1 之间"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "%L处的语句对%L处的分支语句而言不是一个有效的分支目标语句"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "%L处的分支可能导致无穷循环"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "前往叙述于 %L 树叶重要建构用于标贴于 %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "%s 语句在%C处离开 OpenMP 结构块"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "前往叙述于 %L 树叶重要建构用于标贴于 %L"
@@ -90792,221 +90991,221 @@ msgstr "前往叙述于 %L 树叶重要建构用于标贴于 %L"
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "%L处的标号与%L处 GOTO 语句不在相同的块中"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "%L处的 WHERE 掩码外形不一致"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "%L处 WHERE 赋值目标外形不一致"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "%L处 WHERE 中用户定义的非 ELEMENTAL 用户赋值"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "%L处在 WHERE 内不支持的语句"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "%L处向 FORALL 索引变量赋值"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, fuzzy, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "%2$L处带索引‘%1$s’的 FORALL 没有被用在赋值的左侧，所以可能导致对这个对象的多个赋值"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "位置错误的%<@%D%>Objective-C++ 构造"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "%L处 FORALL 索引名必须是一个标量整数"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "%L处外部 FORALL 构造已经有一个同名的索引"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "在%C处需要变量名"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "%L处的 WHERE/ELSEWHERE 子句需要一个 LOGICAL 数组"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "%L处数据传输元素不能有 PRIVATE 组件"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "不能将 %s 转换为 %s，于 %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER expression will be truncated in assignment (%d/%d) at %L"
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "CHARACTER 表达式在%3$L处赋值时将被截断(%1$d/%2$d)"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "%L处一个非纯变量在 PURE 过程中被赋值给带有 POINTER 组件派生类型变量(12.6)"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "%L处 PURE 过程中指针赋值目标错误"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "%L处赋值中的变量类型是 UNKNOWN"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, fuzzy, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr "%L处向 FORALL 索引变量赋值"
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, fuzzy, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "变量必须不是 polymorphic 在中 intrinsic 指派于 %L - 检查该有匹配特定的副常式用于‘=’运算符"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "%L处赋值中的变量类型不能是多态的"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid procedure pointer assignment at %L"
 msgid "Pointer procedure assignment at %L"
 msgstr "%L处过程指针赋值非法"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "%L处计算转移 GOTO 语句的选择表达式必须是一个标量整数表达式"
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "ASSIGNED GOTO 语句在%L处需要一个 INTEGER 变量"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "变量‘%s’在 %L 尚未指派目标标号"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "%L处的替代 RETURN 语句需要一个 SCALAR-INTEGER 返回限定符"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "%C处 CASE 中需要初始化表达式"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "%L处的 ASSIGN 语句需要一个默认标量 INTEGER 变量"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "%2$L处 %1$s 种别无效"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Arithmetic IF statement at %L requires a numeric expression"
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "%L处的算术 IF 语句要求一个数字表达式"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "%L处 DO WHILE 循环的退出条件必须是一个标量 LOGICAL 表达式"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_trans_code()：错误的语句代码"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "%2$L处声明了未使用的参数‘%1$s’"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲突"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲突"
@@ -91014,1069 +91213,1069 @@ msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "%2$L处的绑定标号‘%1$s’与 %4$L 处的全局实体‘%3$s’冲突"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "%L处字符串太长"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "可分配的数组‘%s’在%L处必须有延迟的外形"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "%2$L处标量对象‘%1$s’不能为 ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "数组指针‘%s’在%L处必须有延迟的外形"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "数组‘%s’在%L处不能有延迟的外形"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, fuzzy, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "%3$L处 CLASS 变量‘%2$s’的类型‘%1$s’不能被扩展"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "%2$L处的 CLASS 变量‘%1$s’必须是哑元、可分配的或者指针"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, fuzzy, gcc-internal-format
 #| msgid "The type '%s' cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "‘%s’在%L处不能是主机相关的，因为它被在%L处声明的一个不兼容的同名对象所阻碍"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, fuzzy, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Fortran 2008：%2$L处模块变量‘%1$s’隐含使用了 SAVE，因为默认初始化有此需求"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "语句函数‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "The module or main program array '%s' at %L must have constant shape"
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "%2$L处的模块或主程序数组‘%1$s’必须有常量外形"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "%L处假定字符长度的实体必须是个虚参或是个 PARAMETER"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' at %L must have constant character length in this context"
 msgid "%qs at %L must have constant character length in this context"
 msgstr "变量‘%s’在%L处上下文中字符长度必须为常量"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "变量‘%s’在%L处上下文中字符长度必须为常量"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "可分配的‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 msgid "External %qs at %L cannot have an initializer"
 msgstr "外部‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "哑元‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "内建函数‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "函数结果‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "自动数组‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L"
 msgstr "%s 于 %L"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "%2$L处有字符值的语句函数‘%1$s’必须有常量长度"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003：%3$L处‘%1$s’是 PRIVATE 类型因而不能是 PUBLIC 类型‘%2$s’的虚参"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Fortran 2003: %3$L处 PUBLIC 接口‘%2$s’中的过程‘%1$s’有 PRIVATE 的虚参‘%4$s’"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "函数‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 msgid "External object %qs at %L may not have an initializer"
 msgstr "外部对象‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "%2$L处 ELEMENTAL 函数‘%1$s’必须有一个标量返回值"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "语句函数‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*) 函数‘%s’在%L处不能为数组值"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "指定CHARACTER(*) 函数‘%s’在%L处不能为指针值"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*) 函数‘%s’在%L处不能为纯函数"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "CHARACTER(*) 函数‘%s’在%L处不能是递归的"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "在函数%qs中"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "%2$L处的具有 PASS 的过程指针组件‘%1$s’必须至少有一个实参"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "哑过程‘%s’在%C处不能有泛型接口"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, fuzzy, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 ALLOCATABLE 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, fuzzy, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Coindexed 对象与 polymorphic allocatable subcomponent 于 %L"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "%L处 PURE 过程不能指定 SAVE 属性"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "PROCEDURE 属性与%2$L处‘%1$s’中的 INTENT 属性冲突"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "PROCEDURE 属性与在%2$L处‘%1$s’中的 RESULT 属性冲突"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "EXTERNAL 属性与在%2$L处‘%1$s’中的 FUNCTION 属性冲突"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "%2$L处过程指针结果‘%1$s’缺少指针属性"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr "%1$s 在 MODULE %4$qs 中的 MODULE PROCEDURE 声明与在 (SUB)MODULE %2$qs 中的 %3$L 处的声明之间"
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "%L处的运算符接口必须是一个 SUBROUTINE"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "%L处 FINAL 过程的参数必须不是 OPTIONAL"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "%L处的 FINAL 过程有且只有一个参数"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "%L处 FINAL 过程的参数必须不是 OPTIONAL"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "%L处 FINAL 过程的参数必须不是 POINTER"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "%L处 FINAL 过程的参数必须不是 ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "%L处 FINAL 过程的参数必须不是 OPTIONAL"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "%L处 FINAL 过程的参数必须不是 INTENT(OUT)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "%L处的非标量 FINAL 过程应当有假定外形的参数"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "%2$L处声明的 FINAL 过程‘%1$s’有与‘%4$s’相同的秩(%3$d)"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, fuzzy, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "仅为定义在%2$L处的派生类型‘%1$s’声明了数组 FINAL 过程，建议也定义一个标量过程"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "%4$L处‘%1$s’和‘%2$s’对 GENERIC‘%3$s’不能是混合的 FUNCTION/SUBROUTINE"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "引用%qs有歧义：出现在接口%qs和接口%qs中"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, fuzzy, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "未定义的指定绑定‘%1$s’用作%3$L处的 GENERIC‘%2$s’的目标"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, fuzzy, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "%2$L处 GENERIC‘%1$s’必须定位一个特定的绑定，‘%3$s’也是 GENERIC"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, fuzzy, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "%2$L处 GENERIC‘%1$s’无法覆盖同名的特定绑定"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Type-bound operator at %L can't be NOPASS"
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "%L处类型限定的操作数不能是 NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "%2$L处的‘%1$s’必须是一个模块过程或带有显式接口的外部过程"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "%3$L处有 PASS(%2$s)的过程‘%1$s’没有参数‘%4$s’"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "%2$L处有 PASS 的过程‘%1$s’必须至少带一个参数"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, fuzzy, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "%2$L处非多态的传递对象虚参‘%1$s’"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr " %4$L处的具有 PASS(%3$s) 的‘%2$s’的参数‘%1$s’必须具有派生类型‘%5$s’"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr " %4$L处的具有 PASS(%3$s) 的‘%2$s’的参数‘%1$s’必须具有派生类型‘%5$s’"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "%2$L处‘%1$s’的传递对象虚参必须是标量"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "%2$L处‘%1$s’的传递对象虚参不能是 ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "%2$L处‘%1$s’的传递对象虚参不能是 POINTER"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "%2$L处过程‘%1$s’和‘%3$s’的组件重名"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "%2$L处过程‘%1$s’和‘%3$s’的继承组件重名"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, fuzzy, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "%2$L处声明的派生类型‘%1$s’必须是 ABSTRACT，因为‘%3$s’是 DEFERRED 且没有被覆盖"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "数组指针‘%s’在%L处必须有延迟的外形"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "成分‘%s’于 %L 的类型 (C_PTR) 或类型 (C_FUNPTR) 不应该是 coarray"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "成分‘%s’于 %L 与 coarray 成分应该是 nonpointer，nonallocatable 纯量"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "%2$L 处的“%1$s”不能有 VALUE 属性，因为它不是个虚参"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "%L处 ICHAR 的参数长度必须为 1"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "%3$L处带有 PASS(%2$s)的过程指针组件‘%1$s’没有参数‘%4$s’"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "%2$L处的具有 PASS 的过程指针组件‘%1$s’必须至少有一个实参"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "%4$L处具有 PASS(%3$s) 的‘%2$s’的参数‘%1$s’必须有派生类型‘%5$s’"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "%4$L 处的具有 PASS(%3$s) 的‘%2$s’的参数‘%1$s’必须是标量"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "%4$L处带 PASS(%3$s) 的‘%2$s’的参数‘%1$s’不能有 POINTER 属性"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "%4$L处带 PASS(%3$s) 的‘%2$s’的参数‘%1$s’不能是 ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "%3$L处‘%2$s’的组件‘%1$s’与一个继承的类型限定过程同名"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, fuzzy, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "%2$L处组件‘%1$s’的字符长度必须是一个常量规格表达式"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 #| msgid "Expression at %L must be of INTEGER type, found %s"
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "%L处的表达式必须具有 INTEGER 类型而不是 %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, fuzzy, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "字符成分‘%s’的‘%s’于 %L 与已推迟长度必须是指标或 ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003：%3$L处组合‘%1$s’是一个 PRIVATE 类型，因此不能是 PUBLIC‘%2$s’的组合"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Polymorphic 成分 %s 于 %L 在中串行或绑定©类型 %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "%2$L处声明的有 SEQUENCE 类型的组件 %1$s 没有 SEQUENCE 属性"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "non-constant initialization expression at %L"
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "%L处非常量初始化表达式"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, fuzzy, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "作为延伸类型‘%s’于 %L 有 coarray 成分，亲代类型‘%s’应该也有一个"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, fuzzy, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "%2$L处不能扩展的派生类型‘%1$s’不能是 ABSTRACT"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, fuzzy, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "%3$L处‘%2$s’的组件‘%1$s’与一个继承的类型限定过程同名"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "%2$L处派生类型‘%1$s’必须是可扩展的"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, gcc-internal-format, gfc-internal-format
 msgid "Failed to build PDT class component at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "不允许 %3$L 处 %2$s 名字列表中假定大小的数组“%1$s”"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "%3$L处 NAMELIST 数组对象‘%1$s’在名字列表‘%2$s’不能有假定外形"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "%3$L处 NAMELIST 数组对象‘%1$s’在名字列表‘%2$s’必须有常外形"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "%3$L处 NAMELIST 数组对象‘%1$s’在名字列表‘%2$s’必须有常外形"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "%3$L处 NAMELIST 对象‘%1$s’声明为 PRIVATE 因此不能是 PUBLIC 名字列表‘%2$s’的成员"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "%3$L处 NAMELIST 对象‘%1$s’有使用相关的 PRIVATE 组件因此不能是 NAMELIST‘%2$s’的成员"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "%3$L处 NAMELIST 对象‘%1$s’有 PRIVATE 组件因此不能是 PUBLIC 名字列表‘%2$s’的成员"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "PROCEDURE 属性与%2$L处‘%1$s’中的 NAMELIST 属性冲突"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "%2$L处的参数数组‘%1$s’不能是自动的或有延迟的外形"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, fuzzy, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "%2$L处隐式类型的 PARAMETER‘%1$s’与随后的 IMPLICIT 类型不匹配"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "%L处 PARAMETER 中派生类型不兼容"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "%L处的 IF 分句需要一个标量 LOGICAL 表达式"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "语句函数‘%s’在%L处不允许用作实参"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "%s 属性与 %s 属性在%L处冲突"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "%s 属性与 %s 属性在%L处冲突"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "%2$L 处的“%1$s”不能有 VALUE 属性，因为它不是个虚参"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad specification for assumed size array at %C"
 msgid "Bad specification for assumed size array at %L"
 msgstr "%C处假定大小数组的规格说明错误"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "%L处假定大小的数组必须是一个虚参"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "%L处假定外形的数组必须是一个虚参"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "%L处假定大小的数组必须是一个虚参"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "%L处的符号不是一个 DUMMY 变量"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "%2$L 处的“%1$s”不能有 VALUE 属性，因为它不是个虚参"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "%2$L处带 VALUE 属性的字符哑元‘%1$s’必须具有常数长度"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, fuzzy, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "%2$L处带 VALUE 属性与 C 可互操作的字符哑元‘%1$s’长度必须为 1"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, fuzzy, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "%2$L处派生类型‘%1$s’的类型‘%3$s’尚未定义"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 ALLOCATABLE 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "%2$L处假定外形数组‘%1$s’不能用在初始化表达式中"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 ALLOCATABLE 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "%2$L处变量‘%1$s’不能既有 POINTER 又有 BIND(C) 属性"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "%C处的循环变量不能是一个子组件"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "%2$L处变量‘%1$s’不能是 BIND(C) 因为它既不是一个 COMMON 块也不是于模块级作用域声明的"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "变量‘%s’在%L处上下文中字符长度必须为常量"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "Fortran 2003：%3$L处 PUBLIC %1$s‘%2$s’具有 PRIVATE 派生类型‘%4$s’"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "变量 %s 于 %L 的类型 LOCK_TYPE 或与 subcomponent 的类型 LOCK_TYPE 必须是 coarray"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "变量 %s 于 %L 的类型 LOCK_TYPE 或与 subcomponent 的类型 LOCK_TYPE 必须是 coarray"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, fuzzy, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "%2$L处INTENT(OUT) 虚参‘%1$s’是 ASSUMED SIZE，所以不能有一个默认初始值设定"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "%2$L处的‘%1$s’虚参不能是 INTENT(OUT)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "%2$L处的‘%1$s’虚参不能是 INTENT(OUT)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "函数结果‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "变量‘%s’于 %L 的类型 (C_PTR) 或类型 (C_FUNPTR) 不应该是 coarray"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "变量‘%s’于 %L 与 coarray 成分应该是 nonpointer，nonallocatable 纯量"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "变量‘%s’于 %L 是 coarray 和不是 ALLOCATABLE，保存 nor 虚参数"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "数组‘%s’在%L处不能有延迟的外形"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "%C处可分配的组件必须有延迟的外形"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "函数结果‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "%L处的哑过程不允许出现在 ELEMENTAL 过程中"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "%L处的哑过程不允许出现在 ELEMENTAL 过程中"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "%L处的哑过程不允许出现在 ELEMENTAL 过程中"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 #| msgid "Namelist %s cannot be renamed by USE association to %s"
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "名字列表 %s 不能为对 %s 的 USE 关联来更名"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "%L处的线程私有变量未被保存"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "%2$L 处的对象“%1$s”对于成分的默认初始化必须有 SAVE 属性，"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "可分配的‘%s’在%L处不能有初始值设定"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting list of named entities at %C"
 msgid "Expecting definable entity near %L"
 msgstr "%C处需要有名实体列表"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "%2$L处 BLOCK DATA 元素‘%1$s’必须在 COMMON 中"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, fuzzy, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "%2$L处 BLOCK DATA 元素‘%1$s’必在前一个声明中指定"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "%L处数据传输元素不能有 PRIVATE 组件"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "%2$L处的 DATA 元素‘%1$s’是一个指针所以必须是一个完全的数组"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "在 %2$L 处基本过程的参数“%1$s”不能有 POINTER 属性"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "%L处 DATA 语句中有非常量数组段"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "%L处的 DATA 语名中变量比值多"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Nonconstant array section at %L in DATA statement"
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "%L处 DATA 语句中有非常量数组段"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "开始的 implied-do 循环于 %L 无法被简化到常数"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "结束的 implied-do 循环于 %L 无法被简化到常数"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "步骤的 implied-do 循环于 %L 无法被简化到常数"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "步骤的 implied-do 循环于 %L 无法被简化到常数"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "%L处的 DATA 语句中值比变量多"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "标号 %d 于 %L 经定义但未被使用"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "标号 %d 于 %L 经定义但无法被使用"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "%2$L处的派生类型变量‘%1$s’必须有 SEQUENCE 属性方能成为 EQUIVALENCE 对象"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "%2$L处的派生类型变量‘%1$s’必须没有 ALLOCATABLE 组件方能成为一个 EQUIVALENCE 对象"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "%2$L处的默认初始化的派生类型变量‘%1$s’不能成为 EQUIVALENCE 对象，因为它在 COMMON 中有变量"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "%2$L处的带指针组件的派生类型变量‘%1$s’不能成为一个 EQUIVALENCE 对象"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "%L处 EQUIVALENCE 语句语法错误"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "%L处 EQUIVALENCE 集中的对象必须都带有或者都不带有 PROTECTED 属性"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "%2$L处的公共块成员‘%1$s’不能在纯过程‘%3$s’中成为一个 EQUIVALENCE 对象"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "%2$L处的有名常量‘%1$s’不能是一个 EQUIVALENCE 对象"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "%L处 EQUIVALENCE 语句语法错误"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "%2$L处有非常量界限的数组‘%1$s’不能是一个 EQUIVALENCE 对象"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, fuzzy, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "%2$L处结构组件‘%1$s’不能是一个 EQUIVALENCE 对象"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "%L 的子字符串长度为零"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in character length specification at %C"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "%C处字符长度规格语法错误"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "Fortran 2003：%2$L处 PRIVATE 类型‘%3$s’的 PUBLIC 函数‘%1$s’"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "%2$L处的 ENTRY‘%1$s’没有隐式类型"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "%2$L处的用户运算符‘%1$s’必须是一个 FUNCTION"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "%2$L处用户运算符过程‘%1$s’不能有假定字符长度"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "%2$L处的用户运算符‘%1$s’必须至少有一个实参"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "%L处运算符接口的第一个参数不能是可选的"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "%L处运算符接口的第二个参数不能是可选的"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "%L处的运算符接口必须有至多两个实参"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "%2$L处 PURE 过程中包含的过程‘%1$s’必须也是 PURE"
@@ -92096,101 +92295,101 @@ msgstr "不存在的 include 目录 %qs"
 msgid "%qs is not a directory"
 msgstr "%qs 不是目录"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "%C处的 !$OMP 开始了一个注释行，因为它既不是由一个空白符跟随也不是一个续行"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "%C处的 !$OMP 开始了一个注释行，因为它既不是由一个空白符跟随也不是一个续行"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "行在%L处被截断"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "%2$C处语句超出 %1$d 个续行的限制"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "若延续字符常量中缺少 & 则给出警告"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "%C处的制表符不相容"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid character in name at %C"
 msgid "Invalid character 0x%s at %C"
 msgstr "%C处的名字中有非法字符"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, fuzzy, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "weakref%q+D最终指向其自身"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "第 %d 列第 %d 行有不相容的制表符"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: file %s left but not entered"
 msgid "file %qs left but not entered"
 msgstr "%s:%d：文件 %s 被留下但未进入"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Illegal preprocessor directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s:%d：无效的预处理指令"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, gcc-internal-format
 msgid "File %qs is being included recursively"
 msgstr ""
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, gcc-internal-format
 msgid "Cannot open file %qs"
 msgstr "无法打开文件 %qs"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot open file %qs"
 msgid "Cannot open included file %qs"
 msgstr "无法打开文件 %qs"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 msgid "Cannot open pre-included file %qs"
 msgstr "无法打开输出文件“%s”"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 msgid "Included file %qs is not a regular file"
 msgstr "用法：%s [选项] [输入文件] [输出文件]\n"
@@ -92364,219 +92563,219 @@ msgstr "如果 ATAN2 %L 的第一个参数为 0，第二个参数必须不为 0"
 msgid "gfc_simplify_dim(): Bad type"
 msgstr "gfc_simplify_dim()：不恰当的类型"
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr "在 gfc_simplify_exp()：不恰当的类型"
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr "gfc_simplify_floor()：不恰当的种类"
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "%L处 IACHAR 的参数长度必须为 1"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "%L处 IACHAR 函数的实参不在 0..127 范围内"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "%L处 IBSET 的第二个和第三个参数的总和超过位大小"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "%L处 ICHAR 的参数长度必须为 1"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "%2$L处 %1$s 函数的参数是负的"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "%L处 ISHFTC 的第二个参数大小超过第一个实参的 BIT_SIZE"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %L"
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "%L处 ISHFTC 的第二个参数大小超过第一个实参的 BIT_SIZE"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "%L处 LOG 的实参不可以小于或等于零"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "%L处的 DIM 参数越界"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "%L处 LOG 的实参不可以小于或等于零"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "%L处 LOG 的复数实参不可为零"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "%L处 LOG10 的实参不可以小于或等于零"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_trans_code()：错误的语句代码"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "%L处 NEAREST 的第二个参数不能为 0"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "NEAREST 的结果在%L处为 NaN"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "%L处内建 REPEAT 的 NCOPIES 实参是负的"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "%L处内建 REPEAT 的 NCOPIES 实参太大"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reshaped array too large at %C"
 msgstr "%C处整数太大"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "%L处 SCALE 的结果上溢其种别"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "%3$L处内建函数‘%2$s’的实参‘%1$s’的秩必须为 %4$d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "Bad type in gfc_simplify_sign"
 msgstr "常量表达式中类型错误"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, fuzzy, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "%L处数组构造函数中的元素数超过容许的上限 %d。请参见 -fmax-array-constructor 选项"
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "尚未描述"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "%L处 SQRT 的参数为负"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid argument of SQRT at %L"
 msgstr "%L处 SQRT 的参数为负"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "发信匣的边界在中 IMAGE_INDEX 于 %L 用于尺寸 %d，子有 %ld 和 COARRAY 下限是 %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "发信匣的边界在中 IMAGE_INDEX 于 %L 用于尺寸 %d，子有 %ld 和 COARRAY 上限是 %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, fuzzy, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "%2$L处字符串中的字符‘%1$s’不能被转换到字符种别 %3$d"
@@ -92919,77 +93118,77 @@ msgstr "%C处需要结束名"
 msgid "Labeled DO statement at %L"
 msgstr "%C处的语句标号为零"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "%2$C处的名字‘%1$s’是从模块‘%4$s’对‘%3$s’有歧义的引用"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "%2$C处的名字‘%1$s’是从当前程序单元对‘%3$s’有歧义的引用"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "%2$C处符号‘%1$s’已经与主机相关联"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "%2$L处声明的派生类型‘%1$s’必须使用 BIND 属性方可与 C 互操作"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "衍生类型‘%s’与绑定©属性于 %L 是空的，而也许会是不可访问由 C companion 处理器"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "衍生类型‘%s’与绑定©属性于 %L 是空的，而也许会是不可访问由 C companion 处理器"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "%2$L处的组件‘%1$s’不能有 POINTER 属性，因为它是%4$L处派生类型 BIND(C)‘%3$s’的成员"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure pointer component '%s' at %L cannot be a member of the BIND(C) derived type '%s' at %L"
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "%2$L 处的过程指针组件‘%1$s’不能是%4$L处 BIND(C) 派生类型‘%3$s’的成员"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type '%s' at %L"
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "%2$L处的组件‘%1$s’不能有 ALLOCATABLE 属性，因为它是%4$L处派生类型 BIND(C)‘%3$s’的成员"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "%3$L处的派生类型‘%2$s’的组件‘%1$s’不能与 C 互操作，即使派生类型‘%4$s’是 BIND(C)"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "%3$L处派生类型‘%2$s’中的组件‘%1$s’不能与 C 互操作"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "%2$L处派生类型‘%1$s’不能有 SEQUENCE 属性，因为它是 BIND(C)"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "%2$L处符号‘%1$s’在指定类型之前被使用"
@@ -93020,29 +93219,34 @@ msgstr "%L 处  EQUIVALENCE 中不等的初始值设定重叠"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "%L 处  EQUIVALENCE 中不等的初始值设定重叠"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "%2$L处数组‘%1$s’是个变量，不能被归约为常量表达式"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, fuzzy, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "%L处数组构造函数中的元素数超过容许的上限 %d。请参见 -fmax-array-constructor 选项"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "在%L处建立临时数组"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "走过错误的表达式类型(%d)"
@@ -93146,114 +93350,114 @@ msgstr "%L处向 LOGICAL 赋 0 或 1 以外的值有未定义的结果"
 msgid "non-constant initialization expression at %L"
 msgstr "%L处非常量初始化表达式"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "字母 %c 在%C处已经有了一个隐式类型"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "内建函数变量不是一个过程"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "%2$L处函数‘%1$s’的返回值没有设置"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "%L处指针赋值时参数种别类型不同"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, fuzzy, gcc-internal-format
 msgid "backend decl for module variable %qs already exists"
 msgstr "模块变量 %s 的后端声明已存在"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "%2$L处声明了未使用的变量‘%1$s’"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "%2$L 处的“%1$s”不能有 VALUE 属性，因为它不是个虚参"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "%2$L 处的“%1$s”不能有 VALUE 属性，因为它不是个虚参"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "%2$L处的虚参‘%1$s’被声明为 INTENT(OUT)，但没有设置"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "%2$L处的虚参‘%1$s’被声明为 INTENT(OUT)，但没有设置"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "%L处假定外形的数组必须是一个虚参"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "%2$L处声明了未使用的变量‘%1$s’"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "%2$L处声明了未使用的变量‘%1$s’"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "%2$L处声明了未使用的参数‘%1$qs’"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "未使用的参数 %qs，它已在 %L 处显式导入"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "%3$L处声明的的函数‘%2$s’的返回值‘%1$s’没有设置"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 #| msgid "sorry, unimplemented"
 msgid "Unsigned not yet implemented"
 msgstr "对不起，尚未实现"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr "符号‘%s’在%C处已经在一个 COMMON 块中"
@@ -93283,12 +93487,12 @@ msgstr "不能在%2$C处的 PURE 过程中读取变量‘%1$s’"
 msgid "Unknown intrinsic op"
 msgstr "未知的内建操作"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "%L处参数列表函数未知"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -93304,12 +93508,12 @@ msgstr "内部函数 %s(%d) 无法识别"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "%2$L处‘%1$s’内建函数的‘dim’实参不是一个有效的维数索引"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "%L处指针赋值时参数种别类型不同"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "外部对象‘%s’在%L处不能有初始值设定"
@@ -93335,191 +93539,191 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr "%C处假定大小数组的规格说明错误"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 #| msgid "optional argument"
 msgid "optional class parameter"
 msgstr "可选参数"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "需要表达式类型"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "需要表达式"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 #| msgid "union defined here"
 msgid "Used here"
 msgstr "联合在此定义"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare()：错误的语句代码"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, fuzzy, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "还是所有或没有任何上限必须被指定的于 %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "%C处期待模块过程名"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "%L处 stat 变量必须是一个标量 INTEGER 变量"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "%2$C处的接口‘%1$s’不能是泛型"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "%L处 PURE 过程中指针赋值目标错误"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "%3$L处 %2$s 中的过程‘%1$s’没有显式接口"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "Cannot find symbol %qs"
 msgid "Cannot find symbol %qs at %L"
 msgstr "无法找到符号 %qs"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "过程‘%s’(在 %s 中，位于 %L) 既不是函数也不是子进程"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "过程‘%s’(在 %s 中，位于 %L) 既不是函数也不是子进程"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "-f%s 和 -msdata=%s 互不兼容"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected argument list at %C"
 msgid "Expected positive argument index at %L"
 msgstr "%C处需要实参列表"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "默认参数只允许出现在函数参数中"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "%L 不带 * 虚参的替代返回"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "%L处 SELECT 语句中的实参必须为标量"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "在 %2$L 处基本过程的参数“%1$s”不能有 POINTER 属性"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is specified more than once"
 msgstr "在基类限定中指定了多于一次的%<virtual%>"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe not supported"
 msgid "%<need_device_addr%> not yet supported"
@@ -93868,7 +94072,7 @@ msgstr "close：%s"
 msgid "two or more sections for %s"
 msgstr "两个文件在同一列中：%s\n"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -94215,32 +94419,32 @@ msgstr "数组被用作初始值设定"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "要求的位置不是一个整数常量"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a power of 2"
 msgstr "要求的对齐边界不是 2 的某次方"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "要求的对齐边界太大"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -95313,6 +95517,10 @@ msgstr "未使用的名称 %qE"
 msgid "are you trying to break %s? how dare you?"
 msgstr ""
 
+#, fuzzy, gcc-internal-format
+#~ msgid "%qT is not consteval-only"
+#~ msgstr "实参%qd不是一个常数"
+
 #~ msgid "fatal error: "
 #~ msgstr "致命错误："
 
@@ -95716,10 +95924,6 @@ msgstr ""
 #~ msgid "cannot import module in its own purview"
 #~ msgstr "不能在模块自己的范围内导入模块"
 
-#, fuzzy, gcc-internal-format
-#~ msgid "lambda-expression in template parameter type"
-#~ msgstr "为 lambda 形参指定了默认参数"
-
 #, fuzzy, gcc-internal-format
 #~ msgid "preconditions cannot be statements"
 #~ msgstr "析构函数不能是静态成员函数"
@@ -98614,11 +98818,6 @@ msgstr ""
 #~ msgid "looser throw specifier for %q+#F"
 #~ msgstr "对%q+#F放松的 throw 限定"
 
-#, fuzzy
-#~| msgid "cannot disable built-in function %qs"
-#~ msgid "cannot call function %qD"
-#~ msgstr "无法禁用内建函数%qs"
-
 #~ msgid "right rotate count is negative"
 #~ msgstr "循环右移次数为负"
 
@@ -100896,9 +101095,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "非静态方法%q+D覆盖了静态方法"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D在声明前使用"
-
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "在 %+D 中：重叠的变量和异常范围，在 %d"
 
--- a/src/gcc/po/zh_TW.po
+++ b/src/gcc/po/zh_TW.po
@@ -9,7 +9,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gcc 10.2.0\n"
 "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n"
-"POT-Creation-Date: 2026-03-26 15:06+0000\n"
+"POT-Creation-Date: 2026-04-22 17:18+0000\n"
 "PO-Revision-Date: 2020-11-19 00:56+0800\n"
 "Last-Translator: Yi-Jyun Pan <pan93412@gmail.com>\n"
 "Language-Team: Chinese (traditional) <zh-l10n@lists.linux.org.tw>\n"
@@ -1354,13 +1354,13 @@ msgstr ""
 msgid "Known PTX ISA versions (for use with the -mptx= option):"
 msgstr "已知 MIPS ISA 等級 (用於使用與 -mips 選項)："
 
-#: config/nvptx/nvptx.opt:204
+#: config/nvptx/nvptx.opt:207
 #, fuzzy, no-c-format
 #| msgid "Specify the name of the target CPU"
 msgid "Specify the PTX ISA version to use."
 msgstr "指定目的 CPU 的名稱"
 
-#: config/nvptx/nvptx.opt:208
+#: config/nvptx/nvptx.opt:211
 #, fuzzy, no-c-format
 #| msgid "Use fp registers"
 msgid "Initialize ptx registers."
@@ -2244,13 +2244,13 @@ msgstr ""
 
 #: config/rs6000/rs6000.opt:558 config/riscv/riscv.opt:200
 #: config/i386/i386.opt:1009 config/arm/arm.opt:347
-#: config/aarch64/aarch64.opt:337 config/s390/s390.opt:201
+#: config/aarch64/aarch64.opt:342 config/s390/s390.opt:201
 #, no-c-format
 msgid "Use given stack-protector guard."
 msgstr ""
 
 #: config/rs6000/rs6000.opt:562 config/riscv/riscv.opt:204
-#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:341
+#: config/arm/arm.opt:351 config/aarch64/aarch64.opt:346
 #: config/s390/s390.opt:205
 #, fuzzy, no-c-format
 msgid "Valid arguments to -mstack-protector-guard=:"
@@ -2732,7 +2732,7 @@ msgid "Assume target CPU is configured as big endian."
 msgstr "假定目的 CPU 被配置為高位位元組在前"
 
 #: config/riscv/riscv.opt:30 config/arm/arm.opt:168
-#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:108
+#: config/microblaze/microblaze.opt:64 config/aarch64/aarch64.opt:113
 #, fuzzy, no-c-format
 #| msgid "Assume target CPU is configured as little endian"
 msgid "Assume target CPU is configured as little endian."
@@ -2812,7 +2812,7 @@ msgstr "使用子程式完成函式前言/尾聲"
 msgid "Convert BASE + LARGE_OFFSET addresses to NEW_BASE + SMALL_OFFSET to allow more memory accesses to be generated as compressed instructions.  Currently targets 32-bit integer load/stores."
 msgstr ""
 
-#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:112
+#: config/riscv/riscv.opt:125 config/aarch64/aarch64.opt:117
 #: config/loongarch/loongarch.opt:298
 #, fuzzy, no-c-format
 msgid "Specify the code model."
@@ -2852,7 +2852,7 @@ msgid "Enable the CSR checking for the ISA-dependent CSR and the read-only CSR.
 msgstr ""
 
 #: config/riscv/riscv.opt:169 config/i386/i386.opt:413
-#: config/aarch64/aarch64.opt:155
+#: config/aarch64/aarch64.opt:160
 #, fuzzy, no-c-format
 #| msgid "Omit the frame pointer in leaf functions"
 msgid "Omit the frame pointer in leaf functions."
@@ -2965,7 +2965,7 @@ msgstr ""
 msgid "-param=riscv-two-source-permutes Enable permutes with two source vectors."
 msgstr ""
 
-#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:315
+#: config/riscv/riscv.opt:357 config/aarch64/aarch64.opt:320
 #, no-c-format
 msgid "Override the scalar cost model such that vectorization is always profitable."
 msgstr ""
@@ -3011,7 +3011,7 @@ msgstr ""
 msgid "The possible TLS dialects:"
 msgstr ""
 
-#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:159
+#: config/riscv/riscv.opt:417 config/aarch64/aarch64.opt:164
 #: config/loongarch/loongarch.opt:325
 #, no-c-format
 msgid "Specify TLS dialect."
@@ -5442,7 +5442,7 @@ msgstr "支援 TBM 內建函式和編碼產生"
 msgid "Enable conservative small loop unrolling."
 msgstr ""
 
-#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:421
+#: config/i386/i386.opt:1258 config/aarch64/aarch64.opt:426
 #, no-c-format
 msgid "Limit how much the autovectorizer may unroll a loop."
 msgstr ""
@@ -5812,7 +5812,7 @@ msgstr ""
 msgid "Cost to assume for a branch insn."
 msgstr "成本到假設用於分支 insn"
 
-#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:224
+#: config/arm/arm.opt:335 config/aarch64/aarch64.opt:229
 #, no-c-format
 msgid "Use branch-protection features."
 msgstr ""
@@ -6141,217 +6141,222 @@ msgstr ""
 msgid "Workaround for ARM Cortex-A53 Erratum number 843419."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:116
+#: config/aarch64/aarch64.opt:108
+#, no-c-format
+msgid "Enable narrowing of 64-bit general purpose register writes to 32-bit when upper 32 bits of the register are unused."
+msgstr ""
+
+#: config/aarch64/aarch64.opt:121
 #, fuzzy, no-c-format
 #| msgid "Specify how to access the thread pointer"
 msgid "The register used to access the thread pointer:"
 msgstr "指定如何存取執行緒指標"
 
-#: config/aarch64/aarch64.opt:147
+#: config/aarch64/aarch64.opt:152
 #, fuzzy, no-c-format
 #| msgid "Specify the register allocation order"
 msgid "Specify the thread pointer register."
 msgstr "指定指派暫存器的順序"
 
-#: config/aarch64/aarch64.opt:151
+#: config/aarch64/aarch64.opt:156
 #, no-c-format
 msgid "Don't assume that unaligned accesses are handled by the system."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:163
+#: config/aarch64/aarch64.opt:168
 #, fuzzy, no-c-format
 #| msgid "Specify bit size of immediate TLS offsets"
 msgid "Specifies bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48."
 msgstr "指定執行緒局部存儲偏移量立即數值的位大小"
 
-#: config/aarch64/aarch64.opt:182
+#: config/aarch64/aarch64.opt:187
 #, fuzzy, no-c-format
 msgid "Use features of architecture ARCH."
 msgstr "-mcpu=CPU\t使用特徵的和排程編碼用於給定的 CPU"
 
-#: config/aarch64/aarch64.opt:186
+#: config/aarch64/aarch64.opt:191
 #, fuzzy, no-c-format
 msgid "Use features of and optimize for CPU."
 msgstr "-mcpu=CPU\t使用特徵的和排程編碼用於給定的 CPU"
 
-#: config/aarch64/aarch64.opt:190
+#: config/aarch64/aarch64.opt:195
 #, no-c-format
 msgid "Optimize for CPU."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:194
+#: config/aarch64/aarch64.opt:199
 #, fuzzy, no-c-format
 #| msgid "Generate code that conforms to the given ABI"
 msgid "Generate code that conforms to the specified ABI."
 msgstr "產生遵循給定 ABI 的程式碼"
 
-#: config/aarch64/aarch64.opt:198
+#: config/aarch64/aarch64.opt:203
 #, no-c-format
 msgid "-fdump-tuning-model=<filename> Dump current tuning model to a JSON file."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:202
+#: config/aarch64/aarch64.opt:207
 #, no-c-format
 msgid "-muser-provided-CPU=<json-tuning-file> User specific CPU tunings."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:206
+#: config/aarch64/aarch64.opt:211
 #, no-c-format
 msgid "-moverride=<string>\tPower users only! Override CPU optimization parameters."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:210
+#: config/aarch64/aarch64.opt:215
 #, fuzzy, no-c-format
 msgid "Known AArch64 ABIs (for use with the -mabi= option):"
 msgstr "已知手臂 ABIs (用於使用與 -mabi=選項)："
 
-#: config/aarch64/aarch64.opt:220
+#: config/aarch64/aarch64.opt:225
 #, no-c-format
 msgid "PC relative literal loads."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:228
+#: config/aarch64/aarch64.opt:233
 #, no-c-format
 msgid "Select return address signing scope."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:232
+#: config/aarch64/aarch64.opt:237
 #, fuzzy, no-c-format
 msgid "Supported AArch64 return address signing scope (for use with -msign-return-address= option):"
 msgstr "已知編碼式樣 (用於使用與 -mcmodel=選項)："
 
-#: config/aarch64/aarch64.opt:245
+#: config/aarch64/aarch64.opt:250
 #, no-c-format
 msgid "Enable the reciprocal square root approximation.  Enabling this reduces precision of reciprocal square root results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:251
+#: config/aarch64/aarch64.opt:256
 #, no-c-format
 msgid "Enable the square root approximation.  Enabling this reduces precision of square root results to about 16 bits for single precision and to 32 bits for double precision. If enabled, it implies -mlow-precision-recip-sqrt."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:258
+#: config/aarch64/aarch64.opt:263
 #, no-c-format
 msgid "Enable the division approximation.  Enabling this reduces precision of division results to about 16 bits for single precision and to 32 bits for double precision."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:276
+#: config/aarch64/aarch64.opt:281
 #, no-c-format
 msgid "Specify when to enable an early register allocation pass.  The possibilities are: all functions, functions that have access to strided multi-register instructions, and no functions."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:282
+#: config/aarch64/aarch64.opt:287
 #, no-c-format
 msgid "The possible SVE vector lengths:"
 msgstr ""
 
-#: config/aarch64/aarch64.opt:304
+#: config/aarch64/aarch64.opt:309
 #, no-c-format
 msgid "-msve-vector-bits=<number>\tSet the number of bits in an SVE vector register."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:308
+#: config/aarch64/aarch64.opt:313
 #, no-c-format
 msgid "-mautovec-preference=[default|asimd-only|sve-only|prefer-asimd|prefer-sve] Force an ISA selection strategy for auto-vectorization.  For best performance it is highly recommended to use -mcpu or -mtune instead.  This parameter should only be used for code exploration."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:319
+#: config/aarch64/aarch64.opt:324
 #, no-c-format
 msgid "Enables verbose cost model dumping in the debug dump files."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:323
+#: config/aarch64/aarch64.opt:328
 #, no-c-format
 msgid "Generate code to track when the CPU might be speculating incorrectly."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:327
+#: config/aarch64/aarch64.opt:332
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs before register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:332
+#: config/aarch64/aarch64.opt:337
 #, no-c-format
 msgid "Enable the copy of the AArch64 load/store pair fusion pass that runs after register allocation."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:351
+#: config/aarch64/aarch64.opt:356
 #, no-c-format
 msgid "Use the system register specified on the command line as the stack protector guard register. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:357
+#: config/aarch64/aarch64.opt:362
 #, no-c-format
 msgid "Use an immediate to offset from the stack protector guard register, sp_el0. This option is for use with fstack-protector-strong and not for use in user-land code."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:366
+#: config/aarch64/aarch64.opt:371
 #, fuzzy, no-c-format
 #| msgid "Generate a call to abort if a noreturn function returns"
 msgid "Generate local calls to out-of-line atomic operations."
 msgstr "當 noreturn 函式回傳時呼叫 abort"
 
-#: config/aarch64/aarch64.opt:370
+#: config/aarch64/aarch64.opt:375
 #, no-c-format
 msgid "When vectorizing, consider using multiple different approaches and use the cost model to choose the cheapest one."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:375
+#: config/aarch64/aarch64.opt:380
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for float type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 1."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:379
+#: config/aarch64/aarch64.opt:384
 #, no-c-format
 msgid "The number of Newton iterations for calculating the reciprocal for double type.  The precision of division is proportional to this param when division approximation is enabled.  The default value is 2."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:383
+#: config/aarch64/aarch64.opt:388
 #, no-c-format
 msgid "An old alias for -mautovec-preference.  If both -mautovec-preference and --param=aarch64-autovec-preference are passed, the --param value will be used."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:409
+#: config/aarch64/aarch64.opt:414
 #, no-c-format
 msgid "Constant memcpy size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:413
+#: config/aarch64/aarch64.opt:418
 #, no-c-format
 msgid "Constant memmove size in bytes above which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:417
+#: config/aarch64/aarch64.opt:422
 #, no-c-format
 msgid "Constant memset size in bytes from which to start using MOPS sequence."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:425
+#: config/aarch64/aarch64.opt:430
 #, no-c-format
 msgid "--param=aarch64-ldp-policy=[default|always|never|aligned] Fine-grained policy for load pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:429
+#: config/aarch64/aarch64.opt:434
 #, no-c-format
 msgid "--param=aarch64-stp-policy=[default|always|never|aligned] Fine-grained policy for store pairs."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:448
+#: config/aarch64/aarch64.opt:453
 #, no-c-format
 msgid "Limit on number of alias checks performed when attempting to form an ldp/stp."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:452
+#: config/aarch64/aarch64.opt:457
 #, no-c-format
 msgid "Param to control which writeback opportunities we try to handle in the load/store pair fusion pass.  A value of zero disables writeback handling.  One means we try to form pairs involving one or more existing individual writeback accesses where possible.  A value of two means we also try to opportunistically form writeback opportunities by folding in trailing destructive updates of the base register used by a pair."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:461
+#: config/aarch64/aarch64.opt:466
 #, no-c-format
 msgid "Param to control the treshold in number of granules beyond which an explicit loop for tagging a memory block is emitted."
 msgstr ""
 
-#: config/aarch64/aarch64.opt:466
+#: config/aarch64/aarch64.opt:471
 #, fuzzy, no-c-format
 #| msgid "This switch is deprecated; use -Wextra instead"
 msgid "This option is deprecated."
@@ -11953,7 +11958,7 @@ msgstr "在樹上進行循環向量化"
 
 #: params.opt:1300
 #, no-c-format
-msgid "The scaling multiplier as a percentage to apply to all scalar loop costing when performing vectorization profitability analysis.  The default value is 100."
+msgid "Enable vectorization of loops that may not be profitable according to the cost model but still perform costing between vector modes."
 msgstr ""
 
 #: params.opt:1304
@@ -19341,88 +19346,88 @@ msgstr "遵循 ISO 1998 C++ 標準"
 msgid "Conform to the latest 202Y D language edition (experimental)."
 msgstr "符合到 ISO 2011 C 標準 (實驗性質和不完整支援)"
 
-#: calls.cc:1467
+#: calls.cc:1463
 msgid "a callee-copied argument is stored in the current function's frame"
 msgstr ""
 
-#: calls.cc:1537
+#: calls.cc:1533
 #, fuzzy
 msgid "argument must be passed by copying"
 msgstr "引數 1 必須是映射"
 
-#: calls.cc:2554
+#: calls.cc:2555
 msgid "machine description does not have a sibcall_epilogue instruction pattern"
 msgstr ""
 
-#: calls.cc:2566
+#: calls.cc:2567
 msgid "callee returns a structure"
 msgstr ""
 
-#: calls.cc:2574
+#: calls.cc:2575
 msgid "target is not able to optimize the call into a sibling call"
 msgstr ""
 
-#: calls.cc:2583
+#: calls.cc:2584
 #, fuzzy
 msgid "callee returns twice"
 msgstr "呼叫者邊緣頻率是負"
 
-#: calls.cc:2588
+#: calls.cc:2589
 #, fuzzy
 msgid "callee does not return"
 msgstr "呼叫者邊緣頻率 %i 不匹配 BB 頻率 %i"
 
-#: calls.cc:2595
+#: calls.cc:2596
 #, fuzzy
 msgid "volatile function type"
 msgstr "變數 %qD 有函數型式"
 
-#: calls.cc:2614
+#: calls.cc:2615
 #, fuzzy
 msgid "nested function"
 msgstr "預期的函式"
 
-#: calls.cc:2625
+#: calls.cc:2626
 msgid "callee required more stack slots than the caller"
 msgstr ""
 
-#: calls.cc:2639
+#: calls.cc:2640
 #, fuzzy
 msgid "inconsistent number of popped arguments"
 msgstr "不同的參數數量"
 
-#: calls.cc:2646
+#: calls.cc:2647
 #, fuzzy
 #| msgid "%s does not support split_block"
 msgid "frontend does not support sibling call"
 msgstr "%s 不支援 split_block"
 
-#: calls.cc:2702
+#: calls.cc:2703
 msgid "other reasons"
 msgstr ""
 
-#: calls.cc:3076
+#: calls.cc:3077
 msgid "inside another call"
 msgstr ""
 
-#: calls.cc:3085
+#: calls.cc:3086
 #, fuzzy
 msgid "variable size arguments"
 msgstr "無效的 PHI 引數"
 
-#: calls.cc:3109
+#: calls.cc:3110
 #, fuzzy
 #| msgid "passing %qT for argument %P to %qD"
 msgid "hidden string length argument passed on stack"
 msgstr "將 %qT 做為引數 %P 傳遞給 %qD"
 
-#: calls.cc:3158
+#: calls.cc:3159
 msgid "caller and callee disagree in promotion of function return value"
 msgstr ""
 
 #. Ideally we'd emit a message for all of the ways that it could
 #. have failed.
-#: calls.cc:4085
+#: calls.cc:4086
 #, fuzzy
 msgid "tail call production failed"
 msgstr "靜態假設失敗：%E"
@@ -19540,12 +19545,12 @@ msgstr "「%%l」運算元不是一個標籤"
 #. PRINT_OPERAND must handle them.
 #. We can't handle floating point constants;
 #. TARGET_PRINT_OPERAND must handle them.
-#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13346
+#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370
 #, c-format
 msgid "floating constant misused"
 msgstr "錯誤地使用了浮點常數"
 
-#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13440
+#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464
 #: config/pdp11/pdp11.cc:1872
 #, c-format
 msgid "invalid expression as operand"
@@ -20873,12 +20878,12 @@ msgstr ""
 msgid "this is the insn:"
 msgstr "這是指令："
 
-#: lra-constraints.cc:4197
+#: lra-constraints.cc:4198
 #, fuzzy
 msgid "unable to reload address in "
 msgstr "無效的 %%d 運算元"
 
-#: lra-constraints.cc:4522 reload.cc:3852
+#: lra-constraints.cc:4523 reload.cc:3852
 msgid "unable to generate reloads for:"
 msgstr "無法產生重新載入，為："
 
@@ -21107,7 +21112,7 @@ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
 msgstr "%s%sGGC 準則：--param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
 
 #: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614
-#: c/c-typeck.cc:9587 cp/error.cc:1379 c-family/c-pretty-print.cc:441
+#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441
 #, gcc-internal-format
 msgid "<anonymous>"
 msgstr "<anonymous>"
@@ -21496,20 +21501,20 @@ msgstr "「%c」代碼不支援的運算元"
 #: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229
 #: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468
 #: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872
-#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8092
-#: config/riscv/riscv.cc:8108 config/riscv/riscv.cc:8124
-#: config/riscv/riscv.cc:8140 config/riscv/riscv.cc:8173
-#: config/riscv/riscv.cc:8182 config/riscv/riscv.cc:8191
-#: config/riscv/riscv.cc:8201
+#: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095
+#: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127
+#: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176
+#: config/riscv/riscv.cc:8185 config/riscv/riscv.cc:8194
+#: config/riscv/riscv.cc:8204
 #, c-format
 msgid "invalid operand for '%%%c'"
 msgstr "「%%%c」的運算元無效"
 
 #: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151
 #: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326
-#: config/riscv/riscv.cc:7988 config/riscv/riscv.cc:7996
-#: config/riscv/riscv.cc:8003 config/riscv/riscv.cc:8007
-#: config/riscv/riscv.cc:8049 config/riscv/riscv.cc:8067
+#: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999
+#: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010
+#: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070
 #, fuzzy, c-format
 msgid "invalid vector constant"
 msgstr "無效指令："
@@ -21555,82 +21560,82 @@ msgstr "無效的運算元前綴「%%%c」"
 msgid "invalid address mode"
 msgstr "無效的定址模式"
 
-#: config/aarch64/aarch64.cc:23806
+#: config/aarch64/aarch64.cc:23822
 #, fuzzy
 msgid "invalid conversion from type %<mfloat8_t%>"
 msgstr "從 %<bfloat16_t%> 類型轉換無效"
 
-#: config/aarch64/aarch64.cc:23808
+#: config/aarch64/aarch64.cc:23824
 #, fuzzy
 msgid "invalid conversion to type %<mfloat8_t%>"
 msgstr "轉換至 %<bfloat16_t%> 類型無效"
 
-#: config/aarch64/aarch64.cc:31118
+#: config/aarch64/aarch64.cc:31134
 #, fuzzy
 msgid "preincrement operation not permitted on svbool_t"
 msgstr "沒有 pre-increment 運算子用於型態"
 
-#: config/aarch64/aarch64.cc:31120
+#: config/aarch64/aarch64.cc:31136
 #, fuzzy
 msgid "predecrement operation not permitted on svbool_t"
 msgstr "沒有 pre-decrement 運算子用於型態"
 
-#: config/aarch64/aarch64.cc:31122
+#: config/aarch64/aarch64.cc:31138
 #, fuzzy
 msgid "postincrement operation not permitted on svbool_t"
 msgstr "沒有 post-increment 運算子用於型態"
 
-#: config/aarch64/aarch64.cc:31124
+#: config/aarch64/aarch64.cc:31140
 #, fuzzy
 msgid "postdecrement operation not permitted on svbool_t"
 msgstr "沒有 post-decrement 運算子用於型態"
 
-#: config/aarch64/aarch64.cc:31126
+#: config/aarch64/aarch64.cc:31142
 #, fuzzy
 #| msgid "%<this%> may not be used in this context"
 msgid "negation operation not permitted on svbool_t"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: config/aarch64/aarch64.cc:31128
+#: config/aarch64/aarch64.cc:31144
 msgid "plus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31130
+#: config/aarch64/aarch64.cc:31146
 msgid "minus operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31132
+#: config/aarch64/aarch64.cc:31148
 msgid "multiply operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31134
+#: config/aarch64/aarch64.cc:31150
 msgid "divide operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31137
+#: config/aarch64/aarch64.cc:31153
 msgid "shift operation not permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31142
+#: config/aarch64/aarch64.cc:31158
 msgid "only == and != operations permitted on svbool_t"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:31144
+#: config/aarch64/aarch64.cc:31160
 #, fuzzy
 msgid "subscript operation not supported on svbool_t"
 msgstr "堆疊用法計算不支援用於這個目標"
 
-#: config/aarch64/aarch64.cc:31165 config/aarch64/aarch64.cc:31198
+#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214
 #, fuzzy
 msgid "operation not permitted on type %<mfloat8_t%>"
 msgstr "轉換至 %<bfloat16_t%> 類型無效"
 
-#: config/aarch64/aarch64.cc:31186
+#: config/aarch64/aarch64.cc:31202
 #, fuzzy
 msgid "cannot combine GNU and SVE vectors in a binary operation"
 msgstr "無效的運算元在中二進運算"
 
-#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14652
+#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676
 #: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386
 #, fuzzy, c-format
 msgid "'%%&' used without any local dynamic TLS references"
@@ -21647,13 +21652,13 @@ msgid "invalid %%r value"
 msgstr "無效 %%r 值"
 
 #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591
-#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3011
+#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016
 #, c-format
 msgid "invalid %%R value"
 msgstr "無效 %%R 值"
 
 #: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300
-#: config/xtensa/xtensa.cc:2984
+#: config/xtensa/xtensa.cc:2989
 #, c-format
 msgid "invalid %%N value"
 msgstr "無效 %%N 值"
@@ -21668,7 +21673,7 @@ msgstr "無效 %%P 值"
 msgid "invalid %%h value"
 msgstr "無效 %%h 值"
 
-#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3004
+#: config/alpha/alpha.cc:5904 config/xtensa/xtensa.cc:3009
 #, c-format
 msgid "invalid %%L value"
 msgstr "無效 %%L 值"
@@ -21683,7 +21688,7 @@ msgstr "無效 %%m 值"
 msgid "invalid %%M value"
 msgstr "無效 %%M 值"
 
-#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3018
+#: config/alpha/alpha.cc:5966 config/xtensa/xtensa.cc:3023
 #, c-format
 msgid "invalid %%U value"
 msgstr "無效 %%U 值"
@@ -22033,7 +22038,7 @@ msgstr "非預期的運算元"
 #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327
 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361
 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529
-#: cobol/genutil.cc:1182 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8107
+#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101
 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37
 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53
 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332
@@ -22280,132 +22285,132 @@ msgstr "無效指令："
 msgid "Expected register or constant integer."
 msgstr "預期的介面或指標到介面"
 
-#: config/i386/i386.cc:13434
+#: config/i386/i386.cc:13458
 #, c-format
 msgid "invalid UNSPEC as operand"
 msgstr "無效的 UNSPEC 做為運算元"
 
-#: config/i386/i386.cc:13977
+#: config/i386/i386.cc:14001
 #, fuzzy, c-format
 #| msgid "invalid use of %<restrict%>"
 msgid "invalid use of register '%s'"
 msgstr "錯誤地使用了 %<restrict%>"
 
-#: config/i386/i386.cc:13982
+#: config/i386/i386.cc:14006
 #, fuzzy, c-format
 #| msgid "invalid lvalue in asm output %d"
 msgid "invalid use of asm flag output"
 msgstr "組譯輸出 %d 中左值無效"
 
-#: config/i386/i386.cc:14217
+#: config/i386/i386.cc:14241
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'O'"
 msgstr "無效的運算元大小用於運算元編碼『%c』"
 
-#: config/i386/i386.cc:14252
+#: config/i386/i386.cc:14276
 #, fuzzy, c-format
 msgid "invalid operand size for operand code 'z'"
 msgstr "無效的運算元大小用於運算元編碼『%c』"
 
-#: config/i386/i386.cc:14327
+#: config/i386/i386.cc:14351
 #, fuzzy, c-format
 msgid "invalid operand type used with operand code '%c'"
 msgstr "無效的運算元類型使用的與運算元編碼『%c』"
 
-#: config/i386/i386.cc:14332
+#: config/i386/i386.cc:14356
 #, fuzzy, c-format
 msgid "invalid operand size for operand code '%c'"
 msgstr "無效的運算元大小用於運算元編碼『%c』"
 
-#: config/i386/i386.cc:14410
+#: config/i386/i386.cc:14434
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code 'Y'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『Y』"
 
-#: config/i386/i386.cc:14489
+#: config/i386/i386.cc:14513
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code 'D'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『D』"
 
-#: config/i386/i386.cc:14507
+#: config/i386/i386.cc:14531
 #, fuzzy, c-format
 msgid "operand is not a condition code, invalid operand code '%c'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『D』"
 
-#: config/i386/i386.cc:14528
+#: config/i386/i386.cc:14552
 #, fuzzy, c-format
 msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
 msgstr "運算元不是 offsettable 記憶體參考，無效的運算元編碼『H』"
 
-#: config/i386/i386.cc:14543
+#: config/i386/i386.cc:14567
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'K'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『Y』"
 
-#: config/i386/i386.cc:14571
+#: config/i386/i386.cc:14595
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'r'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『Y』"
 
-#: config/i386/i386.cc:14589
+#: config/i386/i386.cc:14613
 #, fuzzy, c-format
 msgid "operand is not an integer, invalid operand code 'R'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『Y』"
 
-#: config/i386/i386.cc:14612
+#: config/i386/i386.cc:14636
 #, fuzzy, c-format
 msgid "operand is not a specific integer, invalid operand code 'R'"
 msgstr "運算元並非條件編碼，無效的運算元編碼『Y』"
 
-#: config/i386/i386.cc:14639
+#: config/i386/i386.cc:14663
 #, fuzzy, c-format
 msgid "operand is not a memory reference, invalid operand code 'v'"
 msgstr "運算元不是 offsettable 記憶體參考，無效的運算元編碼『H』"
 
-#: config/i386/i386.cc:14727
+#: config/i386/i386.cc:14751
 #, c-format
 msgid "invalid operand code '%c'"
 msgstr "無效的運算元程式碼「%c」"
 
-#: config/i386/i386.cc:14789 config/i386/i386.cc:15178
+#: config/i386/i386.cc:14813 config/i386/i386.cc:15202
 #, c-format
 msgid "invalid constraints for operand"
 msgstr "運算元的約束無效"
 
-#: config/i386/i386.cc:14890
+#: config/i386/i386.cc:14914
 #, fuzzy, c-format
 msgid "invalid vector immediate"
 msgstr "無效的控制述詞"
 
-#: config/i386/i386.cc:18068
+#: config/i386/i386.cc:18092
 msgid "unknown insn mode"
 msgstr "不明的指令模式"
 
-#: config/i386/i386.cc:24802
+#: config/i386/i386.cc:24925
 #, fuzzy
 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>"
 msgstr "從 %<bfloat16_t%> 類型轉換無效"
 
-#: config/i386/i386.cc:24805
+#: config/i386/i386.cc:24928
 #, fuzzy
 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>"
 msgstr "從 %<bfloat16_t%> 類型轉換無效"
 
-#: config/i386/i386.cc:24808
+#: config/i386/i386.cc:24931
 #, fuzzy
 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>"
 msgstr "轉換至 %<bfloat16_t%> 類型無效"
 
-#: config/i386/i386.cc:24811
+#: config/i386/i386.cc:24934
 #, fuzzy
 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>"
 msgstr "轉換至 %<bfloat16_t%> 類型無效"
 
-#: config/i386/i386.cc:24849 config/i386/i386.cc:24874
+#: config/i386/i386.cc:24972 config/i386/i386.cc:24997
 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>"
 msgstr ""
 
-#: config/i386/i386.cc:24852 config/i386/i386.cc:24878
+#: config/i386/i386.cc:24975 config/i386/i386.cc:25001
 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>"
 msgstr ""
 
@@ -22487,9 +22492,9 @@ msgstr "『%%%c』並非有效運算元前綴"
 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572
 #: config/mips/mips.cc:9632 config/mips/mips.cc:9639 config/mips/mips.cc:9660
 #: config/mips/mips.cc:9675 config/mips/mips.cc:9694 config/mips/mips.cc:9703
-#: config/riscv/riscv.cc:7789 config/riscv/riscv.cc:8258
-#: config/riscv/riscv.cc:8264 config/riscv/riscv.cc:8280
-#: config/riscv/riscv.cc:8291
+#: config/riscv/riscv.cc:7792 config/riscv/riscv.cc:8261
+#: config/riscv/riscv.cc:8267 config/riscv/riscv.cc:8283
+#: config/riscv/riscv.cc:8294
 #, fuzzy, c-format
 msgid "invalid use of '%%%c'"
 msgstr "無效的使用的『%%%c』"
@@ -22555,7 +22560,7 @@ msgid "insn contains an invalid address !"
 msgstr "insn 含有無效的位址！"
 
 #: config/microblaze/microblaze.cc:2439 config/microblaze/microblaze.cc:2669
-#: config/xtensa/xtensa.cc:3121
+#: config/xtensa/xtensa.cc:3126
 msgid "invalid address"
 msgstr "無效位址"
 
@@ -22631,7 +22636,7 @@ msgstr "無效的循環移位指令"
 msgid "invalid %%H value"
 msgstr "無效 %%H 值"
 
-#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3039
+#: config/or1k/or1k.cc:1271 config/xtensa/xtensa.cc:3044
 #, c-format
 msgid "invalid %%d value"
 msgstr "無效的 %%d 值"
@@ -22684,34 +22689,34 @@ msgstr "不支援的組合：%s"
 msgid "unsupported memory expression:"
 msgstr "無效的類型在中定點轉換"
 
-#: config/riscv/riscv.cc:7969
+#: config/riscv/riscv.cc:7972
 #, fuzzy, c-format
 msgid "invalid vector operand"
 msgstr "無效的 %%r 運算元"
 
-#: config/riscv/riscv.cc:8214
+#: config/riscv/riscv.cc:8217
 #, c-format
 msgid "modifier 'N' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8227
+#: config/riscv/riscv.cc:8230
 #, fuzzy, c-format
 #| msgid "invalid operand for 'b' modifier"
 msgid "invalid register number for 'N' modifier"
 msgstr "「b」修飾符的運算元無效"
 
-#: config/riscv/riscv.cc:8236
+#: config/riscv/riscv.cc:8239
 #, c-format
 msgid "modifier 'H' require register operand"
 msgstr ""
 
-#: config/riscv/riscv.cc:8241
+#: config/riscv/riscv.cc:8244
 #, fuzzy, c-format
 #| msgid "unsupported operand size for extended register"
 msgid "modifier 'H' is for integer registers only"
 msgstr "擴充的暫存器不支援的運算元大小"
 
-#: config/riscv/riscv.cc:8246
+#: config/riscv/riscv.cc:8249
 #, fuzzy, c-format
 #| msgid "%qV qualifiers cannot be applied to %qT"
 msgid "modifier 'H' cannot be applied to R31"
@@ -22774,7 +22779,7 @@ msgstr "錯誤 128 位元移動"
 msgid "invalid %%A value"
 msgstr "無效 %%J 值"
 
-#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2950
+#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955
 #, c-format
 msgid "invalid %%D value"
 msgstr "無效的 %%D 值"
@@ -22815,7 +22820,7 @@ msgstr "無效 %%J 程式碼"
 msgid "invalid %%k value"
 msgstr "無效 %%k 值"
 
-#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:2997
+#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002
 #, c-format
 msgid "invalid %%K value"
 msgstr "無效 %%K 值"
@@ -22846,18 +22851,18 @@ msgstr "無效 %%T 值"
 msgid "invalid %%u value"
 msgstr "無效 %%u 值"
 
-#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2972
+#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977
 #, c-format
 msgid "invalid %%v value"
 msgstr "無效 %%v 值"
 
-#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3025
+#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030
 #, fuzzy, c-format
 #| msgid "invalid %%H value"
 msgid "invalid %%V value"
 msgstr "無效 %%H 值"
 
-#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3032
+#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037
 #, c-format
 msgid "invalid %%x value"
 msgstr "無效的 %%x 值"
@@ -23083,28 +23088,28 @@ msgstr "無效的 %%s 運算元"
 msgid "floating-point constant not a valid immediate operand"
 msgstr "浮點常數不是一個有效的立即數值運算元"
 
-#: config/stormy16/stormy16.cc:1894 config/stormy16/stormy16.cc:1965
+#: config/stormy16/stormy16.cc:1895 config/stormy16/stormy16.cc:1966
 #, c-format
 msgid "'B' operand is not constant"
 msgstr "「B」運算元不是一個常數"
 
-#: config/stormy16/stormy16.cc:1921
+#: config/stormy16/stormy16.cc:1922
 #, c-format
 msgid "'B' operand has multiple bits set"
 msgstr "「B」運算元設定了多個位"
 
-#: config/stormy16/stormy16.cc:1947
+#: config/stormy16/stormy16.cc:1948
 #, c-format
 msgid "'o' operand is not constant"
 msgstr "「o」運算元不是一個常數"
 
-#: config/stormy16/stormy16.cc:1979
+#: config/stormy16/stormy16.cc:1980
 #, fuzzy, c-format
 #| msgid "'B' operand is not constant"
 msgid "'h' operand is not SImode register"
 msgstr "「B」運算元不是一個常數"
 
-#: config/stormy16/stormy16.cc:1987
+#: config/stormy16/stormy16.cc:1988
 #, c-format
 msgid "xstormy16_print_operand: unknown code"
 msgstr "xstormy16_print_operand：不明程式碼"
@@ -23168,24 +23173,24 @@ msgstr "不合法的運算元偵測到"
 msgid "Unable to load DLL."
 msgstr "產生動態連結程式庫的程式碼"
 
-#: config/xtensa/xtensa.cc:845 config/xtensa/xtensa.cc:879
+#: config/xtensa/xtensa.cc:840 config/xtensa/xtensa.cc:874
 msgid "bad test"
 msgstr "錯誤的測試"
 
-#: config/xtensa/xtensa.cc:2992
+#: config/xtensa/xtensa.cc:2997
 msgid "invalid mask"
 msgstr "無效遮罩"
 
-#: config/xtensa/xtensa.cc:3058 config/xtensa/xtensa.cc:3068
+#: config/xtensa/xtensa.cc:3063 config/xtensa/xtensa.cc:3073
 #, c-format
 msgid "invalid %%t/%%b value"
 msgstr "無效的 %%t/%%b 值"
 
-#: config/xtensa/xtensa.cc:3146
+#: config/xtensa/xtensa.cc:3151
 msgid "no register in address"
 msgstr "位址中無暫存器"
 
-#: config/xtensa/xtensa.cc:3154
+#: config/xtensa/xtensa.cc:3159
 msgid "address offset not a constant"
 msgstr "位址偏移量不是一個常數"
 
@@ -23222,7 +23227,7 @@ msgstr "{匿名}"
 msgid "aka"
 msgstr "又名"
 
-#: c/c-objc-common.cc:395 c/c-typeck.cc:8295
+#: c/c-objc-common.cc:395 c/c-typeck.cc:8303
 #, fuzzy
 msgid "({anonymous})"
 msgstr "({匿名})"
@@ -23248,8 +23253,8 @@ msgstr "({匿名})"
 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543
 #: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520
 #: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234
-#: c/gimple-parser.cc:2246 cp/parser.cc:18008 cp/parser.cc:37077
-#: cp/parser.cc:37716
+#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137
+#: cp/parser.cc:37776
 #, gcc-internal-format
 msgid "expected %<;%>"
 msgstr "需要 %<;%>"
@@ -23277,7 +23282,7 @@ msgstr "預期 %<,%>或 %<)%>"
 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944
 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337
 #: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605
-#: c/c-parser.cc:21763 cp/parser.cc:37764 cp/parser.cc:46127
+#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%>"
 msgstr "預期 %<)%>"
@@ -23285,7 +23290,7 @@ msgstr "預期 %<)%>"
 #: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346
 #: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704
 #: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999
-#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37728
+#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788
 #, fuzzy, gcc-internal-format
 msgid "expected %<]%>"
 msgstr "預期 %<]%>"
@@ -23306,13 +23311,13 @@ msgstr "預期 %<;%>，%<,%>或 %<)%>"
 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695
 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136
 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497
-#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37719
+#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%>"
 msgstr "預期 %<(%>"
 
-#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37731
-#: cp/parser.cc:41634 go/gofrontend/embed.cc:440
+#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791
+#: cp/parser.cc:41694 go/gofrontend/embed.cc:440
 #, fuzzy, gcc-internal-format
 msgid "expected %<[%>"
 msgstr "預期 %<[%>"
@@ -23321,7 +23326,7 @@ msgstr "預期 %<[%>"
 #: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890
 #: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452
 #: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544
-#: c/c-parser.cc:14863 cp/parser.cc:23905 cp/parser.cc:37725
+#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785
 #: go/gofrontend/embed.cc:371
 #, gcc-internal-format
 msgid "expected %<{%>"
@@ -23338,13 +23343,13 @@ msgstr "需要 %<{%>"
 #: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635
 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551
 #: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642
-#: c/c-parser.cc:19056 cp/parser.cc:37758 cp/parser.cc:39474 cp/parser.cc:42574
-#: cp/parser.cc:43478 go/gofrontend/embed.cc:404
+#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634
+#: cp/parser.cc:43538 go/gofrontend/embed.cc:404
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%>"
 msgstr "預期 %<:%>"
 
-#: c/c-parser.cc:9106 cp/parser.cc:37645
+#: c/c-parser.cc:9106 cp/parser.cc:37705
 #, fuzzy, gcc-internal-format
 msgid "expected %<while%>"
 msgstr "預期 %<while%>"
@@ -23354,7 +23359,7 @@ msgstr "預期 %<while%>"
 #: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443
 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286
 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705
-#: cp/parser.cc:37075 cp/parser.cc:37734
+#: cp/parser.cc:37135 cp/parser.cc:37794
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%>"
 msgstr "預期 %<,%>"
@@ -23365,18 +23370,18 @@ msgid "expected %<.%>"
 msgstr "預期 %<.%>"
 
 #: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806
-#: cp/parser.cc:40048 cp/parser.cc:40069
+#: cp/parser.cc:40108 cp/parser.cc:40129
 #, fuzzy, gcc-internal-format
 msgid "expected %<@end%>"
 msgstr "預期 %<@end%>"
 
-#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37743
+#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803
 #, fuzzy, gcc-internal-format
 msgid "expected %<>%>"
 msgstr "預期 %<>%>"
 
 #: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634
-#: cp/parser.cc:37767 cp/parser.cc:45978
+#: cp/parser.cc:37827 cp/parser.cc:46038
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%> or %<)%>"
 msgstr "預期 %<,%>或 %<)%>"
@@ -23386,46 +23391,46 @@ msgstr "預期 %<,%>或 %<)%>"
 #: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199
 #: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524
 #: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060
-#: c/c-parser.cc:24283 cp/parser.cc:37746 cp/parser.cc:47688 cp/parser.cc:47861
+#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921
 #, gcc-internal-format
 msgid "expected %<=%>"
 msgstr "需要 %<=%>"
 
 #: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239
 #: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764
-#: cp/parser.cc:46128 cp/parser.cc:46155 cp/parser.cc:53806 cp/parser.cc:53817
+#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877
 #, fuzzy, gcc-internal-format
 msgid "expected %<)%> or %<,%>"
 msgstr "預期 %<,%>或 %<)%>"
 
 #: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504
 #: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785
-#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37722
-#: cp/parser.cc:40258
+#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782
+#: cp/parser.cc:40318
 #, fuzzy, gcc-internal-format
 msgid "expected %<}%>"
 msgstr "預期 %<}%>"
 
-#: c/c-parser.cc:24164 cp/parser.cc:47786
+#: c/c-parser.cc:24164 cp/parser.cc:47846
 #, fuzzy, gcc-internal-format
 msgid "expected %<else%>"
 msgstr "預期 %<delete%>"
 
-#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50747
+#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp section%> or %<}%>"
 msgstr "預期 %<# pragma omp section%>或 %<}%>"
 
-#: c/c-parser.cc:30216 cp/parser.cc:56058
+#: c/c-parser.cc:30216 cp/parser.cc:56118
 msgid "<message unknown at compile time>"
 msgstr ""
 
-#: c/c-typeck.cc:10458
+#: c/c-typeck.cc:10466
 #, fuzzy
 msgid "(anonymous)"
 msgstr "(匿名)"
 
-#: c/gimple-parser.cc:1446 cp/parser.cc:21168 cp/parser.cc:37740
+#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800
 #, fuzzy, gcc-internal-format
 msgid "expected %<<%>"
 msgstr "預期 %<<%>"
@@ -23452,7 +23457,7 @@ msgstr "candidate 是："
 msgid "  after user-defined conversion:"
 msgstr "啟用使用者定義的指令"
 
-#: cp/call.cc:8800 cp/pt.cc:27736
+#: cp/call.cc:8800 cp/pt.cc:27894
 #, fuzzy
 msgid "candidate is:"
 msgid_plural "candidates are:"
@@ -23567,7 +23572,7 @@ msgstr "<template parameter error>"
 msgid "<statement>"
 msgstr "<statement>"
 
-#: cp/error.cc:2472 cp/error.cc:3636 c-family/c-pretty-print.cc:2688
+#: cp/error.cc:2472 cp/error.cc:3643 c-family/c-pretty-print.cc:2688
 #, fuzzy, gcc-internal-format
 msgid "<unknown>"
 msgstr "<unknown>"
@@ -23597,309 +23602,352 @@ msgstr "<lambda"
 msgid "*this"
 msgstr "*this"
 
-#: cp/error.cc:3360
+#: cp/error.cc:3367
 #, fuzzy
 msgid "<expression error>"
 msgstr "<expression error>"
 
-#: cp/error.cc:3375
+#: cp/error.cc:3382
 #, fuzzy
 msgid "<unknown operator>"
 msgstr "<unknown operator>"
 
-#: cp/error.cc:3865
+#: cp/error.cc:3872
 #, fuzzy
 msgid "At global scope:"
 msgstr "於全域範圍："
 
-#: cp/reflect.cc:565
-#, fuzzy
-#| msgid "accumulator is not a constant integer"
-msgid "array element not a constant integer"
-msgstr "累加數不是一個整常數"
+#: cp/reflect.cc:408
+msgid "reflect_constant_array failed"
+msgstr ""
 
-#: cp/reflect.cc:573 cp/reflect.cc:3906
+#: cp/reflect.cc:424 cp/reflect.cc:659 cp/reflect.cc:4039
 #, fuzzy
 msgid "reflect_constant failed"
 msgstr "預期的初始設定式"
 
-#: cp/reflect.cc:1031
+#: cp/reflect.cc:641
+#, fuzzy
+#| msgid "accumulator is not a constant integer"
+msgid "array element not a constant integer"
+msgstr "累加數不是一個整常數"
+
+#: cp/reflect.cc:1117
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a type"
 msgstr "函式不回傳字串類型"
 
-#: cp/reflect.cc:1043
+#: cp/reflect.cc:1129
 #, fuzzy
 msgid "reflection does not have template arguments"
 msgstr "重新宣告的朋友 %q#D 可能無法有預設模板引數"
 
-#: cp/reflect.cc:1054
+#: cp/reflect.cc:1140
 #, fuzzy
 msgid "reflection does not represent a function or function type"
 msgstr "被呼叫的物件 %qE 不是一個函式"
 
-#: cp/reflect.cc:2355
+#: cp/reflect.cc:2441
 msgid "reflection does not represent an operator function or operator function template"
 msgstr ""
 
-#: cp/reflect.cc:2405
+#: cp/reflect.cc:2491
 #, fuzzy
 msgid "operators argument is not a valid operator"
 msgstr "%qs 無效用於 %qs"
 
-#: cp/reflect.cc:2536
+#: cp/reflect.cc:2622 cp/reflect.cc:6057
 #, fuzzy
 #| msgid "%qE does not have class type"
 msgid "reflection does not have a type"
 msgstr "%qE 不是一個類別"
 
-#: cp/reflect.cc:2652
+#: cp/reflect.cc:2738
 msgid "reflection does not represent an object with static storage duration, or a reference to such an object"
 msgstr ""
 
-#: cp/reflect.cc:2733
+#: cp/reflect.cc:2821
 msgid "reflection does not represent an annotation or a valid argument to a splice-expression"
 msgstr ""
 
-#: cp/reflect.cc:2953
+#: cp/reflect.cc:3041
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent an entity with parent"
 msgstr "函式不回傳字串類型"
 
-#: cp/reflect.cc:3076
+#: cp/reflect.cc:3164
 #, fuzzy
 #| msgid "friend declaration does not name a class or function"
 msgid "reflection does not represent parameter of current function"
 msgstr "夥伴宣告沒有指定類別或函式名"
 
-#: cp/reflect.cc:3097
+#: cp/reflect.cc:3185
 #, fuzzy
 msgid "reflection does not represent a function or function type with a return type"
 msgstr "被呼叫的物件 %qE 不是一個函式"
 
-#: cp/reflect.cc:3128
+#: cp/reflect.cc:3216
 msgid "reflection of virtual direct base relationship with abstract derived class"
 msgstr ""
 
-#: cp/reflect.cc:3134
+#: cp/reflect.cc:3222
 msgid "reflection unsuitable for offset_of"
 msgstr ""
 
-#: cp/reflect.cc:3139
+#: cp/reflect.cc:3227
 #, fuzzy
 msgid "non-constant offset for offset_of"
 msgstr "non-constant 條件用於靜態假設"
 
-#: cp/reflect.cc:3203
+#: cp/reflect.cc:3291
 msgid "reflection not suitable for size_of"
 msgstr ""
 
-#: cp/reflect.cc:3222
+#: cp/reflect.cc:3310
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in size_of"
 msgstr "提領參照不完全類型的指標"
 
-#: cp/reflect.cc:3258
+#: cp/reflect.cc:3347
 #, fuzzy
 #| msgid "Do not tune writable data alignment"
 msgid "reflection not suitable for alignment_of"
 msgstr "不調整可寫資料對齊"
 
-#: cp/reflect.cc:3294
+#: cp/reflect.cc:3383
 #, fuzzy
 msgid "alignment_of on function type"
 msgstr "指派的函式 %qD"
 
-#: cp/reflect.cc:3303
+#: cp/reflect.cc:3392
 #, fuzzy
 msgid "reflection with incomplete type in alignment_of"
 msgstr "間接取值將無法存取物件的不完整型態 %qT 在中敘述"
 
-#: cp/reflect.cc:3338
+#: cp/reflect.cc:3427
 msgid "reflection not suitable for bit_size_of"
 msgstr ""
 
-#: cp/reflect.cc:3362
+#: cp/reflect.cc:3451
 #, fuzzy
 #| msgid "dereferencing pointer to incomplete type"
 msgid "reflection with incomplete type in bit_size_of"
 msgstr "提領參照不完全類型的指標"
 
-#: cp/reflect.cc:3538
+#: cp/reflect.cc:3627
 msgid "reflection with has_identifier false"
 msgstr ""
 
-#: cp/reflect.cc:3578 cp/reflect.cc:3668
+#: cp/reflect.cc:3667
 msgid "identifier_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3582 cp/reflect.cc:3672
+#: cp/reflect.cc:3671
 msgid "u8identifier_of not representable in UTF-8"
 msgstr ""
 
-#: cp/reflect.cc:3805
-msgid "reflection does not represent a type, type alias, variable, function, namespace, enumerator, direct base class relationship, or non-static data member"
+#: cp/reflect.cc:3777
+msgid "display_string_of not representable in ordinary literal encoding"
 msgstr ""
 
-#: cp/reflect.cc:3817
+#: cp/reflect.cc:3782
+msgid "u8display_string_of not representable in UTF-8"
+msgstr ""
+
+#: cp/reflect.cc:3922
+msgid "reflection does not represent a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member"
+msgstr ""
+
+#: cp/reflect.cc:3935
 msgid "reflection does not represent a complete type or type alias"
 msgstr ""
 
-#: cp/reflect.cc:3930
+#: cp/reflect.cc:4063
 msgid "reflect_object failed"
 msgstr ""
 
-#: cp/reflect.cc:3957
+#: cp/reflect.cc:4090
 #, fuzzy
 msgid "reflect_function failed"
 msgstr "預期的函式"
 
-#: cp/reflect.cc:4840
+#: cp/reflect.cc:4970
 #, fuzzy
 #| msgid "argument to '-Xassembler' is missing"
 msgid "value member missing"
 msgstr "「-Xassembler」缺少引數"
 
-#: cp/reflect.cc:4851 cp/reflect.cc:4860
+#: cp/reflect.cc:4981 cp/reflect.cc:4990
 #, fuzzy
 msgid "unexpected value of value member"
 msgstr "預期的指標"
 
-#: cp/reflect.cc:4967
+#: cp/reflect.cc:5097
 msgid "type member missing"
 msgstr ""
 
-#: cp/reflect.cc:4991
+#: cp/reflect.cc:5121
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a complete enumeration type"
 msgstr "函式不回傳字串類型"
 
-#: cp/reflect.cc:5048
+#: cp/reflect.cc:5178
 #, fuzzy
 msgid "reflection does not represent an enumerable enumeration type"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/reflect.cc:5204
+#: cp/reflect.cc:5334
 #, fuzzy
 msgid "reflection represents non-integral or bool type"
 msgstr "預期的整數或布林值型態"
 
-#: cp/reflect.cc:5343
+#: cp/reflect.cc:5473
 #, fuzzy
 #| msgid "function does not return string type"
 msgid "reflection does not represent a template"
 msgstr "函式不回傳字串類型"
 
-#: cp/reflect.cc:5366
+#: cp/reflect.cc:5496
 #, fuzzy
 msgid "invalid argument to can_substitute"
 msgstr "無效的引數的 %qE 屬性"
 
-#: cp/reflect.cc:5428
+#: cp/reflect.cc:5558
 msgid "can_substitute returned false"
 msgstr ""
 
-#: cp/reflect.cc:5559
+#: cp/reflect.cc:5694
 #, fuzzy
 msgid "type is not object or reference type"
 msgstr "目標不是指標或參考"
 
-#: cp/reflect.cc:5804
+#: cp/reflect.cc:5961
 msgid "conversion from ordinary literal encoding to source charset failed"
 msgstr ""
 
-#: cp/reflect.cc:5810
+#: cp/reflect.cc:5967
 #, fuzzy
 msgid "conversion from UTF-8 encoding to source charset failed"
 msgstr "轉換到 %qT 從 %qT 也許會改變它的值"
 
-#: cp/reflect.cc:5818
+#: cp/reflect.cc:5975
 #, fuzzy
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "name is not a valid identifier"
 msgstr "%<%T::%D%> 不是一個有效的宣告"
 
-#: cp/reflect.cc:5824
+#: cp/reflect.cc:5981
 msgid "name is a keyword"
 msgstr ""
 
-#: cp/reflect.cc:5827
+#: cp/reflect.cc:5984
 msgid "name is a built-in trait"
 msgstr ""
 
-#: cp/reflect.cc:5836
+#: cp/reflect.cc:5993
 #, fuzzy
 #| msgid "register name not specified for %q+D"
 msgid "neither name nor bit_width specified"
 msgstr "%q+D 的暫存器名無效"
 
-#: cp/reflect.cc:5842
+#: cp/reflect.cc:5997
+msgid "no name and non-empty annotations specified"
+msgstr ""
+
+#: cp/reflect.cc:6003
 msgid "bit_width specified with non-integral and non-enumeration type"
 msgstr ""
 
-#: cp/reflect.cc:5847
+#: cp/reflect.cc:6008
 #, fuzzy
 #| msgid "no classes specified"
 msgid "both alignment and bit_width specified"
 msgstr "未指定類別"
 
-#: cp/reflect.cc:5851
+#: cp/reflect.cc:6012
 msgid "bit_width specified with no_unique_address true"
 msgstr ""
 
-#: cp/reflect.cc:5856
+#: cp/reflect.cc:6017
 #, fuzzy
 #| msgid "field width specifier"
 msgid "bit_width 0 with specified name"
 msgstr "欄位寬度說明符"
 
-#: cp/reflect.cc:5859
+#: cp/reflect.cc:6020
 #, fuzzy
 #| msgid "right shift count is negative"
 msgid "bit_width is negative"
 msgstr "右移次數為負"
 
-#: cp/reflect.cc:5866
+#: cp/reflect.cc:6026
+#, fuzzy
+msgid "name unspecified and type is const"
+msgstr "對齊指定的用於 typedef %qE"
+
+#: cp/reflect.cc:6030
+#, fuzzy
+msgid "name unspecified and type is volatile"
+msgstr "對齊指定的用於 typedef %qE"
+
+#: cp/reflect.cc:6038
 #, fuzzy
 #| msgid "requested alignment is not a power of 2"
 msgid "alignment is not power of two"
 msgstr "要求的對齊邊界不是 2 的某次方"
 
-#: cp/reflect.cc:5869
+#: cp/reflect.cc:6041
 #, fuzzy
 msgid "alignment is negative"
 msgstr "右旋轉計數是負"
 
-#: cp/reflect.cc:5876
+#: cp/reflect.cc:6048
 #, fuzzy
 msgid "alignment is smaller than alignment_of"
 msgstr "對齊的 %qD 是大於原來的宣告"
 
-#: cp/reflect.cc:6413
+#: cp/reflect.cc:6062
+#, fuzzy
+msgid "reflection does not have non-array object type"
+msgstr "%qD 沒有積分或列舉類型型態"
+
+#: cp/reflect.cc:6506
+#, fuzzy
+#| msgid "%qD is not a member template function"
+msgid "current scope does not represent a function"
+msgstr "%qD 不是一個成員範本函式"
+
+#: cp/reflect.cc:6526
+#, fuzzy
+#| msgid "friend declaration does not name a class or function"
+msgid "current scope does not represent a class nor a member function"
+msgstr "夥伴宣告沒有指定類別或函式名"
+
+#: cp/reflect.cc:6685
 #, fuzzy
 msgid "incomplete parent class"
 msgstr "不完整實作的類別 %qE"
 
-#: cp/reflect.cc:6859
+#: cp/reflect.cc:7149
 #, fuzzy
 msgid "neither complete class type nor namespace"
 msgstr "%qE 並非類別或命名空間"
 
-#: cp/reflect.cc:6889 cp/reflect.cc:6917 cp/reflect.cc:6946 cp/reflect.cc:6984
-#: cp/reflect.cc:7022 cp/reflect.cc:7053
+#: cp/reflect.cc:7179 cp/reflect.cc:7207 cp/reflect.cc:7236 cp/reflect.cc:7274
+#: cp/reflect.cc:7312 cp/reflect.cc:7343
 #, fuzzy
 msgid "not a complete class type"
 msgstr "來源是的不完整類別型態"
 
-#: cp/reflect.cc:7012
+#: cp/reflect.cc:7302
 msgid "closure type"
 msgstr ""
 
-#: cp/reflect.cc:7188 cp/reflect.cc:7247 cp/reflect.cc:7321
+#: cp/reflect.cc:7478 cp/reflect.cc:7537 cp/reflect.cc:7611
 #, fuzzy
 msgid "value cannot be extracted"
 msgstr "模板無法缺席"
@@ -23954,56 +24002,56 @@ msgstr "轉換演員陣容暫離 constness"
 msgid "source type is not polymorphic"
 msgstr "來源型態不是 polymorphic"
 
-#: cp/semantics.cc:6821
+#: cp/semantics.cc:6842
 msgid "candidates are:"
 msgstr "備選為："
 
-#: cp/typeck.cc:7784 c/c-typeck.cc:5822
+#: cp/typeck.cc:7779 c/c-typeck.cc:5830
 #, gcc-internal-format
 msgid "wrong type argument to unary minus"
 msgstr "單位元減的運算元類型錯誤"
 
-#: cp/typeck.cc:7785 c/c-typeck.cc:5808
+#: cp/typeck.cc:7780 c/c-typeck.cc:5816
 #, gcc-internal-format
 msgid "wrong type argument to unary plus"
 msgstr "單位元加的運算元類型錯誤"
 
-#: cp/typeck.cc:7812 c/c-typeck.cc:5867
+#: cp/typeck.cc:7807 c/c-typeck.cc:5875
 #, gcc-internal-format
 msgid "wrong type argument to bit-complement"
 msgstr "按位取反的引數類型錯誤"
 
-#: cp/typeck.cc:7832 c/c-typeck.cc:5875
+#: cp/typeck.cc:7827 c/c-typeck.cc:5883
 #, gcc-internal-format
 msgid "wrong type argument to abs"
 msgstr "不能對該類型的引數求絕對值"
 
-#: cp/typeck.cc:7844 c/c-typeck.cc:5897
+#: cp/typeck.cc:7839 c/c-typeck.cc:5905
 #, gcc-internal-format
 msgid "wrong type argument to conjugation"
 msgstr "不能對該類型的引數求共軛"
 
-#: cp/typeck.cc:7868
+#: cp/typeck.cc:7862
 #, fuzzy
 msgid "in argument to unary !"
 msgstr "在中引數到一元！"
 
-#: cp/typeck.cc:7928
+#: cp/typeck.cc:7922
 #, fuzzy
 msgid "no pre-increment operator for type"
 msgstr "沒有 pre-increment 運算子用於型態"
 
-#: cp/typeck.cc:7930
+#: cp/typeck.cc:7924
 #, fuzzy
 msgid "no post-increment operator for type"
 msgstr "沒有 post-increment 運算子用於型態"
 
-#: cp/typeck.cc:7932
+#: cp/typeck.cc:7926
 #, fuzzy
 msgid "no pre-decrement operator for type"
 msgstr "沒有 pre-decrement 運算子用於型態"
 
-#: cp/typeck.cc:7934
+#: cp/typeck.cc:7928
 #, fuzzy
 msgid "no post-decrement operator for type"
 msgstr "沒有 post-decrement 運算子用於型態"
@@ -24022,68 +24070,68 @@ msgstr ""
 msgid "BOZ constant truncated at %L"
 msgstr "列截斷的於 %L"
 
-#: fortran/check.cc:4174
+#: fortran/check.cc:4175
 #, fuzzy, c-format
 msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
 msgstr "引數『a%d』和『a%d』用於 intrinsic『%s』"
 
-#: fortran/check.cc:4412 fortran/check.cc:4497 fortran/check.cc:4562
-#: fortran/check.cc:5265
+#: fortran/check.cc:4413 fortran/check.cc:4498 fortran/check.cc:4563
+#: fortran/check.cc:5266
 #, fuzzy, c-format
 msgid "arguments '%s' and '%s' for intrinsic %s"
 msgstr "引數『%s』和『%s』用於 intrinsic %s"
 
-#: fortran/check.cc:5016 fortran/intrinsic.cc:5062
+#: fortran/check.cc:5017 fortran/intrinsic.cc:5062
 #, fuzzy, c-format
 msgid "arguments '%s' and '%s' for intrinsic '%s'"
 msgstr "引數『%s』和『%s』用於 intrinsic『%s』"
 
-#: fortran/check.cc:5892
+#: fortran/check.cc:5893
 #, fuzzy
 msgid "NULL() is not interoperable"
 msgstr "%qD 並非變數"
 
-#: fortran/check.cc:5898
+#: fortran/check.cc:5899
 #, fuzzy
 #| msgid "invalid constant"
 msgid "BOZ literal constant"
 msgstr "常數無效"
 
-#: fortran/check.cc:5904
+#: fortran/check.cc:5905
 #, fuzzy
 msgid "Expression is polymorphic"
 msgstr "結束運算式在中做迴圈"
 
-#: fortran/check.cc:5911
+#: fortran/check.cc:5912
 #, fuzzy
 msgid "Expression is a noninteroperable derived type"
 msgstr "『%s』在中延伸運算式於 %C 並非衍生類型"
 
-#: fortran/check.cc:5917
+#: fortran/check.cc:5918
 #, fuzzy
 msgid "Procedure unexpected as argument"
 msgstr "未預期的屬性"
 
-#: fortran/check.cc:5927
+#: fortran/check.cc:5928
 msgid "Extension to use a non-C_Bool-kind LOGICAL"
 msgstr ""
 
-#: fortran/check.cc:5934
+#: fortran/check.cc:5935
 msgid "Extension to use a non-C_CHAR-kind CHARACTER"
 msgstr ""
 
-#: fortran/check.cc:5955
+#: fortran/check.cc:5956
 #, fuzzy
 msgid "Type shall have a character length of 1"
 msgstr "Obsolescent 特徵：舊式字元長度於 %C"
 
-#: fortran/check.cc:5966
+#: fortran/check.cc:5967
 #, fuzzy
 #| msgid "types are not quite compatible"
 msgid "Coarrays are not interoperable"
 msgstr "類型不完全相容"
 
-#: fortran/check.cc:5977
+#: fortran/check.cc:5978
 #, fuzzy
 msgid "Assumed-size arrays are not interoperable"
 msgstr "假設的大小陣列『%s』在中名稱表列『%s』於 %C 未被允許"
@@ -24162,7 +24210,7 @@ msgstr "預期的運算子"
 msgid "Unsigned:"
 msgstr "<unnamed-signed："
 
-#: fortran/expr.cc:4136
+#: fortran/expr.cc:4139
 #, fuzzy
 msgid "array assignment"
 msgstr "陣列指派"
@@ -24172,17 +24220,17 @@ msgid "Index variable %qs redefined at %L in procedure %qs called from within DO
 msgstr ""
 
 #. Macros for unified error messages.
-#: fortran/frontend-passes.cc:4044
+#: fortran/frontend-passes.cc:4109
 #, c-format
 msgid "Incorrect extent in argument B in MATMUL intrinsic in dimension 1: is %ld, should be %ld"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4047
+#: fortran/frontend-passes.cc:4112
 #, c-format
 msgid "Array bound mismatch for dimension 1 of array (%ld/%ld)"
 msgstr ""
 
-#: fortran/frontend-passes.cc:4050
+#: fortran/frontend-passes.cc:4115
 #, c-format
 msgid "Array bound mismatch for dimension 2 of array (%ld/%ld)"
 msgstr ""
@@ -24376,11 +24424,11 @@ msgstr "區塊 IF"
 msgid "implied END DO"
 msgstr "暗示的 END DO"
 
-#: fortran/parse.cc:2532 fortran/resolve.cc:14333
+#: fortran/parse.cc:2532 fortran/resolve.cc:14453
 msgid "assignment"
 msgstr "賦值"
 
-#: fortran/parse.cc:2535 fortran/resolve.cc:14399 fortran/resolve.cc:14402
+#: fortran/parse.cc:2535 fortran/resolve.cc:14519 fortran/resolve.cc:14522
 msgid "pointer assignment"
 msgstr "指標賦值"
 
@@ -24388,155 +24436,155 @@ msgstr "指標賦值"
 msgid "simple IF"
 msgstr "簡單的 IF"
 
-#: fortran/resolve.cc:2489 fortran/resolve.cc:2684
+#: fortran/resolve.cc:2514 fortran/resolve.cc:2709
 #, fuzzy
 msgid "elemental procedure"
 msgstr "elemental 程序"
 
-#: fortran/resolve.cc:2587
+#: fortran/resolve.cc:2612
 #, fuzzy
 #| msgid "no arguments"
 msgid "allocatable argument"
 msgstr "沒有參數"
 
-#: fortran/resolve.cc:2592
+#: fortran/resolve.cc:2617
 #, fuzzy
 msgid "asynchronous argument"
 msgstr "不足引數"
 
-#: fortran/resolve.cc:2597
+#: fortran/resolve.cc:2622
 #, fuzzy
 msgid "optional argument"
 msgstr "無效的 PHI 引數"
 
-#: fortran/resolve.cc:2602
+#: fortran/resolve.cc:2627
 #, fuzzy
 #| msgid "pointer assignment"
 msgid "pointer argument"
 msgstr "指標賦值"
 
-#: fortran/resolve.cc:2607
+#: fortran/resolve.cc:2632
 #, fuzzy
 msgid "target argument"
 msgstr "太多引數"
 
-#: fortran/resolve.cc:2612
+#: fortran/resolve.cc:2637
 #, fuzzy
 msgid "value argument"
 msgstr "無效的 PHI 引數"
 
-#: fortran/resolve.cc:2617
+#: fortran/resolve.cc:2642
 #, fuzzy
 #| msgid "no arguments"
 msgid "volatile argument"
 msgstr "沒有參數"
 
-#: fortran/resolve.cc:2622
+#: fortran/resolve.cc:2647
 #, fuzzy
 msgid "assumed-shape argument"
 msgstr "不匹配的引數"
 
-#: fortran/resolve.cc:2627
+#: fortran/resolve.cc:2652
 #, fuzzy
 msgid "assumed-rank argument"
 msgstr "不匹配的引數"
 
-#: fortran/resolve.cc:2632
+#: fortran/resolve.cc:2657
 #, fuzzy
 msgid "coarray argument"
 msgstr "陣列指派"
 
-#: fortran/resolve.cc:2637
+#: fortran/resolve.cc:2662
 msgid "parametrized derived type argument"
 msgstr ""
 
-#: fortran/resolve.cc:2642
+#: fortran/resolve.cc:2667
 #, fuzzy
 #| msgid "no arguments"
 msgid "polymorphic argument"
 msgstr "沒有參數"
 
-#: fortran/resolve.cc:2647
+#: fortran/resolve.cc:2672
 msgid "NO_ARG_CHECK attribute"
 msgstr ""
 
 #. As assumed-type is unlimited polymorphic (cf. above).
 #. See also TS 29113, Note 6.1.
-#: fortran/resolve.cc:2654
+#: fortran/resolve.cc:2679
 #, fuzzy
 msgid "assumed-type argument"
 msgstr "不匹配的引數"
 
-#: fortran/resolve.cc:2665
+#: fortran/resolve.cc:2690
 msgid "array result"
 msgstr ""
 
-#: fortran/resolve.cc:2670
+#: fortran/resolve.cc:2695
 #, fuzzy
 msgid "pointer or allocatable result"
 msgstr "Coindexed allocatable 物件於 %L"
 
-#: fortran/resolve.cc:2677
+#: fortran/resolve.cc:2702
 #, fuzzy
 msgid "result with non-constant character length"
 msgstr "共同變數『%s』於 %L 必須有常數字元長度"
 
-#: fortran/resolve.cc:2689
+#: fortran/resolve.cc:2714
 #, fuzzy
 msgid "bind(c) procedure"
 msgstr "模組程序"
 
-#: fortran/resolve.cc:8326
+#: fortran/resolve.cc:8404
 #, fuzzy
 msgid "Loop variable"
 msgstr "迴圈變數"
 
-#: fortran/resolve.cc:8330
+#: fortran/resolve.cc:8408
 #, fuzzy
 msgid "iterator variable"
 msgstr "迭代器變數"
 
-#: fortran/resolve.cc:8334
+#: fortran/resolve.cc:8412
 #, fuzzy
 msgid "Start expression in DO loop"
 msgstr "開始運算式在中做迴圈"
 
-#: fortran/resolve.cc:8338
+#: fortran/resolve.cc:8416
 #, fuzzy
 msgid "End expression in DO loop"
 msgstr "結束運算式在中做迴圈"
 
-#: fortran/resolve.cc:8342
+#: fortran/resolve.cc:8420
 #, fuzzy
 msgid "Step expression in DO loop"
 msgstr "步驟運算式在中做迴圈"
 
-#: fortran/resolve.cc:8975 fortran/resolve.cc:8978
+#: fortran/resolve.cc:9053 fortran/resolve.cc:9056
 #, fuzzy
 msgid "DEALLOCATE object"
 msgstr "取消配置物件"
 
-#: fortran/resolve.cc:9419 fortran/resolve.cc:9422
+#: fortran/resolve.cc:9497 fortran/resolve.cc:9500
 #, fuzzy
 msgid "ALLOCATE object"
 msgstr "配置物件"
 
-#: fortran/resolve.cc:9659 fortran/resolve.cc:11846 fortran/resolve.cc:12072
+#: fortran/resolve.cc:9737 fortran/resolve.cc:11924 fortran/resolve.cc:12150
 #, fuzzy
 msgid "STAT variable"
 msgstr "STAT 變數"
 
-#: fortran/resolve.cc:9710 fortran/resolve.cc:11858 fortran/resolve.cc:12084
+#: fortran/resolve.cc:9788 fortran/resolve.cc:11936 fortran/resolve.cc:12162
 #, fuzzy
 msgid "ERRMSG variable"
 msgstr "ERRMSG 變數"
 
-#: fortran/resolve.cc:11654
+#: fortran/resolve.cc:11732
 #, fuzzy
 msgid "item in READ"
 msgstr "項目在中讀取"
 
-#: fortran/resolve.cc:11870
+#: fortran/resolve.cc:11948
 #, fuzzy
 msgid "ACQUIRED_LOCK variable"
 msgstr "ACQUIRED_LOCK 變數"
@@ -24546,32 +24594,32 @@ msgstr "ACQUIRED_LOCK 變數"
 msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
 msgstr "不同的字元長度 (%ld/%ld) 在中陣列建構子"
 
-#: fortran/trans-array.cc:6906
+#: fortran/trans-array.cc:6929
 #, fuzzy
 msgid "Integer overflow when calculating the amount of memory to allocate"
 msgstr "整數溢位時計算數目的記憶體到配置"
 
-#: fortran/trans-array.cc:11451
+#: fortran/trans-array.cc:11543
 #, c-format
 msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration"
 msgstr ""
 
-#: fortran/trans-decl.cc:6690
+#: fortran/trans-decl.cc:6770
 #, fuzzy, c-format
 msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "實際的字串長度不匹配宣告的一個用於虛引數『%s』(%ld/%ld)"
 
-#: fortran/trans-decl.cc:6698
+#: fortran/trans-decl.cc:6778
 #, fuzzy, c-format
 msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
 msgstr "實際的字串長度是短於宣告的一個用於虛引數『%s』(%ld/%ld)"
 
-#: fortran/trans-expr.cc:11598
+#: fortran/trans-expr.cc:11654
 #, fuzzy, c-format
 msgid "Target of rank remapping is too small (%ld < %ld)"
 msgstr "目標的分級重新映射太小 (%ld<%ld)"
 
-#: fortran/trans-expr.cc:13373
+#: fortran/trans-expr.cc:13458
 msgid "Assignment of scalar to unallocated array"
 msgstr ""
 
@@ -24635,27 +24683,27 @@ msgstr "引數 NCOPIES 的重複 intrinsic 是負 (它的值是 %ld)"
 msgid "Argument NCOPIES of REPEAT intrinsic is too large"
 msgstr "引數 NCOPIES 的重複 intrinsic 太大"
 
-#: fortran/trans-intrinsic.cc:13166
+#: fortran/trans-intrinsic.cc:13169
 #, fuzzy, c-format
 msgid "FROMPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "引數『a%d』和『a%d』用於 intrinsic『%s』"
 
-#: fortran/trans-intrinsic.cc:13178
+#: fortran/trans-intrinsic.cc:13181
 #, fuzzy, c-format
 msgid "LEN argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "引數『a%d』和『a%d』用於 intrinsic『%s』"
 
-#: fortran/trans-intrinsic.cc:13190
+#: fortran/trans-intrinsic.cc:13193
 #, fuzzy, c-format
 msgid "TOPOS argument (%ld) out of range 0:%d in intrinsic MVBITS"
 msgstr "引數『a%d』和『a%d』用於 intrinsic『%s』"
 
-#: fortran/trans-intrinsic.cc:13202
+#: fortran/trans-intrinsic.cc:13205
 #, c-format
 msgid "FROMPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
 
-#: fortran/trans-intrinsic.cc:13210
+#: fortran/trans-intrinsic.cc:13213
 #, c-format
 msgid "TOPOS(%ld)+LEN(%ld)>BIT_SIZE(%d) in intrinsic MVBITS"
 msgstr ""
@@ -24762,7 +24810,7 @@ msgid "expected boolean type"
 msgstr "預期的布林值型態"
 
 #: go/gofrontend/expressions.cc:5610 c/c-parser.cc:20202 c/c-parser.cc:20209
-#: cp/parser.cc:44599 cp/parser.cc:44606
+#: cp/parser.cc:44659 cp/parser.cc:44666
 #, fuzzy, gcc-internal-format
 #| msgid "Expected integer"
 msgid "expected integer"
@@ -24836,7 +24884,7 @@ msgstr "不足引數"
 #: go/gofrontend/expressions.cc:11749 go/gofrontend/expressions.cc:11844
 #: go/gofrontend/expressions.cc:14020 go/gofrontend/expressions.cc:14149
 #: go/gofrontend/expressions.cc:14163 go/gofrontend/expressions.cc:14184
-#: cp/pt.cc:9576
+#: cp/pt.cc:9604
 #, fuzzy, gcc-internal-format
 msgid "too many arguments"
 msgstr "太多引數"
@@ -25301,7 +25349,7 @@ msgstr "對 VxWorks 的取樣支援"
 msgid "target OS does not support unaligned accesses"
 msgstr "目標 CPU 不支援 unaligned 存取"
 
-#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:194
+#: config/c6x/c6x.h:346 config/nvptx/nvptx.h:195
 #, fuzzy, gcc-internal-format
 msgid "profiling is not yet implemented for this architecture"
 msgstr "側寫檔不是未實作的用於這個架構"
@@ -25563,13 +25611,13 @@ msgstr "無法辨識的選項 %<-%s%>"
 msgid "Global declarative %s for %s"
 msgstr "全域宣告 %q+#D"
 
-#: cobol/parse_ante.h:2502 cobol/symbols.h:164 cobol/genapi.cc:6385
+#: cobol/parse_ante.h:2508 cobol/symbols.h:164 cobol/genapi.cc:6562
 #: cobol/util.cc:333 cobol/util.cc:380 cobol/util.cc:427 cobol/util.cc:729
 #, gcc-internal-format
 msgid "%s:%d: invalid %<symbol_type_t%> %d"
 msgstr ""
 
-#: cobol/parse_ante.h:3259
+#: cobol/parse_ante.h:3265
 #, gcc-internal-format
 msgid "SET identifier-11 TO LOCALE"
 msgstr ""
@@ -25734,12 +25782,12 @@ msgstr "%qs 被不宜用；使用 -fstack-check"
 msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
 msgstr "%qs 被不宜用；使用 -fno-zero-initialized-in-bss"
 
-#: config/aarch64/aarch64.opt:387
+#: config/aarch64/aarch64.opt:392
 #, fuzzy, gcc-internal-format
 msgid "unknown autovec preference %qs"
 msgstr "不明堆疊檢查參數「%s」"
 
-#: config/aarch64/aarch64.opt:432
+#: config/aarch64/aarch64.opt:437
 #, fuzzy, gcc-internal-format
 msgid "unknown LDP/STP policy %qs"
 msgstr "不明 TLS 式樣 %qs"
@@ -26193,8 +26241,8 @@ msgstr "%qE 屬性衝突與屬性 %s"
 
 #: attribs.cc:539 c-family/c-attribs.cc:1086 c-family/c-attribs.cc:2808
 #: c-family/c-attribs.cc:3398 c-family/c-attribs.cc:5473
-#: c-family/c-attribs.cc:5566 cp/contracts.cc:595 cp/decl.cc:18264
-#: cp/decl.cc:18315 cp/friend.cc:319 cp/tree.cc:5723
+#: c-family/c-attribs.cc:5566 cp/contracts.cc:597 cp/decl.cc:18328
+#: cp/decl.cc:18379 cp/friend.cc:319 cp/tree.cc:5740
 #, fuzzy, gcc-internal-format
 msgid "previous declaration here"
 msgstr "與此處早先的宣告 %q+#D 衝突"
@@ -26211,7 +26259,7 @@ msgstr "%qE 屬性指令忽略"
 msgid "%<%E::%E%> scoped attribute directive ignored"
 msgstr "%qE 屬性指令忽略"
 
-#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4115
+#: attribs.cc:762 c/c-parser.cc:2293 cp/cp-gimplify.cc:4141
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments specified for %qE attribute"
 msgstr "錯誤的引數數量指定的用於 %qE 屬性"
@@ -26221,7 +26269,7 @@ msgstr "錯誤的引數數量指定的用於 %qE 屬性"
 msgid "expected %i or more, found %i"
 msgstr "預期 %<(%>或列尾"
 
-#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4117
+#: attribs.cc:768 c/c-parser.cc:2296 cp/cp-gimplify.cc:4143
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expected %i, found %i"
 msgstr "預期 %<(%>或列尾"
@@ -26304,12 +26352,12 @@ msgstr "型態屬性忽略的之後型態已經定義"
 #: ada/gcc-interface/utils.cc:7519 ada/gcc-interface/utils.cc:7567
 #: ada/gcc-interface/utils.cc:7583 ada/gcc-interface/utils.cc:7617
 #: c/c-decl.cc:5116 c/c-decl.cc:5119 c/c-decl.cc:5146 c/c-parser.cc:6287
-#: cp/tree.cc:5374 cp/tree.cc:5879 d/d-attribs.cc:483 d/d-attribs.cc:702
-#: d/d-attribs.cc:723 d/d-attribs.cc:739 d/d-attribs.cc:756 d/d-attribs.cc:788
-#: d/d-attribs.cc:917 d/d-attribs.cc:976 d/d-attribs.cc:992 d/d-attribs.cc:1008
-#: d/d-attribs.cc:1157 d/d-attribs.cc:1170 d/d-attribs.cc:1387
-#: d/d-attribs.cc:1405 d/d-attribs.cc:1453 d/d-attribs.cc:1491
-#: d/d-attribs.cc:1507 d/d-attribs.cc:1564 d/d-attribs.cc:1592
+#: cp/tree.cc:5391 cp/tree.cc:5896 d/d-attribs.cc:486 d/d-attribs.cc:705
+#: d/d-attribs.cc:726 d/d-attribs.cc:742 d/d-attribs.cc:759 d/d-attribs.cc:791
+#: d/d-attribs.cc:920 d/d-attribs.cc:979 d/d-attribs.cc:995 d/d-attribs.cc:1011
+#: d/d-attribs.cc:1160 d/d-attribs.cc:1173 d/d-attribs.cc:1390
+#: d/d-attribs.cc:1408 d/d-attribs.cc:1473 d/d-attribs.cc:1511
+#: d/d-attribs.cc:1527 d/d-attribs.cc:1584 d/d-attribs.cc:1612
 #: jit/dummy-frontend.cc:284 jit/dummy-frontend.cc:318
 #: jit/dummy-frontend.cc:613 jit/dummy-frontend.cc:698
 #: jit/dummy-frontend.cc:719 jit/dummy-frontend.cc:738
@@ -26426,133 +26474,133 @@ msgstr ""
 msgid "auto-profile contains invalid filename index %d"
 msgstr ""
 
-#: auto-profile.cc:1603
+#: auto-profile.cc:1605
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains inlined function with symbol name %s instead of symbol name %s"
 msgstr ""
 
-#: auto-profile.cc:1606 auto-profile.cc:1832 auto-profile.cc:1841
-#: auto-profile.cc:1883
+#: auto-profile.cc:1608 auto-profile.cc:1834 auto-profile.cc:1843
+#: auto-profile.cc:1885
 #, fuzzy, gcc-internal-format
 msgid "corresponding call"
 msgstr "邊緣 %s->%s 沒有任何相應 callstmt(_S)"
 
-#: auto-profile.cc:1651
+#: auto-profile.cc:1653
 #, gcc-internal-format
 msgid "duplicated count information in auto-profile of %q+F with relative location %i discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1656
+#: auto-profile.cc:1658
 #, fuzzy, gcc-internal-format
 msgid "corresponding source location"
 msgstr "建立執行時期重定址"
 
-#: auto-profile.cc:1827
+#: auto-profile.cc:1829
 #, gcc-internal-format
 msgid "duplicated callsite in auto-profile of %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1835
+#: auto-profile.cc:1837
 #, gcc-internal-format
 msgid "both call targets and inline callsite information is present in auto-profile of function %q+F with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1875
+#: auto-profile.cc:1877
 #, gcc-internal-format
 msgid "auto-profile of %q+F seem to contain lost discriminator %i for call of %s at relative location %i"
 msgstr ""
 
-#: auto-profile.cc:1919
+#: auto-profile.cc:1921
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains multiple targets for a direct call with relative location %i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:1935
+#: auto-profile.cc:1937
 #, gcc-internal-format, gfc-internal-format
 msgid "function contains two calls of the same relative location +%i, discriminator %i, that leads to lost auto-profile"
 msgstr ""
 
-#: auto-profile.cc:1943
+#: auto-profile.cc:1945
 #, gcc-internal-format
 msgid "location of the first call"
 msgstr ""
 
-#: auto-profile.cc:1945
+#: auto-profile.cc:1947
 #, fuzzy, gcc-internal-format
 msgid "location of the second call"
 msgstr "沒有前一個宣告用於 %qD"
 
-#: auto-profile.cc:1999
+#: auto-profile.cc:2001
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains indirect call targets not associated with an indirect call statement"
 msgstr ""
 
-#: auto-profile.cc:2004 auto-profile.cc:2051
+#: auto-profile.cc:2006 auto-profile.cc:2053
 #, gcc-internal-format
 msgid "count %<PRIu64> with relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:2047
+#: auto-profile.cc:2049
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra statements"
 msgstr ""
 
-#: auto-profile.cc:2057 auto-profile.cc:2098
+#: auto-profile.cc:2059 auto-profile.cc:2100
 #, fuzzy, gcc-internal-format
 msgid "location is after end of function"
 msgstr "建立陣列的函式"
 
-#: auto-profile.cc:2086
+#: auto-profile.cc:2088
 #, gcc-internal-format
 msgid "auto-profile of %q+F contains extra callsites"
 msgstr ""
 
-#: auto-profile.cc:2091
+#: auto-profile.cc:2093
 #, gcc-internal-format
 msgid "call of %s with total count %<PRId64>, relative location +%i, discriminator %i"
 msgstr ""
 
-#: auto-profile.cc:3025
+#: auto-profile.cc:3027
 #, fuzzy, gcc-internal-format
 msgid "Not expected TAG."
 msgstr "預期 %<.%>"
 
-#: auto-profile.cc:3048
+#: auto-profile.cc:3050
 #, gcc-internal-format, gfc-internal-format
 msgid "auto-profile contains duplicated function instance %s"
 msgstr ""
 
-#: auto-profile.cc:3210
+#: auto-profile.cc:3212
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot open profile file %s"
 msgstr "無法開放原始碼檔案 %s\n"
 
-#: auto-profile.cc:3216
+#: auto-profile.cc:3218
 #, gcc-internal-format
 msgid "AutoFDO profile magic number does not match"
 msgstr ""
 
-#: auto-profile.cc:3224
+#: auto-profile.cc:3226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "AutoFDO profile version %u does not match %u"
 msgstr "  模板引數 %qE 不匹配 %qD"
 
-#: auto-profile.cc:3236
+#: auto-profile.cc:3238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read summary information from %s"
 msgstr "無法讀取 LTO decls 從 %s"
 
-#: auto-profile.cc:3244
+#: auto-profile.cc:3246
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read string table from %s"
 msgstr "無法讀取 LTO decls 從 %s"
 
-#: auto-profile.cc:3253
+#: auto-profile.cc:3255
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read function profile from %s"
 msgstr "無法讀取 LTO decls 從 %s"
 
-#: auto-profile.cc:3263
+#: auto-profile.cc:3265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot read module profile from %s"
 msgstr "無法讀取 LTO decls 從 %s"
@@ -26563,7 +26611,7 @@ msgstr "無法讀取 LTO decls 從 %s"
 msgid "offset %qwi outside bounds of constant string"
 msgstr "偏移量超過字串常數界"
 
-#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7189
+#: builtins.cc:706 c/c-parser.cc:28578 cp/name-lookup.cc:7229
 #, fuzzy, gcc-internal-format
 msgid "%qE declared here"
 msgstr "%qD 宣告的在此"
@@ -26671,7 +26719,7 @@ msgstr "常數引數超過 %qs 的範圍"
 msgid "illegal argument 0 to %qs"
 msgstr "缺少引數到 %qs"
 
-#: builtins.cc:7817 internal-fn.cc:4098
+#: builtins.cc:7817 internal-fn.cc:4166
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "third argument to %<crc%> builtins must be a constant"
@@ -26748,12 +26796,12 @@ msgstr "%Klast 引數的 %D 不是整數常數介於 0 和 3"
 msgid "cannot tail-call: %s"
 msgstr "[找不到 %s]"
 
-#: calls.cc:2828
+#: calls.cc:2829
 #, gcc-internal-format
 msgid "function call has aggregate value"
 msgstr "函式呼叫有聚合類型"
 
-#: calls.cc:3566
+#: calls.cc:3567
 #, fuzzy, gcc-internal-format
 #| msgid "passing %qT for argument %P to %qD"
 msgid "passing too large argument on stack"
@@ -27411,346 +27459,346 @@ msgstr "基本區塊無法 laid 向下順序的"
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr "bb 記事數量在中 insn 鏈接 (%d) !=n_basic_blocks (%d)"
 
-#: cgraph.cc:3724
+#: cgraph.cc:3734
 #, fuzzy, gcc-internal-format
 #| msgid "caller edge count is negative"
 msgid "caller edge count invalid"
 msgstr "呼叫邊計數為負"
 
-#: cgraph.cc:3821
+#: cgraph.cc:3831
 #, gcc-internal-format
 msgid "missing indirect call in speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3826
+#: cgraph.cc:3836
 #, gcc-internal-format
 msgid "indirect call in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3856
+#: cgraph.cc:3866
 #, gcc-internal-format
 msgid "speculative edges are not adjacent"
 msgstr ""
 
-#: cgraph.cc:3862
+#: cgraph.cc:3872
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has no speculative flag"
 msgstr ""
 
-#: cgraph.cc:3868 cgraph.cc:3898
+#: cgraph.cc:3878 cgraph.cc:3908
 #, gcc-internal-format, gfc-internal-format
 msgid "direct call to %s in speculative call sequence has speculative_id %i out of range"
 msgstr ""
 
-#: cgraph.cc:3875
+#: cgraph.cc:3885
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3886
+#: cgraph.cc:3896
 #, gcc-internal-format
 msgid "call stmt hash does not point to first direct edge of speculative call sequence"
 msgstr ""
 
-#: cgraph.cc:3905
+#: cgraph.cc:3915
 #, gcc-internal-format, gfc-internal-format
 msgid "duplicate reference %s in speculative call sequence with speculative_id %i"
 msgstr ""
 
-#: cgraph.cc:3918
+#: cgraph.cc:3928
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "missing direct call for speculation %i"
 msgstr "缺少形狀參數用於呼叫到 %s 於 %L"
 
-#: cgraph.cc:3923
+#: cgraph.cc:3933
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "missing barrier after block %i"
 msgid "missing ref for speculation %i"
 msgstr "在區塊 %i 之後缺少邊界"
 
-#: cgraph.cc:3932
+#: cgraph.cc:3942
 #, gcc-internal-format, gfc-internal-format
 msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i"
 msgstr ""
 
-#: cgraph.cc:3961
+#: cgraph.cc:3971
 #, gcc-internal-format, gfc-internal-format
 msgid "aux field set for edge %s->%s"
 msgstr "為邊 %s->%s 設定 AUX 欄位"
 
-#: cgraph.cc:3968
+#: cgraph.cc:3978
 #, gcc-internal-format
 msgid "cgraph count invalid"
 msgstr ""
 
-#: cgraph.cc:3973
+#: cgraph.cc:3983
 #, fuzzy, gcc-internal-format
 msgid "inline clone in same comdat group list"
 msgstr "節點是單獨在中 comdat 群組"
 
-#: cgraph.cc:3978
+#: cgraph.cc:3988
 #, fuzzy, gcc-internal-format
 msgid "inline clone count is not compatible"
 msgstr "內聯仿本被所需的"
 
-#: cgraph.cc:3985
+#: cgraph.cc:3995
 #, fuzzy, gcc-internal-format
 msgid "tp_first_run must be non-negative"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: cgraph.cc:3990
+#: cgraph.cc:4000
 #, fuzzy, gcc-internal-format
 #| msgid "Assume symbols might be invalid"
 msgid "local symbols must be defined"
 msgstr "假定符號可能無效"
 
-#: cgraph.cc:3995
+#: cgraph.cc:4005
 #, fuzzy, gcc-internal-format
 msgid "externally visible inline clone"
 msgstr "外部可見的內聯仿本"
 
-#: cgraph.cc:4000
+#: cgraph.cc:4010
 #, fuzzy, gcc-internal-format
 msgid "inline clone with address taken"
 msgstr "內聯仿本與位址佔用"
 
-#: cgraph.cc:4005
+#: cgraph.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "inline clone is forced to output"
 msgstr "內聯仿本被所需的"
 
-#: cgraph.cc:4010
+#: cgraph.cc:4020
 #, fuzzy, gcc-internal-format
 msgid "inline clone is referenced by assembly"
 msgstr "內聯仿本被所需的"
 
-#: cgraph.cc:4017
+#: cgraph.cc:4027
 #, gcc-internal-format
 msgid "calls_comdat_local is set outside of a comdat group"
 msgstr ""
 
-#: cgraph.cc:4022
+#: cgraph.cc:4032
 #, gcc-internal-format
 msgid "invalid calls_comdat_local flag"
 msgstr ""
 
-#: cgraph.cc:4029
+#: cgraph.cc:4039
 #, fuzzy, gcc-internal-format
 msgid "malloc attribute should be used for a function that returns a pointer"
 msgstr "回傳與值在中函式不具任何傳回類型"
 
-#: cgraph.cc:4041
+#: cgraph.cc:4051
 #, fuzzy, gcc-internal-format
 msgid "semantic interposition mismatch"
 msgstr "目標特定選項不匹配"
 
-#: cgraph.cc:4048
+#: cgraph.cc:4058
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "aux field set for indirect edge from %s"
 msgstr "aux 欄位設定用於間接邊緣從 %s"
 
-#: cgraph.cc:4054 cgraph.cc:4121
+#: cgraph.cc:4064 cgraph.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with function count"
 msgstr "%<-march=%s%>不是相容與已選 ABI"
 
-#: cgraph.cc:4061
+#: cgraph.cc:4071
 #, fuzzy, gcc-internal-format
 msgid "edge count is not compatible with inlined to function count"
 msgstr "%<-march=%s%>不是相容與已選 ABI"
 
-#: cgraph.cc:4069
+#: cgraph.cc:4079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: "
 msgstr "間接邊緣從 %s 未被標記為間接或已關聯的 indirectinfo(_I)，相應敘述是："
 
-#: cgraph.cc:4077 cgraph.cc:4151
+#: cgraph.cc:4087 cgraph.cc:4161
 #, gcc-internal-format
 msgid "edge has both call_stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4089
+#: cgraph.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "comdat-local function called by %s outside its comdat"
 msgstr ""
 
-#: cgraph.cc:4099
+#: cgraph.cc:4109
 #, gcc-internal-format
 msgid "inlined_to pointer is wrong"
 msgstr "inlined_to pointer 錯誤"
 
-#: cgraph.cc:4104
+#: cgraph.cc:4114
 #, gcc-internal-format
 msgid "multiple inline callers"
 msgstr "多個內聯呼叫者"
 
-#: cgraph.cc:4111
+#: cgraph.cc:4121
 #, gcc-internal-format
 msgid "inlined_to pointer set for noninline callers"
 msgstr "為非內聯的呼叫者設定了 inlined_to pointer"
 
-#: cgraph.cc:4141
+#: cgraph.cc:4151
 #, fuzzy, gcc-internal-format
 msgid "caller edge count does not match BB count"
 msgstr "呼叫者邊緣頻率 %i 不匹配 BB 頻率 %i"
 
-#: cgraph.cc:4172
+#: cgraph.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "indirect call count does not match BB count"
 msgstr "收到的郵件邊緣計數不匹配 PHI 引數數量"
 
-#: cgraph.cc:4189
+#: cgraph.cc:4199
 #, gcc-internal-format
 msgid "reference has both stmt and lto_stmt_uid set"
 msgstr ""
 
-#: cgraph.cc:4200
+#: cgraph.cc:4210
 #, fuzzy, gcc-internal-format
 msgid "inlined_to pointer is set but no predecessors found"
 msgstr "inlinedto 指標是設定並不是找到任何 predecessors(_T)"
 
-#: cgraph.cc:4205
+#: cgraph.cc:4215
 #, gcc-internal-format
 msgid "inlined_to pointer refers to itself"
 msgstr "inlined_to pointer 參照自身"
 
-#: cgraph.cc:4216
+#: cgraph.cc:4226
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong clone_of"
 msgstr "節點有錯誤的 cloneof(_O)"
 
-#: cgraph.cc:4229
+#: cgraph.cc:4239
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong clone list"
 msgstr "節點有錯誤的仿本清單"
 
-#: cgraph.cc:4235
+#: cgraph.cc:4245
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node is in clone list but it is not clone"
 msgstr "節點是在中仿本清單但是它不是仿本"
 
-#: cgraph.cc:4240
+#: cgraph.cc:4250
 #, fuzzy, gcc-internal-format
 msgid "cgraph_node has wrong prev_clone pointer"
 msgstr "節點有錯誤的 prevclone 指標(_C)"
 
-#: cgraph.cc:4245
+#: cgraph.cc:4255
 #, fuzzy, gcc-internal-format
 msgid "double linked list of clones corrupted"
 msgstr "雙倍鏈結的仿本清單的已損壞"
 
-#: cgraph.cc:4257
+#: cgraph.cc:4267
 #, fuzzy, gcc-internal-format
 msgid "Alias has call edges"
 msgstr "別名有呼叫邊緣"
 
-#: cgraph.cc:4263
+#: cgraph.cc:4273
 #, fuzzy, gcc-internal-format
 msgid "Alias has non-alias reference"
 msgstr "別名有 non-alias 參考"
 
-#: cgraph.cc:4268
+#: cgraph.cc:4278
 #, fuzzy, gcc-internal-format
 msgid "Alias has more than one alias reference"
 msgstr "別名有超過一個別名參考"
 
-#: cgraph.cc:4275
+#: cgraph.cc:4285
 #, fuzzy, gcc-internal-format
 msgid "Analyzed alias has no reference"
 msgstr "分析的別名沒有任何參考"
 
-#: cgraph.cc:4284
+#: cgraph.cc:4294
 #, fuzzy, gcc-internal-format
 msgid "No edge out of thunk node"
 msgstr "沒有邊緣超出 thunk 節點"
 
-#: cgraph.cc:4289
+#: cgraph.cc:4299
 #, fuzzy, gcc-internal-format
 msgid "More than one edge out of thunk node"
 msgstr "超過一個邊緣超出 thunk 節點"
 
-#: cgraph.cc:4294
+#: cgraph.cc:4304
 #, fuzzy, gcc-internal-format
 msgid "Thunk is not supposed to have body"
 msgstr "Thunk 未被猜想到有內文"
 
-#: cgraph.cc:4330
+#: cgraph.cc:4340
 #, gcc-internal-format
 msgid "shared call_stmt:"
 msgstr "共享的 call_stmt："
 
-#: cgraph.cc:4343
+#: cgraph.cc:4353
 #, gcc-internal-format
 msgid "edge points to wrong declaration:"
 msgstr "邊緣指到不對的宣告："
 
-#: cgraph.cc:4352
+#: cgraph.cc:4362
 #, fuzzy, gcc-internal-format
 msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
 msgstr "間接邊緣與不明被呼叫端相應到 callstmt 與已知宣告(_S)："
 
-#: cgraph.cc:4362
+#: cgraph.cc:4372
 #, fuzzy, gcc-internal-format
 msgid "missing callgraph edge for call stmt:"
 msgstr "缺少callgraph 邊緣用於呼叫 stmt："
 
-#: cgraph.cc:4372
+#: cgraph.cc:4382
 #, fuzzy, gcc-internal-format
 #| msgid "expected statement"
 msgid "reference to dead statement"
 msgstr "需要敘述"
 
-#: cgraph.cc:4385
+#: cgraph.cc:4395
 #, gcc-internal-format
 msgid "non-callback edge has callback_id set"
 msgstr ""
 
-#: cgraph.cc:4391
+#: cgraph.cc:4401
 #, gcc-internal-format
 msgid "edge has both callback and has_callback set"
 msgstr ""
 
-#: cgraph.cc:4399
+#: cgraph.cc:4409
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s has no callback-carrying"
 msgstr ""
 
-#: cgraph.cc:4427
+#: cgraph.cc:4437
 #, gcc-internal-format, gfc-internal-format
 msgid "callback edge %s->%s callback edge count mismatch, expected at most %d, found %d"
 msgstr ""
 
-#: cgraph.cc:4440
+#: cgraph.cc:4450
 #, gcc-internal-format, gfc-internal-format
 msgid "callback-carrying edge is pointing towards __builtin_unreachable, but its callback edge %s -> %s is not"
 msgstr ""
 
-#: cgraph.cc:4447
+#: cgraph.cc:4457
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "edge %s->%s has no corresponding call_stmt"
 msgstr "邊緣 %s->%s 沒有任何相應 callstmt(_S)"
 
-#: cgraph.cc:4459
+#: cgraph.cc:4469
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "an indirect edge from %s has no corresponding call_stmt"
 msgstr "間接邊緣從 %s 沒有任何相應 callstmt(_S)"
 
-#: cgraph.cc:4478 cgraph.cc:4491
+#: cgraph.cc:4488 cgraph.cc:4501
 #, gcc-internal-format
 msgid "missing origin for a node in a nested list"
 msgstr ""
 
-#: cgraph.cc:4483
+#: cgraph.cc:4493
 #, fuzzy, gcc-internal-format
 msgid "origin points to a different parent"
 msgstr "轉換的暫存器到不同的大小"
 
-#: cgraph.cc:4499
+#: cgraph.cc:4509
 #, gcc-internal-format
 msgid "verify_cgraph_node failed"
 msgstr "verify_cgraph_node 失敗"
 
-#: cgraph.cc:4621 varpool.cc:300
+#: cgraph.cc:4631 varpool.cc:300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: section %s.%d is missing"
 msgstr "%s：區段 %s 缺少"
@@ -28536,17 +28584,17 @@ msgstr "總計大小的區域物件太大"
 msgid "impossible constraint in %<asm%>"
 msgstr "%<asm%> 中不可能的約束"
 
-#: function.cc:4285
+#: function.cc:4292
 #, gcc-internal-format
 msgid "variable %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "變數 %q+D 能為 %<longjmp%> 或 %<vfork%> 所篡改"
 
-#: function.cc:4306
+#: function.cc:4313
 #, gcc-internal-format
 msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>"
 msgstr "引數 %q+D 可能為 %<longjmp%> 或 %<vfork%> 所篡改"
 
-#: function.cc:5031
+#: function.cc:5038
 #, gcc-internal-format
 msgid "function returns an aggregate"
 msgstr "函式回傳一個聚合"
@@ -29238,7 +29286,7 @@ msgstr ""
 msgid "flexible array member %qD does not have well defined padding bits for %qs"
 msgstr "flexible 陣列成員無法於結束的結構"
 
-#: gimple-fold.cc:4866 cp/constexpr.cc:6367
+#: gimple-fold.cc:4866 cp/constexpr.cc:6380
 #, gcc-internal-format
 msgid "PDP11 bit-field handling unsupported in %qs"
 msgstr ""
@@ -29278,7 +29326,7 @@ msgstr ""
 msgid "reference to label %qD defined inside of %<assume%> attribute expression from outside of the attribute"
 msgstr ""
 
-#: gimple-low.cc:112 cp/name-lookup.cc:9636
+#: gimple-low.cc:112 cp/name-lookup.cc:9676
 #, fuzzy, gcc-internal-format
 msgid "%qD defined here"
 msgstr "標貼 %qD 定義的在此"
@@ -29299,24 +29347,24 @@ msgstr "空指標"
 msgid "function may return address of local variable"
 msgstr "函式回傳局部變數的位址"
 
-#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13501
+#: gimple-ssa-isolate-paths.cc:422 c/c-typeck.cc:13509
 #, gcc-internal-format
 msgid "function returns address of local variable"
 msgstr "函式回傳局部變數的位址"
 
 #: gimple-ssa-isolate-paths.cc:425 gimple-ssa-warn-access.cc:2094
-#: gimple-ssa-warn-access.cc:3761 tree.cc:12759 tree.cc:12796 tree.cc:12837
+#: gimple-ssa-warn-access.cc:3809 tree.cc:12759 tree.cc:12796 tree.cc:12837
 #: tree.cc:12870 c/c-decl.cc:10924 c/c-parser.cc:23376 c/c-parser.cc:23517
-#: c/c-typeck.cc:4034 c/c-typeck.cc:4288 c/c-typeck.cc:4300 c/c-typeck.cc:7088
-#: c/c-typeck.cc:13396 c/c-typeck.cc:13413 c/gimple-parser.cc:2650
+#: c/c-typeck.cc:4042 c/c-typeck.cc:4296 c/c-typeck.cc:4308 c/c-typeck.cc:7096
+#: c/c-typeck.cc:13404 c/c-typeck.cc:13421 c/gimple-parser.cc:2650
 #: c/gimple-parser.cc:2658 cp/call.cc:8461 cp/call.cc:8544 cp/call.cc:8563
 #: cp/call.cc:10845 cp/class.cc:9628 cp/constexpr.cc:902 cp/constexpr.cc:1467
-#: cp/constexpr.cc:5736 cp/constexpr.cc:7566 cp/constexpr.cc:7968
-#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10327 cp/decl2.cc:6719
-#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14487
-#: cp/module.cc:14523 cp/parser.cc:24780 cp/parser.cc:25654 cp/pt.cc:9376
-#: cp/semantics.cc:2781 cp/semantics.cc:5406 cp/typeck.cc:2279
-#: cp/typeck.cc:2500 cp/typeck.cc:4821 cp/typeck.cc:11081
+#: cp/constexpr.cc:5749 cp/constexpr.cc:7589 cp/constexpr.cc:7991
+#: cp/cvt.cc:1123 cp/cvt.cc:1163 cp/decl.cc:10341 cp/decl2.cc:6719
+#: cp/decl2.cc:6768 cp/lambda.cc:666 cp/method.cc:1241 cp/module.cc:14500
+#: cp/module.cc:14536 cp/parser.cc:24844 cp/parser.cc:25718 cp/pt.cc:9404
+#: cp/semantics.cc:2781 cp/semantics.cc:5427 cp/typeck.cc:2279
+#: cp/typeck.cc:2500 cp/typeck.cc:3606 cp/typeck.cc:4816 cp/typeck.cc:11079
 #: rust/backend/rust-constexpr.cc:4627 rust/backend/rust-tree.cc:625
 #: rust/backend/rust-tree.cc:3826
 #, fuzzy, gcc-internal-format
@@ -30193,7 +30241,7 @@ msgstr "大小的陣列 %qE 是負"
 msgid "%qD called on pointer %qE with nonzero offset%s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3839
+#: gimple-ssa-warn-access.cc:2104 gimple-ssa-warn-access.cc:3887
 #, fuzzy, gcc-internal-format
 msgid "returned from %qD"
 msgstr "必要項從 %q#D\n"
@@ -30265,216 +30313,216 @@ msgstr "內聯函式 %q+D 宣告的 weak"
 msgid "unknown architecture specifier in memory model %wi for %qD"
 msgstr "不明 TLS 式樣 %qs"
 
-#: gimple-ssa-warn-access.cc:2985
+#: gimple-ssa-warn-access.cc:2984
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %qs for %qD"
 msgstr "無效的記憶體式樣引數 %d 的 %qE"
 
-#: gimple-ssa-warn-access.cc:2989
+#: gimple-ssa-warn-access.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "invalid memory model %wi for %qD"
 msgstr "無效的記憶體式樣引數 %d 的 %qE"
 
-#: gimple-ssa-warn-access.cc:3003 gimple-ssa-warn-access.cc:3054
+#: gimple-ssa-warn-access.cc:3002 gimple-ssa-warn-access.cc:3053
 #, fuzzy
 msgid "valid models are %e"
 msgstr "有效引數到 %qs 是：%s"
 
-#: gimple-ssa-warn-access.cc:3017
+#: gimple-ssa-warn-access.cc:3016
 #, fuzzy, gcc-internal-format
 msgid "invalid failure memory model %qs for %qD"
 msgstr "無效的記憶體式樣引數 %d 的 %qE"
 
-#: gimple-ssa-warn-access.cc:3022
+#: gimple-ssa-warn-access.cc:3021
 #, fuzzy, gcc-internal-format
 msgid "valid failure models are %qs, %qs, %qs, %qs"
 msgstr "有效引數到 %qs 是：%s"
 
-#: gimple-ssa-warn-access.cc:3038
+#: gimple-ssa-warn-access.cc:3037
 #, fuzzy, gcc-internal-format
 msgid "failure memory model %qs cannot be stronger than success memory model %qs for %qD"
 msgstr "失敗記憶體式樣無法 stronger 比成功記憶體式樣用於 %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3061
+#: gimple-ssa-warn-access.cc:3060
 #, fuzzy, gcc-internal-format
 msgid "failure memory model %wi cannot be stronger than success memory model %wi for %qD"
 msgstr "失敗記憶體式樣無法 stronger 比成功記憶體式樣用於 %<__atomic_compare_exchange%>"
 
-#: gimple-ssa-warn-access.cc:3506
+#: gimple-ssa-warn-access.cc:3554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "bound argument %i value %s is negative for a variable length array argument %i of type %s"
 msgstr "%qE 屬性只有套用到變數和函式"
 
-#: gimple-ssa-warn-access.cc:3514
+#: gimple-ssa-warn-access.cc:3562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "argument %i value %s is negative"
 msgstr "引數的 %s 函式於 %L 是負"
 
-#: gimple-ssa-warn-access.cc:3560
+#: gimple-ssa-warn-access.cc:3608
 #, gcc-internal-format, gfc-internal-format
 msgid "argument %i is null but the corresponding size argument %i value is %s"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3624
+#: gimple-ssa-warn-access.cc:3672
 #, fuzzy, gcc-internal-format
 msgid "referencing argument %u of type %qT"
 msgstr "預期 %qT 但是引數是的型態 %qT"
 
-#: gimple-ssa-warn-access.cc:3638
+#: gimple-ssa-warn-access.cc:3686
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD declared with attribute %qs"
 msgstr "內聯函式 %q+D 宣告的 weak"
 
-#: gimple-ssa-warn-access.cc:3642
+#: gimple-ssa-warn-access.cc:3690
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT and attribute %qs"
 msgstr "無效的元件類型用於屬性 %qs"
 
-#: gimple-ssa-warn-access.cc:3649
+#: gimple-ssa-warn-access.cc:3697
 #, fuzzy, gcc-internal-format
 msgid "in a call to function %qD"
 msgstr "無效的引數到內建函式"
 
-#: gimple-ssa-warn-access.cc:3652
+#: gimple-ssa-warn-access.cc:3700
 #, fuzzy, gcc-internal-format
 msgid "in a call with type %qT"
 msgstr "無效的元件類型用於屬性 %qs"
 
-#: gimple-ssa-warn-access.cc:3758
+#: gimple-ssa-warn-access.cc:3806
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD called on unallocated object %qD"
 msgstr "無法開啟 %s"
 
-#: gimple-ssa-warn-access.cc:3777
+#: gimple-ssa-warn-access.cc:3825
 #, gcc-internal-format
 msgid "%qD called on a pointer to an unallocated object %qE"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3786
+#: gimple-ssa-warn-access.cc:3834
 #, fuzzy, gcc-internal-format
 msgid "assigned here"
 msgstr "聯合定義的在此"
 
-#: gimple-ssa-warn-access.cc:3820
+#: gimple-ssa-warn-access.cc:3868
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD called on pointer returned from a mismatched allocation function"
 msgstr "%qD 不是一個成員範本函式"
 
-#: gimple-ssa-warn-access.cc:3829
+#: gimple-ssa-warn-access.cc:3877
 #, gcc-internal-format
 msgid "%qD called on pointer to an unallocated object"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:3977
+#: gimple-ssa-warn-access.cc:4025
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE may be used after %qD"
 msgstr "Cray 指標『%s』在中 %s 子句於 %L"
 
-#: gimple-ssa-warn-access.cc:3978
+#: gimple-ssa-warn-access.cc:4026
 #, fuzzy, gcc-internal-format
 msgid "pointer %qE used after %qD"
 msgstr "Cray 指標『%s』在中 %s 子句於 %L"
 
-#: gimple-ssa-warn-access.cc:3982
+#: gimple-ssa-warn-access.cc:4030
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "pointer may be used after %qD"
 msgstr "不能為 %q+D 指定對齊"
 
-#: gimple-ssa-warn-access.cc:3983
+#: gimple-ssa-warn-access.cc:4031
 #, fuzzy, gcc-internal-format
 #| msgid "unused parameter %q+D"
 msgid "pointer used after %qD"
 msgstr "未使用的參數 %q+D"
 
-#: gimple-ssa-warn-access.cc:3987
+#: gimple-ssa-warn-access.cc:4035
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "call to %qD here"
 msgstr "  %q+#D 已在此宣告過"
 
-#: gimple-ssa-warn-access.cc:4004
+#: gimple-ssa-warn-access.cc:4052
 #, gcc-internal-format
 msgid "dangling pointer %qE to %qD may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4005
+#: gimple-ssa-warn-access.cc:4053
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using dangling pointer %qE to %qD"
 msgstr "無效的指標模式 %qs"
 
-#: gimple-ssa-warn-access.cc:4010
+#: gimple-ssa-warn-access.cc:4058
 #, fuzzy, gcc-internal-format
 #| msgid "assuming pointer to member %qD"
 msgid "dangling pointer to %qD may be used"
 msgstr "假定是成員指標 %qD"
 
-#: gimple-ssa-warn-access.cc:4011
+#: gimple-ssa-warn-access.cc:4059
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "using a dangling pointer to %qD"
 msgstr "無效的指標模式 %qs"
 
-#: gimple-ssa-warn-access.cc:4014 gimple-ssa-warn-access.cc:4671
-#: gimple-ssa-warn-access.cc:4674 gimple-ssa-warn-restrict.cc:1847
+#: gimple-ssa-warn-access.cc:4062 gimple-ssa-warn-access.cc:4719
+#: gimple-ssa-warn-access.cc:4722 gimple-ssa-warn-restrict.cc:1847
 #: tree-ssa-uninit.cc:943 tree-ssa-uninit.cc:1142 c/c-decl.cc:4225
-#: c/c-decl.cc:4515 c/c-typeck.cc:10985 c/c-typeck.cc:14219 cp/call.cc:8892
+#: c/c-decl.cc:4515 c/c-typeck.cc:10993 c/c-typeck.cc:14227 cp/call.cc:8892
 #: cp/call.cc:8903 cp/class.cc:1755 cp/class.cc:3580 cp/constexpr.cc:1084
-#: cp/decl.cc:5231 cp/decl.cc:14671 cp/decl.cc:15267 cp/decl.cc:15277
-#: cp/decl.cc:16284 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
-#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8073
-#: cp/parser.cc:27838 cp/reflect.cc:175 cp/typeck.cc:1971 cp/typeck.cc:5316
+#: cp/decl.cc:5231 cp/decl.cc:14714 cp/decl.cc:15310 cp/decl.cc:15320
+#: cp/decl.cc:16327 cp/friend.cc:407 cp/friend.cc:417 cp/init.cc:2955
+#: cp/parser.cc:3937 cp/parser.cc:4083 cp/parser.cc:4135 cp/parser.cc:8056
+#: cp/parser.cc:27902 cp/reflect.cc:168 cp/typeck.cc:1971 cp/typeck.cc:5311
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here"
 msgstr "%qD 宣告的在此"
 
-#: gimple-ssa-warn-access.cc:4022
+#: gimple-ssa-warn-access.cc:4070
 #, gcc-internal-format
 msgid "dangling pointer %qE to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4024
+#: gimple-ssa-warn-access.cc:4072
 #, gcc-internal-format
 msgid "using dangling pointer %qE to an unnamed temporary"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4030
+#: gimple-ssa-warn-access.cc:4078
 #, gcc-internal-format
 msgid "dangling pointer to an unnamed temporary may be used"
 msgstr ""
 
-#: gimple-ssa-warn-access.cc:4032
+#: gimple-ssa-warn-access.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "using a dangling pointer to an unnamed temporary"
 msgstr "外掛程式無法暫存器未命名回合"
 
-#: gimple-ssa-warn-access.cc:4036
+#: gimple-ssa-warn-access.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "unnamed temporary defined here"
 msgstr "聯合定義的在此"
 
-#: gimple-ssa-warn-access.cc:4126
+#: gimple-ssa-warn-access.cc:4174
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "%qD called on pointer %qE passed to mismatched allocation function %qD"
 msgstr "呼叫非函式的 %qD"
 
-#: gimple-ssa-warn-access.cc:4131
+#: gimple-ssa-warn-access.cc:4179
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "%qD called on a pointer passed to mismatched reallocation function %qD"
 msgstr "呼叫非函式的 %qD"
 
-#: gimple-ssa-warn-access.cc:4137
+#: gimple-ssa-warn-access.cc:4185
 #, fuzzy, gcc-internal-format
 #| msgid "  in call to %qD"
 msgid "call to %qD"
 msgstr "  在呼叫 %qD 時"
 
-#: gimple-ssa-warn-access.cc:4665
+#: gimple-ssa-warn-access.cc:4713
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "storing the address of local variable %qD in %qE"
@@ -31289,346 +31337,346 @@ msgstr ""
 msgid "invalid use of attribute %<fallthrough%>"
 msgstr "無效的使用的 %<auto%>"
 
-#: ipa-devirt.cc:679 ipa-devirt.cc:764 ipa-devirt.cc:793 ipa-devirt.cc:835
-#: ipa-devirt.cc:866
+#: ipa-devirt.cc:748 ipa-devirt.cc:833 ipa-devirt.cc:862 ipa-devirt.cc:904
+#: ipa-devirt.cc:935
 #, gcc-internal-format
 msgid "virtual table of type %qD violates one definition rule"
 msgstr ""
 
-#: ipa-devirt.cc:682
+#: ipa-devirt.cc:751
 #, gcc-internal-format
 msgid "variable of same assembler name as the virtual table is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:723
+#: ipa-devirt.cc:792
 #, gcc-internal-format
 msgid "virtual table of type %qD contains RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:729
+#: ipa-devirt.cc:798
 #, gcc-internal-format
 msgid "but is prevailed by one without from other translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:733
+#: ipa-devirt.cc:802
 #, gcc-internal-format
 msgid "RTTI will not work on this type"
 msgstr ""
 
-#: ipa-devirt.cc:770
+#: ipa-devirt.cc:839
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table of different size"
 msgstr ""
 
-#: ipa-devirt.cc:799
+#: ipa-devirt.cc:868
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit with different RTTI information"
 msgstr ""
 
-#: ipa-devirt.cc:843 ipa-devirt.cc:874
+#: ipa-devirt.cc:912 ipa-devirt.cc:943
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:847
+#: ipa-devirt.cc:916
 #, fuzzy, gcc-internal-format
 #| msgid "initializer specified for non-virtual method %q+D"
 msgid "contains additional virtual method %qD"
 msgstr "為非虛方法 %q+D 指定了初始值設定項"
 
-#: ipa-devirt.cc:854
+#: ipa-devirt.cc:923
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with more entries"
 msgstr ""
 
-#: ipa-devirt.cc:880
+#: ipa-devirt.cc:949
 #, fuzzy, gcc-internal-format
 msgid "virtual method %qD"
 msgstr "虛擬函式 %q+D"
 
-#: ipa-devirt.cc:884
+#: ipa-devirt.cc:953
 #, gcc-internal-format
 msgid "ought to match virtual method %qD but does not"
 msgstr ""
 
-#: ipa-devirt.cc:890
+#: ipa-devirt.cc:959
 #, gcc-internal-format
 msgid "the conflicting type defined in another translation unit has virtual table with different contents"
 msgstr ""
 
-#: ipa-devirt.cc:924
+#: ipa-devirt.cc:993
 #, gcc-internal-format
 msgid "type %qT (typedef of %qT) violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:932
+#: ipa-devirt.cc:1001
 #, gcc-internal-format
 msgid "type %qT violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:944 ipa-devirt.cc:959 ipa-devirt.cc:1237 ipa-devirt.cc:1290
-#: ipa-devirt.cc:1329 ipa-devirt.cc:1347
+#: ipa-devirt.cc:1013 ipa-devirt.cc:1028 ipa-devirt.cc:1306 ipa-devirt.cc:1359
+#: ipa-devirt.cc:1398 ipa-devirt.cc:1416
 #, fuzzy, gcc-internal-format
 msgid "a different type is defined in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:951
+#: ipa-devirt.cc:1020
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is field %qD"
 msgstr ""
 
-#: ipa-devirt.cc:961
+#: ipa-devirt.cc:1030
 #, gcc-internal-format
 msgid "the first difference of corresponding definitions is method %qD"
 msgstr ""
 
-#: ipa-devirt.cc:1066
+#: ipa-devirt.cc:1135
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match type %qT across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1071
+#: ipa-devirt.cc:1140
 #, gcc-internal-format
 msgid "type %qT defined in anonymous namespace cannot match across the translation unit boundary"
 msgstr ""
 
-#: ipa-devirt.cc:1076
+#: ipa-devirt.cc:1145
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type defined in another translation unit"
 msgstr "不相容的類型在中二進位運算式"
 
-#: ipa-devirt.cc:1092
+#: ipa-devirt.cc:1161
 #, gcc-internal-format
 msgid "type name %qs should match type name %qs"
 msgstr ""
 
-#: ipa-devirt.cc:1096 ipa-devirt.cc:1193
+#: ipa-devirt.cc:1165 ipa-devirt.cc:1262
 #, fuzzy, gcc-internal-format
 msgid "the incompatible type is defined here"
 msgstr "不相容的類型在中發送"
 
-#: ipa-devirt.cc:1124
+#: ipa-devirt.cc:1193
 #, fuzzy, gcc-internal-format
 #| msgid "Array reference out of bounds"
 msgid "array types have different bounds"
 msgstr "對陣列的參照超出範圍"
 
-#: ipa-devirt.cc:1139
+#: ipa-devirt.cc:1208
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "return value type mismatch"
 msgstr "欄位初始值設定類型不匹配"
 
-#: ipa-devirt.cc:1154
+#: ipa-devirt.cc:1223
 #, fuzzy, gcc-internal-format
 #| msgid "field initializer type mismatch"
 msgid "implicit this pointer type mismatch"
 msgstr "欄位初始值設定類型不匹配"
 
-#: ipa-devirt.cc:1157
+#: ipa-devirt.cc:1226
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "type mismatch in parameter %i"
 msgstr "型態不匹配在中 nontype 參數包裝"
 
-#: ipa-devirt.cc:1168
+#: ipa-devirt.cc:1237
 #, fuzzy, gcc-internal-format
 msgid "types have different parameter counts"
 msgstr "不同的參數類型"
 
-#: ipa-devirt.cc:1184
+#: ipa-devirt.cc:1253
 #, gcc-internal-format
 msgid "type %qT itself violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:1190
+#: ipa-devirt.cc:1259
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not derived from type %qT"
 msgid "type %qT should match type %qT"
 msgstr "類型 %qT 不是由類型 %qT 衍生的"
 
-#: ipa-devirt.cc:1265
+#: ipa-devirt.cc:1334
 #, gcc-internal-format
 msgid "a type with different precision is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1273
+#: ipa-devirt.cc:1342
 #, fuzzy, gcc-internal-format
 msgid "a vector type with different number of elements is defined in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:1280
+#: ipa-devirt.cc:1349
 #, gcc-internal-format
 msgid "a type with different signedness is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1305
+#: ipa-devirt.cc:1374
 #, gcc-internal-format
 msgid "it is defined as a pointer in different address space in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1314
+#: ipa-devirt.cc:1383
 #, gcc-internal-format
 msgid "it is defined as a pointer to different type in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1374
+#: ipa-devirt.cc:1443
 #, gcc-internal-format
 msgid "an array of different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1389
+#: ipa-devirt.cc:1458
 #, fuzzy, gcc-internal-format
 msgid "has different return value in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:1412 ipa-devirt.cc:1424
+#: ipa-devirt.cc:1481 ipa-devirt.cc:1493
 #, fuzzy, gcc-internal-format
 msgid "has different parameters in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:1447
+#: ipa-devirt.cc:1516
 #, gcc-internal-format
 msgid "a type defined in another translation unit is not polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1451
+#: ipa-devirt.cc:1520
 #, gcc-internal-format
 msgid "a type defined in another translation unit is polymorphic"
 msgstr ""
 
-#: ipa-devirt.cc:1469 ipa-devirt.cc:1533
+#: ipa-devirt.cc:1538 ipa-devirt.cc:1602
 #, gcc-internal-format
 msgid "a type with different virtual table pointers is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1476 ipa-devirt.cc:1538
+#: ipa-devirt.cc:1545 ipa-devirt.cc:1607
 #, gcc-internal-format
 msgid "a type with different bases is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1484
+#: ipa-devirt.cc:1553
 #, fuzzy, gcc-internal-format
 msgid "a field with different name is defined in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:1498
+#: ipa-devirt.cc:1567
 #, gcc-internal-format
 msgid "a field of same name but different type is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1511
+#: ipa-devirt.cc:1580
 #, fuzzy, gcc-internal-format
 msgid "fields have different layout in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:1518
+#: ipa-devirt.cc:1587
 #, gcc-internal-format
 msgid "one field is a bitfield while the other is not"
 msgstr ""
 
-#: ipa-devirt.cc:1542
+#: ipa-devirt.cc:1611
 #, gcc-internal-format
 msgid "a type with different number of fields is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1565
+#: ipa-devirt.cc:1634
 #, gcc-internal-format
 msgid "a type with different size is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:1574
+#: ipa-devirt.cc:1643
 #, gcc-internal-format
 msgid "one type needs to be constructed while the other does not"
 msgstr ""
 
-#: ipa-devirt.cc:1587
+#: ipa-devirt.cc:1656
 #, fuzzy, gcc-internal-format
 #| msgid "Array bound mismatch"
 msgid "memory layout mismatch"
 msgstr "陣列邊界不匹配"
 
-#: ipa-devirt.cc:1706
+#: ipa-devirt.cc:1775
 #, fuzzy, gcc-internal-format
 msgid "the extra base is defined here"
 msgstr "標貼 %qD 定義的在此"
 
-#: ipa-devirt.cc:3990
+#: ipa-devirt.cc:4060
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:3999
+#: ipa-devirt.cc:4069
 #, gcc-internal-format
 msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4029
+#: ipa-devirt.cc:4099
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4037
+#: ipa-devirt.cc:4107
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4045
+#: ipa-devirt.cc:4115
 #, gcc-internal-format
 msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4056
+#: ipa-devirt.cc:4126
 #, gcc-internal-format
 msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times"
 msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times"
 msgstr[0] ""
 
-#: ipa-devirt.cc:4372
+#: ipa-devirt.cc:4442
 #, gcc-internal-format
 msgid "type %qs violates the C++ One Definition Rule"
 msgstr ""
 
-#: ipa-devirt.cc:4381
+#: ipa-devirt.cc:4451
 #, fuzzy, gcc-internal-format
 msgid "an enum with different number of values is defined in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:4385
+#: ipa-devirt.cc:4455
 #, gcc-internal-format
 msgid "an enum with different value name is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4389
+#: ipa-devirt.cc:4459
 #, gcc-internal-format
 msgid "an enum with different values is defined in another translation unit"
 msgstr ""
 
-#: ipa-devirt.cc:4410
+#: ipa-devirt.cc:4480
 #, fuzzy, gcc-internal-format
 msgid "name %qs differs from name %qs defined in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:4416
+#: ipa-devirt.cc:4486
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined as %u-bit while another translation unit defines it as %u-bit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:4425
+#: ipa-devirt.cc:4495
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to %wd while another translation unit defines it as %wd"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:4431
+#: ipa-devirt.cc:4501
 #, fuzzy, gcc-internal-format
 msgid "name %qs is defined to different value in another translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: ipa-devirt.cc:4436
+#: ipa-devirt.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "mismatching definition"
@@ -31649,7 +31697,7 @@ msgstr "ipa 內聯概要缺少在中輸入檔案"
 msgid "IPA modref summary is missing in input file"
 msgstr "ipa 內聯概要缺少在中輸入檔案"
 
-#: ipa-prop.cc:5358 ipa-prop.cc:5402 ipa-prop.cc:5482 ipa-prop.cc:5534
+#: ipa-prop.cc:5384 ipa-prop.cc:5428 ipa-prop.cc:5508 ipa-prop.cc:5560
 #, fuzzy, gcc-internal-format
 msgid "invalid jump function in LTO stream"
 msgstr "無效的函式在中 gimple 呼叫"
@@ -31893,12 +31941,12 @@ msgstr "最大值條件儲存對數量該可以是 sunk"
 msgid "unable to find a register to spill"
 msgstr "在類別 %qs 中找不到可捨出的暫存器"
 
-#: lra-constraints.cc:4524 reload.cc:3853 reload.cc:4108
+#: lra-constraints.cc:4525 reload.cc:3853 reload.cc:4108
 #, gcc-internal-format
 msgid "inconsistent operand constraints in an %<asm%>"
 msgstr "一句 %<asm%> 中運算元約束不一致"
 
-#: lra-constraints.cc:5701
+#: lra-constraints.cc:5702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "maximum number of generated reload insns per insn achieved (%d)"
 msgstr "最大值條件儲存對數量該可以是 sunk"
@@ -32279,7 +32327,7 @@ msgstr ""
 msgid "%qs clause with %<sink%> modifier refers to iteration never in the iteration space"
 msgstr ""
 
-#: omp-expand.cc:8239
+#: omp-expand.cc:8236
 #, gcc-internal-format
 msgid "invalid OpenMP non-rectangular loop step; %<(%E - %E) * %E%> is not a multiple of loop %d step %qE"
 msgstr ""
@@ -33700,22 +33748,22 @@ msgstr "隱含地流行的 regs 必須被群組於頂的堆疊"
 msgid "output operand %d must use %<&%> constraint"
 msgstr "輸出運算元 %d 必須使用 %<&%> 約束"
 
-#: regcprop.cc:1296
+#: regcprop.cc:1304
 #, fuzzy, gcc-internal-format
 msgid "%qs: [%u] bad %<next_regno%> for empty chain (%u)"
 msgstr "validate_value_data：[%u] 不當的 next_regno 用於清空鏈接 (%u)"
 
-#: regcprop.cc:1308
+#: regcprop.cc:1316
 #, fuzzy, gcc-internal-format
 msgid "%qs: loop in %<next_regno%> chain (%u)"
 msgstr "validate_value_data：迴圈在中 regno 鏈接 (%u)"
 
-#: regcprop.cc:1311
+#: regcprop.cc:1319
 #, fuzzy, gcc-internal-format
 msgid "%qs: [%u] bad %<oldest_regno%> (%u)"
 msgstr "validate_value_data：[%u] 不當的 oldest_regno (%u)"
 
-#: regcprop.cc:1323
+#: regcprop.cc:1331
 #, fuzzy, gcc-internal-format
 msgid "%qs: [%u] non-empty register in chain (%s %u %i)"
 msgstr "validate_value_data：[%u] 非空 reg 在中鏈接 (%s %u %i)"
@@ -34681,171 +34729,171 @@ msgstr "外異動作業在中 %<transaction_safe%> 函式"
 msgid "ignoring loop annotation"
 msgstr ""
 
-#: tree-cfg.cc:2981
+#: tree-cfg.cc:2983
 #, fuzzy, gcc-internal-format
 msgid "constant not recomputed when %<ADDR_EXPR%> changed"
 msgstr "常數無法 recomputed 時 ADDR_EXPR 變更"
 
-#: tree-cfg.cc:2986
+#: tree-cfg.cc:2988
 #, fuzzy, gcc-internal-format
 msgid "side effects not recomputed when %<ADDR_EXPR%> changed"
 msgstr "副作用無法 recomputed 時 ADDR_EXPR 變更"
 
-#: tree-cfg.cc:3001
+#: tree-cfg.cc:3003
 #, fuzzy, gcc-internal-format
 msgid "address taken but %<TREE_ADDRESSABLE%> bit not set"
 msgstr "位址佔用，但是 ADDRESSABLE 位元無法設定"
 
-#: tree-cfg.cc:3027
+#: tree-cfg.cc:3029
 #, fuzzy, gcc-internal-format
 msgid "non-scalar %qs"
 msgstr "non-scalar 型態"
 
-#: tree-cfg.cc:3041
+#: tree-cfg.cc:3043
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size operand to %qs"
 msgstr "無效的位置或大小運算元到 BIT_FIELD_REF"
 
-#: tree-cfg.cc:3047
+#: tree-cfg.cc:3049
 #, fuzzy, gcc-internal-format
 msgid "integral result type precision does not match field size of %qs"
 msgstr "積分結果型態精確度不匹配欄位大小的 BIT_FIELD_REF"
 
-#: tree-cfg.cc:3056
+#: tree-cfg.cc:3058
 #, fuzzy, gcc-internal-format
 msgid "mode size of non-integral result does not match field size of %qs"
 msgstr "模式精確度的 non-integral 結果不匹配欄位大小的 BIT_FIELD_REF"
 
-#: tree-cfg.cc:3064
+#: tree-cfg.cc:3066
 #, fuzzy, gcc-internal-format
 msgid "%qs of non-mode-precision operand"
 msgstr "Shift 的 non-integer 運算元"
 
-#: tree-cfg.cc:3071
+#: tree-cfg.cc:3073
 #, fuzzy, gcc-internal-format
 msgid "position plus size exceeds size of referenced object in %qs"
 msgstr "無效的位置或大小運算元到 BIT_FIELD_REF"
 
-#: tree-cfg.cc:3082
+#: tree-cfg.cc:3084
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs reference"
 msgstr "型態不匹配在中陣列參照"
 
-#: tree-cfg.cc:3098
+#: tree-cfg.cc:3100
 #, fuzzy, gcc-internal-format
 msgid "conversion of %qs on the left hand side of %qs"
 msgstr "轉換的 SSA_NAME 左側的手側邊"
 
-#: tree-cfg.cc:3106
+#: tree-cfg.cc:3108
 #, fuzzy, gcc-internal-format
 msgid "conversion of register to a different size in %qs"
 msgstr "轉換的暫存器到不同的大小"
 
-#: tree-cfg.cc:3126
+#: tree-cfg.cc:3128
 #, gcc-internal-format
 msgid "non-top-level %qs"
 msgstr ""
 
-#: tree-cfg.cc:3141
+#: tree-cfg.cc:3143
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operands to %qs"
 msgstr "%%R 的運算元無效"
 
-#: tree-cfg.cc:3152 tree-cfg.cc:3161 tree-cfg.cc:3178 tree-cfg.cc:3862
-#: tree-cfg.cc:3891 tree-cfg.cc:3908 tree-cfg.cc:3929 tree-cfg.cc:3975
-#: tree-cfg.cc:3996 tree-cfg.cc:4050 tree-cfg.cc:4070 tree-cfg.cc:4106
-#: tree-cfg.cc:4127 tree-cfg.cc:4188 tree-cfg.cc:4263 tree-cfg.cc:4289
-#: tree-cfg.cc:4325 tree-cfg.cc:4374 tree-cfg.cc:4399 tree-cfg.cc:4474
-#: tree-cfg.cc:4568
+#: tree-cfg.cc:3154 tree-cfg.cc:3163 tree-cfg.cc:3180 tree-cfg.cc:3864
+#: tree-cfg.cc:3893 tree-cfg.cc:3910 tree-cfg.cc:3931 tree-cfg.cc:3977
+#: tree-cfg.cc:3998 tree-cfg.cc:4052 tree-cfg.cc:4072 tree-cfg.cc:4108
+#: tree-cfg.cc:4129 tree-cfg.cc:4190 tree-cfg.cc:4265 tree-cfg.cc:4291
+#: tree-cfg.cc:4327 tree-cfg.cc:4376 tree-cfg.cc:4401 tree-cfg.cc:4476
+#: tree-cfg.cc:4570
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs"
 msgstr "型態不匹配在中 nontype 參數包裝"
 
-#: tree-cfg.cc:3172
+#: tree-cfg.cc:3174
 #, fuzzy, gcc-internal-format
 msgid "invalid %qs offset operator"
 msgstr "無效的偏移運算元的 MEM_REF"
 
-#: tree-cfg.cc:3196 tree-cfg.cc:3222
+#: tree-cfg.cc:3198 tree-cfg.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "invalid address operand in %qs"
 msgstr "無效的位址運算元在中 MEM_REF"
 
-#: tree-cfg.cc:3203 tree-cfg.cc:3229
+#: tree-cfg.cc:3205 tree-cfg.cc:3231
 #, fuzzy, gcc-internal-format
 msgid "invalid offset operand in %qs"
 msgstr "無效的偏移運算元在中 MEM_REF"
 
-#: tree-cfg.cc:3210 tree-cfg.cc:3236
+#: tree-cfg.cc:3212 tree-cfg.cc:3238
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid clique in %qs"
 msgstr "錯誤地使用了 %qD"
 
-#: tree-cfg.cc:3243 tree-cfg.cc:4580
+#: tree-cfg.cc:3245 tree-cfg.cc:4582
 #, fuzzy, gcc-internal-format
 #| msgid "simple IF"
 msgid "%qs in gimple IL"
 msgstr "簡單的 IF"
 
-#: tree-cfg.cc:3254
+#: tree-cfg.cc:3256
 #, fuzzy, gcc-internal-format
 #| msgid "used struct type value where scalar is required"
 msgid "%qs as base where non-register is required"
 msgstr "需要標量時使用了結構類型"
 
-#: tree-cfg.cc:3269
+#: tree-cfg.cc:3271
 #, fuzzy, gcc-internal-format
 msgid "invalid expression for min lvalue"
 msgstr "無效的運算式用於最小 lvalue"
 
-#: tree-cfg.cc:3320
+#: tree-cfg.cc:3322
 #, fuzzy, gcc-internal-format
 msgid "gimple call has two targets"
 msgstr "gimple 呼叫有兩目標"
 
-#: tree-cfg.cc:3329
+#: tree-cfg.cc:3331
 #, fuzzy, gcc-internal-format
 msgid "gimple call has no target"
 msgstr "gimple 呼叫沒有任何目標"
 
-#: tree-cfg.cc:3336
+#: tree-cfg.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "invalid function in gimple call"
 msgstr "無效的函式在中 gimple 呼叫"
 
-#: tree-cfg.cc:3346
+#: tree-cfg.cc:3348
 #, fuzzy, gcc-internal-format
 msgid "non-function in gimple call"
 msgstr "non-function 在中 gimple 呼叫"
 
-#: tree-cfg.cc:3357
+#: tree-cfg.cc:3359
 #, fuzzy, gcc-internal-format
 msgid "invalid pure const state for function"
 msgstr "無效的 pure 常數狀態用於函式"
 
-#: tree-cfg.cc:3369
+#: tree-cfg.cc:3371
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS in gimple call"
 msgstr "無效的 LHS 在中 gimple 呼叫"
 
-#: tree-cfg.cc:3377
+#: tree-cfg.cc:3379
 #, fuzzy, gcc-internal-format
 msgid "LHS in %<noreturn%> call"
 msgstr "LHS 在中 noreturn 呼叫"
 
-#: tree-cfg.cc:3391
+#: tree-cfg.cc:3393
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion in gimple call"
 msgstr "無效的轉換在中 gimple 呼叫"
 
-#: tree-cfg.cc:3400
+#: tree-cfg.cc:3402
 #, fuzzy, gcc-internal-format
 msgid "invalid static chain in gimple call"
 msgstr "無效的靜態鏈接在中 gimple 呼叫"
 
-#: tree-cfg.cc:3411
+#: tree-cfg.cc:3413
 #, fuzzy, gcc-internal-format
 msgid "static chain with function that doesn%'t use one"
 msgstr "靜態鏈接與函式該 doesn%'t 使用一個"
@@ -34856,613 +34904,613 @@ msgstr "靜態鏈接與函式該 doesn%'t 使用一個"
 #. __builtin_unreachable internally, for example when IPA figures
 #. out a call cannot happen in a legal program.  In such cases,
 #. we must make sure arguments are stripped off.
-#: tree-cfg.cc:3430
+#: tree-cfg.cc:3432
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments"
 msgstr "呼叫 %<__builtin_next_arg%> 時沒有給定引數"
 
-#: tree-cfg.cc:3461
+#: tree-cfg.cc:3463
 #, gcc-internal-format
 msgid "%<DEFERRED_INIT%> calls should have same constant size for the first argument and LHS"
 msgstr ""
 
-#: tree-cfg.cc:3479
+#: tree-cfg.cc:3481
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to gimple call"
 msgstr "無效的引數到 gimple 呼叫"
 
-#: tree-cfg.cc:3506
+#: tree-cfg.cc:3508
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in gimple comparison"
 msgstr "無效的運算元在中 gimple 比較"
 
-#: tree-cfg.cc:3517
+#: tree-cfg.cc:3519
 #, fuzzy, gcc-internal-format
 msgid "mismatching comparison operand types"
 msgstr "不匹配比較運算元類型"
 
-#: tree-cfg.cc:3534
+#: tree-cfg.cc:3536
 #, fuzzy, gcc-internal-format
 msgid "unsupported operation or type for vector comparison returning a boolean"
 msgstr "無效的向量比較所產生的型態"
 
-#: tree-cfg.cc:3549
+#: tree-cfg.cc:3551
 #, fuzzy, gcc-internal-format
 msgid "non-vector operands in vector comparison"
 msgstr "non-vector 運算元在中向量比較"
 
-#: tree-cfg.cc:3558
+#: tree-cfg.cc:3560
 #, fuzzy, gcc-internal-format
 msgid "invalid vector comparison resulting type"
 msgstr "無效的向量比較所產生的型態"
 
-#: tree-cfg.cc:3565
+#: tree-cfg.cc:3567
 #, fuzzy, gcc-internal-format
 msgid "bogus comparison result type"
 msgstr "假造的比較結果型態"
 
-#: tree-cfg.cc:3587
+#: tree-cfg.cc:3589
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of unary operation"
 msgstr "non-register 做為 LHS 的一元作業"
 
-#: tree-cfg.cc:3593
+#: tree-cfg.cc:3595
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in unary operation"
 msgstr "無效的運算元在中一元作業"
 
-#: tree-cfg.cc:3616
+#: tree-cfg.cc:3618
 #, fuzzy, gcc-internal-format
 msgid "invalid vector types in nop conversion"
 msgstr "無效的類型在中 nop 轉換"
 
-#: tree-cfg.cc:3653
+#: tree-cfg.cc:3655
 #, fuzzy, gcc-internal-format
 msgid "invalid types in nop conversion"
 msgstr "無效的類型在中 nop 轉換"
 
-#: tree-cfg.cc:3668
+#: tree-cfg.cc:3670
 #, fuzzy, gcc-internal-format
 msgid "invalid types in address space conversion"
 msgstr "無效的類型在中位址空間轉換"
 
-#: tree-cfg.cc:3682
+#: tree-cfg.cc:3684
 #, fuzzy, gcc-internal-format
 msgid "invalid types in fixed-point conversion"
 msgstr "無效的類型在中定點轉換"
 
-#: tree-cfg.cc:3697
+#: tree-cfg.cc:3699
 #, fuzzy, gcc-internal-format
 msgid "invalid types in conversion to floating-point"
 msgstr "無效的類型在中轉換到浮點數"
 
-#: tree-cfg.cc:3712
+#: tree-cfg.cc:3714
 #, fuzzy, gcc-internal-format
 msgid "invalid types in conversion to integer"
 msgstr "無效的類型在中轉換到整數"
 
-#: tree-cfg.cc:3752
+#: tree-cfg.cc:3754
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in %qs expression"
 msgstr "型態不匹配在中位址運算式"
 
-#: tree-cfg.cc:3767 tree-cfg.cc:4154 tree-cfg.cc:4176
+#: tree-cfg.cc:3769 tree-cfg.cc:4156 tree-cfg.cc:4178
 #, fuzzy, gcc-internal-format
 msgid "invalid types for %qs"
 msgstr "程式碼「%c」的運算元無效"
 
-#: tree-cfg.cc:3778
+#: tree-cfg.cc:3780
 #, gcc-internal-format
 msgid "%qs should be from a scalar to a like vector"
 msgstr ""
 
-#: tree-cfg.cc:3789
+#: tree-cfg.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %qs"
 msgstr "程式碼「%c」的運算元無效"
 
-#: tree-cfg.cc:3813
+#: tree-cfg.cc:3815
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in unary operation"
 msgstr "non-trivial 轉換在中一元作業"
 
-#: tree-cfg.cc:3838
+#: tree-cfg.cc:3840
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of binary operation"
 msgstr "non-register 做為 LHS 的二進運算"
 
-#: tree-cfg.cc:3845
+#: tree-cfg.cc:3847
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in binary operation"
 msgstr "無效的運算元在中二進運算"
 
-#: tree-cfg.cc:3950
+#: tree-cfg.cc:3952
 #, fuzzy, gcc-internal-format
 msgid "invalid non-vector operands to %qs"
 msgstr "無效的 non-vector 運算元到向量值的加上"
 
-#: tree-cfg.cc:3961
+#: tree-cfg.cc:3963
 #, fuzzy, gcc-internal-format
 #| msgid "invalid pointer mode %qs"
 msgid "invalid (pointer) operands %qs"
 msgstr "無效的指標模式 %qs"
 
-#: tree-cfg.cc:4196
+#: tree-cfg.cc:4198
 #, fuzzy, gcc-internal-format
 msgid "vector type expected in %qs"
 msgstr "向量類型預期的在中向量 permute 運算式"
 
-#: tree-cfg.cc:4209
+#: tree-cfg.cc:4211
 #, fuzzy, gcc-internal-format
 msgid "type mismatch in binary expression"
 msgstr "型態不匹配在中二進位運算式"
 
-#: tree-cfg.cc:4237
+#: tree-cfg.cc:4239
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS of ternary operation"
 msgstr "non-register 做為 LHS 的三進作業"
 
-#: tree-cfg.cc:4245
+#: tree-cfg.cc:4247
 #, fuzzy, gcc-internal-format
 msgid "invalid operands in ternary operation"
 msgstr "無效的運算元在中三進作業"
 
-#: tree-cfg.cc:4277
+#: tree-cfg.cc:4279
 #, gcc-internal-format
 msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result"
 msgstr ""
 
-#: tree-cfg.cc:4309 tree-cfg.cc:4386
+#: tree-cfg.cc:4311 tree-cfg.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "vector types expected in %qs"
 msgstr "向量類型預期的在中向量 permute 運算式"
 
-#: tree-cfg.cc:4342
+#: tree-cfg.cc:4344
 #, fuzzy, gcc-internal-format
 msgid "vectors with different element number found in %qs"
 msgstr "向量與不同的元件號碼找到在中向量 permute 運算式"
 
-#: tree-cfg.cc:4358
+#: tree-cfg.cc:4360
 #, fuzzy, gcc-internal-format
 #| msgid "invalid rotate insn"
 msgid "invalid mask type in %qs"
 msgstr "無效的循環移位指令"
 
-#: tree-cfg.cc:4419
+#: tree-cfg.cc:4421
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "not allowed type combination in %qs"
 msgstr "不支援的組合：%s"
 
-#: tree-cfg.cc:4428
+#: tree-cfg.cc:4430
 #, fuzzy, gcc-internal-format
 msgid "invalid position or size in %qs"
 msgstr "無效的位置或大小運算元到 BIT_FIELD_REF"
 
-#: tree-cfg.cc:4434
+#: tree-cfg.cc:4436
 #, fuzzy, gcc-internal-format
 msgid "%qs into non-mode-precision operand"
 msgstr "Shift 的 non-integer 運算元"
 
-#: tree-cfg.cc:4444
+#: tree-cfg.cc:4446
 #, fuzzy, gcc-internal-format
 #| msgid "constant argument out of range for %qs"
 msgid "insertion out of range in %qs"
 msgstr "常數引數超過 %qs 的範圍"
 
-#: tree-cfg.cc:4454
+#: tree-cfg.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "%qs not at element boundary"
 msgstr "%qD 並非型態"
 
-#: tree-cfg.cc:4510
+#: tree-cfg.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "non-trivial conversion in %qs"
 msgstr "non-trivial 轉換於指派"
 
-#: tree-cfg.cc:4519
+#: tree-cfg.cc:4521
 #, fuzzy, gcc-internal-format
 msgid "invalid LHS (%qs) for assignment: %qs"
 msgstr "無效的 cpu「%s」用於 %s「%s」%s"
 
-#: tree-cfg.cc:4527
+#: tree-cfg.cc:4529
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in clobber statement"
 msgstr "在中敘述"
 
-#: tree-cfg.cc:4535
+#: tree-cfg.cc:4537
 #, fuzzy, gcc-internal-format
 msgid "%qs LHS in assignment statement"
 msgstr "在中敘述"
 
-#: tree-cfg.cc:4554
+#: tree-cfg.cc:4556
 #, fuzzy, gcc-internal-format
 #| msgid "invalid operand to %%R"
 msgid "invalid operand in %qs"
 msgstr "%%R 的運算元無效"
 
-#: tree-cfg.cc:4586
+#: tree-cfg.cc:4588
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid %qs size argument in load"
 msgstr "錯誤地使用了 %qD"
 
-#: tree-cfg.cc:4605 tree-cfg.cc:4631
+#: tree-cfg.cc:4607 tree-cfg.cc:4633
 #, fuzzy, gcc-internal-format
 msgid "invalid RHS for gimple memory store: %qs"
 msgstr "無效的 rhs 用於 gimple 記憶體儲存"
 
-#: tree-cfg.cc:4648
+#: tree-cfg.cc:4650
 #, fuzzy, gcc-internal-format
 msgid "non-register as LHS with vector constructor"
 msgstr "non-register 做為 LHS 的三進作業"
 
-#: tree-cfg.cc:4670 tree-cfg.cc:4688
+#: tree-cfg.cc:4672 tree-cfg.cc:4690
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "incorrect type of vector %qs elements"
 msgstr "左移次數大於或等於類型寬度"
 
-#: tree-cfg.cc:4679 tree-cfg.cc:4696
+#: tree-cfg.cc:4681 tree-cfg.cc:4698
 #, fuzzy, gcc-internal-format
 msgid "incorrect number of vector %qs elements"
 msgstr "不正確引數數量到函式 %qE"
 
-#: tree-cfg.cc:4704
+#: tree-cfg.cc:4706
 #, gcc-internal-format
 msgid "incorrect type of vector CONSTRUCTOR elements"
 msgstr ""
 
-#: tree-cfg.cc:4713
+#: tree-cfg.cc:4715
 #, gcc-internal-format
 msgid "vector %qs with non-NULL element index"
 msgstr ""
 
-#: tree-cfg.cc:4720
+#: tree-cfg.cc:4722
 #, gcc-internal-format
 msgid "vector %qs element is not a GIMPLE value"
 msgstr ""
 
-#: tree-cfg.cc:4729
+#: tree-cfg.cc:4731
 #, fuzzy, gcc-internal-format
 msgid "non-vector %qs with elements"
 msgstr "比較向量與不同的元件類型"
 
-#: tree-cfg.cc:4756
+#: tree-cfg.cc:4758
 #, fuzzy, gcc-internal-format
 msgid "nontemporal store lhs cannot be a gimple register"
 msgstr "non-parameter %qs 無法參數包裝"
 
-#: tree-cfg.cc:4799
+#: tree-cfg.cc:4801
 #, fuzzy, gcc-internal-format
 msgid "invalid operand in return statement"
 msgstr "無效的運算元在中回傳敘述"
 
-#: tree-cfg.cc:4809 c/gimple-parser.cc:2656
+#: tree-cfg.cc:4811 c/gimple-parser.cc:2656
 #, fuzzy, gcc-internal-format
 msgid "invalid conversion in return statement"
 msgstr "無效的轉換在中回傳敘述"
 
-#: tree-cfg.cc:4833
+#: tree-cfg.cc:4835
 #, fuzzy, gcc-internal-format
 msgid "goto destination is neither a label nor a pointer"
 msgstr "前往目的是 neither 標貼 nor 指標"
 
-#: tree-cfg.cc:4852
+#: tree-cfg.cc:4854
 #, fuzzy, gcc-internal-format
 msgid "invalid operand to switch statement"
 msgstr "無效的運算元到開關敘述"
 
-#: tree-cfg.cc:4860
+#: tree-cfg.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "non-integral type switch statement"
 msgstr "無效的運算元到開關敘述"
 
-#: tree-cfg.cc:4870
+#: tree-cfg.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "invalid default case label in switch statement"
 msgstr "%<default%> 標籤未出現在 switch 敘述內"
 
-#: tree-cfg.cc:4882
+#: tree-cfg.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "invalid %<CASE_CHAIN%>"
 msgstr "無效的 CASE_CHAIN"
 
-#: tree-cfg.cc:4888
+#: tree-cfg.cc:4890
 #, fuzzy, gcc-internal-format
 msgid "invalid case label in switch statement"
 msgstr "case 標籤出現在開關敘述外"
 
-#: tree-cfg.cc:4895
+#: tree-cfg.cc:4897
 #, fuzzy, gcc-internal-format
 msgid "invalid case range in switch statement"
 msgstr "無效的運算元到開關敘述"
 
-#: tree-cfg.cc:4905
+#: tree-cfg.cc:4907
 #, fuzzy, gcc-internal-format
 msgid "type precision mismatch in switch statement"
 msgstr "case 標籤出現在開關敘述外"
 
-#: tree-cfg.cc:4912
+#: tree-cfg.cc:4914
 #, fuzzy, gcc-internal-format
 msgid "type mismatch for case label in switch statement"
 msgstr "case 標籤出現在開關敘述外"
 
-#: tree-cfg.cc:4921
+#: tree-cfg.cc:4923
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted in switch statement"
 msgstr "case 標籤出現在開關敘述外"
 
-#: tree-cfg.cc:4964
+#: tree-cfg.cc:4966
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "label context is not the current function declaration"
 msgstr "函式宣告中出現參數名卻未指定類型"
 
-#: tree-cfg.cc:4973
+#: tree-cfg.cc:4975
 #, fuzzy, gcc-internal-format
 msgid "incorrect entry in %<label_to_block_map%>"
 msgstr "不正確條目在中 label_to_block_map"
 
-#: tree-cfg.cc:4983
+#: tree-cfg.cc:4985
 #, fuzzy, gcc-internal-format
 msgid "incorrect setting of landing pad number"
 msgstr "不正確集合降落填充數字"
 
-#: tree-cfg.cc:4999
+#: tree-cfg.cc:5001
 #, fuzzy, gcc-internal-format
 msgid "invalid comparison code in gimple cond"
 msgstr "無效的比較編碼在中 gimple cond"
 
-#: tree-cfg.cc:5007
+#: tree-cfg.cc:5009
 #, fuzzy, gcc-internal-format
 msgid "invalid labels in gimple cond"
 msgstr "無效的標貼在中 gimple cond"
 
-#: tree-cfg.cc:5020
+#: tree-cfg.cc:5022
 #, gcc-internal-format
 msgid "gimple cond condition cannot throw"
 msgstr ""
 
-#: tree-cfg.cc:5106 tree-cfg.cc:5115
+#: tree-cfg.cc:5108 tree-cfg.cc:5117
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> result"
 msgstr "無效的 PHI 結果"
 
-#: tree-cfg.cc:5125
+#: tree-cfg.cc:5127
 #, fuzzy, gcc-internal-format
 msgid "missing %<PHI%> def"
 msgstr "缺少PHI def"
 
-#: tree-cfg.cc:5139
+#: tree-cfg.cc:5141
 #, fuzzy, gcc-internal-format
 msgid "invalid %<PHI%> argument"
 msgstr "無效的 PHI 引數"
 
-#: tree-cfg.cc:5146
+#: tree-cfg.cc:5148
 #, fuzzy, gcc-internal-format
 msgid "incompatible types in %<PHI%> argument %u"
 msgstr "不相容的類型在中 PHI 引數 %u"
 
-#: tree-cfg.cc:5249
+#: tree-cfg.cc:5251
 #, fuzzy, gcc-internal-format
 msgid "%<verify_gimple%> failed"
 msgstr "verifygimple 失敗(_G)"
 
-#: tree-cfg.cc:5308
+#: tree-cfg.cc:5310
 #, fuzzy, gcc-internal-format
 msgid "dead statement in EH table"
 msgstr "dead STMT 在中 EH 表格"
 
-#: tree-cfg.cc:5324
+#: tree-cfg.cc:5326
 #, gcc-internal-format
 msgid "location references block not in block tree"
 msgstr ""
 
-#: tree-cfg.cc:5373
+#: tree-cfg.cc:5375
 #, fuzzy, gcc-internal-format
 #| msgid "implicit declaration of function %qE"
 msgid "local declaration from a different function"
 msgstr "隱含宣告函式 %qE"
 
-#: tree-cfg.cc:5476
+#: tree-cfg.cc:5478
 #, fuzzy, gcc-internal-format
 msgid "gimple_bb (phi) is set to a wrong basic block"
 msgstr "gimplebb (phi) 是設定為錯誤的基本區塊(_B)"
 
-#: tree-cfg.cc:5485
+#: tree-cfg.cc:5487
 #, fuzzy, gcc-internal-format
 msgid "PHI node with location"
 msgstr "從這個地方"
 
-#: tree-cfg.cc:5496 tree-cfg.cc:5543
+#: tree-cfg.cc:5498 tree-cfg.cc:5545
 #, gcc-internal-format
 msgid "incorrect sharing of tree nodes"
 msgstr "對樹結區段的共享不正確"
 
-#: tree-cfg.cc:5504
+#: tree-cfg.cc:5506
 #, gcc-internal-format
 msgid "virtual PHI with argument locations"
 msgstr ""
 
-#: tree-cfg.cc:5531
+#: tree-cfg.cc:5533
 #, fuzzy, gcc-internal-format
 msgid "gimple_bb (stmt) is set to a wrong basic block"
 msgstr "gimplebb (stmt) 是設定為錯誤的基本區塊(_B)"
 
-#: tree-cfg.cc:5571
+#: tree-cfg.cc:5573
 #, fuzzy, gcc-internal-format
 msgid "statement marked for throw, but doesn%'t"
 msgstr "敘述標記的用於丟擲，但是 doesn%'t"
 
-#: tree-cfg.cc:5577
+#: tree-cfg.cc:5579
 #, fuzzy, gcc-internal-format
 msgid "statement marked for throw in middle of block"
 msgstr "敘述標記的用於丟擲在中中間的區塊"
 
-#: tree-cfg.cc:5599
+#: tree-cfg.cc:5601
 #, fuzzy, gcc-internal-format
 msgid "verify_gimple failed"
 msgstr "verifygimple 失敗(_G)"
 
-#: tree-cfg.cc:5623
+#: tree-cfg.cc:5625
 #, fuzzy, gcc-internal-format
 msgid "ENTRY_BLOCK has IL associated with it"
 msgstr "ENTRY_BLOCK 有 IL 關聯的與它"
 
-#: tree-cfg.cc:5630
+#: tree-cfg.cc:5632
 #, fuzzy, gcc-internal-format
 msgid "EXIT_BLOCK has IL associated with it"
 msgstr "EXIT_BLOCK 有 IL 關聯的與它"
 
-#: tree-cfg.cc:5637
+#: tree-cfg.cc:5639
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "fallthru to exit from bb %d"
 msgstr "fallthru 到離開從 bb %d"
 
-#: tree-cfg.cc:5643
+#: tree-cfg.cc:5645
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "entry block count not initialized"
 msgstr "初始值設定項末尾有多餘的大括號組"
 
-#: tree-cfg.cc:5649
+#: tree-cfg.cc:5651
 #, fuzzy, gcc-internal-format
 #| msgid "extra brace group at end of initializer"
 msgid "exit block count not initialized"
 msgstr "初始值設定項末尾有多餘的大括號組"
 
-#: tree-cfg.cc:5656
+#: tree-cfg.cc:5658
 #, gcc-internal-format
 msgid "probability of edge from entry block not initialized"
 msgstr ""
 
-#: tree-cfg.cc:5662
+#: tree-cfg.cc:5664
 #, fuzzy, gcc-internal-format
 msgid "exit block count is not compatible with entry block count"
 msgstr "%<-march=%s%>不是相容與已選 ABI"
 
-#: tree-cfg.cc:5677
+#: tree-cfg.cc:5679
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d not initialized"
 msgstr "%qE 未被初始化的"
 
-#: tree-cfg.cc:5683
+#: tree-cfg.cc:5685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "verify_flow_info: Wrong probability of edge %i->%i %i"
 msgid "probability of edge %d->%d not initialized"
 msgstr "verify_flow_info：邊 %i->%i %i 概率錯"
 
-#: tree-cfg.cc:5690
+#: tree-cfg.cc:5692
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "count of bb %d is not compatible with entry block count"
 msgstr "%<-march=%s%>不是相容與已選 ABI"
 
-#: tree-cfg.cc:5709
+#: tree-cfg.cc:5711
 #, gcc-internal-format
 msgid "nonlocal label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5716
+#: tree-cfg.cc:5718
 #, gcc-internal-format
 msgid "EH landing pad label %qD is not first in a sequence of labels in bb %d"
 msgstr ""
 
-#: tree-cfg.cc:5723
+#: tree-cfg.cc:5725
 #, fuzzy, gcc-internal-format
 #| msgid "label %s to block does not match in bb %d"
 msgid "label %qD to block does not match in bb %d"
 msgstr "標籤 %s 在基本區塊 %d 中不匹配"
 
-#: tree-cfg.cc:5730
+#: tree-cfg.cc:5732
 #, fuzzy, gcc-internal-format
 #| msgid "label %s to block does not match in bb %d"
 msgid "label %qD has incorrect context in bb %d"
 msgstr "標籤 %s 在基本區塊 %d 中不匹配"
 
-#: tree-cfg.cc:5745
+#: tree-cfg.cc:5747
 #, gcc-internal-format, gfc-internal-format
 msgid "control flow in the middle of basic block %d"
 msgstr "基本區塊 %d 中出現流程控制"
 
-#: tree-cfg.cc:5755
+#: tree-cfg.cc:5757
 #, fuzzy, gcc-internal-format
 #| msgid "label %s in the middle of basic block %d"
 msgid "label %qD in the middle of basic block %d"
 msgstr "標籤 %s 在基本區塊 %d 中間"
 
-#: tree-cfg.cc:5774
+#: tree-cfg.cc:5776
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not last in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5783
+#: tree-cfg.cc:5785
 #, gcc-internal-format, gfc-internal-format
 msgid "returns_twice call is not first in basic block %d"
 msgstr ""
 
-#: tree-cfg.cc:5815
+#: tree-cfg.cc:5817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "fallthru edge after a control statement in bb %d"
 msgstr "fallthru 邊緣之後控制敘述在中 bb %d"
 
-#: tree-cfg.cc:5828
+#: tree-cfg.cc:5830
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "true/false edge after a non-GIMPLE_COND in bb %d"
 msgstr "真/假邊緣之後 non-GIMPLE_COND 在中 bb %d"
 
-#: tree-cfg.cc:5851 tree-cfg.cc:5873 tree-cfg.cc:5890 tree-cfg.cc:5959
+#: tree-cfg.cc:5853 tree-cfg.cc:5875 tree-cfg.cc:5892 tree-cfg.cc:5961
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "wrong outgoing edge flags at end of bb %d"
 msgstr "錯誤的外送的郵件邊緣旗標於結束的 bb %d"
 
-#: tree-cfg.cc:5861
+#: tree-cfg.cc:5863
 #, gcc-internal-format, gfc-internal-format
 msgid "explicit goto at end of bb %d"
 msgstr "基本區塊 %d 末尾明確的 goto"
 
-#: tree-cfg.cc:5895
+#: tree-cfg.cc:5897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "return edge does not point to exit in bb %d"
 msgstr "回傳邊緣不點到離開在中 bb %d"
 
-#: tree-cfg.cc:5925
+#: tree-cfg.cc:5927
 #, fuzzy, gcc-internal-format
 msgid "found default case not at the start of case vector"
 msgstr "找到預設大小寫無法於開始的大小寫向量"
 
-#: tree-cfg.cc:5933
+#: tree-cfg.cc:5935
 #, fuzzy, gcc-internal-format
 msgid "case labels not sorted: "
 msgstr "大小寫標貼無法排序："
 
-#: tree-cfg.cc:5950
+#: tree-cfg.cc:5952
 #, gcc-internal-format, gfc-internal-format
 msgid "extra outgoing edge %d->%d"
 msgstr "多餘的出邊 %d->%d"
 
-#: tree-cfg.cc:5973
+#: tree-cfg.cc:5975
 #, gcc-internal-format, gfc-internal-format
 msgid "missing edge %i->%i"
 msgstr "缺少邊 %i->%i"
 
-#: tree-cfg.cc:9785
+#: tree-cfg.cc:9787
 #, fuzzy, gcc-internal-format
 msgid "%<noreturn%> function does return"
 msgstr "%<noreturn%> 函式做回傳"
 
-#: tree-cfg.cc:9805 tree-cfg.cc:9840
+#: tree-cfg.cc:9807 tree-cfg.cc:9842
 #, fuzzy, gcc-internal-format
 msgid "control reaches end of non-void function"
 msgstr "控制達到結束的 non-void 函式"
 
-#: tree-cfg.cc:9910
+#: tree-cfg.cc:9912
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD declared with attribute %<warn_unused_result%>"
 msgstr "忽略傳回值的 %qD，宣告的與屬性 warn_unused_result"
 
-#: tree-cfg.cc:9915 cp/cvt.cc:1167
+#: tree-cfg.cc:9917 cp/cvt.cc:1167
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of function declared with attribute %<warn_unused_result%>"
 msgstr "忽略傳回值的函式宣告的與屬性 warn_unused_result"
@@ -35647,12 +35695,12 @@ msgstr ""
 msgid "target does not support atomic profile update, single mode is selected"
 msgstr ""
 
-#: tree-ssa-alias.cc:4131
+#: tree-ssa-alias.cc:4130
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\""
 msgstr "無效的元件類型用於屬性 %qs"
 
-#: tree-ssa-alias.cc:4170
+#: tree-ssa-alias.cc:4169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "invalid fn spec attribute \"%s\" arg %i"
 msgstr "無效的使用的 %<auto%>"
@@ -36162,7 +36210,7 @@ msgstr "向量作業將被展開 piecewise"
 msgid "vector shuffling operation will be expanded piecewise"
 msgstr "向量隨機播放作業將被展開 piecewise"
 
-#: tree-vect-loop.cc:4493
+#: tree-vect-loop.cc:4492
 #, gcc-internal-format
 msgid "vectorization did not happen for a simd loop"
 msgstr ""
@@ -36584,12 +36632,12 @@ msgstr ""
 msgid "%<TYPE_METHOD_BASETYPE%> is not main variant"
 msgstr ""
 
-#: tree.cc:15620
+#: tree.cc:15640
 #, gcc-internal-format
 msgid "missing %<target%> attribute for multi-versioned %qD"
 msgstr ""
 
-#: tree.cc:15623 tree.cc:15789 tree.cc:15807 tree.cc:15820 cp/decl.cc:1487
+#: tree.cc:15643 tree.cc:15809 tree.cc:15827 tree.cc:15840 cp/decl.cc:1487
 #: cp/decl.cc:2620 cp/decl.cc:2668 cp/decl.cc:2684 cp/decl.cc:3331
 #: cp/decl.cc:3787
 #, fuzzy, gcc-internal-format
@@ -36597,17 +36645,17 @@ msgstr ""
 msgid "previous declaration of %qD"
 msgstr "%q+D 的前一個宣告"
 
-#: tree.cc:15785
+#: tree.cc:15805
 #, fuzzy, gcc-internal-format
 msgid "%qD conflicts with overlapping %<target_clone%> declaration"
 msgstr "%q#D 衝突與前一個宣告"
 
-#: tree.cc:15804
+#: tree.cc:15824
 #, fuzzy
 msgid "%qD conflicts for version %qB"
 msgstr "衝突與前一個宣告在此"
 
-#: tree.cc:15817
+#: tree.cc:15837
 #, fuzzy
 msgid "%qD conflicts with a previous declaration for version %qB"
 msgstr "%q#D 衝突與前一個宣告"
@@ -36686,7 +36734,7 @@ msgstr "將初始化為零的資料存放在 bss 區段中"
 msgid "no initializers are allowed in section %qs"
 msgstr "將初始化為零的資料存放在 bss 區段中"
 
-#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1464
+#: varasm.cc:1547 varasm.cc:1556 d/d-attribs.cc:1484
 #, gcc-internal-format
 msgid "register name not specified for %q+D"
 msgstr "%q+D 的暫存器名無效"
@@ -36841,7 +36889,7 @@ msgstr "weakref %q+D 最終參照其自身"
 msgid "%qs symbol %q+D must have static linkage"
 msgstr "weakref %q+D 必須有靜態鏈結"
 
-#: varasm.cc:6661 config/nvptx/nvptx.cc:7751
+#: varasm.cc:6661 config/nvptx/nvptx.cc:7757
 #, fuzzy, gcc-internal-format
 msgid "alias definitions not supported in this configuration"
 msgstr "別名定義不支援在中這個組態"
@@ -36887,59 +36935,59 @@ msgstr "使用緊實的堆疊版面設置"
 msgid "cannot tail-call: return value must be a call"
 msgstr ""
 
-#: c-family/c-attribs.cc:787 d/d-attribs.cc:1195
+#: c-family/c-attribs.cc:787 d/d-attribs.cc:1198
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument is invalid"
 msgstr "範本參數 %d 無效"
 
-#: c-family/c-attribs.cc:790 d/d-attribs.cc:1198
+#: c-family/c-attribs.cc:790 d/d-attribs.cc:1201
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %d is invalid"
 msgid "%qE attribute argument %i is invalid"
 msgstr "範本參數 %d 無效"
 
-#: c-family/c-attribs.cc:802 d/d-attribs.cc:1210
+#: c-family/c-attribs.cc:802 d/d-attribs.cc:1213
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument has type %qT"
 msgstr "預期 %qT 但是引數是的型態 %qT"
 
-#: c-family/c-attribs.cc:806 d/d-attribs.cc:1214
+#: c-family/c-attribs.cc:806 d/d-attribs.cc:1217
 #, fuzzy, gcc-internal-format
 #| msgid "default argument for %q#D has type %qT"
 msgid "%qE attribute argument %i has type %qT"
 msgstr "%q#D 的預設引數類型為 %qT"
 
 #: c-family/c-attribs.cc:817 c-family/c-attribs.cc:4915
-#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1225
+#: c-family/c-attribs.cc:4919 d/d-attribs.cc:1228
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument value %qE is not an integer constant"
 msgstr "%qE 屬性引數不是整數常數"
 
-#: c-family/c-attribs.cc:822 d/d-attribs.cc:1230
+#: c-family/c-attribs.cc:822 d/d-attribs.cc:1233
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE is not an integer constant"
 msgstr "%qE 屬性引數不是整數常數"
 
-#: c-family/c-attribs.cc:838 d/d-attribs.cc:1244
+#: c-family/c-attribs.cc:838 d/d-attribs.cc:1247
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE does not refer to a function parameter"
 msgstr "預設參數只允許出現在函式參數中"
 
-#: c-family/c-attribs.cc:843 d/d-attribs.cc:1249
+#: c-family/c-attribs.cc:843 d/d-attribs.cc:1252
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE does not refer to a function parameter"
 msgstr "預設參數只允許出現在函式參數中"
 
-#: c-family/c-attribs.cc:871 d/d-attribs.cc:1272
+#: c-family/c-attribs.cc:871 d/d-attribs.cc:1275
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument value %qE exceeds the number of function parameters %u"
 msgstr "預設參數只允許出現在函式參數中"
 
-#: c-family/c-attribs.cc:876 d/d-attribs.cc:1277
+#: c-family/c-attribs.cc:876 d/d-attribs.cc:1280
 #, fuzzy, gcc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "%qE attribute argument %i value %qE exceeds the number of function parameters %u"
@@ -36955,13 +37003,13 @@ msgstr "%qE 屬性只有套用到變數和函式"
 msgid "%qE attribute argument %i value %qE does not refer to a variable argument list"
 msgstr ""
 
-#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1298
+#: c-family/c-attribs.cc:929 c-family/c-attribs.cc:942 d/d-attribs.cc:1301
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for field of type %qT"
 msgid "%qE attribute argument value %qE refers to parameter type %qT"
 msgstr "%qE 屬性為 %qT 型態的欄位所忽略"
 
-#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1303
+#: c-family/c-attribs.cc:933 c-family/c-attribs.cc:947 d/d-attribs.cc:1306
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument %i value %qE refers to parameter type %qT"
 msgstr "%qE 屬性引數不是整數常數"
@@ -37178,12 +37226,12 @@ msgstr "無法為列舉類型使用模式 %qs"
 msgid "mode %qs applied to inappropriate type"
 msgstr "對不合適的類型套用模式 %qs"
 
-#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1024
+#: c-family/c-attribs.cc:2621 c-family/c-attribs.cc:3081 d/d-attribs.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "section attributes are not supported for this target"
 msgstr "區段屬性未被支援用於這個目標"
 
-#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1031
+#: c-family/c-attribs.cc:2627 d/d-attribs.cc:1034
 #, gcc-internal-format
 msgid "section attribute not allowed for %q+D"
 msgstr "%q+D 不能有 section 屬性"
@@ -37193,18 +37241,18 @@ msgstr "%q+D 不能有 section 屬性"
 msgid "section attribute argument not a string constant"
 msgstr "%qE 屬性引數不是字串常數"
 
-#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1047
+#: c-family/c-attribs.cc:2642 d/d-attribs.cc:1050
 #, fuzzy, gcc-internal-format
 msgid "section attribute cannot be specified for local variables"
 msgstr "區段屬性無法指定的用於區域變數"
 
 #: c-family/c-attribs.cc:2653 config/bfin/bfin.cc:4796 config/bfin/bfin.cc:4847
-#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1058
+#: config/bfin/bfin.cc:4873 config/bfin/bfin.cc:4886 d/d-attribs.cc:1061
 #, gcc-internal-format
 msgid "section of %q+D conflicts with previous declaration"
 msgstr "%q+D 的區段與早先的宣告衝突"
 
-#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1067
+#: c-family/c-attribs.cc:2662 c-family/c-attribs.cc:3107 d/d-attribs.cc:1070
 #, fuzzy, gcc-internal-format
 msgid "section of %q+D cannot be overridden"
 msgstr "區段的 %q+D 無法 overridden"
@@ -37293,7 +37341,7 @@ msgstr "%qE 引數不是識別碼"
 msgid "%<counted_by%> argument %qE conflicts with previous declaration %qE"
 msgstr " areadonly' 屬性的內容 %qD 衝突與前一個宣告"
 
-#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1146 jit/dummy-frontend.cc:757
+#: c-family/c-attribs.cc:3042 d/d-attribs.cc:1149 jit/dummy-frontend.cc:757
 #, fuzzy, gcc-internal-format
 msgid "inline function %q+D declared weak"
 msgstr "內聯函式 %q+D 宣告的 weak"
@@ -37339,13 +37387,13 @@ msgstr "忽略屬性於模板引數 %qT"
 msgid "%qE attribute is only applicable on functions"
 msgstr "%qE 屬性只有套用到函式"
 
-#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1094
+#: c-family/c-attribs.cc:3196 d/d-attribs.cc:1097
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute only applies to functions"
 msgid "%<symver%> attribute only applies to functions and variables"
 msgstr "%qs 屬性只能套用於函式"
 
-#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1102
+#: c-family/c-attribs.cc:3204 d/d-attribs.cc:1105
 #, fuzzy, gcc-internal-format
 msgid "%<symver%> attribute is only applicable to symbols"
 msgstr "%qE 屬性只有套用到函式"
@@ -37355,12 +37403,12 @@ msgstr "%qE 屬性只有套用到函式"
 msgid "%<symver%> attribute argument not a string constant"
 msgstr "%qE 屬性引數不是字串常數"
 
-#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1126
+#: c-family/c-attribs.cc:3228 d/d-attribs.cc:1129
 #, gcc-internal-format
 msgid "symver attribute argument must have format %<name@nodename%>"
 msgstr ""
 
-#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1127
+#: c-family/c-attribs.cc:3229 d/d-attribs.cc:1130
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "%<symver%> attribute argument %qs must contain one or two %<@%>"
@@ -37455,23 +37503,23 @@ msgstr "%qE 屬性忽略的因為 %qT 已經定義"
 msgid "visibility argument not a string"
 msgstr "visibility 的引數不是一個字串"
 
-#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1585 jit/dummy-frontend.cc:631
+#: c-family/c-attribs.cc:3649 d/d-attribs.cc:1605 jit/dummy-frontend.cc:631
 #, gcc-internal-format
 msgid "%qE attribute ignored on types"
 msgstr "%qE 屬性在類型上被忽略"
 
-#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1614 jit/dummy-frontend.cc:647
+#: c-family/c-attribs.cc:3665 d/d-attribs.cc:1634 jit/dummy-frontend.cc:647
 #, fuzzy, gcc-internal-format
 msgid "attribute %qE argument must be one of %qs, %qs, %qs, or %qs"
 msgstr "屬性 %qE 引數不是字串"
 
-#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1625 jit/dummy-frontend.cc:659
+#: c-family/c-attribs.cc:3677 d/d-attribs.cc:1645 jit/dummy-frontend.cc:659
 #, fuzzy, gcc-internal-format
 msgid "%qD redeclared with different visibility"
 msgstr "%qD redeclared 與不同的可視性"
 
-#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1628
-#: d/d-attribs.cc:1632 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
+#: c-family/c-attribs.cc:3680 c-family/c-attribs.cc:3684 d/d-attribs.cc:1648
+#: d/d-attribs.cc:1652 jit/dummy-frontend.cc:662 jit/dummy-frontend.cc:666
 #, fuzzy, gcc-internal-format
 msgid "%qD was declared %qs which implies default visibility"
 msgstr "%qD 被宣告 %qs 該項意味著預設可視性"
@@ -37488,7 +37536,7 @@ msgstr ""
 
 #: c-family/c-attribs.cc:3765 c-family/c-attribs.cc:4362
 #: c-family/c-attribs.cc:6538 c-family/c-attribs.cc:6565
-#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700
+#: config/m32c/m32c.cc:2942 ada/gcc-interface/utils.cc:7700 d/d-attribs.cc:1457
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applies only to functions"
 msgstr "%qE 屬性套用只有到函式"
@@ -37562,7 +37610,7 @@ msgid "%qE attribute argument 1 must take a pointer type as its first argument;
 msgstr "%qE 屬性引數不是字串常數"
 
 #: c-family/c-attribs.cc:4061 c-family/c-attribs.cc:4109
-#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1329
+#: c-family/c-attribs.cc:4136 d/d-attribs.cc:1332
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "%qE attribute ignored on a function returning %qT"
@@ -37642,7 +37690,7 @@ msgstr "%qD 不是相容與 %qD"
 msgid "%qE argument is not a function"
 msgstr "cleanup 引數不是一個函式"
 
-#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6814
+#: c-family/c-attribs.cc:4716 cp/name-lookup.cc:6854
 #, fuzzy, gcc-internal-format
 msgid "deprecated message is not a string"
 msgstr "不宜用訊息並非字串"
@@ -37712,7 +37760,7 @@ msgid "%qE attribute ignored on non-enum"
 msgstr "%qE 屬性在類型上被忽略"
 
 #: c-family/c-attribs.cc:5205 config/mips/mips.cc:1346 config/mips/mips.cc:1607
-#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7590
+#: config/mips/mips.cc:1661 config/riscv/riscv.cc:7593
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute requires a string argument"
 msgstr "%qE 屬性需要字串常數引數"
@@ -37880,15 +37928,15 @@ msgid "requested position is less than zero"
 msgstr "要求的位置小於 0"
 
 #: c-family/c-attribs.cc:6375 ada/gcc-interface/utils.cc:7597
-#: d/d-attribs.cc:771 jit/dummy-frontend.cc:798
+#: d/d-attribs.cc:774 jit/dummy-frontend.cc:798
 #, fuzzy, gcc-internal-format
 msgid "empty string in attribute %<target%>"
 msgstr "預期的繫結屬性於 %C"
 
 #. The argument must be a constant string.
-#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1038
-#: d/d-attribs.cc:1112 d/d-attribs.cc:1415 d/d-attribs.cc:1458
-#: d/d-attribs.cc:1520 d/d-attribs.cc:1599
+#: c-family/c-attribs.cc:6416 config/sh/sh.cc:8561 d/d-attribs.cc:1041
+#: d/d-attribs.cc:1115 d/d-attribs.cc:1418 d/d-attribs.cc:1478
+#: d/d-attribs.cc:1540 d/d-attribs.cc:1619
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument not a string constant"
 msgstr "%qE 屬性引數不是字串常數"
@@ -38163,7 +38211,7 @@ msgid "suggest parentheses around assignment used as truth value"
 msgstr "建議在做為真值的賦值敘述前後加上括號"
 
 #: c-family/c-common.cc:3910 c/c-decl.cc:5192 c/c-decl.cc:7734
-#: c/c-parser.cc:4189 c/c-typeck.cc:18701
+#: c/c-parser.cc:4189 c/c-typeck.cc:18709
 #, gcc-internal-format
 msgid "invalid use of %<restrict%>"
 msgstr "錯誤地使用了 %<restrict%>"
@@ -38337,8 +38385,8 @@ msgstr "變數引數太少，不足以填滿一個哨符"
 msgid "missing sentinel in function call"
 msgstr "函式呼叫中缺少哨符"
 
-#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:837
-#: d/d-attribs.cc:887
+#: c-family/c-common.cc:6259 c-family/c-common.cc:6312 d/d-attribs.cc:840
+#: d/d-attribs.cc:890
 #, fuzzy, gcc-internal-format
 msgid "bad option %qs to attribute %<optimize%>"
 msgstr "不當的選項 %s 到 pragma 屬性"
@@ -39386,7 +39434,7 @@ msgstr "不受支援的 non-standard 串接的字串實字"
 msgid "traditional C rejects string constant concatenation"
 msgstr "傳統 C 不接受字串常數粘貼"
 
-#: c-family/c-omp.cc:136 cp/pt.cc:20275
+#: c-family/c-omp.cc:136 cp/pt.cc:20421
 #, gcc-internal-format
 msgid "%<#pragma omp critical%> with %<hint%> clause requires a name, except when %<omp_sync_hint_none%> is used"
 msgstr ""
@@ -39441,7 +39489,7 @@ msgstr ""
 msgid "%<iterator%> modifier may not be specified on %<depobj%> construct"
 msgstr ""
 
-#: c-family/c-omp.cc:1005 cp/semantics.cc:12083
+#: c-family/c-omp.cc:1005 cp/semantics.cc:12104
 #, fuzzy, gcc-internal-format
 msgid "invalid type for iteration variable %qE"
 msgstr "無效的型態用於迭代變數 %qE"
@@ -39456,17 +39504,17 @@ msgstr "無效的型態用於迭代變數 %qE"
 msgid "%qE is not initialized"
 msgstr "%qE 未被初始化的"
 
-#: c-family/c-omp.cc:1047 cp/semantics.cc:11967
+#: c-family/c-omp.cc:1047 cp/semantics.cc:11988
 #, fuzzy, gcc-internal-format
 msgid "missing controlling predicate"
 msgstr "缺少控制述詞"
 
-#: c-family/c-omp.cc:1153 cp/semantics.cc:11558
+#: c-family/c-omp.cc:1153 cp/semantics.cc:11579
 #, fuzzy, gcc-internal-format
 msgid "invalid controlling predicate"
 msgstr "無效的控制述詞"
 
-#: c-family/c-omp.cc:1160 cp/semantics.cc:11973
+#: c-family/c-omp.cc:1160 cp/semantics.cc:11994
 #, fuzzy, gcc-internal-format
 msgid "missing increment expression"
 msgstr "缺少遞增運算式"
@@ -39476,7 +39524,7 @@ msgstr "缺少遞增運算式"
 msgid "increment is not constant 1 or -1 for %<!=%> condition"
 msgstr ""
 
-#: c-family/c-omp.cc:1292 cp/semantics.cc:11675
+#: c-family/c-omp.cc:1292 cp/semantics.cc:11696
 #, fuzzy, gcc-internal-format
 msgid "invalid increment expression"
 msgstr "無效的遞增運算式"
@@ -39574,19 +39622,19 @@ msgstr ""
 msgid "%<inscan%> %<reduction%> clause on construct other than %<for%>, %<simd%>, %<for simd%>, %<parallel for%>, %<parallel for simd%>"
 msgstr ""
 
-#: c-family/c-omp.cc:3078 c/c-typeck.cc:18475 cp/semantics.cc:10586
+#: c-family/c-omp.cc:3078 c/c-typeck.cc:18483 cp/semantics.cc:10607
 #, gcc-internal-format
 msgid "%qD specified in %<allocate%> clause but not in an explicit privatization clause"
 msgstr ""
 
 #: c-family/c-omp.cc:3170 c-family/c-omp.cc:3185 c/c-parser.cc:28140
-#: cp/parser.cc:53709
+#: cp/parser.cc:53769
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qD is not a function argument"
 msgstr "%qD 不是一個函式範本"
 
-#: c-family/c-omp.cc:3466 c/c-typeck.cc:17546 cp/semantics.cc:9158
+#: c-family/c-omp.cc:3466 c/c-typeck.cc:17554 cp/semantics.cc:9179
 #, gcc-internal-format
 msgid "bit-field %qE in %qs clause"
 msgstr ""
@@ -39596,8 +39644,8 @@ msgstr ""
 msgid "%qE does not have a mappable type in %qs clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c-family/c-omp.cc:3482 c/c-typeck.cc:15808 c/c-typeck.cc:17645
-#: c/c-typeck.cc:17833
+#: c-family/c-omp.cc:3482 c/c-typeck.cc:15816 c/c-typeck.cc:17653
+#: c/c-typeck.cc:17841
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qE in %qs clause"
 msgstr "太多 %qs 子句"
@@ -40142,7 +40190,7 @@ msgstr "無效的位置用於 %<pragma %s%>，忽略"
 msgid "malformed %<#pragma %s%>, ignored"
 msgstr "異常的 %<# pragma %s%>，忽略"
 
-#: c-family/c-pragma.cc:1440 cp/lex.cc:694
+#: c-family/c-pragma.cc:1440 cp/lex.cc:697
 #, fuzzy, gcc-internal-format
 msgid "junk at end of %<#pragma %s%>"
 msgstr "垃圾於結束的 %<# pragma %s%>"
@@ -40215,8 +40263,8 @@ msgstr "在這裡不允許使用 %<#pragma%>"
 msgid "wrong type argument to %s"
 msgstr "錯誤的型態引數到 %s"
 
-#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4883
-#: cp/constexpr.cc:9158 m2/gm2-gcc/m2expr.cc:869
+#: c-family/c-warn.cc:60 c-family/c-warn.cc:73 cp/constexpr.cc:4896
+#: cp/constexpr.cc:9191 m2/gm2-gcc/m2expr.cc:869
 #: rust/backend/rust-constexpr.cc:1960 rust/backend/rust-constexpr.cc:4551
 #, gcc-internal-format
 msgid "overflow in constant expression"
@@ -40718,17 +40766,17 @@ msgstr "遞減的函式 %qD"
 msgid "function %qD used as %<asm%> output"
 msgstr "函式 %qD 使用的做為 %<asm%> 輸出"
 
-#: c-family/c-warn.cc:1914 c/c-typeck.cc:6401
+#: c-family/c-warn.cc:1914 c/c-typeck.cc:6409
 #, fuzzy, gcc-internal-format
 msgid "assignment of read-only location %qE"
 msgstr "指派的唯讀位置 %qE"
 
-#: c-family/c-warn.cc:1915 c/c-typeck.cc:6404
+#: c-family/c-warn.cc:1915 c/c-typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "increment of read-only location %qE"
 msgstr "遞增的唯讀位置 %qE"
 
-#: c-family/c-warn.cc:1916 c/c-typeck.cc:6407
+#: c-family/c-warn.cc:1916 c/c-typeck.cc:6415
 #, fuzzy, gcc-internal-format
 msgid "decrement of read-only location %qE"
 msgstr "遞減的唯讀位置 %qE"
@@ -41003,7 +41051,7 @@ msgid "passing argument %i to %qs-qualified parameter aliases with argument %Z"
 msgid_plural "passing argument %i to %qs-qualified parameter aliases with arguments %Z"
 msgstr[0] "傳遞引數 %d 的 %qE 捨棄 %qv 限定元從指標目標類型"
 
-#: c-family/c-warn.cc:2934 c/c-typeck.cc:7041 cp/call.cc:6602
+#: c-family/c-warn.cc:2934 c/c-typeck.cc:7049 cp/call.cc:6602
 #, gcc-internal-format
 msgid "this condition has identical branches"
 msgstr ""
@@ -41957,7 +42005,7 @@ msgid "ACLE function %qD requires ISA extension %qs"
 msgstr "內建函式 %s 需求 -mvsx 選項"
 
 #: config/aarch64/aarch64-builtins.cc:2675 config/aarch64/aarch64.cc:12191
-#: config/aarch64/aarch64.cc:19694 config/aarch64/aarch64.cc:20321
+#: config/aarch64/aarch64.cc:19710 config/aarch64/aarch64.cc:20337
 #, gcc-internal-format
 msgid "you can enable %qs using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
@@ -42647,7 +42695,7 @@ msgstr "永遠不同的 Objective-C 類型傳遞參數 %d (屬於 %qE)"
 
 #: config/aarch64/aarch64-sve-builtins.cc:4883
 #: config/arm/arm-mve-builtins.cc:502 config/arm/arm-mve-builtins.cc:527
-#: config/riscv/riscv-vector-builtins.cc:5584
+#: config/riscv/riscv-vector-builtins.cc:5591
 #, fuzzy, gcc-internal-format
 msgid "duplicate definition of %qs"
 msgstr "刪除的定義的 %qD"
@@ -42694,7 +42742,7 @@ msgid "SVE type %qT does not have a defined alignment"
 msgstr "型態 %qT 沒有已知大小"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5252
-#: config/riscv/riscv-vector-builtins.cc:5468
+#: config/riscv/riscv-vector-builtins.cc:5475
 #, fuzzy, gcc-internal-format
 msgid "variables of type %qT cannot have thread-local storage duration"
 msgstr "%qE 屬性忽略的因為 %qT 已經定義"
@@ -42750,7 +42798,7 @@ msgid "SVE type %qT not allowed in %<map%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
 #: config/aarch64/aarch64-sve-builtins.cc:5302
-#: config/riscv/riscv-vector-builtins.cc:5527
+#: config/riscv/riscv-vector-builtins.cc:5534
 #, gcc-internal-format
 msgid "cannot reference %qT object types in %<target%> region"
 msgstr ""
@@ -42848,19 +42896,19 @@ msgid "SVE type %qT cannot be passed to an unprototyped function"
 msgstr "傳遞 AltiVec 引數給無原型的函式"
 
 #: config/aarch64/aarch64.cc:7951 config/aarch64/aarch64.cc:8032
-#: config/aarch64/aarch64.cc:22639
+#: config/aarch64/aarch64.cc:22655
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 13.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7958 config/aarch64/aarch64.cc:8039
-#: config/aarch64/aarch64.cc:22646
+#: config/aarch64/aarch64.cc:22662
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 14.1"
 msgstr ""
 
 #: config/aarch64/aarch64.cc:7969 config/aarch64/aarch64.cc:8049
-#: config/aarch64/aarch64.cc:22654 config/arm/arm.cc:7326
+#: config/aarch64/aarch64.cc:22670 config/arm/arm.cc:7326
 #: config/arm/arm.cc:7356 config/arm/arm.cc:29418
 #, gcc-internal-format
 msgid "parameter passing for argument of type %qT changed in GCC 9.1"
@@ -42906,189 +42954,189 @@ msgstr ""
 msgid "use %<__arm_preserves(\"za\")%> if the callee preserves ZA"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19278
+#: config/aarch64/aarch64.cc:19294
 #, gcc-internal-format
 msgid "unknown flag passed in %<-moverride=%s%> (%s)"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19322
+#: config/aarch64/aarch64.cc:19338
 #, fuzzy, gcc-internal-format
 #| msgid "%qs attribute ignored"
 msgid "%qs string ill-formed"
 msgstr "忽略 %qs 屬性"
 
-#: config/aarch64/aarch64.cc:19378
+#: config/aarch64/aarch64.cc:19394
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constraints for operand"
 msgid "invalid format for %<sve_width%>"
 msgstr "運算元的約束無效"
 
-#: config/aarch64/aarch64.cc:19390
+#: config/aarch64/aarch64.cc:19406
 #, fuzzy, gcc-internal-format
 #| msgid "invalid %%h value"
 msgid "invalid %<sve_width%> value: %d"
 msgstr "無效 %%h 值"
 
-#: config/aarch64/aarch64.cc:19410
+#: config/aarch64/aarch64.cc:19426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "tuning string missing in option (%s)"
 msgstr "無效的範圍 %s 在中選項 %s"
 
-#: config/aarch64/aarch64.cc:19428
+#: config/aarch64/aarch64.cc:19444
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown tuning option (%s)"
 msgstr "不明 spec 函式 %qs"
 
-#: config/aarch64/aarch64.cc:19638 config/arm/arm.cc:3214
-#: config/riscv/riscv.cc:12481
+#: config/aarch64/aarch64.cc:19654 config/arm/arm.cc:3214
+#: config/riscv/riscv.cc:12484
 #, gcc-internal-format
 msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19647 config/riscv/riscv.cc:12490
+#: config/aarch64/aarch64.cc:19663 config/riscv/riscv.cc:12493
 #, gcc-internal-format
 msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19655
+#: config/aarch64/aarch64.cc:19671
 #, fuzzy, gcc-internal-format
 #| msgid "Specify the register allocation order"
 msgid "specify a system register with a small string length"
 msgstr "指定指派暫存器的順序"
 
-#: config/aarch64/aarch64.cc:19665 config/arm/arm.cc:3226
-#: config/riscv/riscv.cc:12519 config/rs6000/rs6000.cc:4515
+#: config/aarch64/aarch64.cc:19681 config/arm/arm.cc:3226
+#: config/riscv/riscv.cc:12522 config/rs6000/rs6000.cc:4515
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid offset in %qs"
 msgstr "%qs 無效用於 %qs"
 
-#: config/aarch64/aarch64.cc:19673
+#: config/aarch64/aarch64.cc:19689
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> requires %<-ffixed-x18%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19676
+#: config/aarch64/aarch64.cc:19692
 #, gcc-internal-format
 msgid "%<-fsanitize=shadow-call-stack%> conflicts with the use of register x18 by the target operating system"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19682
+#: config/aarch64/aarch64.cc:19698
 #, fuzzy, gcc-internal-format
 msgid "%<-fsanitize=memtag-stack%> requires the ISA extension %qs"
 msgstr "不使用 SPE ABI 延伸"
 
-#: config/aarch64/aarch64.cc:19690
+#: config/aarch64/aarch64.cc:19706
 #, fuzzy, gcc-internal-format
 msgid "streaming functions require the ISA extension %qs"
 msgstr "不使用 SPE ABI 延伸"
 
-#: config/aarch64/aarch64.cc:19692
+#: config/aarch64/aarch64.cc:19708
 #, fuzzy, gcc-internal-format
 msgid "functions with SME state require the ISA extension %qs"
 msgstr "內建函式 %s 需求 -mvsx 選項"
 
-#: config/aarch64/aarch64.cc:19785
+#: config/aarch64/aarch64.cc:19801
 #, gcc-internal-format
 msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19801 config/riscv/riscv.cc:12539
+#: config/aarch64/aarch64.cc:19817 config/riscv/riscv.cc:12542
 #, gcc-internal-format
 msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19896
+#: config/aarch64/aarch64.cc:19912
 #, fuzzy, gcc-internal-format
 msgid "invalid argument given to %<-mharden-sls=%>"
 msgstr "有效引數到 %qs 是：%s"
 
-#: config/aarch64/aarch64.cc:19907
+#: config/aarch64/aarch64.cc:19923
 #, gcc-internal-format
 msgid "%qs must be by itself for %<-mharden-sls=%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:19912
+#: config/aarch64/aarch64.cc:19928
 #, fuzzy, gcc-internal-format
 msgid "invalid argument %qs for %<-mharden-sls=%>"
 msgstr "無效的引數到內建函式"
 
-#: config/aarch64/aarch64.cc:20068
+#: config/aarch64/aarch64.cc:20084
 #, fuzzy, gcc-internal-format
 msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch and resulted in options %qs being added"
 msgstr "切換 -mcpu=%s 衝突與 -march=%s 切換"
 
-#: config/aarch64/aarch64.cc:20135
+#: config/aarch64/aarch64.cc:20151
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "assembler does not support %<-mabi=ilp32%>"
 msgstr "%s 不支援 %s"
 
-#: config/aarch64/aarch64.cc:20138
+#: config/aarch64/aarch64.cc:20154
 #, fuzzy, gcc-internal-format
 msgid "%<-mabi=ilp32%> is deprecated"
 msgstr "%qE 被不宜用"
 
-#: config/aarch64/aarch64.cc:20144
+#: config/aarch64/aarch64.cc:20160
 #, gcc-internal-format
 msgid "return address signing is only supported for %<-mabi=lp64%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20218
+#: config/aarch64/aarch64.cc:20234
 #, gcc-internal-format
 msgid "code model %qs with %<-f%s%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20221
+#: config/aarch64/aarch64.cc:20237
 #, fuzzy, gcc-internal-format
 msgid "code model %qs not supported in ilp32 mode"
 msgstr "編碼式樣 %qs 不支援在中 x32 模式"
 
-#: config/aarch64/aarch64.cc:20319
+#: config/aarch64/aarch64.cc:20335
 #, fuzzy, gcc-internal-format
 msgid "functions with %qs state require the ISA extension %qs"
 msgstr "內建函式 %s 需求 -mvsx 選項"
 
-#: config/aarch64/aarch64.cc:20429
+#: config/aarch64/aarch64.cc:20445
 #, gcc-internal-format
 msgid "missing name in %<target(\"arch=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20432
+#: config/aarch64/aarch64.cc:20448
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"arch=\")%> pragma or attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:20436
+#: config/aarch64/aarch64.cc:20452
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %s of value %qs in %<target()%> pragma or attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:20471
+#: config/aarch64/aarch64.cc:20487
 #, gcc-internal-format
 msgid "missing name in %<target(\"cpu=\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20474
+#: config/aarch64/aarch64.cc:20490
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"cpu=\")%> pragma or attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:20478 config/aarch64/aarch64.cc:20562
+#: config/aarch64/aarch64.cc:20494 config/aarch64/aarch64.cc:20578
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target()%> pragma or attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:20517
+#: config/aarch64/aarch64.cc:20533
 #, fuzzy, gcc-internal-format
 msgid "invalid name %qs in %<target(\"tune=\")%> pragma or attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:20558
+#: config/aarch64/aarch64.cc:20574
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target()%> pragma or attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:20618 config/aarch64/aarch64.cc:20796
+#: config/aarch64/aarch64.cc:20634 config/aarch64/aarch64.cc:20812
 #: config/loongarch/loongarch-target-attr.cc:197
 #: config/loongarch/loongarch-target-attr.cc:395
 #, fuzzy, gcc-internal-format
@@ -43096,24 +43144,24 @@ msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attr
 msgid "malformed %<target()%> pragma or attribute"
 msgstr "%<#pragma init%> 格式錯誤"
 
-#: config/aarch64/aarch64.cc:20664
+#: config/aarch64/aarch64.cc:20680
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not accept an argument"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20672 config/i386/i386-options.cc:1302
+#: config/aarch64/aarch64.cc:20688 config/i386/i386-options.cc:1302
 #: config/loongarch/loongarch-target-attr.cc:233
 #, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> does not allow a negated form"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20727
+#: config/aarch64/aarch64.cc:20743
 #: config/loongarch/loongarch-target-attr.cc:281
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s=%s\")%> is not valid"
 msgstr "屬性 (目標 (「%s」)) 為未知"
 
-#: config/aarch64/aarch64.cc:20784 config/arm/arm.cc:33537
+#: config/aarch64/aarch64.cc:20800 config/arm/arm.cc:33537
 #: config/loongarch/loongarch-target-attr.cc:383
 #: config/riscv/riscv-target-attr.cc:473 config/rs6000/rs6000.cc:24725
 #: config/s390/s390.cc:16979
@@ -43121,202 +43169,202 @@ msgstr "屬性 (目標 (「%s」)) 為未知"
 msgid "attribute %<target%> argument not a string"
 msgstr "屬性 %qE 引數不是字串"
 
-#: config/aarch64/aarch64.cc:20821
+#: config/aarch64/aarch64.cc:20837
 #, gcc-internal-format
 msgid "arch extension %qs should be prefixed by %<+%>"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:20824
+#: config/aarch64/aarch64.cc:20840
 #, fuzzy, gcc-internal-format
 msgid "pragma or attribute %<target(\"%s\")%> is not valid"
 msgstr "屬性 (目標 (「%s」)) 為未知"
 
-#: config/aarch64/aarch64.cc:20833
+#: config/aarch64/aarch64.cc:20849
 #: config/loongarch/loongarch-target-attr.cc:418
 #, gcc-internal-format
 msgid "malformed %<target(\"%s\")%> pragma or attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21104 config/loongarch/loongarch.cc:11491
+#: config/aarch64/aarch64.cc:21120 config/loongarch/loongarch.cc:11491
 #: config/riscv/riscv-target-attr.cc:552
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> has multiple values"
 msgstr "屬性 %qE 引數不是字串"
 
-#: config/aarch64/aarch64.cc:21112 config/loongarch/loongarch.cc:11501
+#: config/aarch64/aarch64.cc:21128 config/loongarch/loongarch.cc:11501
 #: config/riscv/riscv-target-attr.cc:562
 #, fuzzy, gcc-internal-format
 msgid "attribute %<target_version%> argument not a string"
 msgstr "屬性 %qE 引數不是字串"
 
-#: config/aarch64/aarch64.cc:21134
+#: config/aarch64/aarch64.cc:21150
 #, fuzzy, gcc-internal-format
 msgid "missing value in %<target_version%> attribute"
 msgstr "缺少%<=%>(之後 %<getter%>屬性)missing %<=%> (after %<getter%> attribute)缺少%<=%>(之後 %<getter%>屬性)"
 
-#: config/aarch64/aarch64.cc:21138
+#: config/aarch64/aarch64.cc:21154
 #, fuzzy, gcc-internal-format
 msgid "invalid feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr "%qs 後缺少檔案名稱"
 
-#: config/aarch64/aarch64.cc:21144
+#: config/aarch64/aarch64.cc:21160
 #, gcc-internal-format
 msgid "duplicate feature modifier %qs of value %qs in %<target_version%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21726 config/i386/i386-features.cc:5490
-#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12048
-#: config/riscv/riscv.cc:15547 config/rs6000/rs6000.cc:28526
+#: config/aarch64/aarch64.cc:21742 config/i386/i386-features.cc:5490
+#: config/i386/i386-features.cc:5740 config/loongarch/loongarch.cc:12062
+#: config/riscv/riscv.cc:15560 config/rs6000/rs6000.cc:28526
 #, fuzzy, gcc-internal-format
 msgid "virtual function multiversioning not supported"
 msgstr "不支援堆疊限制運算式"
 
-#: config/aarch64/aarch64.cc:21783 config/i386/i386-features.cc:5593
-#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15601
+#: config/aarch64/aarch64.cc:21799 config/i386/i386-features.cc:5593
+#: config/loongarch/loongarch.cc:11645 config/riscv/riscv.cc:15614
 #: config/rs6000/rs6000.cc:25381
 #, fuzzy, gcc-internal-format
 msgid "multiversioning needs %<ifunc%> which is not supported on this target"
 msgstr "ifunc 未被支援在中這個組態"
 
-#: config/aarch64/aarch64.cc:21822
+#: config/aarch64/aarch64.cc:21838
 #, gcc-internal-format
 msgid "%q+D has an inconsistent function multi-version priority value"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:21825
+#: config/aarch64/aarch64.cc:21841
 #, fuzzy, gcc-internal-format
 msgid "%q+D was previously declared here with priority value of %d"
 msgstr "%q#T 是在之前宣告的在此"
 
-#: config/aarch64/aarch64.cc:23434 config/arm/arm.cc:6696
+#: config/aarch64/aarch64.cc:23450 config/arm/arm.cc:6696
 #: config/rs6000/rs6000-call.cc:366 config/s390/s390.cc:13289
 msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23439 config/arm/arm.cc:6701
+#: config/aarch64/aarch64.cc:23455 config/arm/arm.cc:6701
 #: config/rs6000/rs6000-call.cc:361 config/s390/s390.cc:13284
 msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:23444 config/arm/arm.cc:6706
+#: config/aarch64/aarch64.cc:23460 config/arm/arm.cc:6706
 msgid "parameter passing for argument of type %qT changed %{in GCC 12.1%}"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:25006 config/aarch64/aarch64.cc:25009
+#: config/aarch64/aarch64.cc:25022 config/aarch64/aarch64.cc:25025
 #, fuzzy, gcc-internal-format
 msgid "lane %wd out of range %wd - %wd"
 msgstr "運算元號超出範圍"
 
-#: config/aarch64/aarch64.cc:30718 config/i386/i386.cc:26917
-#: config/i386/i386.cc:27048
+#: config/aarch64/aarch64.cc:30734 config/i386/i386.cc:27040
+#: config/i386/i386.cc:27171
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported combination: %s"
 msgid "unsupported simdlen %wd"
 msgstr "不支援的組合：%s"
 
-#: config/aarch64/aarch64.cc:30732
+#: config/aarch64/aarch64.cc:30748
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support return type %qT for simd"
 msgstr "不受支援的引數類型到內建函式"
 
-#: config/aarch64/aarch64.cc:30736 config/i386/i386.cc:26939
+#: config/aarch64/aarch64.cc:30752 config/i386/i386.cc:27062
 #, gcc-internal-format
 msgid "unsupported return type %qT for simd"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:30770
+#: config/aarch64/aarch64.cc:30786
 #, fuzzy, gcc-internal-format
 msgid "GCC does not currently support argument type %qT for simd"
 msgstr "不受支援的引數類型到內建函式"
 
-#: config/aarch64/aarch64.cc:30774 config/i386/i386.cc:26970
+#: config/aarch64/aarch64.cc:30790 config/i386/i386.cc:27093
 #, fuzzy, gcc-internal-format
 msgid "unsupported argument type %qT for simd"
 msgstr "不受支援的引數類型到內建函式"
 
-#: config/aarch64/aarch64.cc:30845
+#: config/aarch64/aarch64.cc:30861
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support simdlen %wd for type %qT"
 msgstr "-shared 選項目前在 VAX ELF 下不受支援"
 
-#: config/aarch64/aarch64.cc:30865
+#: config/aarch64/aarch64.cc:30881
 #, fuzzy, gcc-internal-format
 #| msgid "the -shared option is not currently supported for VAX ELF"
 msgid "GCC does not currently support a simdclone with simdlens %wd and %wd for these types."
 msgstr "-shared 選項目前在 VAX ELF 下不受支援"
 
-#: config/aarch64/aarch64.cc:31055
+#: config/aarch64/aarch64.cc:31071
 #, fuzzy, gcc-internal-format
 msgid "cannot apply attribute %qs to %q+D after the function has been defined"
 msgstr "型態屬性忽略的之後型態已經定義"
 
-#: config/aarch64/aarch64.cc:31057
+#: config/aarch64/aarch64.cc:31073
 #, fuzzy, gcc-internal-format
 msgid "%q+D defined here"
 msgstr "標貼 %qD 定義的在此"
 
-#: config/aarch64/aarch64.cc:31876
+#: config/aarch64/aarch64.cc:31892
 #, gcc-internal-format
 msgid "non-local gotos in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32184
+#: config/aarch64/aarch64.cc:32200
 #, gcc-internal-format
 msgid "catching non-call exceptions in functions with SME state"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32824 config/arm/arm-mve-builtins.cc:614
-#: config/riscv/riscv-vector-builtins.cc:5216
+#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:614
+#: config/riscv/riscv-vector-builtins.cc:5223
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be an integer constant expression"
 msgstr "引數 1 的 %qE 必須是指標到常數大小型態"
 
-#: config/aarch64/aarch64.cc:32837
+#: config/aarch64/aarch64.cc:32853
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects the value %wd"
 msgstr "根據原型，引數 %d (%qE) 將以不同的寬度傳遞"
 
-#: config/aarch64/aarch64.cc:32840 config/arm/arm-mve-builtins.cc:626
-#: config/riscv/riscv-vector-builtins.cc:5230
+#: config/aarch64/aarch64.cc:32856 config/arm/arm-mve-builtins.cc:626
+#: config/riscv/riscv-vector-builtins.cc:5237
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd]"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:32853
+#: config/aarch64/aarch64.cc:32869
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects either %wd or %wd"
 msgstr "根據原型，引數 %d (%qE) 將以不同的寬度傳遞"
 
-#: config/aarch64/aarch64.cc:32867 config/arm/arm-mve-builtins.cc:665
+#: config/aarch64/aarch64.cc:32883 config/arm/arm-mve-builtins.cc:665
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects %wd, %wd, %wd or %wd"
 msgstr "根據原型，引數 %d (%qE) 將以不同的寬度傳遞"
 
-#: config/aarch64/aarch64.cc:32879 config/arm/arm-mve-builtins.cc:652
+#: config/aarch64/aarch64.cc:32895 config/arm/arm-mve-builtins.cc:652
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE with different width due to prototype"
 msgid "passing %wd to argument %d of %qE, which expects a valid %qT value"
 msgstr "根據原型，引數 %d (%qE) 將以不同的寬度傳遞"
 
-#: config/aarch64/aarch64.cc:33113
+#: config/aarch64/aarch64.cc:33129
 #, fuzzy, gcc-internal-format
 msgid "empty string not valid for a %<target_clones%> version"
 msgstr "預期的繫結屬性於 %C"
 
-#: config/aarch64/aarch64.cc:33117
+#: config/aarch64/aarch64.cc:33133
 #, fuzzy
 msgid "invalid feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr "%qs 後缺少檔案名稱"
 
-#: config/aarch64/aarch64.cc:33123
+#: config/aarch64/aarch64.cc:33139
 msgid "duplicate feature modifier %qs in version %qB for %<target_clones%> attribute"
 msgstr ""
 
-#: config/aarch64/aarch64.cc:33129
+#: config/aarch64/aarch64.cc:33145
 #, fuzzy
 msgid "invalid feature %qs in version %qB for %<target_clones%> attribute"
 msgstr "不當的值 (%s) 用於 %stune=%s %s"
@@ -43516,12 +43564,12 @@ msgstr "%qs 屬性的引數不是「ilink1」或「ilink2」"
 #: config/i386/i386-options.cc:3785 config/i386/i386-options.cc:3841
 #: config/i386/i386-options.cc:3892 config/i386/i386-options.cc:3929
 #: config/m68k/m68k.cc:804 config/mcore/mcore.cc:3066 config/mingw/winnt.cc:354
-#: config/nvptx/nvptx.cc:5888 config/riscv/riscv.cc:7562
+#: config/nvptx/nvptx.cc:5894 config/riscv/riscv.cc:7565
 #: config/rl78/rl78.cc:821 config/rl78/rl78.cc:890
 #: config/rs6000/rs6000.cc:20653 config/rx/rx.cc:2712 config/rx/rx.cc:2738
 #: config/s390/s390.cc:1158 config/s390/s390.cc:1248 config/sh/sh.cc:8441
 #: config/sh/sh.cc:8459 config/sh/sh.cc:8483 config/sh/sh.cc:8554
-#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2402
+#: config/sh/sh.cc:8577 config/stormy16/stormy16.cc:2403
 #: config/v850/v850.cc:2010 config/visium/visium.cc:727
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to functions"
@@ -43660,22 +43708,22 @@ msgid "argument of %qE attribute ignored"
 msgstr "%qE 屬性被忽略"
 
 #: config/arc/arc.cc:11018 config/avr/avr.cc:11452 config/bfin/bfin.cc:4817
-#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5911
+#: config/mingw/winnt.cc:63 config/nvptx/nvptx.cc:5917
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute only applies to variables"
 msgstr "%qE 屬性只有套用到變數"
 
-#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25075
+#: config/arm/aarch-common.cc:553 config/i386/i386.cc:25198
 #, fuzzy, gcc-internal-format
 msgid "alternatives not allowed in %<asm%> flag output"
 msgstr "By-value 引數於 %L 未被允許在中這個語境"
 
-#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25139
+#: config/arm/aarch-common.cc:614 config/i386/i386.cc:25262
 #, fuzzy, gcc-internal-format
 msgid "unknown %<asm%> flag output %qs"
 msgstr "不明 IRA 演算法 %qs"
 
-#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25168
+#: config/arm/aarch-common.cc:624 config/i386/i386.cc:25291
 #, fuzzy, gcc-internal-format
 msgid "invalid type for %<asm%> flag output"
 msgstr "無效的型態用於製作函式"
@@ -44231,12 +44279,12 @@ msgstr "-fpic 未被支援"
 msgid "%<-fPIE%> is not supported"
 msgstr "-fPIC 未被支援"
 
-#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12976
+#: config/avr/avr.cc:1019 config/avr/avr.cc:1024 config/riscv/riscv.cc:12979
 #, fuzzy, gcc-internal-format
 msgid "function attributes %qs and %qs are mutually exclusive"
 msgstr "函式屬性 %qs，%qs 和 %qs 彼此互斥"
 
-#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12988
+#: config/avr/avr.cc:1046 config/riscv/riscv.cc:12991
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have arguments"
 msgstr "%qs 函式無法有引數"
@@ -44246,7 +44294,7 @@ msgstr "%qs 函式無法有引數"
 msgid "method %qs has an implicit %<this%> argument"
 msgstr ""
 
-#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12985
+#: config/avr/avr.cc:1052 config/riscv/riscv.cc:12988
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot return a value"
 msgstr "%qs 函式無法回傳值"
@@ -44586,7 +44634,7 @@ msgstr "%<__int128%>未被支援由這個目標"
 
 #: config/bpf/bpf.cc:1058 config/loongarch/loongarch-builtins.cc:3042
 #: config/mips/mips.cc:17579 config/riscv/riscv-builtins.cc:369
-#: config/riscv/riscv-vector-builtins.cc:5196
+#: config/riscv/riscv-vector-builtins.cc:5203
 #, fuzzy, gcc-internal-format
 msgid "invalid argument to built-in function"
 msgstr "無效的引數到內建函式"
@@ -44919,7 +44967,7 @@ msgstr ""
 msgid "using %<vector_length (64)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6741
+#: config/gcn/gcn.cc:6607 config/nvptx/nvptx.cc:6747
 #, gcc-internal-format
 msgid "using %<num_workers (%d)%>, ignoring %d"
 msgstr ""
@@ -45089,174 +45137,174 @@ msgstr "%qs 的引數必須是一個 2 位無號原文"
 msgid "parameter to builtin not valid: %s"
 msgstr "-ffpe-trap 的參數無效：%s"
 
-#: config/i386/i386-expand.cc:11087
+#: config/i386/i386-expand.cc:11093
 #, fuzzy, gcc-internal-format
 msgid "interrupt service routine cannot be called directly"
 msgstr "插斷服務常式無法編碼的在中姆指模式"
 
-#: config/i386/i386-expand.cc:11562 config/i386/i386-expand.cc:13276
+#: config/i386/i386-expand.cc:11568 config/i386/i386-expand.cc:13282
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 2-bit immediate"
 msgstr "最後一筆引數必須是 2-bit 即時"
 
-#: config/i386/i386-expand.cc:12062
+#: config/i386/i386-expand.cc:12068
 #, fuzzy, gcc-internal-format
 msgid "the fifth argument must be an 8-bit immediate"
 msgstr "fifth 引數必須是 8-bit 即時"
 
-#: config/i386/i386-expand.cc:12157
+#: config/i386/i386-expand.cc:12163
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be an 8-bit immediate"
 msgstr "第三引數必須是 8-bit 即時"
 
-#: config/i386/i386-expand.cc:13205
+#: config/i386/i386-expand.cc:13211
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 1-bit immediate"
 msgstr "最後一筆引數必須是 1-bit 即時"
 
-#: config/i386/i386-expand.cc:13220
+#: config/i386/i386-expand.cc:13226
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 3-bit immediate"
 msgstr "最後一筆引數必須是 32-bit 即時"
 
-#: config/i386/i386-expand.cc:13255
+#: config/i386/i386-expand.cc:13261
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 4-bit immediate"
 msgstr "最後一筆引數必須是 4-bit 即時"
 
-#: config/i386/i386-expand.cc:13295
+#: config/i386/i386-expand.cc:13301
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 1-bit immediate"
 msgstr "最後一筆引數必須是 1-bit 即時"
 
-#: config/i386/i386-expand.cc:13304
+#: config/i386/i386-expand.cc:13310
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "'%s' needs isa option %s"
 msgstr "%qE 需要 isa 選項 %s"
 
-#: config/i386/i386-expand.cc:13317
+#: config/i386/i386-expand.cc:13323
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 5-bit immediate"
 msgstr "最後一筆引數必須是 5-bit 即時"
 
-#: config/i386/i386-expand.cc:13327
+#: config/i386/i386-expand.cc:13333
 #, fuzzy, gcc-internal-format
 msgid "the next to last argument must be an 8-bit immediate"
 msgstr "下一個到最後一筆引數必須是 8-bit 即時"
 
-#: config/i386/i386-expand.cc:13332
+#: config/i386/i386-expand.cc:13338
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be an 8-bit immediate"
 msgstr "最後一筆引數必須是 8-bit 即時"
 
-#: config/i386/i386-expand.cc:13471
+#: config/i386/i386-expand.cc:13477
 #, fuzzy, gcc-internal-format
 msgid "the third argument must be comparison constant"
 msgstr "引數必須是常數"
 
-#: config/i386/i386-expand.cc:13476
+#: config/i386/i386-expand.cc:13482
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect insn:"
 msgid "incorrect comparison mode"
 msgstr "錯誤指令："
 
-#: config/i386/i386-expand.cc:13482 config/i386/i386-expand.cc:13905
+#: config/i386/i386-expand.cc:13488 config/i386/i386-expand.cc:13911
 #, fuzzy, gcc-internal-format
 #| msgid "incorrect sharing of tree nodes"
 msgid "incorrect rounding operand"
 msgstr "對樹結區段的共享不正確"
 
-#: config/i386/i386-expand.cc:13885
+#: config/i386/i386-expand.cc:13891
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 4-bit immediate"
 msgstr "最後一筆引數必須是 4-bit 即時"
 
-#: config/i386/i386-expand.cc:13893
+#: config/i386/i386-expand.cc:13899
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be a 5-bit immediate"
 msgstr "最後一筆引數必須是 5-bit 即時"
 
-#: config/i386/i386-expand.cc:13896
+#: config/i386/i386-expand.cc:13902
 #, fuzzy, gcc-internal-format
 msgid "the immediate argument must be an 8-bit immediate"
 msgstr "最後一筆引數必須是 8-bit 即時"
 
-#: config/i386/i386-expand.cc:14376
+#: config/i386/i386-expand.cc:14382
 #, fuzzy, gcc-internal-format
 msgid "the fourth argument must be one of enum %qs"
 msgstr "最後一筆引數必須是尺度 1,- 2,- 4, 8"
 
-#: config/i386/i386-expand.cc:14446
+#: config/i386/i386-expand.cc:14452
 #, fuzzy, gcc-internal-format
 #| msgid "selector must be an integer constant in the range 0..%wi"
 msgid "selector must be an integer constant in the range [0, %wi]"
 msgstr "選擇子必須是 0 到 %wi 間的整常數"
 
-#: config/i386/i386-expand.cc:14702
+#: config/i386/i386-expand.cc:14708
 #, fuzzy, gcc-internal-format
 msgid "%qE needs unknown isa option"
 msgstr "%qE 需要不明 isa 選項"
 
-#: config/i386/i386-expand.cc:14706
+#: config/i386/i386-expand.cc:14712
 #, fuzzy, gcc-internal-format
 msgid "%qE needs isa option %s"
 msgstr "%qE 需要 isa 選項 %s"
 
-#: config/i386/i386-expand.cc:15206
+#: config/i386/i386-expand.cc:15212
 #, fuzzy, gcc-internal-format
 msgid "second, third and fourth argument must be a const"
 msgstr "引數必須是常數"
 
-#: config/i386/i386-expand.cc:15212
+#: config/i386/i386-expand.cc:15218
 #, fuzzy, gcc-internal-format
 #| msgid "invalid second argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid second argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%> 的第二個引數無效；使用 0"
 
-#: config/i386/i386-expand.cc:15221
+#: config/i386/i386-expand.cc:15227
 #, fuzzy, gcc-internal-format
 msgid "invalid third argument"
 msgstr "無效的 PHI 引數"
 
 #. Ignore the hint.
-#: config/i386/i386-expand.cc:15230 config/i386/i386-expand.cc:15291
+#: config/i386/i386-expand.cc:15236 config/i386/i386-expand.cc:15297
 #, gcc-internal-format
 msgid "instruction prefetch applies when in 64-bit mode with RIP-relative addressing and option %<-mprefetchi%>; they stay NOPs otherwise"
 msgstr ""
 
-#: config/i386/i386-expand.cc:15240
+#: config/i386/i386-expand.cc:15246
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid forth argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%> 的第三個引數無效；使用 0"
 
-#: config/i386/i386-expand.cc:15251
+#: config/i386/i386-expand.cc:15257
 #, fuzzy, gcc-internal-format
 #| msgid "invalid third argument to %<__builtin_prefetch%>; using zero"
 msgid "invalid third argument to %<__builtin_ia32_prefetch%>; using zero"
 msgstr "%<__builtin_prefetch%> 的第三個引數無效；使用 0"
 
-#: config/i386/i386-expand.cc:15279
+#: config/i386/i386-expand.cc:15285
 #, fuzzy, gcc-internal-format
 msgid "second argument must be a const"
 msgstr "秒引數必須是切片或字串"
 
-#: config/i386/i386-expand.cc:15825
+#: config/i386/i386-expand.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be a 32-bit immediate"
 msgstr "最後一筆引數必須是 32-bit 即時"
 
-#: config/i386/i386-expand.cc:15858
+#: config/i386/i386-expand.cc:15864
 #, fuzzy, gcc-internal-format
 msgid "last argument must be an immediate"
 msgstr "最後一筆引數必須是即時"
 
-#: config/i386/i386-expand.cc:16596 config/i386/i386-expand.cc:16808
+#: config/i386/i386-expand.cc:16602 config/i386/i386-expand.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "the last argument must be scale 1, 2, 4, 8"
 msgstr "最後一筆引數必須是尺度 1,- 2,- 4, 8"
 
-#: config/i386/i386-expand.cc:16826
+#: config/i386/i386-expand.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "the argument to %<xabort%> intrinsic must be an 8-bit immediate"
 msgstr "下一個到最後一筆引數必須是 8-bit 即時"
@@ -45660,8 +45708,8 @@ msgstr ""
 msgid "%<-fcf-protection=full%> is not enabled by %<-fhardened%> because it was specified on the command line"
 msgstr ""
 
-#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12356
-#: config/riscv/riscv.cc:12360
+#: config/i386/i386-options.cc:3138 config/riscv/riscv.cc:12359
+#: config/riscv/riscv.cc:12363
 #, fuzzy, gcc-internal-format
 msgid "%<-fcf-protection%> is not compatible with this target"
 msgstr "%<-march=%s%>不是相容與已選 ABI"
@@ -45909,7 +45957,7 @@ msgstr "ABI 的傳遞結構與複雜浮點數成員已變更在中 GCC 4.4"
 msgid "the ABI of passing C structures with zero-width bit-fields has changed in GCC %{12.1%}"
 msgstr "ABI 的傳遞結構與複雜浮點數成員已變更在中 GCC 4.4"
 
-#: config/i386/i386.cc:2835 config/i386/i386.cc:4212 config/i386/i386.cc:4222
+#: config/i386/i386.cc:2835 config/i386/i386.cc:4223 config/i386/i386.cc:4233
 #, fuzzy, gcc-internal-format
 #| msgid "SSE register return with SSE disabled"
 msgid "SSE register return with SSE2 disabled"
@@ -45936,12 +45984,12 @@ msgstr "已停用 SSE 卻在 SSE 暫存器中傳遞參數"
 msgid "x87 register return with x87 disabled"
 msgstr "x87 暫存器回傳與 x87 已停用"
 
-#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4240
+#: config/i386/i386.cc:3194 config/i386/i386.cc:3439 config/i386/i386.cc:4251
 #, fuzzy, gcc-internal-format
 msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
 msgstr "呼叫 %qD 與屬性 sseregparm 而無需 SSE/SSE2 已啟用"
 
-#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4242
+#: config/i386/i386.cc:3196 config/i386/i386.cc:3441 config/i386/i386.cc:4253
 #, gcc-internal-format
 msgid "this is a GCC bug that can be worked around by adding attribute used to function called"
 msgstr ""
@@ -45951,134 +45999,134 @@ msgstr ""
 msgid "the ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
 msgstr "ABI 用於傳遞參數與 %d-byte 對齊已變更在中 GCC 4.6"
 
-#: config/i386/i386.cc:6936
+#: config/i386/i386.cc:6947
 #, fuzzy, gcc-internal-format
 #| msgid "assert: %s is assign compatible with %s"
 msgid "%<-mcall-ms2sysv-xlogues%> is not compatible with %s"
 msgstr "assert：%s 與 %s 賦值相容"
 
-#: config/i386/i386.cc:9289
+#: config/i386/i386.cc:9313
 #, fuzzy, gcc-internal-format
 msgid "%<ms_hook_prologue%> attribute is not compatible with %<-mfentry%> for 32-bit"
 msgstr "ms_hook_prologue 屬性 isn%'t 相容與 -mfentry 用於 32-bit"
 
-#: config/i386/i386.cc:9379
+#: config/i386/i386.cc:9403
 #, gcc-internal-format
 msgid "Dynamic Realign Argument Pointer (DRAP) not supported in interrupt service routine.  This may be worked around by avoiding functions with aggregate return."
 msgstr ""
 
-#: config/i386/i386.cc:10459
+#: config/i386/i386.cc:10483
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute is not supported on this platform"
 msgid "Stack realignment not supported with %<__builtin_eh_return%>"
 msgstr "%qE 屬性在此平臺上不受支援"
 
-#: config/i386/i386.cc:10464
+#: config/i386/i386.cc:10488
 #, fuzzy, gcc-internal-format
 msgid "regparm nested function not supported with %<__builtin_eh_return%>"
 msgstr "巢狀的函式不支援於這個目標"
 
-#: config/i386/i386.cc:10855
+#: config/i386/i386.cc:10879
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support fastcall with nested function"
 msgstr "-fsplit-stack 不支援 fastcall 與巢狀的函式"
 
-#: config/i386/i386.cc:10875
+#: config/i386/i386.cc:10899
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 2 register parameters for a nested function"
 msgstr "-fsplit-stack 不支援 2 暫存器  參數用於巢狀的函式"
 
 #. FIXME: We could make this work by pushing a register
 #. around the addition and comparison.
-#: config/i386/i386.cc:10886
+#: config/i386/i386.cc:10910
 #, fuzzy, gcc-internal-format
 msgid "%<-fsplit-stack%> does not support 3 register parameters"
 msgstr "-fsplit-stack 不支援 3 暫存器參數"
 
-#: config/i386/i386.cc:12641
+#: config/i386/i386.cc:12665
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with a function with the %<no_caller_saved_registers%> attribute"
 msgstr ""
 
-#: config/i386/i386.cc:12645
+#: config/i386/i386.cc:12669
 #, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an exception service routine"
 msgstr ""
 
-#: config/i386/i386.cc:12647
+#: config/i386/i386.cc:12671
 #, fuzzy, gcc-internal-format
 msgid "%<-mtls-dialect=gnu2%> must be used with an interrupt service routine"
 msgstr "2 位元組 cop 指令未被允許在中 64-bit VLIW 模式"
 
-#: config/i386/i386.cc:13991
+#: config/i386/i386.cc:14015
 #, gcc-internal-format
 msgid "%<V%> modifier on non-integer register"
 msgstr ""
 
-#: config/i386/i386.cc:14002 config/i386/i386.cc:14016
+#: config/i386/i386.cc:14026 config/i386/i386.cc:14040
 #, fuzzy, gcc-internal-format
 #| msgid "unsupported operand size for extended register"
 msgid "unsupported size for integer register"
 msgstr "擴充的暫存器不支援的運算元大小"
 
-#: config/i386/i386.cc:14048
+#: config/i386/i386.cc:14072
 #, gcc-internal-format
 msgid "extended registers have no high halves"
 msgstr "擴充的暫存器沒有高半部分"
 
-#: config/i386/i386.cc:14063
+#: config/i386/i386.cc:14087
 #, gcc-internal-format
 msgid "unsupported operand size for extended register"
 msgstr "擴充的暫存器不支援的運算元大小"
 
-#: config/i386/i386.cc:14262 config/i386/i386.cc:14264
+#: config/i386/i386.cc:14286 config/i386/i386.cc:14288
 #, fuzzy, gcc-internal-format
 msgid "non-integer operand used with operand code %<z%>"
 msgstr "non-integer 運算元使用的與運算元編碼『%c』"
 
-#: config/i386/i386.cc:18507
+#: config/i386/i386.cc:18531
 #, gcc-internal-format
 msgid "empty class %qT parameter passing ABI changes in %<-fabi-version=12%> (GCC 8)"
 msgstr ""
 
-#: config/i386/i386.cc:23913
+#: config/i386/i386.cc:24036
 #, fuzzy
 msgid "the alignment of %<_Atomic %T%> fields changed in %{GCC 11.1%}"
 msgstr "mangling 的 %<va_list%> 已變更在中 GCC 4.4"
 
-#: config/i386/i386.cc:24008
+#: config/i386/i386.cc:24131
 #, fuzzy, gcc-internal-format
 #| msgid "no low registers available for popping high registers"
 msgid "no register available for profiling %<-mcmodel=large%s%>"
 msgstr "高暫存器彈堆疊時沒有可用的低暫存器"
 
-#: config/i386/i386.cc:24112
+#: config/i386/i386.cc:24235
 #, fuzzy, gcc-internal-format
 #| msgid "-mcmodel= is not supported on 32 bit systems"
 msgid "profiling %<-mcmodel=large%> with PIC is not supported"
 msgstr "32 位元系統不支援 -mcmodel="
 
-#: config/i386/i386.cc:24827
+#: config/i386/i386.cc:24950
 #, gcc-internal-format
 msgid "%<__bfloat16%> is redefined from typedef %<short%> to real %<__bf16%> since GCC 13.1, be careful of implicit conversion between %<__bf16%> and %<short%>; an explicit bitcast may be needed here"
 msgstr ""
 
-#: config/i386/i386.cc:26876
+#: config/i386/i386.cc:26999
 #, fuzzy, gcc-internal-format
 msgid "unknown architecture specific memory model"
 msgstr "不明 TLS 式樣 %qs"
 
-#: config/i386/i386.cc:26883
+#: config/i386/i386.cc:27006
 #, gcc-internal-format
 msgid "%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:26890
+#: config/i386/i386.cc:27013
 #, gcc-internal-format
 msgid "%<HLE_RELEASE%> not used with %<RELEASE%> or stronger memory model"
 msgstr ""
 
-#: config/i386/i386.cc:27576
+#: config/i386/i386.cc:27699
 #, fuzzy, gcc-internal-format
 msgid "%<-fexcess-precision=16%> is not compatible with %<-mfpmath=387%>"
 msgstr "-fdirectives-only 是不相容的與 -traditional"
@@ -46131,7 +46179,7 @@ msgstr "gp_offset (%ld) 或 end_offset (%ld) 是少於零"
 msgid "argument %qd is not a constant"
 msgstr "引數 %qd 不是一個常數"
 
-#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3116
+#: config/iq2000/iq2000.cc:2890 config/xtensa/xtensa.cc:3121
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgid "%<PRINT_OPERAND_ADDRESS%>, null pointer"
@@ -46143,7 +46191,7 @@ msgstr "PRINT_OPERAND_ADDRESS，空指標"
 msgid "%<PRINT_OPERAND%>: Unknown punctuation %<%c%>"
 msgstr "PRINT_OPERAND：不明的標點「%c」"
 
-#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2942
+#: config/iq2000/iq2000.cc:3054 config/xtensa/xtensa.cc:2947
 #, fuzzy, gcc-internal-format
 #| msgid "PRINT_OPERAND null pointer"
 msgid "%<PRINT_OPERAND%> null pointer"
@@ -46300,48 +46348,48 @@ msgstr "屬性 (目標 (「%s」)) 為未知"
 msgid "attribute %<target%> argument %qs is unknown"
 msgstr "屬性 (目標 (「%s」)) 為未知"
 
-#: config/loongarch/loongarch-target-attr.cc:544
+#: config/loongarch/loongarch-target-attr.cc:541
 #, fuzzy, gcc-internal-format
 msgid "\"default\" cannot be set together with other features in %qs"
 msgstr "mudflap 無法使用的一起與 link-time 最佳化"
 
-#: config/loongarch/loongarch-target-attr.cc:556
+#: config/loongarch/loongarch-target-attr.cc:553
 #, gcc-internal-format
 msgid "character before %<;%> in attribute %qs cannot be empty"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:567
+#: config/loongarch/loongarch-target-attr.cc:564
 #, fuzzy, gcc-internal-format
 msgid "in attribute %qs priority cannot be empty"
 msgstr "唯讀內容無法設定"
 
-#: config/loongarch/loongarch-target-attr.cc:576
+#: config/loongarch/loongarch-target-attr.cc:573
 #, gcc-internal-format
 msgid "in attribute %qs the number of features cannot exceed two"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:600
+#: config/loongarch/loongarch-target-attr.cc:597
 #, gcc-internal-format
 msgid "Setting the priority value to %qs is illegal in attribute %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:611
+#: config/loongarch/loongarch-target-attr.cc:608
 #, gcc-internal-format
 msgid "in attribute %qs, the second feature should be \"priority=%<num%>\" instead of %qs"
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:630
-#: config/loongarch/loongarch-target-attr.cc:662
+#: config/loongarch/loongarch-target-attr.cc:627
+#: config/loongarch/loongarch-target-attr.cc:661
 #, gcc-internal-format
 msgid "in attribute %qs you need to set a legal value for \"arch\""
 msgstr ""
 
-#: config/loongarch/loongarch-target-attr.cc:684
+#: config/loongarch/loongarch-target-attr.cc:685
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs is not supported in %<target_version%> or %<target_clones%>"
 msgstr "%<__int128%>未被支援由這個目標"
 
-#: config/loongarch/loongarch-target-attr.cc:701
+#: config/loongarch/loongarch-target-attr.cc:704
 #, fuzzy, gcc-internal-format
 msgid "%qs is not supported in target attribute"
 msgstr "巢狀的函式不支援於這個目標"
@@ -47109,7 +47157,7 @@ msgid "MSP430 built-in functions only work inside interrupt handlers"
 msgstr ""
 
 #: config/msp430/msp430.cc:2861 config/pru/pru.cc:3165 config/rx/rx.cc:2651
-#: config/xtensa/xtensa.cc:4155 config/xtensa/xtensa.cc:4181
+#: config/xtensa/xtensa.cc:4161 config/xtensa/xtensa.cc:4187
 #, fuzzy, gcc-internal-format
 msgid "bad builtin code"
 msgstr "不當的內建編碼"
@@ -47347,84 +47395,84 @@ msgstr "%s：無法開啟圖檔案\n"
 msgid "option %s is not supported together with %<-fopenacc%>"
 msgstr "內建函式 %s 未被支援與目前的選項"
 
-#: config/nvptx/nvptx.cc:348
+#: config/nvptx/nvptx.cc:354
 #, gcc-internal-format
 msgid "PTX version (%<-mptx%>) needs to be at least %s to support selected %<-misa%> (sm_%s)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:365
+#: config/nvptx/nvptx.cc:371
 #, fuzzy, gcc-internal-format
 msgid "%<-march=%> must be specified"
 msgstr "%<-march=%s%>不是相容與已選 ABI"
 
-#: config/nvptx/nvptx.cc:388
+#: config/nvptx/nvptx.cc:394
 #, fuzzy, gcc-internal-format
 msgid "not generating patch area, nops not supported"
 msgstr "寫入位址空間 %qs 不支援"
 
-#: config/nvptx/nvptx.cc:485
+#: config/nvptx/nvptx.cc:491
 #, gcc-internal-format
 msgid "static initialization of variable %q+D in %<.shared%> memory is not supported"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2407
+#: config/nvptx/nvptx.cc:2413
 #, gcc-internal-format
 msgid "cannot emit unaligned pointers in ptx assembly"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:2657
+#: config/nvptx/nvptx.cc:2663
 #, gcc-internal-format
 msgid "PTX does not support weak declarations (only weak definitions)"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:5893
+#: config/nvptx/nvptx.cc:5899
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored on types"
 msgid "%qE attribute requires a void return type"
 msgstr "%qE 屬性在類型上被忽略"
 
-#: config/nvptx/nvptx.cc:5916
+#: config/nvptx/nvptx.cc:5922
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%qE attribute not allowed with auto storage class"
 msgstr "__BELOW100__ 屬性不允許用於自動存儲類別"
 
-#: config/nvptx/nvptx.cc:6361
+#: config/nvptx/nvptx.cc:6367
 #, fuzzy, gcc-internal-format
 msgid "barrier value must be within [0,15]"
 msgstr "引數 %d 的 %qE 必須是在中範圍 %d...%d"
 
-#: config/nvptx/nvptx.cc:6374
+#: config/nvptx/nvptx.cc:6380
 #, fuzzy, gcc-internal-format
 msgid "complement argument must be constant"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: config/nvptx/nvptx.cc:6714
+#: config/nvptx/nvptx.cc:6720
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%> due to call to vector-partitionable routine, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6722
+#: config/nvptx/nvptx.cc:6728
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring runtime setting"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:6736
+#: config/nvptx/nvptx.cc:6742
 #, gcc-internal-format
 msgid "using %<vector_length (%d)%>, ignoring %d"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7622
+#: config/nvptx/nvptx.cc:7628
 #, gcc-internal-format
 msgid "variable %qD adjusted for OpenACC privatization level: %qs"
 msgstr ""
 
-#: config/nvptx/nvptx.cc:7761
+#: config/nvptx/nvptx.cc:7767
 #, fuzzy, gcc-internal-format
 msgid "weak alias definitions not supported in this configuration"
 msgstr "別名定義不支援在中這個組態"
 
-#: config/nvptx/nvptx.cc:7774
+#: config/nvptx/nvptx.cc:7780
 #, fuzzy, gcc-internal-format
 msgid "non-function alias definitions not supported in this configuration"
 msgstr "別名定義不支援在中這個組態"
@@ -47664,331 +47712,331 @@ msgstr ""
 msgid "invalid number of operands for insn %s, expected %d but got %d.\n"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5246
+#: config/riscv/riscv-vector-builtins.cc:5253
 #, gcc-internal-format
 msgid "passing %wd to argument %d of %qE, which expects a value in the range [%wd, %wd] or %wd"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5455
+#: config/riscv/riscv-vector-builtins.cc:5462
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a fixed size"
 msgstr "型態 %qT 沒有已知大小"
 
-#: config/riscv/riscv-vector-builtins.cc:5461
+#: config/riscv/riscv-vector-builtins.cc:5468
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT does not have a defined alignment"
 msgstr "型態 %qT 沒有已知大小"
 
-#: config/riscv/riscv-vector-builtins.cc:5476
+#: config/riscv/riscv-vector-builtins.cc:5483
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to RVV type %qT"
 msgstr "在參照不完全類型的指標上執行算術運算"
 
-#: config/riscv/riscv-vector-builtins.cc:5484
+#: config/riscv/riscv-vector-builtins.cc:5491
 #, gcc-internal-format
 msgid "member variables cannot have RVV type %qT"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5486
+#: config/riscv/riscv-vector-builtins.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "fields cannot have RVV type %qT"
 msgstr "欄位 %qD 類型不完全"
 
-#: config/riscv/riscv-vector-builtins.cc:5492
+#: config/riscv/riscv-vector-builtins.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "array elements cannot have RVV type %qT"
 msgstr "函式參數無法有 __fp16 型態"
 
-#: config/riscv/riscv-vector-builtins.cc:5498
+#: config/riscv/riscv-vector-builtins.cc:5505
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot allocate objects with RVV type %qT"
 msgstr "無法為有抽象類型 %qT 的物件指派記憶體"
 
-#: config/riscv/riscv-vector-builtins.cc:5504
+#: config/riscv/riscv-vector-builtins.cc:5511
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot delete objects with RVV type %qT"
 msgstr "無法為有抽象類型 %qT 的物件指派記憶體"
 
-#: config/riscv/riscv-vector-builtins.cc:5510
+#: config/riscv/riscv-vector-builtins.cc:5517
 #, fuzzy, gcc-internal-format
 #| msgid "cannot allocate an object of abstract type %qT"
 msgid "cannot throw or catch RVV type %qT"
 msgstr "無法為有抽象類型 %qT 的物件指派記憶體"
 
-#: config/riscv/riscv-vector-builtins.cc:5516
+#: config/riscv/riscv-vector-builtins.cc:5523
 #, fuzzy, gcc-internal-format
 msgid "capture by copy of RVV type %qT"
 msgstr "無效的使用的不完整型態 %q#T"
 
-#: config/riscv/riscv-vector-builtins.cc:5522
+#: config/riscv/riscv-vector-builtins.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<map%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: config/riscv/riscv-vector-builtins.cc:5532
+#: config/riscv/riscv-vector-builtins.cc:5539
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is disallowed in Java %<throw%> or %<catch%>"
 msgid "RVV type %qT not allowed in %<target%> %<private%> clause"
 msgstr "在 Java %<throw%> 或 %<catch%> 中不能使用類型 %qT"
 
-#: config/riscv/riscv-vector-builtins.cc:5538
+#: config/riscv/riscv-vector-builtins.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> %<firstprivate%> clause"
 msgstr "%qE 並非變數在中子句 %<firstprivate%>"
 
-#: config/riscv/riscv-vector-builtins.cc:5544
+#: config/riscv/riscv-vector-builtins.cc:5551
 #, gcc-internal-format
 msgid "RVV type %qT not allowed in %<target%> device clauses"
 msgstr ""
 
-#: config/riscv/riscv-vector-builtins.cc:5656
+#: config/riscv/riscv-vector-builtins.cc:5663
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfbfmin or zvfbfwma ISA extension"
 msgstr "內建函式 %s 需求 -maltivec 選項"
 
-#: config/riscv/riscv-vector-builtins.cc:5666
+#: config/riscv/riscv-vector-builtins.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zvfhmin or zvfh ISA extension"
 msgstr "內建函式 %s 需求 -maltivec 選項"
 
-#: config/riscv/riscv-vector-builtins.cc:5676
+#: config/riscv/riscv-vector-builtins.cc:5683
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "內建函式 %s 需求 -maltivec 選項"
 
-#: config/riscv/riscv-vector-builtins.cc:5686
+#: config/riscv/riscv-vector-builtins.cc:5693
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64d or v ISA extension"
 msgstr "內建函式 %s 需求 -maltivec 選項"
 
-#: config/riscv/riscv-vector-builtins.cc:5695
+#: config/riscv/riscv-vector-builtins.cc:5702
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "內建函式 %s 需求 -maltivec 選項"
 
-#: config/riscv/riscv-vector-builtins.cc:5713
+#: config/riscv/riscv-vector-builtins.cc:5720
 #, fuzzy, gcc-internal-format
 msgid "unrecognized RVV builtin"
 msgstr "無法辨識的 wide sub-instruction"
 
-#: config/riscv/riscv-vector-builtins.cc:5720
+#: config/riscv/riscv-vector-builtins.cc:5727
 #, fuzzy, gcc-internal-format
 msgid "built-in function %qE requires the %qs ISA extension"
 msgstr "內建函式 %s 需求 -mvsx 選項"
 
-#: config/riscv/riscv-vector-builtins.cc:5772
+#: config/riscv/riscv-vector-builtins.cc:5779
 #, fuzzy, gcc-internal-format
 #| msgid "no matching function for call to %<%D(%A)%>"
 msgid "no matching function call to %qE with empty arguments"
 msgstr "對 %<%D(%A)%> 的呼叫沒有匹配的函式"
 
-#: config/riscv/riscv.cc:1033
+#: config/riscv/riscv.cc:1036
 #, fuzzy, gcc-internal-format
 msgid "unknown cpu %qs for %<-mtune%>"
 msgstr "不當的值 %qs 用於 -mtune 切換"
 
-#: config/riscv/riscv.cc:3464
+#: config/riscv/riscv.cc:3467
 #, fuzzy, gcc-internal-format
 msgid "this operation requires the RVV ISA extension"
 msgstr "不使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:3465
+#: config/riscv/riscv.cc:3468
 #, gcc-internal-format
 msgid "you can enable RVV using the command-line option %<-march%>, or by using the %<target%> attribute or pragma"
 msgstr ""
 
-#: config/riscv/riscv.cc:6308 config/riscv/riscv.cc:6396
+#: config/riscv/riscv.cc:6311 config/riscv/riscv.cc:6399
 #, fuzzy, gcc-internal-format
 msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10"
 msgstr "ABI 的傳遞結構與複雜浮點數成員已變更在中 GCC 4.4"
 
-#: config/riscv/riscv.cc:6337 config/riscv/riscv.cc:6414
+#: config/riscv/riscv.cc:6340 config/riscv/riscv.cc:6417
 #, fuzzy, gcc-internal-format
 msgid "ABI for flattened empty union and zero length array changed in GCC 16"
 msgstr "ABI 的傳遞結構與複雜浮點數成員已變更在中 GCC 4.4"
 
-#: config/riscv/riscv.cc:7029
+#: config/riscv/riscv.cc:7032
 #, fuzzy, gcc-internal-format
 #| msgid "AltiVec argument passed to unprototyped function"
 msgid "RVV type %qT cannot be passed to an unprototyped function"
 msgstr "傳遞 AltiVec 引數給無原型的函式"
 
-#: config/riscv/riscv.cc:7318 config/riscv/riscv.cc:7380
+#: config/riscv/riscv.cc:7321 config/riscv/riscv.cc:7383
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the V ISA extension"
 msgstr "使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:7330
+#: config/riscv/riscv.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64x, zve64f, zve64d or v ISA extension"
 msgstr "使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:7344
+#: config/riscv/riscv.cc:7347
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zvfhmin or zvfh ISA extension"
 msgstr "使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:7353
+#: config/riscv/riscv.cc:7356
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve32f, zve64f, zve64d or v ISA extension"
 msgstr "使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:7362
+#: config/riscv/riscv.cc:7365
 #, fuzzy, gcc-internal-format
 msgid "%s %qT requires the zve64d or v ISA extension"
 msgstr "使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:7372
+#: config/riscv/riscv.cc:7375
 #, gcc-internal-format
 msgid "%s %qT requires the minimal vector length %qd but %qd is given"
 msgstr ""
 
-#: config/riscv/riscv.cc:7438
+#: config/riscv/riscv.cc:7441
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the V ISA extension"
 msgstr "內建函式 %s 需求 -mvsx 選項"
 
-#: config/riscv/riscv.cc:7464
+#: config/riscv/riscv.cc:7467
 #, gcc-internal-format
 msgid "unsupported %<ABI_VLEN%> value %d for %qs attribute; %<ABI_VLEN%> must be in the range [32, 16384] and must be a power of 2"
 msgstr ""
 
-#: config/riscv/riscv.cc:7489
+#: config/riscv/riscv.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "function attribute %qs requires the vector ISA extension"
 msgstr "內建函式 %s 需求 -mvsx 選項"
 
-#: config/riscv/riscv.cc:7599
+#: config/riscv/riscv.cc:7602
 #, fuzzy, gcc-internal-format
 msgid "attribute 'rnmi' requires the Smrnmi ISA extension"
 msgstr "不使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:7607
+#: config/riscv/riscv.cc:7610
 #, fuzzy, gcc-internal-format
 msgid "argument to %qE attribute is not %<\"supervisor\"%>, %<\"machine\"%>, or %<\"rnmi\"%>"
 msgstr "引數到 %qE 屬性是 neither 零，nor 一個"
 
-#: config/riscv/riscv.cc:7649
+#: config/riscv/riscv.cc:7652
 #, gcc-internal-format
 msgid "%qs is only supported when %<-mrvv-vector-bits=zvl%> is specified"
 msgstr ""
 
-#: config/riscv/riscv.cc:7658
+#: config/riscv/riscv.cc:7661
 #, fuzzy, gcc-internal-format
 msgid "%qs applied to non-RVV type %qT"
 msgstr "%qE 屬性在不是類別的類型上被忽略"
 
-#: config/riscv/riscv.cc:7666
+#: config/riscv/riscv.cc:7669
 #, fuzzy, gcc-internal-format
 msgid "%qs requires an integer constant"
 msgstr "%qE 屬性需求整數常數引數"
 
-#: config/riscv/riscv.cc:7676
+#: config/riscv/riscv.cc:7679
 #, gcc-internal-format
 msgid "invalid RVV vector size %qd, expected size is %qd based on LMUL of type and %qs"
 msgstr ""
 
-#: config/riscv/riscv.cc:12270
+#: config/riscv/riscv.cc:12273
 #, gcc-internal-format
 msgid "%<-mdiv%> requires %<-march%> to subsume the %<M%> extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12275
+#: config/riscv/riscv.cc:12278
 #, fuzzy, gcc-internal-format
 msgid "Currently the %<V%> implementation requires the %<M%> extension"
 msgstr "不使用 SPE ABI 延伸"
 
-#: config/riscv/riscv.cc:12335
+#: config/riscv/riscv.cc:12338
 #, gcc-internal-format
 msgid "Current RISC-V GCC does not support VLEN greater than 4096bit for 'V' Extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12341
+#: config/riscv/riscv.cc:12344
 #, fuzzy, gcc-internal-format
 msgid "Current RISC-V GCC does not support RVV in big-endian mode"
 msgstr "目標 CPU 不支援手臂模式"
 
-#: config/riscv/riscv.cc:12387 config/riscv/riscv.cc:12390
+#: config/riscv/riscv.cc:12390 config/riscv/riscv.cc:12393
 #, fuzzy, gcc-internal-format
 #| msgid "code model %qs not supported in the %s bit mode"
 msgid "code model %qs with %qs"
 msgstr "程式碼模式 %qs 在 %s 位模式下不受支援"
 
-#: config/riscv/riscv.cc:12419
+#: config/riscv/riscv.cc:12422
 #, gcc-internal-format
 msgid "requested ABI requires %<-march%> to subsume the %qc extension"
 msgstr ""
 
-#: config/riscv/riscv.cc:12426
+#: config/riscv/riscv.cc:12429
 #, gcc-internal-format
 msgid "rv32e requires ilp32e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12428
+#: config/riscv/riscv.cc:12431
 #, gcc-internal-format
 msgid "rv64e requires lp64e ABI"
 msgstr ""
 
-#: config/riscv/riscv.cc:12433
+#: config/riscv/riscv.cc:12436
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support complex types"
 msgid "ILP32E ABI does not support the %qc extension"
 msgstr "ISO C90 不支援複數類型"
 
-#: config/riscv/riscv.cc:12438
+#: config/riscv/riscv.cc:12441
 #, gcc-internal-format
 msgid "LP64E ABI is marked for deprecation in GCC"
 msgstr ""
 
-#: config/riscv/riscv.cc:12439
+#: config/riscv/riscv.cc:12442
 msgid "if you need LP64E please notify the GCC project via %{PR116152%}"
 msgstr ""
 
-#: config/riscv/riscv.cc:12447
+#: config/riscv/riscv.cc:12450
 #, gcc-internal-format
 msgid "z*inx requires ABI ilp32, ilp32e, lp64 or lp64e"
 msgstr ""
 
-#: config/riscv/riscv.cc:12451
+#: config/riscv/riscv.cc:12454
 #, gcc-internal-format
 msgid "ABI requires %<-march=rv%d%>"
 msgstr ""
 
-#: config/riscv/riscv.cc:12461
+#: config/riscv/riscv.cc:12464
 #, fuzzy, gcc-internal-format
 msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d"
 msgstr "-mpreferred-stack-boundary=%d 未被介於 %d 和 %d"
 
-#: config/riscv/riscv.cc:12474
+#: config/riscv/riscv.cc:12477
 #, gcc-internal-format
 msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]"
 msgstr ""
 
-#: config/riscv/riscv.cc:12501 config/rs6000/rs6000.cc:4527
+#: config/riscv/riscv.cc:12504 config/rs6000/rs6000.cc:4527
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid base register in %qs"
 msgstr "%qs 並非有效類別名稱"
 
-#: config/riscv/riscv.cc:12515 config/rs6000/rs6000.cc:4510
+#: config/riscv/riscv.cc:12518 config/rs6000/rs6000.cc:4510
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a valid number in %qs"
 msgstr "%qs 無效用於 %qs"
 
-#: config/riscv/riscv.cc:13047
+#: config/riscv/riscv.cc:13050
 #, fuzzy, gcc-internal-format
 msgid "%qs function cannot have different interrupt type"
 msgstr "%qs 函式無法有引數"
 
-#: config/riscv/riscv.cc:13644
+#: config/riscv/riscv.cc:13657
 #, gcc-internal-format
 msgid "cannot allocate vl register for %qs on this target"
 msgstr ""
 
-#: config/riscv/riscv.cc:15067
+#: config/riscv/riscv.cc:15080
 #, fuzzy
 msgid "invalid version %qB for %<target_clones%> attribute"
 msgstr "不當的值 (%s) 用於 %stune=%s %s"
@@ -49028,23 +49076,23 @@ msgstr "局部變數記憶體需求超過容量限制"
 msgid "%<function_profiler%> support"
 msgstr "function_profiler 支援"
 
-#: config/stormy16/stormy16.cc:1452
+#: config/stormy16/stormy16.cc:1453
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use va_start in interrupt function"
 msgid "cannot use %<va_start%> in interrupt function"
 msgstr "不能為插斷函式使用 va_start"
 
-#: config/stormy16/stormy16.cc:2031
+#: config/stormy16/stormy16.cc:2032
 #, gcc-internal-format, gfc-internal-format
 msgid "switch statement of size %lu entries too large"
 msgstr "switch 敘述太大(%lu 個條目)"
 
-#: config/stormy16/stormy16.cc:2425
+#: config/stormy16/stormy16.cc:2426
 #, gcc-internal-format
 msgid "%<__BELOW100__%> attribute only applies to variables"
 msgstr "屬性 %<__BELOW100__%> 只對變數類型起作用"
 
-#: config/stormy16/stormy16.cc:2432
+#: config/stormy16/stormy16.cc:2433
 #, fuzzy, gcc-internal-format
 #| msgid "__BELOW100__ attribute not allowed with auto storage class"
 msgid "%<__BELOW100__%> attribute not allowed with auto storage class"
@@ -49280,34 +49328,34 @@ msgstr ""
 msgid "%qs is defined but plugin support is disabled"
 msgstr "%q+D 定義後未使用"
 
-#: config/xtensa/xtensa.cc:2778
+#: config/xtensa/xtensa.cc:2783
 #, gcc-internal-format
 msgid "boolean registers required for the floating-point option"
 msgstr "浮點選項需要布林暫存器"
 
-#: config/xtensa/xtensa.cc:2813
+#: config/xtensa/xtensa.cc:2818
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s is not supported with CONST16 instructions"
 msgid "%<-f%s%> is not supported with CONST16 instructions"
 msgstr "CONST16 指令不支援 -f%s"
 
-#: config/xtensa/xtensa.cc:2820
+#: config/xtensa/xtensa.cc:2825
 #, gcc-internal-format
 msgid "PIC is required but not supported with CONST16 instructions"
 msgstr "需要 PIC，但 CONST16 指令不支援"
 
-#: config/xtensa/xtensa.cc:4290
+#: config/xtensa/xtensa.cc:4296
 #, fuzzy, gcc-internal-format
 #| msgid "only uninitialized variables can be placed in a .bss section"
 msgid "only uninitialized variables can be placed in a %<.bss%> section"
 msgstr "只有未初始化的變數才能放在 .bss 區段中"
 
-#: config/xtensa/xtensa.cc:6141
+#: config/xtensa/xtensa.cc:6147
 #, gcc-internal-format
 msgid "constantsynth: method %qs invalid insn sequence, expected %wd (%wx)"
 msgstr ""
 
-#: config/xtensa/xtensa.cc:6146
+#: config/xtensa/xtensa.cc:6152
 #, gcc-internal-format
 msgid "constantsynth: method %qs value mismatch, expected %wd (%wx) synthesized %wd (%wx)"
 msgstr ""
@@ -49400,7 +49448,7 @@ msgstr "%qs 屬性需求原型與具名引數"
 msgid "%qs attribute only applies to variadic functions"
 msgstr "%qs 屬性只有套用到 variadic 函式"
 
-#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:362 d/d-attribs.cc:488
+#: ada/gcc-interface/utils.cc:7336 d/d-attribs.cc:365 d/d-attribs.cc:491
 #: rust/rust-attribs.cc:195
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute has no effect"
@@ -49484,8 +49532,8 @@ msgstr "%qD 並非型態"
 msgid "could not get size of source file"
 msgstr "無法寫入回應檔案 %s"
 
-#: c/c-convert.cc:104 c/c-typeck.cc:2883 c/c-typeck.cc:15490 cp/typeck.cc:2635
-#: cp/typeck.cc:9874 cp/typeck.cc:10682 d/d-convert.cc:262
+#: c/c-convert.cc:104 c/c-typeck.cc:2889 c/c-typeck.cc:15498 cp/typeck.cc:2635
+#: cp/typeck.cc:9872 cp/typeck.cc:10680 d/d-convert.cc:262
 #, gcc-internal-format
 msgid "void value not ignored as it ought to be"
 msgstr "void 值未如預期地被忽略"
@@ -49981,7 +50029,7 @@ msgstr "切換跳躍進入敘述運算式"
 msgid "%qE defined as wrong kind of tag"
 msgstr "%qE 定義為錯誤的 kind 的標籤"
 
-#: c/c-decl.cc:4824 cp/tree.cc:5397
+#: c/c-decl.cc:4824 cp/tree.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qD with void return type"
 msgstr "忽略屬性套用到 %qT 之後定義"
@@ -50138,7 +50186,7 @@ msgstr "ISO C90 不支援在參數陣列宣告中使用 %<static%> 或類型限
 msgid "ISO C90 does not support %<[*]%> array declarators"
 msgstr "ISO C90 不支援 %<[*]%> 陣列宣告"
 
-#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9309
+#: c/c-decl.cc:5718 cp/decl2.cc:2180 cp/name-lookup.cc:9349
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%s%> not allowed to be specified in this context"
@@ -50149,7 +50197,7 @@ msgstr "%<this%> 不能用在此上下文中"
 msgid "%q+D is usually a function"
 msgstr "%q+D 一般是一個函式"
 
-#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19852
+#: c/c-decl.cc:5815 c/c-decl.cc:10959 cp/decl.cc:19918
 #, fuzzy, gcc-internal-format
 msgid "no previous declaration for %qD"
 msgstr "沒有前一個宣告用於 %qD"
@@ -50228,7 +50276,7 @@ msgstr "不能將帶有 volatile 欄位的物件放入暫存器"
 msgid "uninitialized %<const %D%> is invalid in C++"
 msgstr "uninitialized 常數 %qD 無效在中 C++"
 
-#: c/c-decl.cc:6356 cp/decl.cc:10251
+#: c/c-decl.cc:6356 cp/decl.cc:10265
 #, gcc-internal-format
 msgid "%q+D in declare target directive does not have mappable type"
 msgstr ""
@@ -50432,7 +50480,7 @@ msgstr "貯藏類別指定的用於參數 %qE"
 msgid "storage class specified for unnamed parameter"
 msgstr "貯藏類別指定的用於未命名參數"
 
-#: c/c-decl.cc:7170 cp/decl.cc:14915
+#: c/c-decl.cc:7170 cp/decl.cc:14958
 #, gcc-internal-format
 msgid "storage class specified for typename"
 msgstr "為類型名指定了存儲類別"
@@ -50608,7 +50656,7 @@ msgstr "型態名稱宣告的做為函式回傳陣列"
 msgid "function definition has qualified void return type"
 msgstr "函式定義有限定的 void 回傳類型"
 
-#: c/c-decl.cc:7724 cp/decl.cc:15330
+#: c/c-decl.cc:7724 cp/decl.cc:15373
 #, gcc-internal-format
 msgid "type qualifiers ignored on function return type"
 msgstr "忽略函式回傳類型的類型限定"
@@ -50738,7 +50786,7 @@ msgstr "ISO C 不允許使用 const 或 volatile 限定函式類型"
 msgid "a member of a structure or union cannot have a variably modified type"
 msgstr "成員的結構或聯合無法有 variably 已修改型態"
 
-#: c/c-decl.cc:8019 cp/decl.cc:13680
+#: c/c-decl.cc:8019 cp/decl.cc:13723
 #, gcc-internal-format
 msgid "variable or field %qE declared void"
 msgstr "變數或欄位 %qE 宣告為 void"
@@ -50956,7 +51004,7 @@ msgstr "定義輸入 %qs 運算式無效在中 C++"
 msgid "%qT defined in underspecified object initializer"
 msgstr "初始值設定項裡有不明的欄位 %qE"
 
-#: c/c-decl.cc:9085 cp/decl.cc:6314 cp/parser.cc:31012
+#: c/c-decl.cc:9085 cp/decl.cc:6328 cp/parser.cc:31076
 #, gcc-internal-format
 msgid "declaration does not declare anything"
 msgstr "沒有宣告任何東西"
@@ -51021,7 +51069,7 @@ msgstr "結構不包含任何具名成員"
 msgid "struct has no members"
 msgstr "結構體沒有成員"
 
-#: c/c-decl.cc:9744 cp/decl.cc:16369
+#: c/c-decl.cc:9744 cp/decl.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "flexible array member in union is a GCC extension"
 msgstr "flexible 陣列成員在中聯合"
@@ -51088,7 +51136,7 @@ msgstr "%<enum %E%> 重宣告"
 msgid "%<enum%> declared with but defined without fixed underlying type"
 msgstr ""
 
-#: c/c-decl.cc:10327 cp/decl.cc:19106 m2/gm2-gcc/m2type.cc:2100
+#: c/c-decl.cc:10327 cp/decl.cc:19170 m2/gm2-gcc/m2type.cc:2100
 #, fuzzy, gcc-internal-format
 #| msgid "specified mode too small for enumeral values"
 msgid "specified mode too small for enumerated values"
@@ -51147,7 +51195,7 @@ msgstr "列舉值值 %E 太大用於下層的型態 %<%T%>"
 msgid "ISO C restricts enumerator values to range of %<int%> before C23"
 msgstr "ISO C 將列舉值限制在 %<int%> 範圍內"
 
-#: c/c-decl.cc:10806 cp/decl.cc:6655 cp/decl.cc:19710
+#: c/c-decl.cc:10806 cp/decl.cc:6669 cp/decl.cc:19776
 #, fuzzy, gcc-internal-format
 msgid "inline function %qD given attribute %qs"
 msgstr "內聯函式 %qD 給定的屬性 noinline"
@@ -51298,12 +51346,12 @@ msgstr "引數 %qD 與內建原型不符"
 msgid "argument %qD doesn%'t match prototype"
 msgstr "引數 %qD 與原型不符"
 
-#: c/c-decl.cc:11607 cp/decl.cc:20645
+#: c/c-decl.cc:11607 cp/decl.cc:20711
 #, gcc-internal-format
 msgid "no return statement in function returning non-void"
 msgstr "在有回傳值的函式中未發現 return 敘述"
 
-#: c/c-decl.cc:11626 cp/decl.cc:20721
+#: c/c-decl.cc:11626 cp/decl.cc:20787
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD set but not used"
 msgstr "參數 %qD 設定並不是使用"
@@ -51389,7 +51437,7 @@ msgstr "%<__thread%> 與 %<register%> 一起使用"
 msgid "two or more data types in declaration specifiers"
 msgstr "宣告指定了兩個以上的資料類型"
 
-#: c/c-decl.cc:12221 cp/parser.cc:37533
+#: c/c-decl.cc:12221 cp/parser.cc:37593
 #, gcc-internal-format
 msgid "%<long long long%> is too long for GCC"
 msgstr "%<long long long%> 對 GCC 來說太長了"
@@ -51499,7 +51547,7 @@ msgstr "ISO C90 不支援複數類型"
 msgid "ISO C does not support the %<_Float%d%s%> type before C23"
 msgstr "ISO C 不支援 %<__int128%>型態"
 
-#: c/c-decl.cc:12921 cp/parser.cc:22574
+#: c/c-decl.cc:12921 cp/parser.cc:22638
 #, fuzzy, gcc-internal-format
 msgid "%<_Float%d%s%> is not supported on this target"
 msgstr "%<__int128%>未被支援用於這個目標"
@@ -51665,12 +51713,12 @@ msgstr "固定格式的列長至少為七。"
 msgid "ISO C does not support %<%s_BitInt(%d)%> before C23"
 msgstr "ISO C++不支援 %<__int128%>用於 %qs"
 
-#: c/c-decl.cc:13967 cp/semantics.cc:6991
+#: c/c-decl.cc:13967 cp/semantics.cc:7012
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not %<omp_out%> nor %<omp_in%>"
 msgstr ""
 
-#: c/c-decl.cc:13971 cp/semantics.cc:6995
+#: c/c-decl.cc:13971 cp/semantics.cc:7016
 #, gcc-internal-format
 msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>"
 msgstr ""
@@ -51734,39 +51782,39 @@ msgstr ""
 msgid "%qs is a keyword with %qs onwards"
 msgstr "%qs 必須被使用與 %qs"
 
-#: c/c-fold.cc:410 c/c-typeck.cc:14758 cp/typeck.cc:6053
+#: c/c-fold.cc:410 c/c-typeck.cc:14766 cp/typeck.cc:6048
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count is negative"
 msgid "left shift of negative value"
 msgstr "左移次數為負"
 
-#: c/c-fold.cc:423 c/c-typeck.cc:14767 cp/typeck.cc:6061
+#: c/c-fold.cc:423 c/c-typeck.cc:14775 cp/typeck.cc:6056
 #, gcc-internal-format
 msgid "left shift count is negative"
 msgstr "左移次數為負"
 
-#: c/c-fold.cc:424 c/c-typeck.cc:14694 cp/typeck.cc:6000
+#: c/c-fold.cc:424 c/c-typeck.cc:14702 cp/typeck.cc:5995
 #, gcc-internal-format
 msgid "right shift count is negative"
 msgstr "右移次數為負"
 
-#: c/c-fold.cc:434 c/c-typeck.cc:14786 cp/typeck.cc:6069
+#: c/c-fold.cc:434 c/c-typeck.cc:14794 cp/typeck.cc:6064
 #, gcc-internal-format
 msgid "left shift count >= width of type"
 msgstr "左移次數大於或等於類型寬度"
 
-#: c/c-fold.cc:435 c/c-typeck.cc:14718 cp/typeck.cc:6011
+#: c/c-fold.cc:435 c/c-typeck.cc:14726 cp/typeck.cc:6006
 #, gcc-internal-format
 msgid "right shift count >= width of type"
 msgstr "右移次數大於或等於類型寬度"
 
-#: c/c-fold.cc:442 c/c-typeck.cc:14778
+#: c/c-fold.cc:442 c/c-typeck.cc:14786
 #, fuzzy, gcc-internal-format
 #| msgid "left shift count >= width of type"
 msgid "left shift count >= width of vector element"
 msgstr "左移次數大於或等於類型寬度"
 
-#: c/c-fold.cc:443 c/c-typeck.cc:14705
+#: c/c-fold.cc:443 c/c-typeck.cc:14713
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count >= width of type"
 msgid "right shift count >= width of vector element"
@@ -51787,7 +51835,7 @@ msgstr ""
 msgid "to match this %qs"
 msgstr "沒有匹配用於 %qs 在中 %<%s %E%>"
 
-#: c/c-parser.cc:1513 cp/parser.cc:37770
+#: c/c-parser.cc:1513 cp/parser.cc:37830
 #, fuzzy, gcc-internal-format
 msgid "expected end of line"
 msgstr "預期的列尾"
@@ -51797,7 +51845,7 @@ msgstr "預期的列尾"
 msgid "ISO C forbids an empty translation unit"
 msgstr "ISO C 禁止清空轉譯單位"
 
-#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54560
+#: c/c-parser.cc:2110 c/c-parser.cc:2119 c/c-parser.cc:29067 cp/parser.cc:54620
 #: cp/semantics.cc:4059 cp/semantics.cc:4075
 #, gcc-internal-format
 msgid "%qs without corresponding %qs"
@@ -51845,8 +51893,8 @@ msgid "unknown type name %qE"
 msgstr "不明型態名稱 %qE"
 
 #: c/c-parser.cc:2573 c/c-parser.cc:16296 c/c-parser.cc:25964
-#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51254
-#: cp/parser.cc:57386
+#: c/c-parser.cc:26708 c/c-parser.cc:27297 cp/parser.cc:51314
+#: cp/parser.cc:57446
 #, gcc-internal-format
 msgid "expected declaration specifiers"
 msgstr "需要指定宣告"
@@ -51884,7 +51932,7 @@ msgstr ""
 msgid "expected %<;%>, identifier or %<(%>"
 msgstr "預期 %<;%>，識別碼或 %<(%>"
 
-#: c/c-parser.cc:2729 cp/parser.cc:40037 cp/parser.cc:40109
+#: c/c-parser.cc:2729 cp/parser.cc:40097 cp/parser.cc:40169
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored for methods"
 msgstr "前綴屬性被忽略用於方法"
@@ -51899,13 +51947,13 @@ msgstr "前綴屬性被忽略用於實作"
 msgid "unexpected attribute"
 msgstr "未預期的屬性"
 
-#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14521 cp/parser.cc:14778
+#: c/c-parser.cc:2795 c/c-parser.cc:8512 cp/parser.cc:14536 cp/parser.cc:14793
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<fallthrough%> attribute not followed by %<;%>"
 msgstr "%q+D 不能有 section 屬性"
 
-#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4095
+#: c/c-parser.cc:2798 c/c-parser.cc:8479 cp/cp-gimplify.cc:4121
 #, fuzzy, gcc-internal-format
 #| msgid "section attribute not allowed for %q+D"
 msgid "%<assume%> attribute not followed by %<;%>"
@@ -51953,7 +52001,7 @@ msgstr "檔案作用欄位中出現 %<auto%> 空宣告"
 msgid "%qs may only be used with a single declarator"
 msgstr "%<auto%> 只能被指定的用於變數或函式宣告"
 
-#: c/c-parser.cc:3185 cp/parser.cc:18168
+#: c/c-parser.cc:3185 cp/parser.cc:18206
 #, gcc-internal-format
 msgid "expected %<,%> or %<;%>"
 msgstr "需要 %<,%> 或 %<;%>"
@@ -51990,7 +52038,7 @@ msgid "%<__GIMPLE%> function cannot be a nested function"
 msgstr "函式 %qs 不能被宣告為 %<mutable%>"
 
 #: c/c-parser.cc:3534 c/c-parser.cc:9832 c/c-parser.cc:16369
-#: c/c-parser.cc:21727 cp/parser.cc:46078
+#: c/c-parser.cc:21727 cp/parser.cc:46138
 #, gcc-internal-format
 msgid "expected string literal"
 msgstr "需要字面字串"
@@ -52020,7 +52068,7 @@ msgstr "運算式在中靜態假設不是常數"
 msgid "static assertion failed: %E"
 msgstr "靜態假設失敗：%E"
 
-#: c/c-parser.cc:3572 cp/semantics.cc:13123
+#: c/c-parser.cc:3572 cp/semantics.cc:13144
 #, fuzzy, gcc-internal-format
 msgid "static assertion failed"
 msgstr "靜態假設失敗：%E"
@@ -52077,8 +52125,8 @@ msgstr "無法為列舉類型使用模式 %qs"
 #: c/c-parser.cc:20146 c/c-parser.cc:20283 c/c-parser.cc:21498
 #: c/c-parser.cc:24571 c/c-parser.cc:27783 c/c-parser.cc:27983
 #: c/c-parser.cc:29186 c/gimple-parser.cc:1971 c/gimple-parser.cc:2018
-#: cp/parser.cc:10760 cp/parser.cc:37773 cp/parser.cc:41014 cp/parser.cc:44543
-#: cp/parser.cc:44735 cp/parser.cc:52957 cp/parser.cc:56605
+#: cp/parser.cc:10754 cp/parser.cc:37833 cp/parser.cc:41074 cp/parser.cc:44603
+#: cp/parser.cc:44795 cp/parser.cc:53017 cp/parser.cc:56665
 #, gcc-internal-format
 msgid "expected identifier"
 msgstr "需要識別碼"
@@ -52110,12 +52158,12 @@ msgstr "對未定義類型 %<%s %E%> 的使用無效"
 msgid "%<enum%> underlying type incompatible with previous declaration"
 msgstr "%q#D 衝突與前一個宣告"
 
-#: c/c-parser.cc:4291 cp/parser.cc:24136
+#: c/c-parser.cc:4291 cp/parser.cc:24200
 #, gcc-internal-format
 msgid "comma at end of enumerator list"
 msgstr "列舉表以逗號結尾"
 
-#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46141
+#: c/c-parser.cc:4297 c/c-parser.cc:21775 cp/parser.cc:46201
 #: go/gofrontend/embed.cc:424
 #, gcc-internal-format
 msgid "expected %<,%> or %<}%>"
@@ -52199,22 +52247,22 @@ msgstr "需要指定宣告或 %<...%>"
 msgid "parentheses must be omitted if attribute argument list is empty"
 msgstr ""
 
-#: c/c-parser.cc:6014 cp/parser.cc:33010
+#: c/c-parser.cc:6014 cp/parser.cc:33074
 #, fuzzy, gcc-internal-format
 msgid "expected OpenMP directive name"
 msgstr "預期的函式"
 
-#: c/c-parser.cc:6061 cp/parser.cc:33066
+#: c/c-parser.cc:6061 cp/parser.cc:33130
 #, fuzzy, gcc-internal-format
 msgid "expected %<directive%> or %<sequence%>"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:6206 cp/parser.cc:33234
+#: c/c-parser.cc:6206 cp/parser.cc:33298
 #, fuzzy, gcc-internal-format
 msgid "%<omp::%E%> attribute requires argument"
 msgstr "%qD 屬性需要單一 NTBS 引數"
 
-#: c/c-parser.cc:6222 cp/parser.cc:33250
+#: c/c-parser.cc:6222 cp/parser.cc:33314
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute does not take any arguments"
 msgstr "%qE 屬性沒有任何效果"
@@ -52225,7 +52273,7 @@ msgstr "%qE 屬性沒有任何效果"
 msgid "ISO C does not support %<[[]]%> attributes before C23"
 msgstr "ISO C90 不支援 %<[*]%> 陣列宣告"
 
-#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10232
+#: c/c-parser.cc:6593 c/c-parser.cc:6659 c/c-typeck.cc:10240
 #, fuzzy, gcc-internal-format
 #| msgid "variable-sized object may not be initialized"
 msgid "variable-sized object may not be initialized except with an empty initializer"
@@ -52257,17 +52305,17 @@ msgstr "ISO C90 不允許指定子物件的初始值"
 msgid "obsolete use of designated initializer without %<=%>"
 msgstr "過時的用法，應使用 %<=%> 來指定元素初始值"
 
-#: c/c-parser.cc:7203 cp/parser.cc:14900
+#: c/c-parser.cc:7203 cp/parser.cc:14915
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested in %<#pragma acc loop%>"
 msgstr ""
 
-#: c/c-parser.cc:7210 cp/parser.cc:14907
+#: c/c-parser.cc:7210 cp/parser.cc:14922
 #, fuzzy, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<ordered%> clause"
 msgstr "已排序的區域必須是接近巢狀的內部迴圈區域與已排序的子句"
 
-#: c/c-parser.cc:7217 cp/parser.cc:14914
+#: c/c-parser.cc:7217 cp/parser.cc:14929
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<reduction%> %<inscan%> clause"
 msgstr ""
@@ -52277,44 +52325,44 @@ msgstr ""
 msgid "inner loops must be perfectly nested in %<pragma omp tile%>"
 msgstr ""
 
-#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13804 cp/parser.cc:13954
-#: cp/parser.cc:53983
+#: c/c-parser.cc:7280 c/c-parser.cc:7435 cp/parser.cc:13819 cp/parser.cc:13969
+#: cp/parser.cc:54043
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same statement"
 msgstr ""
 
-#: c/c-parser.cc:7288 cp/parser.cc:13812
+#: c/c-parser.cc:7288 cp/parser.cc:13827
 #, gcc-internal-format
 msgid "OpenMP %<omp::decl%> attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13836
-#: cp/parser.cc:53963 cp/parser.cc:54102
+#: c/c-parser.cc:7312 c/c-parser.cc:7533 c/c-parser.cc:28639 cp/parser.cc:13851
+#: cp/parser.cc:54023 cp/parser.cc:54162
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs attribute argument"
 msgstr ""
 
-#: c/c-parser.cc:7404 cp/parser.cc:13923
+#: c/c-parser.cc:7404 cp/parser.cc:13938
 #, gcc-internal-format
 msgid "OpenMP construct among %<omp::directive%> attributes requires all %<omp::directive%> attributes on the same statement to be in the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7412 cp/parser.cc:13931
+#: c/c-parser.cc:7412 cp/parser.cc:13946
 #, gcc-internal-format
 msgid "multiple OpenMP standalone directives among %<omp::directive%> attributes must be all within the same %<omp::sequence%>"
 msgstr ""
 
-#: c/c-parser.cc:7424 cp/parser.cc:13943
+#: c/c-parser.cc:7424 cp/parser.cc:13958
 #, gcc-internal-format
 msgid "standalone OpenMP directives in %<omp::directive%> attribute can only appear on an empty statement"
 msgstr ""
 
-#: c/c-parser.cc:7545 cp/parser.cc:14063
+#: c/c-parser.cc:7545 cp/parser.cc:14078
 #, gcc-internal-format
 msgid "mixing OpenMP directives with attribute and pragma syntax on the same declaration"
 msgstr ""
 
-#: c/c-parser.cc:7603 cp/parser.cc:16828
+#: c/c-parser.cc:7603 cp/parser.cc:16866
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute does not take any arguments"
 msgstr "%qE 屬性沒有任何效果"
@@ -52345,7 +52393,7 @@ msgstr "ISO C90 禁止混合的宣告和編碼"
 msgid "expected %<}%> before %<else%>"
 msgstr "預期 %<}%>之前 %<else%>expected %<}%> before %<else%>預期 %<}%>之前 %<else%>"
 
-#: c/c-parser.cc:7937 cp/parser.cc:14967
+#: c/c-parser.cc:7937 cp/parser.cc:14982
 #, fuzzy, gcc-internal-format
 msgid "%<else%> without a previous %<if%>"
 msgstr "%<else%> 而無需前一個 %<if%>"
@@ -52360,7 +52408,7 @@ msgstr "標籤位於複合敘述末尾"
 #. delimiter without consuming it, but here we need to consume
 #. it to proceed further.
 #: c/c-parser.cc:8029 c/c-parser.cc:8033 c/c-parser.cc:8541
-#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14427
+#: c/gimple-parser.cc:722 c/gimple-parser.cc:2510 cp/parser.cc:14442
 #, gcc-internal-format
 msgid "expected statement"
 msgstr "需要敘述"
@@ -52395,27 +52443,27 @@ msgstr "ISO C 不支援十進位浮點數"
 msgid "declaration in the controlling expression must have an initializer"
 msgstr "運算式清單視為複合式表示式在中初始設定式"
 
-#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17957
+#: c/c-parser.cc:8672 cp/parser.cc:5589 cp/parser.cc:17995
 #, fuzzy, gcc-internal-format
 msgid "expected declaration"
 msgstr "預期的宣告"
 
-#: c/c-parser.cc:8753 cp/parser.cc:16965
+#: c/c-parser.cc:8753 cp/parser.cc:17003
 #, fuzzy, gcc-internal-format
 msgid "suggest braces around empty body in an %<if%> statement"
 msgstr "建議大括號周圍清空內文在中 %<if%> 敘述"
 
-#: c/c-parser.cc:8796 cp/parser.cc:16968
+#: c/c-parser.cc:8796 cp/parser.cc:17006
 #, fuzzy, gcc-internal-format
 msgid "suggest braces around empty body in an %<else%> statement"
 msgstr "建議大括號周圍清空內文在中 %<else%> 敘述"
 
-#: c/c-parser.cc:8890 cp/parser.cc:15381
+#: c/c-parser.cc:8890 cp/parser.cc:15396
 #, fuzzy, gcc-internal-format
 msgid "suggest explicit braces to avoid ambiguous %<else%>"
 msgstr "建議明確的大括號到避免模稜兩可的 %<else%>"
 
-#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16378
+#: c/c-parser.cc:9008 c/c-parser.cc:9087 c/c-parser.cc:9222 cp/parser.cc:16399
 #, gcc-internal-format
 msgid "loop not permitted in intervening code in OpenMP loop body"
 msgstr ""
@@ -52435,12 +52483,12 @@ msgstr "多重迭代變數在中快速列舉類型"
 msgid "invalid iterating variable in fast enumeration"
 msgstr "無效的迭代變數在中快速列舉類型"
 
-#: c/c-parser.cc:9335 cp/parser.cc:15689
+#: c/c-parser.cc:9335 cp/parser.cc:15704
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
 msgstr ""
 
-#: c/c-parser.cc:9341 cp/parser.cc:15695
+#: c/c-parser.cc:9341 cp/parser.cc:15710
 #, gcc-internal-format
 msgid "missing loop condition in loop with %<GCC unroll%> pragma"
 msgstr ""
@@ -52456,8 +52504,8 @@ msgstr "缺少收集在中快速列舉類型"
 msgid "duplicate %<asm%> qualifier %qE"
 msgstr "重複的 cv 限定"
 
-#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25090
-#: cp/parser.cc:25108 cp/parser.cc:25123
+#: c/c-parser.cc:9532 c/c-parser.cc:9543 c/c-parser.cc:9554 cp/parser.cc:25154
+#: cp/parser.cc:25172 cp/parser.cc:25187
 #, fuzzy, gcc-internal-format
 #| msgid "%J  first type here"
 msgid "first seen here"
@@ -52481,12 +52529,12 @@ msgstr "ISO C 不允許省略 ?: 運算式中的第二項"
 
 #. Location of the binary operator.
 #. Quiet warning.
-#: c/c-parser.cc:10344 cp/typeck.cc:5829
+#: c/c-parser.cc:10344 cp/typeck.cc:5824
 #, gcc-internal-format
 msgid "division %<sizeof (%T) / sizeof (%T)%> does not compute the number of array elements"
 msgstr ""
 
-#: c/c-parser.cc:10350 cp/typeck.cc:5834
+#: c/c-parser.cc:10350 cp/typeck.cc:5829
 #, fuzzy, gcc-internal-format
 msgid "first %<sizeof%> operand was declared here"
 msgstr "型態的欄位宣告的在此"
@@ -52672,7 +52720,7 @@ msgstr "ISO C 不支援 %<__int128%>型態"
 
 #: c/c-parser.cc:11876 c/c-parser.cc:13612 c/c-parser.cc:13634
 #: c/c-parser.cc:23988 c/gimple-parser.cc:1887 c/gimple-parser.cc:2527
-#: cp/parser.cc:47626
+#: cp/parser.cc:47686
 #, gcc-internal-format
 msgid "expected expression"
 msgstr "需要運算式"
@@ -52687,13 +52735,13 @@ msgstr "運算式中的大括號組只允許出現在函式中"
 msgid "ISO C forbids braced-groups within expressions"
 msgstr "ISO C 不允許在運算式中使用大括號組"
 
-#: c/c-parser.cc:12018 cp/parser.cc:12389
+#: c/c-parser.cc:12018 cp/parser.cc:12383
 #, fuzzy, gcc-internal-format
 #| msgid "second parameter of %<va_start%> not last named argument"
 msgid "optional second parameter of %<va_start%> not last named argument"
 msgstr "%<va_start%> 的第二個參數不是最後一個具名參數"
 
-#: c/c-parser.cc:12057 cp/parser.cc:12444
+#: c/c-parser.cc:12057 cp/parser.cc:12438
 #, gcc-internal-format
 msgid "%<va_start%> macro used with additional arguments other than identifier of the last named argument"
 msgstr ""
@@ -52844,7 +52892,7 @@ msgstr "兩者引數到 %<__builtin___clear_cache%>必須是指標"
 msgid "the argument to %<__builtin_counted_by_ref%> must be a field of a structure"
 msgstr "%<__builtin_prefetch%> 的第三個引數必須是一個常數"
 
-#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8703
+#: c/c-parser.cc:12986 c/c-parser.cc:13015 cp/parser.cc:8686
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shuffle%>"
 msgstr "錯誤的引數數量到 %<__builtin_shuffle%>"
@@ -52884,7 +52932,7 @@ msgstr "non-integer 引數 3 在中呼叫到函式 %qE"
 msgid "rotate count is negative"
 msgstr "左旋轉計數是負"
 
-#: c/c-parser.cc:13589 cp/parser.cc:6977
+#: c/c-parser.cc:13589 cp/parser.cc:6960
 #, gcc-internal-format
 msgid "%<omp_all_memory%> may only be used in OpenMP %<depend%> clause"
 msgstr ""
@@ -52996,7 +53044,7 @@ msgstr ""
 msgid "absolute value function %qD given an argument of type %qT but has parameter of type %qT which may cause truncation of value"
 msgstr ""
 
-#: c/c-parser.cc:14074 cp/parser.cc:9140
+#: c/c-parser.cc:14074 cp/parser.cc:9123
 #, gcc-internal-format
 msgid "calls to the OpenMP runtime API are not permitted in intervening code"
 msgstr ""
@@ -53036,12 +53084,12 @@ msgstr "objective-c 方法宣告被預期"
 msgid "no type or storage class may be specified here,"
 msgstr "沒有型態或貯藏類別也許會被指定的在此，"
 
-#: c/c-parser.cc:15652 cp/parser.cc:40871
+#: c/c-parser.cc:15652 cp/parser.cc:40931
 #, fuzzy, gcc-internal-format
 msgid "empty property attribute list"
 msgstr "不明內容屬性"
 
-#: c/c-parser.cc:15666 cp/parser.cc:40884
+#: c/c-parser.cc:15666 cp/parser.cc:40944
 #, fuzzy, gcc-internal-format
 #| msgid "missing Code attribute"
 msgid "missing property attribute"
@@ -53052,57 +53100,57 @@ msgstr "缺少 Code 屬性"
 msgid "unknown property attribute %<%s%s%>"
 msgstr "不明內容屬性"
 
-#: c/c-parser.cc:15708 cp/parser.cc:40921
+#: c/c-parser.cc:15708 cp/parser.cc:40981
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute"
 msgstr "不明內容屬性"
 
-#: c/c-parser.cc:15717 cp/parser.cc:40930
+#: c/c-parser.cc:15717 cp/parser.cc:40990
 #, fuzzy, gcc-internal-format
 msgid "expected %<=%> after Objective-C %qE"
 msgstr "重複 %<@%>之前 Objective-C 字串"
 
-#: c/c-parser.cc:15728 cp/parser.cc:40944
+#: c/c-parser.cc:15728 cp/parser.cc:41004
 #, fuzzy, gcc-internal-format
 msgid "expected %qE selector name"
 msgstr "預期 selection-statement"
 
-#: c/c-parser.cc:15744 cp/parser.cc:40963
+#: c/c-parser.cc:15744 cp/parser.cc:41023
 #, fuzzy, gcc-internal-format
 msgid "setter method names must terminate with %<:%>"
 msgstr "setter 名稱必須終止與 %<:%>"
 
-#: c/c-parser.cc:15968 cp/semantics.cc:14906
+#: c/c-parser.cc:15968 cp/semantics.cc:14927
 #, gcc-internal-format
 msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u"
 msgstr ""
 
-#: c/c-parser.cc:16010 cp/parser.cc:56964
+#: c/c-parser.cc:16010 cp/parser.cc:57024
 #, gcc-internal-format
 msgid "intervening code must not contain executable OpenMP directives"
 msgstr ""
 
 #: c/c-parser.cc:16030 c/c-parser.cc:26705 c/c-parser.cc:27014
-#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51251
-#: cp/parser.cc:51599 cp/parser.cc:51714 cp/parser.cc:51813 cp/parser.cc:56996
-#: cp/parser.cc:57012 cp/parser.cc:57028 cp/parser.cc:57044 cp/parser.cc:57061
-#: cp/parser.cc:57078 cp/parser.cc:57095 cp/parser.cc:57126 cp/parser.cc:57140
-#: cp/parser.cc:57165 cp/parser.cc:57179
+#: c/c-parser.cc:27077 c/c-parser.cc:27187 cp/parser.cc:51311
+#: cp/parser.cc:51659 cp/parser.cc:51774 cp/parser.cc:51873 cp/parser.cc:57056
+#: cp/parser.cc:57072 cp/parser.cc:57088 cp/parser.cc:57104 cp/parser.cc:57121
+#: cp/parser.cc:57138 cp/parser.cc:57155 cp/parser.cc:57186 cp/parser.cc:57200
+#: cp/parser.cc:57225 cp/parser.cc:57239
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma %s%> may only be used in compound statements"
 msgstr "%<# pragma omp flush%>也許會只有被已用於複合陳述"
 
-#: c/c-parser.cc:16053 cp/parser.cc:57154
+#: c/c-parser.cc:16053 cp/parser.cc:57214
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be at file scope"
 msgstr "%<# pragma GCC pchpreprocess%(_P)>必須是先"
 
-#: c/c-parser.cc:16156 cp/parser.cc:57284
+#: c/c-parser.cc:16156 cp/parser.cc:57344
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> may only be used in a loop construct with %<inscan%> %<reduction%> clause"
 msgstr "%<# pragma omp section%>也許會只有被已用於 %<# pragma omp sections%>建構"
 
-#: c/c-parser.cc:16163 cp/parser.cc:57290
+#: c/c-parser.cc:16163 cp/parser.cc:57350
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
 msgstr "%<# pragma omp section%>也許會只有被已用於 %<# pragma omp sections%>建構"
@@ -53112,12 +53160,12 @@ msgstr "%<# pragma omp section%>也許會只有被已用於 %<# pragma omp secti
 msgid "%<#pragma %s%> may only be used at file scope"
 msgstr "%<# pragma GCC pchpreprocess%(_P)>必須是先"
 
-#: c/c-parser.cc:16262 cp/parser.cc:57373
+#: c/c-parser.cc:16262 cp/parser.cc:57433
 #, fuzzy, gcc-internal-format
 msgid "for, while or do statement expected"
 msgstr "用於敘述預期"
 
-#: c/c-parser.cc:16278 cp/parser.cc:56986
+#: c/c-parser.cc:16278 cp/parser.cc:57046
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC pch_preprocess%> must be first"
 msgstr "%<# pragma GCC pchpreprocess%(_P)>必須是先"
@@ -53127,11 +53175,11 @@ msgstr "%<# pragma GCC pchpreprocess%(_P)>必須是先"
 #: c/c-parser.cc:23793 c/c-parser.cc:23800 c/c-parser.cc:28193
 #: c/c-parser.cc:29773 c/c-parser.cc:29781 c/c-parser.cc:30157
 #: c/c-parser.cc:30167 c/c-parser.cc:30276 c/c-parser.cc:30283
-#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41414
-#: cp/parser.cc:45726 cp/parser.cc:47152 cp/parser.cc:47189 cp/parser.cc:47378
-#: cp/parser.cc:47441 cp/parser.cc:47448 cp/parser.cc:47455 cp/parser.cc:53195
-#: cp/parser.cc:53202 cp/parser.cc:53209 cp/parser.cc:53216 cp/parser.cc:53764
-#: cp/parser.cc:55835 cp/parser.cc:55843 cp/parser.cc:55995 cp/parser.cc:56005
+#: c/c-parser.cc:30290 c/c-parser.cc:30297 cp/parser.cc:41474
+#: cp/parser.cc:45786 cp/parser.cc:47212 cp/parser.cc:47249 cp/parser.cc:47438
+#: cp/parser.cc:47501 cp/parser.cc:47508 cp/parser.cc:47515 cp/parser.cc:53255
+#: cp/parser.cc:53262 cp/parser.cc:53269 cp/parser.cc:53276 cp/parser.cc:53824
+#: cp/parser.cc:55895 cp/parser.cc:55903 cp/parser.cc:56055 cp/parser.cc:56065
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses"
 msgstr "太多 %qs 子句"
@@ -53146,58 +53194,58 @@ msgstr "numthreads 運算式必須是積分(_T)"
 msgid "%qD is not a variable"
 msgstr "%qD 並非變數"
 
-#: c/c-parser.cc:17303 cp/semantics.cc:9531
+#: c/c-parser.cc:17303 cp/semantics.cc:9552
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a pointer variable"
 msgstr "%qD 並非變數"
 
-#: c/c-parser.cc:17345 cp/parser.cc:42305
+#: c/c-parser.cc:17345 cp/parser.cc:42365
 #, fuzzy, gcc-internal-format
 msgid "collapse argument needs positive constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: c/c-parser.cc:17440 cp/parser.cc:42383
+#: c/c-parser.cc:17440 cp/parser.cc:42443
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%> or %<present%>"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:17442 cp/parser.cc:42385
+#: c/c-parser.cc:17442 cp/parser.cc:42445
 #, fuzzy, gcc-internal-format
 msgid "expected %<none%>, %<shared%>, %<private%> or %<firstprivate%>"
 msgstr "預期 %<# pragma omp section%>或 %<}%>"
 
-#: c/c-parser.cc:17527 cp/parser.cc:42455
+#: c/c-parser.cc:17527 cp/parser.cc:42515
 #, fuzzy, gcc-internal-format
 msgid "expected constant logical expression"
 msgstr "預期的整數運算式"
 
-#: c/c-parser.cc:17604 cp/parser.cc:42537
+#: c/c-parser.cc:17604 cp/parser.cc:42597
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>, %<update%>, %<enter%> or %<exit%>"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
 #: c/c-parser.cc:17624 c/c-parser.cc:27070 c/c-parser.cc:27180
-#: cp/parser.cc:42555 cp/parser.cc:51591 cp/parser.cc:51706
+#: cp/parser.cc:42615 cp/parser.cc:51651 cp/parser.cc:51766
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%>"
 msgstr "預期 %<catch%>"
 
-#: c/c-parser.cc:17677 cp/parser.cc:42610
+#: c/c-parser.cc:17677 cp/parser.cc:42670
 #, gcc-internal-format
 msgid "too many %<if%> clauses with %qs modifier"
 msgstr ""
 
-#: c/c-parser.cc:17684 cp/parser.cc:42617
+#: c/c-parser.cc:17684 cp/parser.cc:42677
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:17686 cp/parser.cc:42619
+#: c/c-parser.cc:17686 cp/parser.cc:42679
 #, fuzzy, gcc-internal-format
 msgid "too many %<if%> clauses without modifier"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:17692 cp/parser.cc:42625
+#: c/c-parser.cc:17692 cp/parser.cc:42685
 #, gcc-internal-format
 msgid "if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier"
 msgstr ""
@@ -53220,22 +53268,22 @@ msgstr "%<num_threads%> 值必須是正值"
 msgid "%<num_tasks%> value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: c/c-parser.cc:17931 cp/semantics.cc:9746
+#: c/c-parser.cc:17931 cp/semantics.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: c/c-parser.cc:17980 cp/semantics.cc:9776
+#: c/c-parser.cc:17980 cp/semantics.cc:9797
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> value must be non-negative"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: c/c-parser.cc:18014 cp/parser.cc:42851
+#: c/c-parser.cc:18014 cp/parser.cc:42911
 #, fuzzy, gcc-internal-format
 msgid "expected constant integer expression with valid sync-hint value"
 msgstr "預期的整數運算式"
 
-#: c/c-parser.cc:18086 cp/parser.cc:42921
+#: c/c-parser.cc:18086 cp/parser.cc:42981
 #, fuzzy, gcc-internal-format
 msgid "expected %<alloc%>, %<to%>, %<from%>, %<tofrom%>, %<firstprivate%>, %<none%> or %<default%>"
 msgstr "預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>，%<min%>或 %<max%>expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>，%<min%>或 %<max%>"
@@ -53245,100 +53293,100 @@ msgstr "預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>
 msgid "expected %<scalar%>, %<aggregate%>, %<pointer%> or %<all%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:18231 cp/parser.cc:43073
+#: c/c-parser.cc:18231 cp/parser.cc:43133
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with %qs category"
 msgstr ""
 
-#: c/c-parser.cc:18234 cp/parser.cc:43076
+#: c/c-parser.cc:18234 cp/parser.cc:43136
 #, gcc-internal-format
 msgid "too many %<defaultmap%> clauses with unspecified category"
 msgstr ""
 
-#: c/c-parser.cc:18318 cp/semantics.cc:8423 cp/semantics.cc:8488
+#: c/c-parser.cc:18318 cp/semantics.cc:8444 cp/semantics.cc:8509
 #, fuzzy, gcc-internal-format
 msgid "%qs expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8458
-#: cp/semantics.cc:8502
+#: c/c-parser.cc:18330 c/c-parser.cc:18453 cp/semantics.cc:8479
+#: cp/semantics.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "%qs value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: c/c-parser.cc:18392 cp/parser.cc:42068
+#: c/c-parser.cc:18392 cp/parser.cc:42128
 #, fuzzy, gcc-internal-format
 msgid "too many %<static%> arguments"
 msgstr "太多引數"
 
-#: c/c-parser.cc:18426 cp/parser.cc:42101
+#: c/c-parser.cc:18426 cp/parser.cc:42161
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument"
 msgstr "未預期的屬性"
 
-#: c/c-parser.cc:18593 cp/semantics.cc:9962
+#: c/c-parser.cc:18593 cp/semantics.cc:9983
 #, fuzzy, gcc-internal-format
 msgid "%<tile%> argument needs positive integral constant"
 msgstr "%qE 屬性引數不是整數常數"
 
-#: c/c-parser.cc:18661 cp/parser.cc:46354
+#: c/c-parser.cc:18661 cp/parser.cc:46414
 #, fuzzy, gcc-internal-format
 msgid "too many %<self%> clauses"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:18703 cp/parser.cc:43126
+#: c/c-parser.cc:18703 cp/parser.cc:43186
 #, fuzzy, gcc-internal-format
 msgid "expected %<reproducible%> or %<unconstrained%>"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43135
-#: cp/parser.cc:43145
+#: c/c-parser.cc:18712 c/c-parser.cc:18718 cp/parser.cc:43195
+#: cp/parser.cc:43205
 #, fuzzy, gcc-internal-format
 msgid "expected %<concurrent%>"
 msgstr "預期 %<using%>"
 
-#: c/c-parser.cc:18754 cp/parser.cc:43185
+#: c/c-parser.cc:18754 cp/parser.cc:43245
 #, fuzzy, gcc-internal-format
 msgid "expected %<teams%>, %<parallel%> or %<thread%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:18807 cp/parser.cc:43253
+#: c/c-parser.cc:18807 cp/parser.cc:43313
 #, fuzzy, gcc-internal-format
 msgid "ordered argument needs positive constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: c/c-parser.cc:18902 cp/parser.cc:43335
+#: c/c-parser.cc:18902 cp/parser.cc:43395
 #, gcc-internal-format
 msgid "%<-%> operator for reductions deprecated in OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55273
+#: c/c-parser.cc:18941 c/c-parser.cc:29312 cp/parser.cc:55333
 #, fuzzy, gcc-internal-format
 msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
 msgstr "預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>，%<min%>或 %<max%>expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>，%<min%>或 %<max%>"
 
-#: c/c-parser.cc:19063 cp/parser.cc:43522
+#: c/c-parser.cc:19063 cp/parser.cc:43582
 #, fuzzy, gcc-internal-format
 #| msgid "both %<long%> and %<void%> in declaration specifiers"
 msgid "both %<monotonic%> and %<nonmonotonic%> modifiers specified"
 msgstr "宣告中同時使用了 %<long%> 和 %<void%>"
 
-#: c/c-parser.cc:19117 cp/parser.cc:43538
+#: c/c-parser.cc:19117 cp/parser.cc:43598
 #, fuzzy, gcc-internal-format
 msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
 msgstr "排程 %<runtime%> 不需 %<chunksize%(_S)>參數"
 
-#: c/c-parser.cc:19121 cp/parser.cc:43541
+#: c/c-parser.cc:19121 cp/parser.cc:43601
 #, fuzzy, gcc-internal-format
 msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
 msgstr "排程 %<auto%> 不需 %<chunksize%(_S)>參數"
 
-#: c/c-parser.cc:19134 cp/semantics.cc:8549
+#: c/c-parser.cc:19134 cp/semantics.cc:8570
 #, fuzzy, gcc-internal-format
 msgid "chunk size value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: c/c-parser.cc:19157 cp/parser.cc:43561
+#: c/c-parser.cc:19157 cp/parser.cc:43621
 #, fuzzy, gcc-internal-format
 msgid "invalid schedule kind"
 msgstr "無效的排程 kind"
@@ -53348,39 +53396,39 @@ msgstr "無效的排程 kind"
 msgid "%<num_teams%> value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: c/c-parser.cc:19315 cp/semantics.cc:8516
+#: c/c-parser.cc:19315 cp/semantics.cc:8537
 #, gcc-internal-format
 msgid "%<num_teams%> lower bound %qE bigger than upper bound %qE"
 msgstr ""
 
-#: c/c-parser.cc:19364 cp/semantics.cc:8645
+#: c/c-parser.cc:19364 cp/semantics.cc:8666
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: c/c-parser.cc:19409 cp/semantics.cc:8773
+#: c/c-parser.cc:19409 cp/semantics.cc:8794
 #, fuzzy, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47144
+#: c/c-parser.cc:19521 c/c-parser.cc:23443 cp/parser.cc:47204
 #, fuzzy, gcc-internal-format
 msgid "expected %<allocator%> or %<align%>"
 msgstr "預期 %<,%>或 %<)%>"
 
 #: c/c-parser.cc:19528 c/c-parser.cc:19695 c/c-parser.cc:19737
-#: cp/parser.cc:44046
+#: cp/parser.cc:44106
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qs"
 msgid "duplicate %qs modifier"
 msgstr "重複的 %qs"
 
-#: c/c-parser.cc:19576 cp/semantics.cc:8906
+#: c/c-parser.cc:19576 cp/semantics.cc:8927
 #, gcc-internal-format
 msgid "%<allocate%> clause allocator expression has type %qT rather than %<omp_allocator_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:19587 cp/semantics.cc:8861 cp/semantics.cc:8877
+#: c/c-parser.cc:19587 cp/semantics.cc:8882 cp/semantics.cc:8898
 #, fuzzy, gcc-internal-format
 msgid "%<allocate%> clause %<align%> modifier argument needs to be positive constant power of two integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
@@ -53395,23 +53443,23 @@ msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 msgid "legacy %<%s(%s)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19813 cp/parser.cc:44108
+#: c/c-parser.cc:19813 cp/parser.cc:44168
 #, gcc-internal-format
 msgid "the specification of arguments to %<uses_allocators%> where each item is of the form %<allocator(traits)%> is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:19821 cp/parser.cc:44116
+#: c/c-parser.cc:19821 cp/parser.cc:44176
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause only accepts a single allocator when using modifiers"
 msgstr ""
 
-#: c/c-parser.cc:19955 cp/parser.cc:44326
+#: c/c-parser.cc:19955 cp/parser.cc:44386
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple linear modifiers"
 msgstr "重複的 cv 限定"
 
-#: c/c-parser.cc:19967 cp/parser.cc:44339
+#: c/c-parser.cc:19967 cp/parser.cc:44399
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple %<step%> modifiers"
@@ -53422,7 +53470,7 @@ msgstr "重複的 cv 限定"
 msgid "%<linear%> clause step expression must be integral"
 msgstr "排程資料塊大小運算式必須是積分"
 
-#: c/c-parser.cc:20037 cp/parser.cc:44462
+#: c/c-parser.cc:20037 cp/parser.cc:44522
 #, gcc-internal-format
 msgid "specifying the list items as arguments to the modifiers is deprecated since OpenMP 5.2"
 msgstr ""
@@ -53437,322 +53485,322 @@ msgstr "崩潰引數需要正面的常數整數運算式"
 msgid "%<simdlen%> clause expression must be positive constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: c/c-parser.cc:20463 cp/parser.cc:44917
+#: c/c-parser.cc:20463 cp/parser.cc:44977
 #, gcc-internal-format
 msgid "%<sink%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20472 cp/parser.cc:44926
+#: c/c-parser.cc:20472 cp/parser.cc:44986
 #, gcc-internal-format
 msgid "%<source%> modifier with %<depend%> clause deprecated since OpenMP 5.2, use with %<doacross%>"
 msgstr ""
 
-#: c/c-parser.cc:20489 cp/parser.cc:44943
+#: c/c-parser.cc:20489 cp/parser.cc:45003
 #, fuzzy, gcc-internal-format
 msgid "%<iterator%> modifier incompatible with %qs"
 msgstr "%qs 是不相容的與 %qs"
 
-#: c/c-parser.cc:20537 cp/parser.cc:44998 cp/parser.cc:45796 cp/parser.cc:45863
+#: c/c-parser.cc:20537 cp/parser.cc:45058
 #, fuzzy, gcc-internal-format
 msgid "invalid depend kind"
 msgstr "無效的排程 kind"
 
-#: c/c-parser.cc:20598 cp/parser.cc:45028
+#: c/c-parser.cc:20598 cp/parser.cc:45088
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid doacross kind"
 msgstr "無效遮罩"
 
-#: c/c-parser.cc:20633 cp/parser.cc:45229
+#: c/c-parser.cc:20633 cp/parser.cc:45289
 #, fuzzy, gcc-internal-format
 msgid "expected %<fallback%> modifier"
 msgstr "預期 %<;%>之後類別定義"
 
-#: c/c-parser.cc:20650 cp/parser.cc:45253
+#: c/c-parser.cc:20650 cp/parser.cc:45313
 #, gcc-internal-format
 msgid "expected %<abort%>, %<default_mem%>, or %<null%> as fallback mode"
 msgstr ""
 
-#: c/c-parser.cc:20679 cp/semantics.cc:8469
+#: c/c-parser.cc:20679 cp/semantics.cc:8490
 #, fuzzy, gcc-internal-format
 msgid "%<dyn_groupprivate%> value must be non-negative"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: c/c-parser.cc:20787 cp/parser.cc:45369
+#: c/c-parser.cc:20787 cp/parser.cc:45429
 #, fuzzy, gcc-internal-format
 msgid "illegal comma"
 msgstr "不合法的運算元偵測到"
 
-#: c/c-parser.cc:20797 cp/parser.cc:45379
+#: c/c-parser.cc:20797 cp/parser.cc:45439
 #, fuzzy, gcc-internal-format
 msgid "too many %<always%> modifiers"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:20808 cp/parser.cc:45393
+#: c/c-parser.cc:20808 cp/parser.cc:45453
 #, fuzzy, gcc-internal-format
 msgid "too many %<close%> modifiers"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45153
-#: cp/parser.cc:45407
+#: c/c-parser.cc:20819 c/c-parser.cc:21311 cp/parser.cc:45213
+#: cp/parser.cc:45467
 #, fuzzy, gcc-internal-format
 msgid "too many %<iterator%> modifiers"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:20835 cp/parser.cc:45427
+#: c/c-parser.cc:20835 cp/parser.cc:45487
 #, fuzzy, gcc-internal-format
 msgid "too many %<mapper%> modifiers"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:20855 cp/parser.cc:45453
+#: c/c-parser.cc:20855 cp/parser.cc:45513
 #, gcc-internal-format
 msgid "in %<declare mapper%> directives, parameter to %<mapper%> modifier must be %<default%>"
 msgstr ""
 
-#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45470
-#: cp/parser.cc:55509
+#: c/c-parser.cc:20871 c/c-parser.cc:29134 cp/parser.cc:45530
+#: cp/parser.cc:55569
 #, fuzzy, gcc-internal-format
 #| msgid "expected identifier or %<(%>"
 msgid "expected identifier or %<default%>"
 msgstr "需要識別碼或 %<(%>"
 
-#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45139
-#: cp/parser.cc:45492
+#: c/c-parser.cc:20889 c/c-parser.cc:21300 cp/parser.cc:45199
+#: cp/parser.cc:45552
 #, fuzzy, gcc-internal-format
 msgid "too many %<present%> modifiers"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:20898 cp/parser.cc:45504
+#: c/c-parser.cc:20898 cp/parser.cc:45564
 #, gcc-internal-format
 msgid "%<map%> clause with map-type modifier other than %<always%>, %<close%>, %<iterator%>, %<mapper%> or %<present%>"
 msgstr ""
 
-#: c/c-parser.cc:20910 cp/parser.cc:45519
+#: c/c-parser.cc:20910 cp/parser.cc:45579
 #, gcc-internal-format
 msgid "%<map%> clause modifiers without comma separation is deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:20945 cp/parser.cc:45553
+#: c/c-parser.cc:20945 cp/parser.cc:45613
 #, fuzzy, gcc-internal-format
 #| msgid "invalid mask"
 msgid "invalid map kind"
 msgstr "無效遮罩"
 
-#: c/c-parser.cc:21029 cp/parser.cc:45649
+#: c/c-parser.cc:21029 cp/parser.cc:45709
 #, gcc-internal-format
 msgid "%<ancestor%> device modifier not preceded by %<requires%> directive with %<reverse_offload%> clause"
 msgstr ""
 
-#: c/c-parser.cc:21041 cp/parser.cc:45660
+#: c/c-parser.cc:21041 cp/parser.cc:45720
 #, fuzzy, gcc-internal-format
 msgid "expected %<ancestor%> or %<device_num%>"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:21064 cp/semantics.cc:8670
+#: c/c-parser.cc:21064 cp/semantics.cc:8691
 #, fuzzy, gcc-internal-format
 msgid "the %<device%> clause expression must evaluate to %<1%>"
 msgstr "排程資料塊大小運算式必須是積分"
 
-#: c/c-parser.cc:21097 cp/parser.cc:45731
+#: c/c-parser.cc:21097 cp/parser.cc:45791
 #, fuzzy, gcc-internal-format
 msgid "invalid dist_schedule kind"
 msgstr "無效的排程 kind"
 
-#: c/c-parser.cc:21161 cp/parser.cc:45770
+#: c/c-parser.cc:21161 cp/parser.cc:45830
 #, gcc-internal-format
 msgid "%<master%> affinity deprecated since OpenMP 5.1, use %<primary%>"
 msgstr ""
 
-#: c/c-parser.cc:21184
+#: c/c-parser.cc:21184 cp/parser.cc:45856
 #, fuzzy, gcc-internal-format
 msgid "invalid proc_bind kind"
 msgstr "無效的排程 kind"
 
-#: c/c-parser.cc:21228
+#: c/c-parser.cc:21228 cp/parser.cc:45923
 #, fuzzy, gcc-internal-format
 msgid "expected %<host%>, %<nohost%> or %<any%>"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
-#: c/c-parser.cc:21321 cp/parser.cc:45168
+#: c/c-parser.cc:21321 cp/parser.cc:45228
 #, fuzzy, gcc-internal-format
 msgid "%qs clause with modifier other than %<iterator%> or %<present%>"
 msgstr "%qE 有無效的型態用於 %<reduction%>"
 
-#: c/c-parser.cc:21417 cp/semantics.cc:10084 cp/semantics.cc:10102
+#: c/c-parser.cc:21417 cp/semantics.cc:10105 cp/semantics.cc:10123
 #, fuzzy, gcc-internal-format
 msgid "%<partial%> argument needs positive constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: c/c-parser.cc:21518 cp/semantics.cc:9243
+#: c/c-parser.cc:21518 cp/semantics.cc:9264
 #, gcc-internal-format
 msgid "%<detach%> clause event handle has type %qT rather than %<omp_event_handle_t%>"
 msgstr ""
 
-#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45923
-#: cp/parser.cc:46035
+#: c/c-parser.cc:21589 c/c-parser.cc:21683 cp/parser.cc:45983
+#: cp/parser.cc:46095
 #, fuzzy, gcc-internal-format
 #| msgid "wide string literal in %<asm%>"
 msgid "string literal must not contain %<\\0%>"
 msgstr "%<asm%> 中出現寬字面字串"
 
-#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45930
-#: cp/parser.cc:46070
+#: c/c-parser.cc:21598 c/c-parser.cc:21719 cp/parser.cc:45990
+#: cp/parser.cc:46130
 #, fuzzy, gcc-internal-format
 msgid "unknown foreign runtime identifier %qs"
 msgstr "不明 TLS 式樣 %qs"
 
-#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:45945
-#: cp/parser.cc:46092
+#: c/c-parser.cc:21613 c/c-parser.cc:21742 cp/parser.cc:46005
+#: cp/parser.cc:46152
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression"
 msgstr "預期的整數運算式"
 
-#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:45953
-#: cp/parser.cc:46100 cp/semantics.cc:7747
+#: c/c-parser.cc:21621 c/c-parser.cc:21750 cp/parser.cc:46013
+#: cp/parser.cc:46160 cp/semantics.cc:7768
 #, gcc-internal-format
 msgid "unknown foreign runtime identifier %qwd"
 msgstr ""
 
-#: c/c-parser.cc:21659 cp/parser.cc:46012
+#: c/c-parser.cc:21659 cp/parser.cc:46072
 #, fuzzy, gcc-internal-format
 msgid "expected %<fr%> or %<attr%> preference selector"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:21667 cp/parser.cc:46020
+#: c/c-parser.cc:21667 cp/parser.cc:46080
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "duplicated %<fr%> preference selector"
 msgstr "重複的 %<const%>"
 
-#: c/c-parser.cc:21693 cp/parser.cc:46044
+#: c/c-parser.cc:21693 cp/parser.cc:46104
 #, gcc-internal-format
 msgid "%<attr%> string literal must start with %<ompx_%>"
 msgstr ""
 
-#: c/c-parser.cc:21701 cp/parser.cc:46051
+#: c/c-parser.cc:21701 cp/parser.cc:46111
 #, gcc-internal-format
 msgid "%<attr%> string literal must not contain a comma"
 msgstr ""
 
-#: c/c-parser.cc:21713 cp/parser.cc:46063
+#: c/c-parser.cc:21713 cp/parser.cc:46123
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "non-empty string literal expected"
 msgstr "需要字面字串"
 
-#: c/c-parser.cc:21823 cp/parser.cc:46203
+#: c/c-parser.cc:21823 cp/parser.cc:46263
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<targetsync%> modifier"
 msgstr "重複的 cv 限定"
 
-#: c/c-parser.cc:21830 cp/parser.cc:46210
+#: c/c-parser.cc:21830 cp/parser.cc:46270
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<target%> modifier"
 msgstr "重複的 cv 限定"
 
-#: c/c-parser.cc:21837 cp/parser.cc:46217
+#: c/c-parser.cc:21837 cp/parser.cc:46277
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %<const%>"
 msgid "duplicate %<prefer_type%> modifier"
 msgstr "重複的 %<const%>"
 
-#: c/c-parser.cc:21858 cp/parser.cc:46238
+#: c/c-parser.cc:21858 cp/parser.cc:46298
 #, fuzzy, gcc-internal-format
 msgid "expected %<prefer_type%>, %<target%>, or %<targetsync%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46275
-#: cp/parser.cc:53789
+#: c/c-parser.cc:21894 c/c-parser.cc:28222 cp/parser.cc:46335
+#: cp/parser.cc:53849
 #, gcc-internal-format
 msgid "missing required %<target%> and/or %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-parser.cc:22135 cp/parser.cc:46570
+#: c/c-parser.cc:22135 cp/parser.cc:46630
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenACC clause"
 msgstr "預期的指標"
 
 #: c/c-parser.cc:22146 c/c-parser.cc:22556 c/c-parser.cc:30589
-#: cp/parser.cc:46581 cp/parser.cc:47049 cp/parser.cc:54743
+#: cp/parser.cc:46641 cp/parser.cc:47109 cp/parser.cc:54803
 #, fuzzy, gcc-internal-format
 msgid "%qs is not valid for %qs"
 msgstr "%qs 無效用於 %qs"
 
-#: c/c-parser.cc:22191 cp/parser.cc:46629
+#: c/c-parser.cc:22191 cp/parser.cc:46689
 #, gcc-internal-format
 msgid "clauses in %<simd%> trait should be separated by %<,%>"
 msgstr ""
 
-#: c/c-parser.cc:22344 cp/parser.cc:46822
+#: c/c-parser.cc:22344 cp/parser.cc:46882
 #, fuzzy, gcc-internal-format
 msgid "%qs must be the first clause of %qs"
 msgstr "%qs 必須被使用與 %qs"
 
-#: c/c-parser.cc:22384 cp/parser.cc:46858
+#: c/c-parser.cc:22384 cp/parser.cc:46918
 #, gcc-internal-format
 msgid "%<to%> clause with %<declare target%> deprecated since OpenMP 5.2, use %<enter%>"
 msgstr ""
 
-#: c/c-parser.cc:22545 cp/parser.cc:47038
+#: c/c-parser.cc:22545 cp/parser.cc:47098
 #, fuzzy, gcc-internal-format
 msgid "expected an OpenMP clause"
 msgstr "預期的指標"
 
-#: c/c-parser.cc:22706 cp/parser.cc:52281
+#: c/c-parser.cc:22706 cp/parser.cc:52341
 #, gcc-internal-format
 msgid "no valid clauses specified in %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22716 cp/parser.cc:52291
+#: c/c-parser.cc:22716 cp/parser.cc:52351
 #, fuzzy, gcc-internal-format
 msgid "array section in %<#pragma acc declare%>"
 msgstr "陣列區段在中『%s』呼叫於 %L"
 
-#: c/c-parser.cc:22736 cp/parser.cc:52311
+#: c/c-parser.cc:22736 cp/parser.cc:52371
 #, gcc-internal-format
 msgid "%qD must be a global variable in %<#pragma acc declare link%>"
 msgstr ""
 
-#: c/c-parser.cc:22747 cp/parser.cc:52322
+#: c/c-parser.cc:22747 cp/parser.cc:52382
 #, fuzzy, gcc-internal-format
 msgid "invalid OpenACC clause at file scope"
 msgstr "無效的輸入宣告"
 
-#: c/c-parser.cc:22754 cp/parser.cc:52329
+#: c/c-parser.cc:22754 cp/parser.cc:52389
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
 msgstr "宣告的 %<extern%> 變數 %qD 在中 %<for%>迴圈初始宣告"
 
-#: c/c-parser.cc:22762 cp/parser.cc:52337
+#: c/c-parser.cc:22762 cp/parser.cc:52397
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<--%> on bool variable %qD"
 msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
 msgstr "對於 bool 變數 %qD 使用 %<--%> 無效"
 
-#: c/c-parser.cc:22773 cp/parser.cc:52359
+#: c/c-parser.cc:22773 cp/parser.cc:52419
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<--%> on bool variable %qD"
 msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>"
 msgstr "對於 bool 變數 %qD 使用 %<--%> 無效"
 
-#: c/c-parser.cc:22783 cp/parser.cc:52382
+#: c/c-parser.cc:22783 cp/parser.cc:52442
 #, gcc-internal-format
 msgid "variable %qD used more than once with %<#pragma acc declare%>"
 msgstr ""
 
-#: c/c-parser.cc:22876 cp/parser.cc:52466
+#: c/c-parser.cc:22876 cp/parser.cc:52526
 #, fuzzy, gcc-internal-format
 msgid "expected %<data%> after %<#pragma acc %s%>"
 msgstr "預期的字串之後 %<# pragma message%>"
 
-#: c/c-parser.cc:22892 cp/parser.cc:52483
+#: c/c-parser.cc:22892 cp/parser.cc:52543
 #, gcc-internal-format
 msgid "%<#pragma acc %s data%> has no data movement clause"
 msgstr ""
 
-#: c/c-parser.cc:22924 cp/parser.cc:52241
+#: c/c-parser.cc:22924 cp/parser.cc:52301
 #, gcc-internal-format
 msgid "%<host_data%> construct requires %<use_device%> clause"
 msgstr ""
@@ -53767,7 +53815,7 @@ msgstr "%qE 未被宣告"
 msgid "expected function name"
 msgstr "預期的函式"
 
-#: c/c-parser.cc:23175 cp/parser.cc:56273
+#: c/c-parser.cc:23175 cp/parser.cc:56333
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a function"
@@ -53778,22 +53826,22 @@ msgstr "%qD 不是一個成員範本函式"
 msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23238 cp/parser.cc:56324 cp/parser.cc:56371
+#: c/c-parser.cc:23238 cp/parser.cc:56384 cp/parser.cc:56431
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition"
 msgstr ""
 
-#: c/c-parser.cc:23269 cp/parser.cc:56399
+#: c/c-parser.cc:23269 cp/parser.cc:56459
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before use"
 msgstr ""
 
-#: c/c-parser.cc:23270 cp/parser.cc:56401
+#: c/c-parser.cc:23270 cp/parser.cc:56461
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma acc routine%> must be applied before definition"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 
-#: c/c-parser.cc:23315 cp/parser.cc:52699
+#: c/c-parser.cc:23315 cp/parser.cc:52759
 #, gcc-internal-format
 msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause"
 msgstr ""
@@ -53819,7 +53867,7 @@ msgstr ""
 msgid "modified here"
 msgstr "聯合定義的在此"
 
-#: c/c-parser.cc:23467 cp/parser.cc:47164 cp/parser.cc:47179
+#: c/c-parser.cc:23467 cp/parser.cc:47224 cp/parser.cc:47239
 #, fuzzy, gcc-internal-format
 msgid "%<align%> clause argument needs to be positive constant power of two integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
@@ -53854,111 +53902,111 @@ msgstr ""
 msgid "%<allocator%> clause requires a predefined allocator as %qD is static"
 msgstr ""
 
-#: c/c-parser.cc:23694 cp/parser.cc:47344
+#: c/c-parser.cc:23694 cp/parser.cc:47404
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, or %<capture%> clause"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
-#: c/c-parser.cc:23733 cp/parser.cc:47383
+#: c/c-parser.cc:23733 cp/parser.cc:47443
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acquire%> or %<relaxed%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:23757 cp/parser.cc:47412
+#: c/c-parser.cc:23757 cp/parser.cc:47472
 #, fuzzy, gcc-internal-format
 msgid "expected %<read%>, %<write%>, %<update%>, %<capture%>, %<compare%>, %<weak%>, %<fail%>, %<seq_cst%>, %<acq_rel%>, %<release%>, %<relaxed%> or %<hint%> clause"
 msgstr "預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>，%<min%>或 %<max%>expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>預期 %<+%>，%<*%>，%<-%>，%<&%>，%<^%>，%<|%>，%<&&%>，%<||%>，%<min%>或 %<max%>"
 
-#: c/c-parser.cc:23772 cp/parser.cc:47427
+#: c/c-parser.cc:23772 cp/parser.cc:47487
 #, fuzzy, gcc-internal-format
 msgid "too many atomic clauses"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:23779 cp/parser.cc:47434
+#: c/c-parser.cc:23779 cp/parser.cc:47494
 #, fuzzy, gcc-internal-format
 msgid "too many memory order clauses"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47472
-#: cp/parser.cc:47479
+#: c/c-parser.cc:23817 c/c-parser.cc:23824 cp/parser.cc:47532
+#: cp/parser.cc:47539
 #, fuzzy, gcc-internal-format
 msgid "%qs clause is incompatible with %<read%> or %<write%> clauses"
 msgstr "%qE 有無效的型態用於 %<reduction%>"
 
-#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47485
-#: cp/parser.cc:47490
+#: c/c-parser.cc:23830 c/c-parser.cc:23835 cp/parser.cc:47545
+#: cp/parser.cc:47550
 #, fuzzy, gcc-internal-format
 #| msgid "%qT referred to as %qs"
 msgid "%qs clause requires %qs clause"
 msgstr "%qT 做為 %qs 被參照"
 
-#: c/c-parser.cc:23858 cp/parser.cc:47513
+#: c/c-parser.cc:23858 cp/parser.cc:47573
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23869 cp/parser.cc:47524
+#: c/c-parser.cc:23869 cp/parser.cc:47584
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause implicitly provided by a %<requires%> directive"
 msgstr ""
 
-#: c/c-parser.cc:23901 cp/parser.cc:47556
+#: c/c-parser.cc:23901 cp/parser.cc:47616
 #, gcc-internal-format
 msgid "%<#pragma omp atomic read%> incompatible with %<release%> clause"
 msgstr ""
 
-#: c/c-parser.cc:23911 cp/parser.cc:47566
+#: c/c-parser.cc:23911 cp/parser.cc:47626
 #, gcc-internal-format
 msgid "%<#pragma omp atomic write%> incompatible with %<acquire%> clause"
 msgstr ""
 
-#: c/c-parser.cc:24032 cp/parser.cc:47666
+#: c/c-parser.cc:24032 cp/parser.cc:47726
 #, fuzzy, gcc-internal-format
 msgid "expected %<==%> comparison in %<if%> condition"
 msgstr "預期 %<;%>之後聯合定義"
 
-#: c/c-parser.cc:24039 cp/parser.cc:47673
+#: c/c-parser.cc:24039 cp/parser.cc:47733
 #, gcc-internal-format
 msgid "expected %<==%>, %<<%> or %<>%> comparison in %<if%> condition"
 msgstr ""
 
-#: c/c-parser.cc:24112 cp/parser.cc:47738 cp/parser.cc:48021 cp/parser.cc:48115
-#: cp/parser.cc:48133
+#: c/c-parser.cc:24112 cp/parser.cc:47798 cp/parser.cc:48081 cp/parser.cc:48175
+#: cp/parser.cc:48193
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic compare%>"
 msgstr "無效的表單的 %<# pragma omp atomic%>"
 
-#: c/c-parser.cc:24123 cp/parser.cc:47749
+#: c/c-parser.cc:24123 cp/parser.cc:47809
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<else%>"
 msgstr "預期 %<delete%>"
 
-#: c/c-parser.cc:24183 cp/parser.cc:48188
+#: c/c-parser.cc:24183 cp/parser.cc:48248
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<pragma omp atomic compare%>"
 msgstr "無效的表單的 %<# pragma omp atomic%>"
 
-#: c/c-parser.cc:24454 cp/parser.cc:48042 cp/parser.cc:48068
+#: c/c-parser.cc:24454 cp/parser.cc:48102 cp/parser.cc:48128
 #, fuzzy, gcc-internal-format
 msgid "invalid form of %<#pragma omp atomic%>"
 msgstr "無效的表單的 %<# pragma omp atomic%>"
 
-#: c/c-parser.cc:24458 cp/parser.cc:48108 cp/parser.cc:48142
+#: c/c-parser.cc:24458 cp/parser.cc:48168 cp/parser.cc:48202
 #, fuzzy, gcc-internal-format
 msgid "invalid operator for %<#pragma omp atomic%>"
 msgstr "無效的運算子用於 %<# pragma omp atomic%>"
 
-#: c/c-parser.cc:24509 cp/parser.cc:48177
+#: c/c-parser.cc:24509 cp/parser.cc:48237
 #, gcc-internal-format
 msgid "%<weak%> clause requires atomic equality comparison"
 msgstr ""
 
-#: c/c-parser.cc:24515 cp/semantics.cc:12395 cp/semantics.cc:12405
+#: c/c-parser.cc:24515 cp/semantics.cc:12416 cp/semantics.cc:12426
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
 msgstr "%<# pragma omp 基元的 capture%>使用兩不同的變數用於記憶體"
 
-#: c/c-parser.cc:24618 cp/semantics.cc:12482
+#: c/c-parser.cc:24618 cp/semantics.cc:12503
 #, fuzzy, gcc-internal-format
 msgid "%<depobj%> expression is not lvalue expression"
 msgstr "運算式 %qE 並非 constant-expression"
@@ -53968,28 +54016,28 @@ msgstr "運算式 %qE 並非 constant-expression"
 msgid "%<destroy%> expression is not lvalue expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: c/c-parser.cc:24667 cp/parser.cc:48330
+#: c/c-parser.cc:24667 cp/parser.cc:48390
 #, gcc-internal-format
 msgid "the %<destroy%> expression %qE should be the same as the %<depobj%> argument %qE"
 msgstr ""
 
-#: c/c-parser.cc:24698 cp/parser.cc:48366
+#: c/c-parser.cc:24698 cp/parser.cc:48426
 #, fuzzy, gcc-internal-format
 #| msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>"
 msgid "expected %<in%>, %<out%>, %<inout%>, %<mutexinoutset%> or %<inoutset%>"
 msgstr "需要 %<:%>，%<,%>，%<;%>，%<}%> 或 %<__attribute__%>"
 
-#: c/c-parser.cc:24710 cp/parser.cc:48382
+#: c/c-parser.cc:24710 cp/parser.cc:48442
 #, fuzzy, gcc-internal-format
 msgid "expected %<depend%>, %<destroy%> or %<update%> clause"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
-#: c/c-parser.cc:24751 cp/parser.cc:48420
+#: c/c-parser.cc:24751 cp/parser.cc:48480
 #, fuzzy, gcc-internal-format
 msgid "expected %<seq_cst%>, %<acq_rel%>, %<release%> or %<acquire%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:24759 cp/parser.cc:48428
+#: c/c-parser.cc:24759 cp/parser.cc:48488
 #, gcc-internal-format
 msgid "%<flush%> list specified together with memory order clause"
 msgstr ""
@@ -53999,32 +54047,32 @@ msgstr ""
 msgid "expected %<(%> or end of line"
 msgstr "預期 %<(%>或列尾"
 
-#: c/c-parser.cc:24835 cp/parser.cc:49166
+#: c/c-parser.cc:24835 cp/parser.cc:49226
 #, gcc-internal-format
 msgid "%<[[omp::directive(%s)]]%> must be the only specified attribute on a statement"
 msgstr ""
 
-#: c/c-parser.cc:24902 cp/parser.cc:49235
+#: c/c-parser.cc:24902 cp/parser.cc:49295
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero preceding executable statements"
 msgstr "%<# pragma omp taskwait%>也許會只有被已用於複合陳述"
 
-#: c/c-parser.cc:24936 cp/parser.cc:49268
+#: c/c-parser.cc:24936 cp/parser.cc:49328
 #, fuzzy, gcc-internal-format
 msgid "expected %<inclusive%> or %<exclusive%> clause"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:24941 cp/parser.cc:49274
+#: c/c-parser.cc:24941 cp/parser.cc:49334
 #, fuzzy, gcc-internal-format
 msgid "expected %<#pragma omp scan%>"
 msgstr "預期 %<# pragma omp%>子句"
 
-#: c/c-parser.cc:24950 cp/parser.cc:49283
+#: c/c-parser.cc:24950 cp/parser.cc:49343
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp scan%> with zero succeeding executable statements"
 msgstr "%<# pragma omp taskwait%>也許會只有被已用於複合陳述"
 
-#: c/c-parser.cc:24975 cp/parser.cc:49306
+#: c/c-parser.cc:24975 cp/parser.cc:49366
 #, fuzzy, gcc-internal-format
 msgid "for statement expected"
 msgstr "用於敘述預期"
@@ -54032,68 +54080,68 @@ msgstr "用於敘述預期"
 #. Don't call cp_parser_error here since it overrides the
 #. provided message with a more confusing one if there was
 #. a bad pragma or attribute directive.
-#: c/c-parser.cc:25004 cp/parser.cc:49328 cp/parser.cc:49330 cp/parser.cc:49515
+#: c/c-parser.cc:25004 cp/parser.cc:49388 cp/parser.cc:49390 cp/parser.cc:49575
 #, fuzzy, gcc-internal-format
 msgid "loop nest expected"
 msgstr "用於敘述預期"
 
-#: c/c-parser.cc:25056 cp/parser.cc:49403
+#: c/c-parser.cc:25056 cp/parser.cc:49463
 #, gcc-internal-format
 msgid "attributes other than OpenMP directives are not allowed on %<for%> in loop nest"
 msgstr ""
 
-#: c/c-parser.cc:25085 cp/parser.cc:49434
+#: c/c-parser.cc:25085 cp/parser.cc:49494
 #, gcc-internal-format
 msgid "%<unroll%> construct with %<partial%> clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25096 cp/parser.cc:49445
+#: c/c-parser.cc:25096 cp/parser.cc:49505
 #, gcc-internal-format
 msgid "generated loop of %<unroll%> construct without %<partial%> clause does not have canonical form"
 msgstr ""
 
-#: c/c-parser.cc:25119 cp/parser.cc:49471
+#: c/c-parser.cc:25119 cp/parser.cc:49531
 #, gcc-internal-format
 msgid "%<tile%> construct generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: c/c-parser.cc:25130 cp/parser.cc:49482
+#: c/c-parser.cc:25130 cp/parser.cc:49542
 #, gcc-internal-format
 msgid "expected %<for%> loop or OpenMP loop transformation construct"
 msgstr ""
 
-#: c/c-parser.cc:25218 cp/semantics.cc:11957 cp/semantics.cc:12050
+#: c/c-parser.cc:25218 cp/semantics.cc:11978 cp/semantics.cc:12071
 #, fuzzy, gcc-internal-format
 msgid "expected iteration declaration or initialization"
 msgstr "預期的迭代宣告或初始化"
 
-#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49809
-#: cp/parser.cc:49824
+#: c/c-parser.cc:25307 c/c-parser.cc:25322 cp/parser.cc:49869
+#: cp/parser.cc:49884
 #, fuzzy, gcc-internal-format
 msgid "not enough nested loops"
 msgstr "不足 perfectly 巢狀的迴圈"
 
-#: c/c-parser.cc:25425 cp/parser.cc:50117
+#: c/c-parser.cc:25425 cp/parser.cc:50177
 #, gcc-internal-format
 msgid "%<ordered%> clause parameter is less than %<collapse%>"
 msgstr ""
 
-#: c/c-parser.cc:25548 cp/parser.cc:49644 cp/parser.cc:49687 cp/pt.cc:19181
+#: c/c-parser.cc:25548 cp/parser.cc:49704 cp/parser.cc:49747 cp/pt.cc:19322
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be firstprivate"
 msgstr "迭代變數 %qD 不應為 firstprivate"
 
-#: c/c-parser.cc:25796 cp/parser.cc:50510
+#: c/c-parser.cc:25796 cp/parser.cc:50570
 #, gcc-internal-format
 msgid "%<master%> construct deprecated since OpenMP 5.1, use %<masked%>"
 msgstr ""
 
-#: c/c-parser.cc:25988 cp/parser.cc:50669
+#: c/c-parser.cc:25988 cp/parser.cc:50729
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp ordered%> with %qs clause may only be used in compound statements"
 msgstr "%<# pragma omp barrier%>也許會只有被已用於複合陳述"
 
-#: c/c-parser.cc:26204 cp/parser.cc:50875
+#: c/c-parser.cc:26204 cp/parser.cc:50935
 #, fuzzy, gcc-internal-format
 msgid "expected %<for%> after %qs"
 msgstr "預期 %<operator%>"
@@ -54103,7 +54151,7 @@ msgstr "預期 %<operator%>"
 msgid "expected a function name"
 msgstr "預期的函式"
 
-#: c/c-parser.cc:26439 cp/parser.cc:53409
+#: c/c-parser.cc:26439 cp/parser.cc:53469
 #, fuzzy, gcc-internal-format
 msgid "expected target-function call"
 msgstr "預期的函式"
@@ -54113,47 +54161,47 @@ msgstr "預期的函式"
 msgid "%<#pragma omp dispatch%> must be followed by a function call with optional assignment"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 
-#: c/c-parser.cc:26696 cp/parser.cc:51242
+#: c/c-parser.cc:26696 cp/parser.cc:51302
 #, fuzzy, gcc-internal-format
 msgid "expected %<point%>"
 msgstr "預期 %<using%>"
 
-#: c/c-parser.cc:26963 cp/parser.cc:51529
+#: c/c-parser.cc:26963 cp/parser.cc:51589
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:26979 cp/parser.cc:51545
+#: c/c-parser.cc:26979 cp/parser.cc:51605
 #, gcc-internal-format
 msgid "%<#pragma omp target data%> must contain at least one %<map%>, %<use_device_ptr%> or %<use_device_addr%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27027 cp/parser.cc:51826
+#: c/c-parser.cc:27027 cp/parser.cc:51886
 #, gcc-internal-format
 msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:27129 cp/parser.cc:51652
+#: c/c-parser.cc:27129 cp/parser.cc:51712
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> with map-type other than %<to%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27141 cp/parser.cc:51664
+#: c/c-parser.cc:27141 cp/parser.cc:51724
 #, gcc-internal-format
 msgid "%<#pragma omp target enter data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27240 cp/parser.cc:51769
+#: c/c-parser.cc:27240 cp/parser.cc:51829
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<tofrom%>, %<release%> or %<delete%> on %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27253 cp/parser.cc:51782
+#: c/c-parser.cc:27253 cp/parser.cc:51842
 #, gcc-internal-format
 msgid "%<#pragma omp target exit data%> must contain at least one %<map%> clause"
 msgstr ""
 
-#: c/c-parser.cc:27505 cp/semantics.cc:11460
+#: c/c-parser.cc:27505 cp/semantics.cc:11481
 #, gcc-internal-format
 msgid "%<#pragma omp target%> with map-type other than %<to%>, %<from%>, %<tofrom%> or %<alloc%> on %<map%> clause"
 msgstr ""
@@ -54168,60 +54216,60 @@ msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 
-#: c/c-parser.cc:27688 cp/parser.cc:52844
+#: c/c-parser.cc:27688 cp/parser.cc:52904
 #, fuzzy, gcc-internal-format
 msgid "expected trait selector name"
 msgstr "預期 selection-statement"
 
-#: c/c-parser.cc:27700 cp/parser.cc:52858
+#: c/c-parser.cc:27700 cp/parser.cc:52918
 #, fuzzy, gcc-internal-format
 msgid "unknown selector %qs for context selector set %qs"
 msgstr "不明運算子 %qs 在中 %%:version-compare"
 
-#: c/c-parser.cc:27728 cp/parser.cc:52887
+#: c/c-parser.cc:27728 cp/parser.cc:52947
 #, fuzzy, gcc-internal-format
 msgid "selector %qs does not accept any properties"
 msgstr "%s 只有接受 2 引數"
 
-#: c/c-parser.cc:27750 cp/parser.cc:52919
+#: c/c-parser.cc:27750 cp/parser.cc:52979
 #, fuzzy, gcc-internal-format
 #| msgid "%<friend%> can only be specified inside a class"
 msgid "%<score%> cannot be specified in traits in the %qs trait-selector-set"
 msgstr "%<friend%> 只能在類別中指定"
 
-#: c/c-parser.cc:27759 cp/parser.cc:52929 cp/pt.cc:18829
+#: c/c-parser.cc:27759 cp/parser.cc:52989 cp/pt.cc:18970
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: c/c-parser.cc:27762 cp/parser.cc:52932 cp/pt.cc:18836
+#: c/c-parser.cc:27762 cp/parser.cc:52992 cp/pt.cc:18977
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: c/c-parser.cc:27803 cp/parser.cc:52978
+#: c/c-parser.cc:27803 cp/parser.cc:53038
 #, fuzzy, gcc-internal-format
 #| msgid "expected string literal"
 msgid "expected identifier or string literal"
 msgstr "需要字面字串"
 
-#: c/c-parser.cc:27839 cp/parser.cc:53017 cp/pt.cc:18862
+#: c/c-parser.cc:27839 cp/parser.cc:53077 cp/pt.cc:19003
 #, fuzzy, gcc-internal-format
 msgid "property must be integer expression"
 msgstr "預期的整數運算式"
 
-#: c/c-parser.cc:27850 cp/parser.cc:53032
+#: c/c-parser.cc:27850 cp/parser.cc:53092
 #, fuzzy, gcc-internal-format
 msgid "properties for %<simd%> selector may not be specified in %<metadirective%>"
 msgstr "內容 %qs 已經指定的在中 %<@synthesize%>"
 
-#: c/c-parser.cc:27871 cp/parser.cc:53048 fortran/openmp.cc:6674
+#: c/c-parser.cc:27871 cp/parser.cc:53108 fortran/openmp.cc:6674
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<requires%> selector is not supported yet"
 msgstr "尚未支援程式碼模式 %<large%>"
 
-#: c/c-parser.cc:27930 cp/parser.cc:53111
+#: c/c-parser.cc:27930 cp/parser.cc:53171
 #, fuzzy, gcc-internal-format
 msgid "expected context selector set name"
 msgstr "預期 selection-statement"
@@ -54231,27 +54279,27 @@ msgstr "預期 selection-statement"
 msgid "variant %qD is not a function"
 msgstr "『%s』於 %L 並非函式"
 
-#: c/c-parser.cc:28009 cp/decl.cc:9307
+#: c/c-parser.cc:28009 cp/decl.cc:9321
 #, gcc-internal-format
 msgid "variant %qD is a built-in"
 msgstr ""
 
-#: c/c-parser.cc:28015 cp/decl.cc:9229
+#: c/c-parser.cc:28015 cp/decl.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "variant %qD is the same as base function"
 msgstr "『%s』於 %L 並非函式"
 
-#: c/c-parser.cc:28069 cp/parser.cc:53627
+#: c/c-parser.cc:28069 cp/parser.cc:53687
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>, %<adjust_args%> or %<append_args%> clause"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
-#: c/c-parser.cc:28085 cp/parser.cc:53640
+#: c/c-parser.cc:28085 cp/parser.cc:53700
 #, fuzzy, gcc-internal-format
 msgid "too many %<match%> clauses"
 msgstr "太多 %qs 子句"
 
-#: c/c-parser.cc:28147 cp/parser.cc:53716
+#: c/c-parser.cc:28147 cp/parser.cc:53776
 #, fuzzy, gcc-internal-format
 #| msgid "Array specification at %C has more than %d dimensions"
 msgid "%qD is specified more than once"
@@ -54262,7 +54310,7 @@ msgstr "%C 處陣列指定了多於 %d 的維數"
 msgid "%qD is not of pointer type"
 msgstr "%qD 並非變數"
 
-#: c/c-parser.cc:28174 cp/parser.cc:53749
+#: c/c-parser.cc:28174 cp/parser.cc:53809
 #, fuzzy, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%>"
 msgstr "預期 %<none%> 或 %<shared%>"
@@ -54272,17 +54320,17 @@ msgstr "預期 %<none%> 或 %<shared%>"
 msgid "%<need_device_addr%> is not valid for C"
 msgstr "%qs 無效用於 %qs"
 
-#: c/c-parser.cc:28184 cp/parser.cc:53756
+#: c/c-parser.cc:28184 cp/parser.cc:53816
 #, gcc-internal-format
 msgid "expected %<nothing%> or %<need_device_ptr%> followed by %<:%>"
 msgstr ""
 
-#: c/c-parser.cc:28204 cp/parser.cc:53773
+#: c/c-parser.cc:28204 cp/parser.cc:53833
 #, fuzzy, gcc-internal-format
 msgid "expected %<interop%>"
 msgstr "預期 %<using%>"
 
-#: c/c-parser.cc:28249 cp/parser.cc:53836
+#: c/c-parser.cc:28249 cp/parser.cc:53896
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%> clause"
 msgstr "預期 %<catch%>"
@@ -54302,12 +54350,12 @@ msgstr ""
 msgid "base function %qD declared here"
 msgstr "%qD 宣告的在此"
 
-#: c/c-parser.cc:28330 cp/decl.cc:9289
+#: c/c-parser.cc:28330 cp/decl.cc:9303
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qD must be of %<omp_interop_t%>"
 msgstr "引數 %d 的 %qE 必須是指標類型"
 
-#: c/c-parser.cc:28334 cp/decl.cc:9154 cp/decl.cc:9292
+#: c/c-parser.cc:28334 cp/decl.cc:9168 cp/decl.cc:9306
 #, fuzzy, gcc-internal-format
 msgid "%<append_args%> specified here"
 msgstr "%<long%> 和 %<short%>指定的一起用於 %qs"
@@ -54318,7 +54366,7 @@ msgstr "%<long%> 和 %<short%>指定的一起用於 %qs"
 msgid "variant %qD and base %qD have incompatible types after %<append_args%> adjustment"
 msgstr "-f%s 和 -msdata=%s 互不相容"
 
-#: c/c-parser.cc:28396 cp/decl.cc:9298
+#: c/c-parser.cc:28396 cp/decl.cc:9312
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "variant %qD and base %qD have incompatible types"
@@ -54329,7 +54377,7 @@ msgstr "-f%s 和 -msdata=%s 互不相容"
 msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 
-#: c/c-parser.cc:28467 cp/parser.cc:53886
+#: c/c-parser.cc:28467 cp/parser.cc:53946
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
@@ -54345,84 +54393,84 @@ msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 msgid "no declaration of base function %qs"
 msgstr "隱含宣告函式 %qE"
 
-#: c/c-parser.cc:28575 cp/parser.cc:25651
+#: c/c-parser.cc:28575 cp/parser.cc:25715
 #, fuzzy, gcc-internal-format
 msgid "variant function definition does not match declaration of %qE"
 msgstr "函式定義不宣告參數"
 
-#: c/c-parser.cc:28733 cp/parser.cc:54282
+#: c/c-parser.cc:28733 cp/parser.cc:54342
 #, gcc-internal-format
 msgid "use of %<omp declare target%> as a synonym for %<omp begin declare target%> has been deprecated since OpenMP 5.2"
 msgstr ""
 
-#: c/c-parser.cc:28770 cp/parser.cc:54175
+#: c/c-parser.cc:28770 cp/parser.cc:54235
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %qs clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-parser.cc:28774 cp/parser.cc:54179
+#: c/c-parser.cc:28774 cp/parser.cc:54239
 #, fuzzy, gcc-internal-format
 msgid "%qD specified both in declare target %<link%> and %<to%> or %<enter%> clauses"
 msgstr "%qE 有無效的型態用於 %<reduction%>"
 
-#: c/c-parser.cc:28834 cp/parser.cc:54317
+#: c/c-parser.cc:28834 cp/parser.cc:54377
 #, gcc-internal-format
 msgid "directive with only %<device_type%> or %<indirect%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:28837 cp/parser.cc:54320
+#: c/c-parser.cc:28837 cp/parser.cc:54380
 #, gcc-internal-format
 msgid "%<device_type%> clause must specify 'any' when used with an %<indirect%> clause"
 msgstr ""
 
-#: c/c-parser.cc:28901 cp/parser.cc:54390
+#: c/c-parser.cc:28901 cp/parser.cc:54450
 #, fuzzy, gcc-internal-format
 msgid "expected %<match%>"
 msgstr "預期 %<catch%>"
 
-#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54443
+#: c/c-parser.cc:28954 c/c-parser.cc:29056 cp/parser.cc:54503
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%> or %<variant%>"
 msgstr "預期 %<none%> 或 %<shared%>"
 
-#: c/c-parser.cc:28968 cp/parser.cc:54456
+#: c/c-parser.cc:28968 cp/parser.cc:54516
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare target%>, %<declare variant%>, or %<assumes%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:29001 cp/parser.cc:54494
+#: c/c-parser.cc:29001 cp/parser.cc:54554
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%> or %<#pragma omp begin declare target%>"
 msgstr "%<# pragma GCC pop_options%>而無需相應 %<# pragma GCC push_options%>"
 
-#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54505
-#: cp/parser.cc:54570
+#: c/c-parser.cc:29012 c/c-parser.cc:29077 cp/parser.cc:54565
+#: cp/parser.cc:54630
 #, gcc-internal-format
 msgid "%qs in attribute syntax terminated with %qs in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54512
-#: cp/parser.cc:54575
+#: c/c-parser.cc:29019 c/c-parser.cc:29082 cp/parser.cc:54572
+#: cp/parser.cc:54635
 #, fuzzy, gcc-internal-format
 msgid "%qs in pragma syntax terminated with %qs in attribute syntax"
 msgstr "%s 屬性與 %s 屬性在 %L 處衝突"
 
-#: c/c-parser.cc:29033 cp/parser.cc:54526
+#: c/c-parser.cc:29033 cp/parser.cc:54586
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp end declare variant%> without corresponding %<#pragma omp begin declare variant%>"
 msgstr "%<# pragma GCC pop_options%>而無需相應 %<# pragma GCC push_options%>"
 
-#: c/c-parser.cc:29043 cp/parser.cc:54536
+#: c/c-parser.cc:29043 cp/parser.cc:54596
 #, gcc-internal-format
 msgid "%<begin declare variant%> in attribute syntax terminated with %<end declare variant%> in pragma syntax"
 msgstr ""
 
-#: c/c-parser.cc:29048 cp/parser.cc:54541
+#: c/c-parser.cc:29048 cp/parser.cc:54601
 #, gcc-internal-format
 msgid "%<begin declare variant%> in pragma syntax terminated with %<end declare variant%> in attribute syntax"
 msgstr ""
 
-#: c/c-parser.cc:29090 cp/parser.cc:54583
+#: c/c-parser.cc:29090 cp/parser.cc:54643
 #, fuzzy, gcc-internal-format
 msgid "expected %<declare%> or %<assumes%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
@@ -54449,12 +54497,12 @@ msgstr "%qD 的宣告隱藏了一個全域宣告"
 msgid "%<#pragma omp declare mapper%> previously declared here"
 msgstr "%q#T 是在之前宣告的在此"
 
-#: c/c-parser.cc:29206 cp/parser.cc:55578
+#: c/c-parser.cc:29206 cp/parser.cc:55638
 #, fuzzy, gcc-internal-format
 msgid "unexpected clause"
 msgstr "預期 class-key"
 
-#: c/c-parser.cc:29214 cp/parser.cc:55589
+#: c/c-parser.cc:29214 cp/parser.cc:55649
 #, fuzzy, gcc-internal-format
 msgid "missing %<map%> clause"
 msgstr "缺少PHI def"
@@ -54515,32 +54563,32 @@ msgstr ""
 msgid "expected %<simd%>, %<reduction%>, %<target%> or %<variant%>"
 msgstr "預期 %<# pragma omp section%>或 %<}%>"
 
-#: c/c-parser.cc:29728 cp/parser.cc:55784
+#: c/c-parser.cc:29728 cp/parser.cc:55844
 #, fuzzy, gcc-internal-format
 msgid "expected %<acq_rel%>, %<acquire%>, %<relaxed%>, %<release%> or %<seq_cst%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: c/c-parser.cc:29757 cp/parser.cc:55819
+#: c/c-parser.cc:29757 cp/parser.cc:55879
 #, gcc-internal-format
 msgid "expected %<unified_address%>, %<unified_shared_memory%>, %<self_maps%>, %<dynamic_allocators%>, %<reverse_offload%> or %<atomic_default_mem_order%> clause"
 msgstr ""
 
-#: c/c-parser.cc:29776 cp/parser.cc:55838
+#: c/c-parser.cc:29776 cp/parser.cc:55898
 #, gcc-internal-format
 msgid "%qs clause used lexically after first target construct or offloading API"
 msgstr ""
 
-#: c/c-parser.cc:29788 cp/parser.cc:55850
+#: c/c-parser.cc:29788 cp/parser.cc:55910
 #, gcc-internal-format
 msgid "more than one %<atomic_default_mem_order%> clause in a single compilation unit"
 msgstr ""
 
-#: c/c-parser.cc:29797 cp/parser.cc:55859
+#: c/c-parser.cc:29797 cp/parser.cc:55919
 #, gcc-internal-format
 msgid "%<atomic_default_mem_order%> clause used lexically after first %<atomic%> construct without memory order clause"
 msgstr ""
 
-#: c/c-parser.cc:29811 cp/parser.cc:55873
+#: c/c-parser.cc:29811 cp/parser.cc:55933
 #, gcc-internal-format
 msgid "%<pragma omp requires%> requires at least one clause"
 msgstr ""
@@ -54555,161 +54603,161 @@ msgstr ""
 msgid "variable sized type %qT in %<reduction%> clause"
 msgstr "%qE 有無效的型態用於 %<reduction%>"
 
-#: c/c-parser.cc:29954 cp/parser.cc:52050
+#: c/c-parser.cc:29954 cp/parser.cc:52110
 #, fuzzy, gcc-internal-format
 msgid "expected %<sizes%>"
 msgstr "預期 %<while%>"
 
-#: c/c-parser.cc:29983 cp/semantics.cc:9986 cp/semantics.cc:10003
+#: c/c-parser.cc:29983 cp/semantics.cc:10007 cp/semantics.cc:10024
 #, fuzzy, gcc-internal-format
 msgid "%<sizes%> argument needs positive integral constant"
 msgstr "%qE 屬性引數不是整數常數"
 
-#: c/c-parser.cc:30099 cp/parser.cc:55930
+#: c/c-parser.cc:30099 cp/parser.cc:55990
 #, fuzzy, gcc-internal-format
 msgid "expected %<at%>, %<severity%> or %<message%> clause"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
-#: c/c-parser.cc:30132 cp/parser.cc:55965
+#: c/c-parser.cc:30132 cp/parser.cc:56025
 #, fuzzy, gcc-internal-format
 msgid "expected %qs or %qs"
 msgstr "預期 %<,%>或 %<)%>"
 
-#: c/c-parser.cc:30189 cp/parser.cc:56027
+#: c/c-parser.cc:30189 cp/parser.cc:56087
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may only be used in compound statements"
 msgstr "%<# pragma omp barrier%>也許會只有被已用於複合陳述"
 
-#: c/c-parser.cc:30196 cp/parser.cc:56034
+#: c/c-parser.cc:30196 cp/parser.cc:56094
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp error%> with %<at(execution)%> clause may not be used in intervening code"
 msgstr "%<# pragma omp barrier%>也許會只有被已用於複合陳述"
 
-#: c/c-parser.cc:30223 cp/parser.cc:56065
+#: c/c-parser.cc:30223 cp/parser.cc:56125
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered: %s"
 msgstr ""
 
-#: c/c-parser.cc:30226 cp/parser.cc:56068
+#: c/c-parser.cc:30226 cp/parser.cc:56128
 #, gcc-internal-format
 msgid "%<pragma omp error%> encountered"
 msgstr ""
 
-#: c/c-parser.cc:30257 cp/parser.cc:53176
+#: c/c-parser.cc:30257 cp/parser.cc:53236
 #, fuzzy, gcc-internal-format
 msgid "expected at least one assumption clause"
 msgstr "Cray 指標『%s』在中 %s 子句於 %L"
 
-#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53269
-#: cp/parser.cc:54812 cp/parser.cc:54839
+#: c/c-parser.cc:30350 c/c-parser.cc:30657 cp/parser.cc:53329
+#: cp/parser.cc:54872 cp/parser.cc:54899
 #, fuzzy, gcc-internal-format
 msgid "expected directive name"
 msgstr "預期的函式"
 
-#: c/c-parser.cc:30362 cp/parser.cc:53281
+#: c/c-parser.cc:30362 cp/parser.cc:53341
 #, gcc-internal-format
 msgid "invalid OpenMP directive name in %qs clause argument: declarative, informational, and meta directives not permitted"
 msgstr ""
 
-#: c/c-parser.cc:30370 cp/parser.cc:53289
+#: c/c-parser.cc:30370 cp/parser.cc:53349
 #, gcc-internal-format
 msgid "unknown OpenMP directive name in %qs clause argument"
 msgstr ""
 
-#: c/c-parser.cc:30377 cp/parser.cc:53296
+#: c/c-parser.cc:30377 cp/parser.cc:53356
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned in both %<absent%> and %<contains%> clauses"
 msgstr ""
 
-#: c/c-parser.cc:30388 cp/parser.cc:53307
+#: c/c-parser.cc:30388 cp/parser.cc:53367
 #, gcc-internal-format
 msgid "%<%s%s%s%s%s%> directive mentioned multiple times in %qs clauses"
 msgstr ""
 
-#: c/c-parser.cc:30411 cp/parser.cc:53334
+#: c/c-parser.cc:30411 cp/parser.cc:53394
 #, fuzzy, gcc-internal-format
 msgid "unknown assumption clause %qs"
 msgstr "不明 spec 函式 %qs"
 
-#: c/c-parser.cc:30424 cp/parser.cc:53344
+#: c/c-parser.cc:30424 cp/parser.cc:53404
 #, fuzzy, gcc-internal-format
 msgid "expected assumption clause"
 msgstr "預期的指標"
 
-#: c/c-parser.cc:30553 cp/parser.cc:54705
+#: c/c-parser.cc:30553 cp/parser.cc:54765
 #, fuzzy, gcc-internal-format
 msgid "expected %<when%>, %<otherwise%>, or %<default%> clause"
 msgstr "預期 %<;%>，%<,%>或 %<)%>"
 
-#: c/c-parser.cc:30565 cp/parser.cc:54718
+#: c/c-parser.cc:30565 cp/parser.cc:54778
 #, gcc-internal-format
 msgid "%<default%> clause on metadirectives deprecated since OpenMP 5.2, use %<otherwise%>"
 msgstr ""
 
-#: c/c-parser.cc:30575 cp/parser.cc:54728
+#: c/c-parser.cc:30575 cp/parser.cc:54788
 #, gcc-internal-format
 msgid "too many %<otherwise%> or %<default%> clauses in %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30583 cp/parser.cc:54737
+#: c/c-parser.cc:30583 cp/parser.cc:54797
 #, fuzzy, gcc-internal-format
 msgid "%<otherwise%> or %<default%> clause must appear last in %<metadirective%>"
 msgstr "內容 %qs 已經指定的在中 %<@synthesize%>"
 
-#: c/c-parser.cc:30670 cp/parser.cc:54825
+#: c/c-parser.cc:30670 cp/parser.cc:54885
 #, fuzzy, gcc-internal-format
 #| msgid "unknown register name: %s"
 msgid "unknown directive name"
 msgstr "不明的暫存器名：%s"
 
-#: c/c-parser.cc:30685 cp/parser.cc:54845
+#: c/c-parser.cc:30685 cp/parser.cc:54905
 #, gcc-internal-format
 msgid "metadirectives cannot be used as variants of a %<metadirective%>"
 msgstr ""
 
-#: c/c-parser.cc:30691 cp/parser.cc:54851
+#: c/c-parser.cc:30691 cp/parser.cc:54911
 #, gcc-internal-format
 msgid "declarative directive variants of a %<metadirective%> are not supported"
 msgstr ""
 
-#: c/c-parser.cc:31023 cp/parser.cc:51178
+#: c/c-parser.cc:31023 cp/parser.cc:51238
 #, gcc-internal-format
 msgid "%<omp groupprivate%>"
 msgstr ""
 
-#: c/c-parser.cc:31049 cp/semantics.cc:10764
+#: c/c-parser.cc:31049 cp/semantics.cc:10785
 #, fuzzy, gcc-internal-format
 msgid "%qE declared %<threadprivate%> after first use"
 msgstr "%qE 宣告 %<threadprivate%> 之後先使用"
 
-#: c/c-parser.cc:31051 cp/semantics.cc:10766
+#: c/c-parser.cc:31051 cp/semantics.cc:10787
 #, fuzzy, gcc-internal-format
 msgid "automatic variable %qE cannot be %<threadprivate%>"
 msgstr "自動變數 %qE 無法 %<threadprivate%>"
 
-#: c/c-parser.cc:31055 cp/semantics.cc:10768
+#: c/c-parser.cc:31055 cp/semantics.cc:10789
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE has incomplete type"
 msgstr "%<threadprivate%> %qE 有不完整型態"
 
-#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56696
-#: cp/semantics.cc:12642
+#: c/c-parser.cc:31136 c/c-parser.cc:31205 cp/parser.cc:56756
+#: cp/semantics.cc:12663
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_atomic%> without transactional memory support enabled"
 msgstr "%<__transaction_atomic%>而無需 transactional 記憶體支援已啟用"
 
-#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56694
-#: cp/semantics.cc:12640
+#: c/c-parser.cc:31138 c/c-parser.cc:31207 cp/parser.cc:56754
+#: cp/semantics.cc:12661
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_relaxed%> without transactional memory support enabled"
 msgstr "%<__transaction_relaxed%>而無需 transactional 記憶體支援已啟用"
 
-#: c/c-parser.cc:31239 cp/parser.cc:56827
+#: c/c-parser.cc:31239 cp/parser.cc:56887
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> without transactional memory support enabled"
 msgstr "%<__transaction_cancel%>而無需 transactional 記憶體支援已啟用"
 
-#: c/c-parser.cc:31245 cp/parser.cc:56833
+#: c/c-parser.cc:31245 cp/parser.cc:56893
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
 msgstr "%<__transaction_cancel%>在之內 %<__transaction_relaxed%>"
@@ -54719,7 +54767,7 @@ msgstr "%<__transaction_cancel%>在之內 %<__transaction_relaxed%>"
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a %<transaction_may_cancel_outer%> function"
 msgstr "%<transaction_may_cancel_outer%> 函式呼叫無法在之內外異動作業或 %<transaction_may_cancel_outer%>"
 
-#: c/c-parser.cc:31262 cp/parser.cc:56851
+#: c/c-parser.cc:31262 cp/parser.cc:56911
 #, fuzzy, gcc-internal-format
 msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
 msgstr "%<__transaction_cancel%>無法在之內 %<__transaction_atomic%>"
@@ -54735,7 +54783,7 @@ msgstr "封閉平行"
 msgid "%qD has an incomplete type %qT"
 msgstr "%qD 類型不完全"
 
-#: c/c-typeck.cc:260 c/c-typeck.cc:13154 c/c-typeck.cc:13228 cp/call.cc:5129
+#: c/c-typeck.cc:260 c/c-typeck.cc:13162 c/c-typeck.cc:13236 cp/call.cc:5129
 #, gcc-internal-format
 msgid "invalid use of void expression"
 msgstr "對 void 運算式的無效使用"
@@ -54768,172 +54816,172 @@ msgstr "對不完全的 typedef %qD 的無效使用"
 msgid "%qT and %qT are in disjoint named address spaces"
 msgstr "%qT 和 %qT 是在中 disjoint 具名的位址空間"
 
-#: c/c-typeck.cc:657
+#: c/c-typeck.cc:663
 #, fuzzy, gcc-internal-format
 msgid "%qs attribute can only be applied to variadic functions"
 msgstr "%qs 屬性只有套用到 variadic 函式"
 
-#: c/c-typeck.cc:730
+#: c/c-typeck.cc:736
 #, gcc-internal-format
 msgid "function types not truly compatible in ISO C"
 msgstr "函式類型與 ISO C 不完全相容"
 
-#: c/c-typeck.cc:1218
+#: c/c-typeck.cc:1224
 #, fuzzy, gcc-internal-format
 msgid "cannot mix operands of decimal floating and vector types"
 msgstr "can%'t 混合運算元的十進位浮點數和向量類型"
 
-#: c/c-typeck.cc:1223
+#: c/c-typeck.cc:1229
 #, fuzzy, gcc-internal-format
 msgid "cannot mix operands of decimal floating and complex types"
 msgstr "can%'t 混合運算元的十進位浮點數和複雜類型"
 
-#: c/c-typeck.cc:1228
+#: c/c-typeck.cc:1234
 #, fuzzy, gcc-internal-format
 msgid "cannot mix operands of decimal floating and other floating types"
 msgstr "can%'t 混合運算元的十進位浮點數和其他浮點數類型"
 
-#: c/c-typeck.cc:1258
+#: c/c-typeck.cc:1264
 #, gcc-internal-format
 msgid "%<_Complex _BitInt(%d)%> unsupported"
 msgstr ""
 
-#: c/c-typeck.cc:1907
+#: c/c-typeck.cc:1913
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pointers to arrays with different qualifiers in ISO C before C23"
 msgstr "指標目標類型不相容的在中 C++"
 
-#: c/c-typeck.cc:1911
+#: c/c-typeck.cc:1917
 #, gcc-internal-format
 msgid "types are not quite compatible"
 msgstr "類型不完全相容"
 
-#: c/c-typeck.cc:1915
+#: c/c-typeck.cc:1921
 #, fuzzy, gcc-internal-format
 msgid "pointer target types incompatible in C++"
 msgstr "指標目標類型不相容的在中 C++"
 
-#: c/c-typeck.cc:2133
+#: c/c-typeck.cc:2139
 #, gcc-internal-format
 msgid "function return types not compatible due to %<volatile%>"
 msgstr "由於 %<volatile%>，函式回傳類型不相容"
 
-#: c/c-typeck.cc:2348
+#: c/c-typeck.cc:2354
 #, fuzzy, gcc-internal-format
 msgid "converting an array compound literal to a pointer leads to a dangling pointer in C++"
 msgstr "轉換陣列複合實字到指標被不當形式的在中 C++"
 
-#: c/c-typeck.cc:3128
+#: c/c-typeck.cc:3134
 #, fuzzy, gcc-internal-format
 #| msgid "%Jinvalid use of structure with flexible array member"
 msgid "%<counted_by%> attribute is not allowed for a pointer to structure or union with flexible array member"
 msgstr "%J對包含彈性陣列成員的結構的無效使用"
 
-#: c/c-typeck.cc:3370 c/c-typeck.cc:11302
+#: c/c-typeck.cc:3378 c/c-typeck.cc:11310
 #, fuzzy, gcc-internal-format
 #| msgid "%qT has no member named %qE"
 msgid "%qT has no member named %qE; did you mean %qE?"
 msgstr "%qT 沒具名為 %qE 的成員"
 
-#: c/c-typeck.cc:3374 c/c-typeck.cc:11306
+#: c/c-typeck.cc:3382 c/c-typeck.cc:11314
 #, gcc-internal-format
 msgid "%qT has no member named %qE"
 msgstr "%qT 沒具名為 %qE 的成員"
 
-#: c/c-typeck.cc:3383
+#: c/c-typeck.cc:3391
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic structure %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3386
+#: c/c-typeck.cc:3394
 #, gcc-internal-format
 msgid "accessing a member %qE of an atomic union %qE"
 msgstr ""
 
-#: c/c-typeck.cc:3453
+#: c/c-typeck.cc:3461
 #, gcc-internal-format
 msgid "%qE is a pointer to pointer; did you mean to dereference it before applying %<->%> to it?"
 msgstr ""
 
-#: c/c-typeck.cc:3462
+#: c/c-typeck.cc:3470
 #, gcc-internal-format
 msgid "%qE is a pointer; did you mean to use %<->%>?"
 msgstr ""
 
-#: c/c-typeck.cc:3469
+#: c/c-typeck.cc:3477
 #, gcc-internal-format
 msgid "request for member %qE in something not a structure or union"
 msgstr "在非結構或聯合中請求成員 %qE"
 
-#: c/c-typeck.cc:3517
+#: c/c-typeck.cc:3525
 #, gcc-internal-format
 msgid "dereferencing %<void *%> pointer"
 msgstr "提領 %<void *%> 指標"
 
-#: c/c-typeck.cc:3572
+#: c/c-typeck.cc:3580
 #, fuzzy, gcc-internal-format
 msgid "subscripted value is neither array nor pointer nor vector"
 msgstr "註標的值是 neither 陣列 nor 指標 nor 向量"
 
-#: c/c-typeck.cc:3582 cp/typeck.cc:4273 cp/typeck.cc:4367
+#: c/c-typeck.cc:3590 cp/typeck.cc:4268 cp/typeck.cc:4362
 #, gcc-internal-format
 msgid "array subscript is not an integer"
 msgstr "陣列下標不是一個整數"
 
-#: c/c-typeck.cc:3588
+#: c/c-typeck.cc:3596
 #, gcc-internal-format
 msgid "subscripted value is pointer to function"
 msgstr "下標運算的左運算元是函式指標"
 
-#: c/c-typeck.cc:3643
+#: c/c-typeck.cc:3651
 #, fuzzy, gcc-internal-format
 #| msgid "array subscript is not an integer"
 msgid "array subscript is negative"
 msgstr "陣列下標不是一個整數"
 
-#: c/c-typeck.cc:3656
+#: c/c-typeck.cc:3664
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C forbids subscripting %<register%> array"
 msgid "ISO C forbids subscripting %<register%> array before C2Y"
 msgstr "ISO C 不允許按下標存取 %<register%> 陣列"
 
-#: c/c-typeck.cc:3660
+#: c/c-typeck.cc:3668
 #, gcc-internal-format
 msgid "ISO C90 forbids subscripting non-lvalue array"
 msgstr "ISO C90 不允許非左值的陣列做為下標運算的左運算元"
 
-#: c/c-typeck.cc:3865
+#: c/c-typeck.cc:3873
 #, fuzzy, gcc-internal-format
 #| msgid "%qD declared as reference but not initialized"
 msgid "underspecified %qD referenced in its initializer"
 msgstr "%qD 宣告為參照卻未被初始化"
 
-#: c/c-typeck.cc:3910
+#: c/c-typeck.cc:3918
 #, fuzzy, gcc-internal-format
 msgid "enum constant defined in struct or union is not visible in C++"
 msgstr "enum 轉換在中初始化無效在中 C++"
 
-#: c/c-typeck.cc:3912
+#: c/c-typeck.cc:3920
 #, fuzzy, gcc-internal-format
 msgid "enum constant defined here"
 msgstr "enum 常數定義的在此"
 
-#: c/c-typeck.cc:4031 cp/typeck.cc:2277
+#: c/c-typeck.cc:4039 cp/typeck.cc:2277
 #, gcc-internal-format
 msgid "%<sizeof%> on array function parameter %qE will return size of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:4374
+#: c/c-typeck.cc:4382
 #, fuzzy, gcc-internal-format
 msgid "called object %qE is not a function or function pointer"
 msgstr "被呼叫的物件 %qE 不是一個函式"
 
-#: c/c-typeck.cc:4380
+#: c/c-typeck.cc:4388
 #, fuzzy, gcc-internal-format
 msgid "called object %qD is not a function or function pointer"
 msgstr "被呼叫的物件 %qE 不是一個函式"
 
-#: c/c-typeck.cc:4386
+#: c/c-typeck.cc:4394
 #, fuzzy, gcc-internal-format
 msgid "called object is not a function or function pointer"
 msgstr "被呼叫的物件 %qE 不是一個函式"
@@ -54941,1933 +54989,1933 @@ msgstr "被呼叫的物件 %qE 不是一個函式"
 #. This situation leads to run-time undefined behavior.  We can't,
 #. therefore, simply error unless we can prove that all possible
 #. executions of the program must execute the code.
-#: c/c-typeck.cc:4415
+#: c/c-typeck.cc:4423
 #, gcc-internal-format
 msgid "function called through a non-compatible type"
 msgstr "函式經由不相容的類型呼叫"
 
-#: c/c-typeck.cc:4420 c/c-typeck.cc:4476
+#: c/c-typeck.cc:4428 c/c-typeck.cc:4484
 #, fuzzy, gcc-internal-format
 msgid "function with qualified void return type called"
 msgstr "函式與經資格修飾虛值傳回類型 called"
 
-#: c/c-typeck.cc:4531
+#: c/c-typeck.cc:4539
 #, gcc-internal-format, gfc-internal-format
 msgid "type of formal parameter %d is incomplete"
 msgstr "引數 %d 的類型不完全"
 
-#: c/c-typeck.cc:4543
+#: c/c-typeck.cc:4551
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than floating due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為整數而不是浮點數傳遞"
 
-#: c/c-typeck.cc:4549
+#: c/c-typeck.cc:4557
 #, gcc-internal-format
 msgid "passing argument %d of %qE as integer rather than complex due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為整數而不是複數傳遞"
 
-#: c/c-typeck.cc:4555
+#: c/c-typeck.cc:4563
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than floating due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為複數而不是浮點數傳遞"
 
-#: c/c-typeck.cc:4561
+#: c/c-typeck.cc:4569
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than integer due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為浮點數而不是整數傳遞"
 
-#: c/c-typeck.cc:4567
+#: c/c-typeck.cc:4575
 #, gcc-internal-format
 msgid "passing argument %d of %qE as complex rather than integer due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為複數而不是整數傳遞"
 
-#: c/c-typeck.cc:4573
+#: c/c-typeck.cc:4581
 #, gcc-internal-format
 msgid "passing argument %d of %qE as floating rather than complex due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為浮點數而不是複數傳遞"
 
-#: c/c-typeck.cc:4589
+#: c/c-typeck.cc:4597
 #, gcc-internal-format
 msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為 %<float%> 而不是 %<double%> 傳遞"
 
-#: c/c-typeck.cc:4615
+#: c/c-typeck.cc:4623
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
 msgstr "傳遞引數 %d 的 %qE 做為 %qT 而非 %qT 由於原型"
 
-#: c/c-typeck.cc:4641
+#: c/c-typeck.cc:4649
 #, gcc-internal-format
 msgid "passing argument %d of %qE with different width due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將以不同的寬度傳遞"
 
-#: c/c-typeck.cc:4665
+#: c/c-typeck.cc:4673
 #, gcc-internal-format
 msgid "passing argument %d of %qE as unsigned due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將作用無號數傳遞"
 
-#: c/c-typeck.cc:4670
+#: c/c-typeck.cc:4678
 #, gcc-internal-format
 msgid "passing argument %d of %qE as signed due to prototype"
 msgstr "根據原型，引數 %d (%qE) 將做為有號數傳遞"
 
-#: c/c-typeck.cc:4838
+#: c/c-typeck.cc:4846
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %qE; expected %i, have %i"
 msgstr "太多引數到方法 %qE"
 
-#: c/c-typeck.cc:4842
+#: c/c-typeck.cc:4850
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to function %qE; expected %i, have %i"
 msgstr "提供給函式 %qE 的引數太多"
 
-#: c/c-typeck.cc:4852
+#: c/c-typeck.cc:4860
 #, fuzzy, gcc-internal-format
 #| msgid "too many arguments to function %qE"
 msgid "too many arguments to built-in function %qE expecting %d"
 msgstr "提供給函式 %qE 的引數太多"
 
-#: c/c-typeck.cc:4865
+#: c/c-typeck.cc:4873
 #, gcc-internal-format
 msgid "ISO C23 does not allow arguments for method %qE declared without parameters"
 msgstr ""
 
-#: c/c-typeck.cc:4870
+#: c/c-typeck.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "ISO C23 does not allow arguments for function %qE declared without parameters"
 msgstr "內聯函式 %q+D 宣告的 weak"
 
-#: c/c-typeck.cc:4949
+#: c/c-typeck.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT when passing argument to function"
 msgstr "隱含轉換從 %qT 到 %qT 時傳遞引數到函式"
 
-#: c/c-typeck.cc:5030
+#: c/c-typeck.cc:5038
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected at least %i, have %i"
 msgstr "提供給函式 %qE 的引數太少"
 
-#: c/c-typeck.cc:5031
+#: c/c-typeck.cc:5039
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to function %qE; expected %i, have %i"
 msgstr "提供給函式 %qE 的引數太少"
 
-#: c/c-typeck.cc:5045
+#: c/c-typeck.cc:5053
 #, fuzzy, gcc-internal-format
 #| msgid "too few arguments to function %qE"
 msgid "too few arguments to built-in function %qE expecting %u"
 msgstr "提供給函式 %qE 的引數太少"
 
-#: c/c-typeck.cc:5223 c/c-typeck.cc:5251 cp/typeck.cc:6099 cp/typeck.cc:6391
+#: c/c-typeck.cc:5231 c/c-typeck.cc:5259 cp/typeck.cc:6094 cp/typeck.cc:6386
 #, fuzzy, gcc-internal-format
 msgid "comparison with string literal results in unspecified behavior"
 msgstr "比較與字串實字結果於未規定行為"
 
-#: c/c-typeck.cc:5231 c/c-typeck.cc:5242 cp/typeck.cc:6136 cp/typeck.cc:6160
+#: c/c-typeck.cc:5239 c/c-typeck.cc:5250 cp/typeck.cc:6131 cp/typeck.cc:6155
 #, fuzzy, gcc-internal-format
 #| msgid "comparison between pointer and integer"
 msgid "comparison between pointer and zero character constant"
 msgstr "比較指標和整數"
 
-#: c/c-typeck.cc:5234 c/c-typeck.cc:5245 cp/typeck.cc:6139 cp/typeck.cc:6163
+#: c/c-typeck.cc:5242 c/c-typeck.cc:5253 cp/typeck.cc:6134 cp/typeck.cc:6158
 #, fuzzy, gcc-internal-format
 #| msgid "casting %qT to %qT does not dereference pointer"
 msgid "did you mean to dereference the pointer?"
 msgstr "從 %qT 轉換到 %qT 並未提領指標"
 
-#: c/c-typeck.cc:5263 c/c-typeck.cc:5270 c/c-typeck.cc:6701 c/c-typeck.cc:6706
-#: c/c-typeck.cc:9255 cp/tree.cc:6866
+#: c/c-typeck.cc:5271 c/c-typeck.cc:5278 c/c-typeck.cc:6709 c/c-typeck.cc:6714
+#: c/c-typeck.cc:9263 cp/tree.cc:6889
 #, fuzzy, gcc-internal-format
 msgid "zero as null pointer constant"
 msgstr "零做為空指標常數"
 
-#: c/c-typeck.cc:5291
+#: c/c-typeck.cc:5299
 #, fuzzy, gcc-internal-format
 msgid "comparison between %qT and %qT"
 msgstr "比較介於 %qT 和 %qT"
 
-#: c/c-typeck.cc:5350
+#: c/c-typeck.cc:5358
 #, gcc-internal-format
 msgid "pointer of type %<void *%> used in subtraction"
 msgstr "在減法中使用類型為 %<void *%> 的指標"
 
-#: c/c-typeck.cc:5353
+#: c/c-typeck.cc:5361
 #, gcc-internal-format
 msgid "pointer to a function used in subtraction"
 msgstr "函式指標不能相減"
 
-#: c/c-typeck.cc:5387
+#: c/c-typeck.cc:5395
 #, gcc-internal-format
 msgid "arithmetic on pointer to an incomplete type"
 msgstr "在參照不完全類型的指標上執行算術運算"
 
-#: c/c-typeck.cc:5396 cp/typeck.cc:7197
+#: c/c-typeck.cc:5404 cp/typeck.cc:7192
 #, fuzzy, gcc-internal-format
 #| msgid "arithmetic on pointer to an incomplete type"
 msgid "arithmetic on pointer to an empty aggregate"
 msgstr "在參照不完全類型的指標上執行算術運算"
 
-#: c/c-typeck.cc:5847
+#: c/c-typeck.cc:5855
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on a boolean expression"
 msgstr "預期的布林表示式"
 
-#: c/c-typeck.cc:5851
+#: c/c-typeck.cc:5859
 #, gcc-internal-format
 msgid "did you mean to use logical not?"
 msgstr ""
 
-#: c/c-typeck.cc:5861
+#: c/c-typeck.cc:5869
 #, gcc-internal-format
 msgid "ISO C does not support %<~%> for complex conjugation"
 msgstr "ISO C 不支援用 ~ 求共軛複數"
 
-#: c/c-typeck.cc:5885
+#: c/c-typeck.cc:5893
 #, fuzzy, gcc-internal-format
 #| msgid "wrong type argument to abs"
 msgid "wrong type argument to absu"
 msgstr "不能對該類型的引數求絕對值"
 
-#: c/c-typeck.cc:5911
+#: c/c-typeck.cc:5919
 #, gcc-internal-format
 msgid "wrong type argument to unary exclamation mark"
 msgstr "單位元 ! 的引數類型無效"
 
-#: c/c-typeck.cc:5969
+#: c/c-typeck.cc:5977
 #, fuzzy, gcc-internal-format
 msgid "increment of enumeration value is invalid in C++"
 msgstr "遞增的列舉類型值無效在中 C++"
 
-#: c/c-typeck.cc:5972
+#: c/c-typeck.cc:5980
 #, fuzzy, gcc-internal-format
 msgid "decrement of enumeration value is invalid in C++"
 msgstr "遞減的列舉類型值無效在中 C++"
 
-#: c/c-typeck.cc:5979
+#: c/c-typeck.cc:5987
 #, fuzzy, gcc-internal-format
 msgid "increment of a boolean expression"
 msgstr "預期的布林表示式"
 
-#: c/c-typeck.cc:5982
+#: c/c-typeck.cc:5990
 #, fuzzy, gcc-internal-format
 msgid "decrement of a boolean expression"
 msgstr "預期的布林表示式"
 
-#: c/c-typeck.cc:5998
+#: c/c-typeck.cc:6006
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support %<++%> and %<--%> on complex types"
 msgid "ISO C does not support %<++%> and %<--%> on complex types before C2Y"
 msgstr "ISO C 不支援對複數類型進行 %<++%> 或 %<--%> 作業"
 
-#: c/c-typeck.cc:6025 c/c-typeck.cc:6059
+#: c/c-typeck.cc:6033 c/c-typeck.cc:6067
 #, gcc-internal-format
 msgid "wrong type argument to increment"
 msgstr "該類型的引數不能自增"
 
-#: c/c-typeck.cc:6027 c/c-typeck.cc:6062
+#: c/c-typeck.cc:6035 c/c-typeck.cc:6070
 #, gcc-internal-format
 msgid "wrong type argument to decrement"
 msgstr "該類型的引數不能自減"
 
-#: c/c-typeck.cc:6047
+#: c/c-typeck.cc:6055
 #, fuzzy, gcc-internal-format
 msgid "increment of pointer to an incomplete type %qT"
 msgstr "無法遞增指標到不完整型態 %qT"
 
-#: c/c-typeck.cc:6051
+#: c/c-typeck.cc:6059
 #, fuzzy, gcc-internal-format
 msgid "decrement of pointer to an incomplete type %qT"
 msgstr "無法遞減指標到不完整型態 %qT"
 
-#: c/c-typeck.cc:6200
+#: c/c-typeck.cc:6208
 #, fuzzy, gcc-internal-format
 msgid "taking address of expression of type %<void%>"
 msgstr "需位址的運算式的型態 %<void%>"
 
-#: c/c-typeck.cc:6263 c/c-typeck.cc:6460 d/d-codegen.cc:759
+#: c/c-typeck.cc:6271 c/c-typeck.cc:6468 d/d-codegen.cc:759
 #, gcc-internal-format
 msgid "cannot take address of bit-field %qD"
 msgstr "無法取得位元段 %qD 的位址"
 
-#: c/c-typeck.cc:6277
+#: c/c-typeck.cc:6285
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgid "cannot take address of scalar with reverse storage order"
 msgstr "無法取右值運算式 %<this%> 的位址"
 
-#: c/c-typeck.cc:6285
+#: c/c-typeck.cc:6293
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of array with reverse scalar storage order requested"
 msgstr "要求暫存器變數 %qD 的位址。"
 
-#: c/c-typeck.cc:6479
+#: c/c-typeck.cc:6487
 #, fuzzy, gcc-internal-format
 #| msgid "address of register variable %qD requested"
 msgid "address of register compound literal requested"
 msgstr "要求暫存器變數 %qD 的位址。"
 
-#: c/c-typeck.cc:6501
+#: c/c-typeck.cc:6509
 #, gcc-internal-format
 msgid "global register variable %qD used in nested function"
 msgstr "巢狀函式中使用了全域暫存器變數 %qD"
 
-#: c/c-typeck.cc:6504
+#: c/c-typeck.cc:6512
 #, gcc-internal-format
 msgid "register variable %qD used in nested function"
 msgstr "巢狀函式中使用了暫存器變數 %qD"
 
-#: c/c-typeck.cc:6509
+#: c/c-typeck.cc:6517
 #, gcc-internal-format
 msgid "address of global register variable %qD requested"
 msgstr "要求全域暫存器變數 %qD 的位址"
 
-#: c/c-typeck.cc:6518 d/d-codegen.cc:775
+#: c/c-typeck.cc:6526 d/d-codegen.cc:775
 #, gcc-internal-format
 msgid "address of register variable %qD requested"
 msgstr "要求暫存器變數 %qD 的位址。"
 
-#: c/c-typeck.cc:6656
+#: c/c-typeck.cc:6664
 #, gcc-internal-format
 msgid "non-lvalue array in conditional expression"
 msgstr "非左值陣列出現在條件運算式中"
 
-#: c/c-typeck.cc:6691
+#: c/c-typeck.cc:6699
 #, fuzzy, gcc-internal-format
 msgid "different enum types in conditional is invalid in C++: %qT vs %qT"
 msgstr "定義輸入複合實字無效在中 C++"
 
-#: c/c-typeck.cc:6751
+#: c/c-typeck.cc:6759
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other result of conditional"
 msgstr "隱含轉換從 %qT 到 %qT 到匹配其他結果的條件"
 
-#: c/c-typeck.cc:6810 c/c-typeck.cc:6816
+#: c/c-typeck.cc:6818 c/c-typeck.cc:6824
 #, gcc-internal-format
 msgid "operand of %<?:%> changes signedness from %qT to %qT due to unsignedness of other operand"
 msgstr ""
 
-#: c/c-typeck.cc:6833
+#: c/c-typeck.cc:6841
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr with only one void side"
 msgstr "ISO C 不允許條件運算式僅有一邊為空"
 
-#: c/c-typeck.cc:6853
+#: c/c-typeck.cc:6861
 #, fuzzy, gcc-internal-format
 msgid "pointers to disjoint address spaces used in conditional expression"
 msgstr "指標到 disjoint 位址空間已用於條件運算式"
 
-#: c/c-typeck.cc:6877
+#: c/c-typeck.cc:6885
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression"
 msgstr "條件運算式指標類型不匹配"
 
-#: c/c-typeck.cc:6881
+#: c/c-typeck.cc:6889
 #, fuzzy, gcc-internal-format
 #| msgid "pointer type mismatch in conditional expression"
 msgid "pointer to array loses qualifier in conditional expression in ISO C before C23"
 msgstr "條件運算式指標類型不匹配"
 
-#: c/c-typeck.cc:6886
+#: c/c-typeck.cc:6894
 #, gcc-internal-format
 msgid "ISO C forbids conditional expr between %<void *%> and function pointer"
 msgstr "ISO C 不允許在條件運算式中同時使用 %<void *%> 和函式指標"
 
-#: c/c-typeck.cc:6910
+#: c/c-typeck.cc:6918
 #, gcc-internal-format
 msgid "pointer type mismatch in conditional expression"
 msgstr "條件運算式指標類型不匹配"
 
-#: c/c-typeck.cc:6913
+#: c/c-typeck.cc:6921
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "first expression has type %qT"
 msgstr "需要運算式類型"
 
-#: c/c-typeck.cc:6914
+#: c/c-typeck.cc:6922
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "second expression has type %qT"
 msgstr "需要運算式類型"
 
-#: c/c-typeck.cc:6925 c/c-typeck.cc:6938
+#: c/c-typeck.cc:6933 c/c-typeck.cc:6946
 #, gcc-internal-format
 msgid "pointer/integer type mismatch in conditional expression"
 msgstr "條件運算式中指標/整數類型不匹配"
 
-#: c/c-typeck.cc:6965
+#: c/c-typeck.cc:6973
 #, gcc-internal-format
 msgid "type mismatch in conditional expression"
 msgstr "條件運算式中類型不匹配"
 
-#: c/c-typeck.cc:7081
+#: c/c-typeck.cc:7089
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>: %E"
 msgstr "忽略傳回值的 %qD，宣告的與屬性 warn_unused_result"
 
-#: c/c-typeck.cc:7085
+#: c/c-typeck.cc:7093
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of %qD, declared with attribute %<nodiscard%>"
 msgstr "忽略傳回值的 %qD，宣告的與屬性 warn_unused_result"
 
-#: c/c-typeck.cc:7104
+#: c/c-typeck.cc:7112
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>: %E"
 msgstr "忽略傳回值的 %qD，宣告的與屬性 warn_unused_result"
 
-#: c/c-typeck.cc:7109
+#: c/c-typeck.cc:7117
 #, fuzzy, gcc-internal-format
 msgid "ignoring return value of type %qT, declared with attribute %<nodiscard%>"
 msgstr "忽略傳回值的 %qD，宣告的與屬性 warn_unused_result"
 
-#: c/c-typeck.cc:7118 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
+#: c/c-typeck.cc:7126 cp/cvt.cc:1145 rust/backend/rust-tree.cc:644
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "in call to %qD, declared here"
 msgstr "  %q+#D 已在此宣告過"
 
-#: c/c-typeck.cc:7167
+#: c/c-typeck.cc:7175
 #, gcc-internal-format
 msgid "left-hand operand of comma expression has no effect"
 msgstr "逗號運算式的左運算元不起作用"
 
-#: c/c-typeck.cc:7185 c/c-typeck.cc:13831
+#: c/c-typeck.cc:7193 c/c-typeck.cc:13839
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "right-hand operand of comma expression has no effect"
 msgstr "逗號運算式的左運算元不起作用"
 
-#: c/c-typeck.cc:7256
+#: c/c-typeck.cc:7264
 #, fuzzy
 msgid "cast adds %q#v qualifier to function type"
 msgstr "演員陣容加入 %q#v 限定元到函數型式"
 
-#: c/c-typeck.cc:7262
+#: c/c-typeck.cc:7270
 #, fuzzy
 msgid "cast discards %qv qualifier from pointer target type"
 msgstr "演員陣容捨棄 %q#v 限定元從指標目標類型"
 
-#: c/c-typeck.cc:7297
+#: c/c-typeck.cc:7305
 #, fuzzy, gcc-internal-format
 msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
 msgstr "要是安全所有中介指標在中演員陣容從 %qT 到 %qT 必須是 %<const%> 經資格修飾"
 
-#: c/c-typeck.cc:7389
+#: c/c-typeck.cc:7397
 #, gcc-internal-format
 msgid "cast specifies array type"
 msgstr "類型轉換指定了陣列類型"
 
-#: c/c-typeck.cc:7395
+#: c/c-typeck.cc:7403
 #, gcc-internal-format
 msgid "cast specifies function type"
 msgstr "類型轉換指定了函式類型"
 
-#: c/c-typeck.cc:7410
+#: c/c-typeck.cc:7418
 #, gcc-internal-format
 msgid "ISO C forbids casting nonscalar to the same type"
 msgstr "ISO C 不允許將非標量轉換為其自身類型"
 
-#: c/c-typeck.cc:7414
+#: c/c-typeck.cc:7422
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %qT"
 msgstr "%qT 使用了局部類型 %qT"
 
-#: c/c-typeck.cc:7434
+#: c/c-typeck.cc:7442
 #, gcc-internal-format
 msgid "ISO C forbids casts to union type"
 msgstr "ISO C 不允許轉換為聯合類型"
 
-#: c/c-typeck.cc:7444
+#: c/c-typeck.cc:7452
 #, gcc-internal-format
 msgid "cast to union type from type not present in union"
 msgstr "類型轉換的來源類型未出現在聯合中"
 
-#: c/c-typeck.cc:7479
+#: c/c-typeck.cc:7487
 #, fuzzy, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint generic address space pointer"
 msgstr "演員陣容到 %s 位址空間指標從 disjoint 通用位址空間指標"
 
-#: c/c-typeck.cc:7484
+#: c/c-typeck.cc:7492
 #, fuzzy, gcc-internal-format
 msgid "cast to generic address space pointer from disjoint %qs address space pointer"
 msgstr "演員陣容到通用位址空間指標從 disjoint %s 位址空間指標"
 
-#: c/c-typeck.cc:7489
+#: c/c-typeck.cc:7497
 #, fuzzy, gcc-internal-format
 msgid "cast to %qs address space pointer from disjoint %qs address space pointer"
 msgstr "演員陣容到 %s 位址空間指標從 disjoint %s 位址空間指標"
 
-#: c/c-typeck.cc:7522
+#: c/c-typeck.cc:7530
 #, gcc-internal-format
 msgid "cast increases required alignment of target type"
 msgstr "類型轉換增大了目的類型的對齊需求"
 
-#: c/c-typeck.cc:7534
+#: c/c-typeck.cc:7542
 #, gcc-internal-format
 msgid "cast from pointer to integer of different size"
 msgstr "當將一個指標轉換為大小不同的整數時給出警告"
 
-#: c/c-typeck.cc:7540
+#: c/c-typeck.cc:7548
 #, gcc-internal-format
 msgid "cast from function call of type %qT to non-matching type %qT"
 msgstr "從類型為 %qT 的函式呼叫轉換到不匹配的類型 %qT"
 
-#: c/c-typeck.cc:7550 cp/typeck.cc:9654
+#: c/c-typeck.cc:7558 cp/typeck.cc:9652
 #, gcc-internal-format
 msgid "cast to pointer from integer of different size"
 msgstr "當將一個指標轉換為大小不同的整數時給出警告"
 
-#: c/c-typeck.cc:7564
+#: c/c-typeck.cc:7572
 #, gcc-internal-format
 msgid "ISO C forbids conversion of function pointer to object pointer type"
 msgstr "ISO C 不允許將一個函式指標轉換為一個物件指標"
 
-#: c/c-typeck.cc:7573
+#: c/c-typeck.cc:7581
 #, gcc-internal-format
 msgid "ISO C forbids conversion of object pointer to function pointer type"
 msgstr "ISO C 不允許將一個物件指標轉換為一個函式指標"
 
-#: c/c-typeck.cc:7583
+#: c/c-typeck.cc:7591
 #, fuzzy, gcc-internal-format
 msgid "cast between incompatible function types from %qT to %qT"
 msgstr "can%'t 轉換從不完整型態 %qT 到 %qT"
 
-#: c/c-typeck.cc:7698
+#: c/c-typeck.cc:7706
 #, fuzzy, gcc-internal-format
 msgid "defining a type in a cast is invalid in C++"
 msgstr "定義輸入演員陣容無效在中 C++"
 
-#: c/c-typeck.cc:7740
+#: c/c-typeck.cc:7748
 #, fuzzy, gcc-internal-format
 #| msgid "assignment suppression"
 msgid "assignment to expression with array type"
 msgstr "取消賦值"
 
-#: c/c-typeck.cc:7881
+#: c/c-typeck.cc:7889
 #, fuzzy, gcc-internal-format
 msgid "enum conversion in assignment is invalid in C++"
 msgstr "enum 轉換在中指派無效在中 C++"
 
-#: c/c-typeck.cc:8075 c/c-typeck.cc:8094 c/c-typeck.cc:8153
+#: c/c-typeck.cc:8083 c/c-typeck.cc:8102 c/c-typeck.cc:8161
 #, gcc-internal-format
 msgid "(near initialization for %qs)"
 msgstr "(在 %qs 的初始化附近)"
 
-#: c/c-typeck.cc:8169
+#: c/c-typeck.cc:8177
 #, gcc-internal-format
 msgid "array initialized from parenthesized string constant"
 msgstr "用括號中的字串常數初始化陣列"
 
-#: c/c-typeck.cc:8219
+#: c/c-typeck.cc:8227
 #, fuzzy
 msgid "expected %e but argument is of type %e"
 msgstr "預期 %qT 但是引數是的型態 %qT"
 
-#: c/c-typeck.cc:8253
+#: c/c-typeck.cc:8261
 #, gcc-internal-format
 msgid "%qD argument %d type is %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8256
+#: c/c-typeck.cc:8264
 #, gcc-internal-format
 msgid "%qD argument %d promotes to %qT where %qT is expected in a call to built-in function declared without prototype"
 msgstr ""
 
-#: c/c-typeck.cc:8261
+#: c/c-typeck.cc:8269
 #, fuzzy, gcc-internal-format
 msgid "built-in %qD declared here"
 msgstr "%qD 宣告的在此"
 
-#: c/c-typeck.cc:8318 c/c-typeck.cc:9217
+#: c/c-typeck.cc:8326 c/c-typeck.cc:9225
 #, fuzzy
 msgid "%e declared here"
 msgstr "宣告的在此"
 
-#: c/c-typeck.cc:8511
+#: c/c-typeck.cc:8519
 #, fuzzy, gcc-internal-format
 msgid "enum conversion when passing argument %d of %qE is invalid in C++"
 msgstr "enum 轉換時傳遞引數 %d 的 %qE 無效在中 C++"
 
-#: c/c-typeck.cc:8516
+#: c/c-typeck.cc:8524
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but argument is of type %qT"
 msgstr "預期 %qT 但是引數是的型態 %qT"
 
-#: c/c-typeck.cc:8520
+#: c/c-typeck.cc:8528
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in assignment is invalid in C++"
 msgstr "enum 轉換在中指派無效在中 C++"
 
-#: c/c-typeck.cc:8525
+#: c/c-typeck.cc:8533
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in initialization is invalid in C++"
 msgstr "enum 轉換在中初始化無效在中 C++"
 
-#: c/c-typeck.cc:8530
+#: c/c-typeck.cc:8538
 #, fuzzy, gcc-internal-format
 msgid "enum conversion from %qT to %qT in return is invalid in C++"
 msgstr "enum 轉換在中回傳無效在中 C++"
 
-#: c/c-typeck.cc:8548
+#: c/c-typeck.cc:8556
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %q#T to %q#T"
 msgid "implicit conversion from %qT to %qT"
 msgstr "從 %q#T 到 %q#T 的轉換"
 
-#: c/c-typeck.cc:8730 c/c-typeck.cc:9120
+#: c/c-typeck.cc:8738 c/c-typeck.cc:9128
 #, fuzzy
 msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
 msgstr "傳遞引數 %d 的 %qE 製作 %q#v 經資格修飾函式指標從資格不符的"
 
-#: c/c-typeck.cc:8733 c/c-typeck.cc:9123
+#: c/c-typeck.cc:8741 c/c-typeck.cc:9131
 #, fuzzy
 msgid "assignment makes %q#v qualified function pointer from unqualified"
 msgstr "指派製作 %q#v 經資格修飾函式指標從資格不符的"
 
-#: c/c-typeck.cc:8736 c/c-typeck.cc:9125
+#: c/c-typeck.cc:8744 c/c-typeck.cc:9133
 #, fuzzy
 msgid "initialization makes %q#v qualified function pointer from unqualified"
 msgstr "初始化製作 %q#v 經資格修飾函式指標從資格不符的"
 
-#: c/c-typeck.cc:8739 c/c-typeck.cc:9127
+#: c/c-typeck.cc:8747 c/c-typeck.cc:9135
 #, fuzzy
 msgid "return makes %q#v qualified function pointer from unqualified"
 msgstr "回傳製作 %q#v 經資格修飾函式指標從資格不符的"
 
-#: c/c-typeck.cc:8747 c/c-typeck.cc:9010 c/c-typeck.cc:9053
+#: c/c-typeck.cc:8755 c/c-typeck.cc:9018 c/c-typeck.cc:9061
 #, fuzzy
 msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
 msgstr "傳遞引數 %d 的 %qE 捨棄 %qv 限定元從指標目標類型"
 
-#: c/c-typeck.cc:8749 c/c-typeck.cc:9012 c/c-typeck.cc:9055
+#: c/c-typeck.cc:8757 c/c-typeck.cc:9020 c/c-typeck.cc:9063
 #, fuzzy
 msgid "assignment discards %qv qualifier from pointer target type"
 msgstr "指派捨棄 %qv 限定元從指標目標類型"
 
-#: c/c-typeck.cc:8751 c/c-typeck.cc:9014 c/c-typeck.cc:9057
+#: c/c-typeck.cc:8759 c/c-typeck.cc:9022 c/c-typeck.cc:9065
 #, fuzzy
 msgid "initialization discards %qv qualifier from pointer target type"
 msgstr "初始化捨棄 %qv 限定元從指標目標類型"
 
-#: c/c-typeck.cc:8753 c/c-typeck.cc:9016 c/c-typeck.cc:9059
+#: c/c-typeck.cc:8761 c/c-typeck.cc:9024 c/c-typeck.cc:9067
 #, fuzzy
 msgid "return discards %qv qualifier from pointer target type"
 msgstr "回傳捨棄 %qv 限定元從指標目標類型"
 
-#: c/c-typeck.cc:8762
+#: c/c-typeck.cc:8770
 #, gcc-internal-format
 msgid "ISO C prohibits argument conversion to union type"
 msgstr "ISO C 不允許將引數轉換為聯合"
 
-#: c/c-typeck.cc:8821
+#: c/c-typeck.cc:8829
 #, gcc-internal-format
 msgid "request for implicit conversion from %qT to %qT not permitted in C++"
 msgstr "C++ 中不允許從 %qT 到 %qT 的隱含轉換"
 
-#: c/c-typeck.cc:8848
+#: c/c-typeck.cc:8856
 #, fuzzy, gcc-internal-format
 msgid "passing argument %d of %qE from pointer to non-enclosed address space"
 msgstr "傳遞引數 %d 的 %qE 從指標到 non-enclosed 位址空間"
 
-#: c/c-typeck.cc:8859
+#: c/c-typeck.cc:8867
 #, fuzzy, gcc-internal-format
 msgid "assignment from pointer to non-enclosed address space"
 msgstr "指派從指標到 non-enclosed 位址空間"
 
-#: c/c-typeck.cc:8870
+#: c/c-typeck.cc:8878
 #, fuzzy, gcc-internal-format
 msgid "initialization from pointer to non-enclosed address space"
 msgstr "初始化從指標到 non-enclosed 位址空間"
 
-#: c/c-typeck.cc:8880
+#: c/c-typeck.cc:8888
 #, fuzzy, gcc-internal-format
 msgid "return from pointer to non-enclosed address space"
 msgstr "回傳從指標到 non-enclosed 位址空間"
 
-#: c/c-typeck.cc:8896
+#: c/c-typeck.cc:8904
 #, fuzzy, gcc-internal-format
 msgid "expected %qT but pointer is of type %qT"
 msgstr "預期 %qT 但是引數是的型態 %qT"
 
-#: c/c-typeck.cc:8911
+#: c/c-typeck.cc:8919
 #, gcc-internal-format
 msgid "argument %d of %qE might be a candidate for a format attribute"
 msgstr "引數 %d(屬於 %qE)可能是 format 屬性的備選"
 
-#: c/c-typeck.cc:8917
+#: c/c-typeck.cc:8925
 #, gcc-internal-format
 msgid "assignment left-hand side might be a candidate for a format attribute"
 msgstr "賦值的左手邊可能是 format 屬性的備選時"
 
-#: c/c-typeck.cc:8923
+#: c/c-typeck.cc:8931
 #, gcc-internal-format
 msgid "initialization left-hand side might be a candidate for a format attribute"
 msgstr "初始化的左手邊可能是 format 屬性的備選時"
 
-#: c/c-typeck.cc:8928 cp/typeck.cc:10845
+#: c/c-typeck.cc:8936 cp/typeck.cc:10843
 #, gcc-internal-format
 msgid "return type might be a candidate for a format attribute"
 msgstr "回傳類型可能是 format 屬性的備選"
 
-#: c/c-typeck.cc:8952
+#: c/c-typeck.cc:8960
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE from incompatible pointer type"
 msgid "passing argument %d of %qE from incompatible scalar storage order"
 msgstr "傳遞參數 %d (屬於 %qE)時在不相容的指標類型間轉換"
 
-#: c/c-typeck.cc:8962
+#: c/c-typeck.cc:8970
 #, fuzzy, gcc-internal-format
 msgid "assignment to %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "無法遞增指標到不完整型態 %qT"
 
-#: c/c-typeck.cc:8972
+#: c/c-typeck.cc:8980
 #, fuzzy, gcc-internal-format
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %qT from pointer type %qT with incompatible scalar storage order"
 msgstr "永遠不相容的指標類型初始化"
 
-#: c/c-typeck.cc:8977
+#: c/c-typeck.cc:8985
 #, fuzzy, gcc-internal-format
 msgid "returning %qT from pointer type with incompatible scalar storage order %qT"
 msgstr "回傳與值在中函式不具任何傳回類型"
 
-#: c/c-typeck.cc:9027
+#: c/c-typeck.cc:9035
 #, gcc-internal-format
 msgid "ISO C forbids passing argument %d of %qE between function pointer and %<void *%>"
 msgstr "ISO C 不允許將引數 %d(屬於 %qE)在函式指標和 %<void *%> 間傳遞"
 
-#: c/c-typeck.cc:9030
+#: c/c-typeck.cc:9038
 #, gcc-internal-format
 msgid "ISO C forbids assignment between function pointer and %<void *%>"
 msgstr "ISO C 不允許在函式指標和 %<void *%> 間賦值"
 
-#: c/c-typeck.cc:9032
+#: c/c-typeck.cc:9040
 #, gcc-internal-format
 msgid "ISO C forbids initialization between function pointer and %<void *%>"
 msgstr "ISO C 不允許在函式指標和 %<void *%> 間初始化"
 
-#: c/c-typeck.cc:9034
+#: c/c-typeck.cc:9042
 #, gcc-internal-format
 msgid "ISO C forbids return between function pointer and %<void *%>"
 msgstr "ISO C 不允許在函式指標和 %<void *%> 間回傳"
 
-#: c/c-typeck.cc:9064
+#: c/c-typeck.cc:9072
 #, gcc-internal-format
 msgid "array with qualifier on the element is not qualified before C23"
 msgstr ""
 
-#: c/c-typeck.cc:9082
+#: c/c-typeck.cc:9090
 #, gcc-internal-format
 msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgstr "傳遞參數 %d (屬於 %qE) 給指標時目的與指標有/無號不一致"
 
-#: c/c-typeck.cc:9090
+#: c/c-typeck.cc:9098
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in assignment differ in signedness"
 msgid "pointer targets in assignment from %qT to %qT differ in signedness"
 msgstr "對指標賦值時目的與指標有/無號不一致"
 
-#: c/c-typeck.cc:9096
+#: c/c-typeck.cc:9104
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in initialization differ in signedness"
 msgid "pointer targets in initialization of %qT from %qT differ in signedness"
 msgstr "初始化指標時目的與指標有/無號不一致"
 
-#: c/c-typeck.cc:9101
+#: c/c-typeck.cc:9109
 #, fuzzy, gcc-internal-format
 #| msgid "pointer targets in passing argument %d of %qE differ in signedness"
 msgid "pointer targets in returning %qT from a function with return type %qT differ in signedness"
 msgstr "傳遞參數 %d (屬於 %qE) 給指標時目的與指標有/無號不一致"
 
-#: c/c-typeck.cc:9148
+#: c/c-typeck.cc:9156
 #, gcc-internal-format
 msgid "passing argument %d of %qE from incompatible pointer type"
 msgstr "傳遞參數 %d (屬於 %qE)時在不相容的指標類型間轉換"
 
-#: c/c-typeck.cc:9159
+#: c/c-typeck.cc:9167
 #, fuzzy
 msgid "assignment to %e from pointer to %qD with incompatible type %e"
 msgstr "無法遞增指標到不完整型態 %qT"
 
-#: c/c-typeck.cc:9165
+#: c/c-typeck.cc:9173
 #, fuzzy
 #| msgid "assignment from incompatible pointer type"
 msgid "assignment to %e from incompatible pointer type %e"
 msgstr "永遠不相容的指標類型賦值"
 
-#: c/c-typeck.cc:9174
+#: c/c-typeck.cc:9182
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from pointer to %qD with incompatible type %e"
 msgstr "永遠不相容的指標類型初始化"
 
-#: c/c-typeck.cc:9180
+#: c/c-typeck.cc:9188
 #, fuzzy
 #| msgid "initialization from incompatible pointer type"
 msgid "initialization of %e from incompatible pointer type %e"
 msgstr "永遠不相容的指標類型初始化"
 
-#: c/c-typeck.cc:9188
+#: c/c-typeck.cc:9196
 #, fuzzy
 #| msgid "pointer to member type %qT incompatible with object type %qT"
 msgid "returning pointer to %qD of type %e from a function with incompatible type %e"
 msgstr "成員指標類型 %qT 與物件類型 %qT 不相容"
 
-#: c/c-typeck.cc:9194
+#: c/c-typeck.cc:9202
 #, fuzzy
 msgid "returning %e from a function with incompatible return type %e"
 msgstr "回傳與值在中函式不具任何傳回類型"
 
-#: c/c-typeck.cc:9272
+#: c/c-typeck.cc:9280
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgstr "傳遞參數 %d (屬於 %qE)時將整數賦給指標，未作類型轉換"
 
-#: c/c-typeck.cc:9282
+#: c/c-typeck.cc:9290
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes pointer from integer without a cast"
 msgid "assignment to %qT from %qT makes pointer from integer without a cast"
 msgstr "賦值時將整數賦給指標，未作類型轉換"
 
-#: c/c-typeck.cc:9288
+#: c/c-typeck.cc:9296
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes pointer from integer without a cast"
 msgid "initialization of %qT from %qT makes pointer from integer without a cast"
 msgstr "初始化時將整數賦給指標，未作類型轉換"
 
-#: c/c-typeck.cc:9293
+#: c/c-typeck.cc:9301
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes pointer from integer without a cast"
 msgid "returning %qT from a function with return type %qT makes pointer from integer without a cast"
 msgstr "傳遞參數 %d (屬於 %qE)時將整數賦給指標，未作類型轉換"
 
-#: c/c-typeck.cc:9315
+#: c/c-typeck.cc:9323
 #, gcc-internal-format
 msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgstr "傳遞參數 %d (屬於 %qE)時將指標賦給整數，未作類型轉換"
 
-#: c/c-typeck.cc:9325
+#: c/c-typeck.cc:9333
 #, fuzzy, gcc-internal-format
 #| msgid "assignment makes integer from pointer without a cast"
 msgid "assignment to %qT from %qT makes integer from pointer without a cast"
 msgstr "賦值時將指標賦給整數，未作類型轉換"
 
-#: c/c-typeck.cc:9331
+#: c/c-typeck.cc:9339
 #, fuzzy, gcc-internal-format
 #| msgid "initialization makes integer from pointer without a cast"
 msgid "initialization of %qT from %qT makes integer from pointer without a cast"
 msgstr "初始化將指標賦給整數，未作類型轉換"
 
-#: c/c-typeck.cc:9335
+#: c/c-typeck.cc:9343
 #, fuzzy, gcc-internal-format
 #| msgid "passing argument %d of %qE makes integer from pointer without a cast"
 msgid "returning %qT from a function with return type %qT makes integer from pointer without a cast"
 msgstr "傳遞參數 %d (屬於 %qE)時將指標賦給整數，未作類型轉換"
 
-#: c/c-typeck.cc:9368
+#: c/c-typeck.cc:9376
 #, gcc-internal-format
 msgid "incompatible type for argument %d of %qE"
 msgstr "引數 %d(屬於 %qE)類型不相容"
 
-#: c/c-typeck.cc:9379
+#: c/c-typeck.cc:9387
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when assigning to type %qT from type %qT"
 msgstr "不相容的類型時指派輸入 %qT 從型態 %qT"
 
-#: c/c-typeck.cc:9390
+#: c/c-typeck.cc:9398
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when initializing type %qT using type %qT"
 msgstr "不相容的類型時初始化型態 %qT 使用型態 %qT"
 
-#: c/c-typeck.cc:9400
+#: c/c-typeck.cc:9408
 #, fuzzy, gcc-internal-format
 msgid "incompatible types when returning type %qT but %qT was expected"
 msgstr "不相容的類型時傳回類型 %qT 但是 %qT 被預期"
 
-#: c/c-typeck.cc:9480
+#: c/c-typeck.cc:9488
 #, gcc-internal-format
 msgid "traditional C rejects automatic aggregate initialization"
 msgstr "傳統 C 不接受自動的聚合初始化"
 
-#: c/c-typeck.cc:9722
+#: c/c-typeck.cc:9730
 #, gcc-internal-format
 msgid "%<constexpr%> pointer initializer is not null"
 msgstr ""
 
-#: c/c-typeck.cc:9739 c/c-typeck.cc:9749 c/c-typeck.cc:9811 c/c-typeck.cc:9964
+#: c/c-typeck.cc:9747 c/c-typeck.cc:9757 c/c-typeck.cc:9819 c/c-typeck.cc:9972
 #, gcc-internal-format
 msgid "%<constexpr%> initializer not representable in type of object"
 msgstr ""
 
-#: c/c-typeck.cc:9745
+#: c/c-typeck.cc:9753
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> integer initializer is not an integer constant expression"
 msgstr "陣列索引在中初始設定式不是整數常數運算式"
 
-#: c/c-typeck.cc:9759
+#: c/c-typeck.cc:9767
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> initializer is not an arithmetic constant expression"
 msgstr "陣列索引在中初始設定式不是整數常數運算式"
 
-#: c/c-typeck.cc:9776
+#: c/c-typeck.cc:9784
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a real type is of complex type"
 msgstr ""
 
-#: c/c-typeck.cc:9785
+#: c/c-typeck.cc:9793
 #, gcc-internal-format
 msgid "%<constexpr%> initializer for a binary floating-point type is of decimal type"
 msgstr ""
 
-#: c/c-typeck.cc:9929 c/c-typeck.cc:10915 cp/typeck2.cc:1329
+#: c/c-typeck.cc:9937 c/c-typeck.cc:10923 cp/typeck2.cc:1329
 #, gcc-internal-format
 msgid "initialization of a flexible array member"
 msgstr "對彈性陣列成員的初始化"
 
-#: c/c-typeck.cc:9945 cp/typeck2.cc:1346
+#: c/c-typeck.cc:9953 cp/typeck2.cc:1346
 #, gcc-internal-format
 msgid "cannot initialize array of %qT from a string literal with type array of %qT"
 msgstr ""
 
-#: c/c-typeck.cc:9991
+#: c/c-typeck.cc:9999
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long (%wu chars into %wu available)"
 msgstr "用以初始化字元陣列的字串太長"
 
-#: c/c-typeck.cc:9996
+#: c/c-typeck.cc:10004
 #, fuzzy, gcc-internal-format
 #| msgid "initializer-string for array of chars is too long"
 msgid "initializer-string for array of %qT is too long for C++ (%wu chars into %wu available)"
 msgstr "用以初始化字元陣列的字串太長"
 
-#: c/c-typeck.cc:10003
+#: c/c-typeck.cc:10011
 #, gcc-internal-format
 msgid "initializer-string for array of %qT truncates NUL terminator but destination lacks %qs attribute (%wu chars into %wu available)"
 msgstr ""
 
-#: c/c-typeck.cc:10015
+#: c/c-typeck.cc:10023
 #, gcc-internal-format
 msgid "array of inappropriate type initialized from string constant"
 msgstr "用字串常數初始化的陣列類型不合適"
 
-#: c/c-typeck.cc:10083 cp/typeck.cc:2671
+#: c/c-typeck.cc:10091 cp/typeck.cc:2671
 #, gcc-internal-format
 msgid "invalid use of non-lvalue array"
 msgstr "對非左值陣列的無效使用"
 
-#: c/c-typeck.cc:10097 c/c-typeck.cc:10237 c/c-typeck.cc:11009
+#: c/c-typeck.cc:10105 c/c-typeck.cc:10245 c/c-typeck.cc:11017
 #, gcc-internal-format
 msgid "invalid initializer"
 msgstr "無效的初始值設定"
 
-#: c/c-typeck.cc:10109 c/c-typeck.cc:10133 c/c-typeck.cc:10136
-#: c/c-typeck.cc:10144 c/c-typeck.cc:10206 c/c-typeck.cc:11993
-#: c/c-typeck.cc:12077
+#: c/c-typeck.cc:10117 c/c-typeck.cc:10141 c/c-typeck.cc:10144
+#: c/c-typeck.cc:10152 c/c-typeck.cc:10214 c/c-typeck.cc:12001
+#: c/c-typeck.cc:12085
 #, gcc-internal-format
 msgid "initializer element is not constant"
 msgstr "初始值設定元素不是常數"
 
-#: c/c-typeck.cc:10118
+#: c/c-typeck.cc:10126
 #, gcc-internal-format
 msgid "array initialized from non-constant array expression"
 msgstr "用非常數的陣列運算式初始化陣列"
 
-#: c/c-typeck.cc:10149 c/c-typeck.cc:10219 c/c-typeck.cc:12087
+#: c/c-typeck.cc:10157 c/c-typeck.cc:10227 c/c-typeck.cc:12095
 #, fuzzy, gcc-internal-format
 msgid "initializer element is not a constant expression"
 msgstr "初始設定式元件並非常數運算式"
 
-#: c/c-typeck.cc:10171 cp/typeck2.cc:1428
+#: c/c-typeck.cc:10179 cp/typeck2.cc:1428
 #, fuzzy, gcc-internal-format
 #| msgid "conversion from %qT to %qT discards qualifiers"
 msgid "conversion from %qT to %qT changes value from %qd to %qd"
 msgstr "從 %qT 到 %qT 的轉換丟失了限定資訊"
 
-#: c/c-typeck.cc:10213 c/c-typeck.cc:12082
+#: c/c-typeck.cc:10221 c/c-typeck.cc:12090
 #, gcc-internal-format
 msgid "initializer element is not computable at load time"
 msgstr "初始值設定中的元素在載入時無法被計算出"
 
-#: c/c-typeck.cc:10524 cp/decl.cc:8528
+#: c/c-typeck.cc:10532 cp/decl.cc:8542
 #, gcc-internal-format
 msgid "opaque vector types cannot be initialized"
 msgstr "不透明的向量類型不能被初始化"
 
-#: c/c-typeck.cc:10755
+#: c/c-typeck.cc:10763
 #, gcc-internal-format
 msgid "extra brace group at end of initializer"
 msgstr "初始值設定項末尾有多餘的大括號組"
 
-#: c/c-typeck.cc:10842 c/c-typeck.cc:10845
+#: c/c-typeck.cc:10850 c/c-typeck.cc:10853
 #, gcc-internal-format
 msgid "braces around scalar initializer"
 msgstr "標量初始化帶大括號"
 
-#: c/c-typeck.cc:10917 c/c-typeck.cc:10921 c/c-typeck.cc:12685
-#: c/c-typeck.cc:12810 cp/typeck2.cc:1356 cp/typeck2.cc:1714
+#: c/c-typeck.cc:10925 c/c-typeck.cc:10929 c/c-typeck.cc:12693
+#: c/c-typeck.cc:12818 cp/typeck2.cc:1356 cp/typeck2.cc:1714
 #, gcc-internal-format
 msgid "initialization of flexible array member in a nested context"
 msgstr "在巢狀的上下文中初始化彈性陣列成員"
 
-#: c/c-typeck.cc:10958
+#: c/c-typeck.cc:10966
 #, gcc-internal-format
 msgid "missing braces around initializer"
 msgstr "初始值設定周圍缺少大括號"
 
-#: c/c-typeck.cc:10981
+#: c/c-typeck.cc:10989
 #, fuzzy, gcc-internal-format
 msgid "missing initializer for field %qD of %qT"
 msgstr "成員 %qD 缺少初始值設定"
 
-#: c/c-typeck.cc:11021
+#: c/c-typeck.cc:11029
 #, gcc-internal-format
 msgid "extra elements in scalar initializer"
 msgstr "標量初始化設定中有多餘元素"
 
-#: c/c-typeck.cc:11144 c/c-typeck.cc:11226
+#: c/c-typeck.cc:11152 c/c-typeck.cc:11234
 #, gcc-internal-format
 msgid "array index in non-array initializer"
 msgstr "在非陣列初始值設定項中出現陣列索引"
 
-#: c/c-typeck.cc:11149 c/c-typeck.cc:11288
+#: c/c-typeck.cc:11157 c/c-typeck.cc:11296
 #, gcc-internal-format
 msgid "field name not in record or union initializer"
 msgstr "欄位名不在記錄或聯合初始化設定中"
 
-#: c/c-typeck.cc:11199
+#: c/c-typeck.cc:11207
 #, gcc-internal-format
 msgid "array index in initializer not of integer type"
 msgstr "初始值設定中陣列索引不是整型"
 
-#: c/c-typeck.cc:11208 c/c-typeck.cc:11217
+#: c/c-typeck.cc:11216 c/c-typeck.cc:11225
 #, fuzzy, gcc-internal-format
 msgid "array index in initializer is not an integer constant expression"
 msgstr "陣列索引在中初始設定式不是整數常數運算式"
 
-#: c/c-typeck.cc:11222 c/c-typeck.cc:11224
+#: c/c-typeck.cc:11230 c/c-typeck.cc:11232
 #, gcc-internal-format
 msgid "nonconstant array index in initializer"
 msgstr "初始值設定中陣列索引不是常數"
 
-#: c/c-typeck.cc:11228 c/c-typeck.cc:11231
+#: c/c-typeck.cc:11236 c/c-typeck.cc:11239
 #, gcc-internal-format
 msgid "array index in initializer exceeds array bounds"
 msgstr "初始化時陣列索引越界"
 
-#: c/c-typeck.cc:11250
+#: c/c-typeck.cc:11258
 #, gcc-internal-format
 msgid "empty index range in initializer"
 msgstr "初始值設定項中索引範圍為空"
 
-#: c/c-typeck.cc:11259
+#: c/c-typeck.cc:11267
 #, gcc-internal-format
 msgid "array index range in initializer exceeds array bounds"
 msgstr "初始值設定中資料索引範圍超出陣列邊界"
 
-#: c/c-typeck.cc:11393 c/c-typeck.cc:11448 c/c-typeck.cc:11489
-#: c/c-typeck.cc:11549 c/c-typeck.cc:11596 c/c-typeck.cc:12184
+#: c/c-typeck.cc:11401 c/c-typeck.cc:11456 c/c-typeck.cc:11497
+#: c/c-typeck.cc:11557 c/c-typeck.cc:11604 c/c-typeck.cc:12192
 #, fuzzy, gcc-internal-format
 msgid "initialized field overwritten"
 msgstr "初始化的欄位覆寫"
 
-#: c/c-typeck.cc:11484 c/c-typeck.cc:11545 c/c-typeck.cc:11592
-#: c/c-typeck.cc:12181
+#: c/c-typeck.cc:11492 c/c-typeck.cc:11553 c/c-typeck.cc:11600
+#: c/c-typeck.cc:12189
 #, gcc-internal-format
 msgid "initialized field with side-effects overwritten"
 msgstr "帶副作用的欄位初始化設定被覆寫"
 
-#: c/c-typeck.cc:12109
+#: c/c-typeck.cc:12117
 #, fuzzy, gcc-internal-format
 msgid "enum conversion in initialization is invalid in C++"
 msgstr "enum 轉換在中初始化無效在中 C++"
 
-#: c/c-typeck.cc:12555
+#: c/c-typeck.cc:12563
 #, fuzzy, gcc-internal-format
 #| msgid "excess elements in union initializer"
 msgid "excess elements in %qT initializer"
 msgstr "聯合初始值設定項中有多餘元素"
 
-#: c/c-typeck.cc:12567 c/c-typeck.cc:12644
+#: c/c-typeck.cc:12575 c/c-typeck.cc:12652
 #, gcc-internal-format
 msgid "excess elements in struct initializer"
 msgstr "結構初始值設定項中有多餘元素"
 
-#: c/c-typeck.cc:12588
+#: c/c-typeck.cc:12596
 #, gcc-internal-format
 msgid "positional initialization of field in %<struct%> declared with %<designated_init%> attribute"
 msgstr ""
 
-#: c/c-typeck.cc:12659 c/c-typeck.cc:12785 cp/typeck2.cc:1333
+#: c/c-typeck.cc:12667 c/c-typeck.cc:12793 cp/typeck2.cc:1333
 #, gcc-internal-format
 msgid "non-static initialization of a flexible array member"
 msgstr "對彈性陣列成員非靜態地初始化"
 
-#: c/c-typeck.cc:12755
+#: c/c-typeck.cc:12763
 #, gcc-internal-format
 msgid "excess elements in union initializer"
 msgstr "聯合初始值設定項中有多餘元素"
 
-#: c/c-typeck.cc:12777
+#: c/c-typeck.cc:12785
 #, gcc-internal-format
 msgid "traditional C rejects initialization of unions"
 msgstr "傳統 C 不接受對聯合的初始化"
 
-#: c/c-typeck.cc:12878
+#: c/c-typeck.cc:12886
 #, gcc-internal-format
 msgid "excess elements in array initializer"
 msgstr "陣列初始值設定項中有多餘的元素"
 
-#: c/c-typeck.cc:12955 c/c-typeck.cc:12957
+#: c/c-typeck.cc:12963 c/c-typeck.cc:12965
 #, gcc-internal-format
 msgid "excess elements in vector initializer"
 msgstr "向量初始值設定項中有多餘元素"
 
-#: c/c-typeck.cc:12991
+#: c/c-typeck.cc:12999
 #, gcc-internal-format
 msgid "excess elements in scalar initializer"
 msgstr "標量初始值設定項中有多餘元素"
 
-#: c/c-typeck.cc:13159 c/c-typeck.cc:13234 cp/semantics.cc:2371
+#: c/c-typeck.cc:13167 c/c-typeck.cc:13242 cp/semantics.cc:2371
 #: cp/semantics.cc:2481
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "constraint allows registers outside of a function"
 msgstr "ISO C 不支援在函式外使用多餘的 %<;%>"
 
-#: c/c-typeck.cc:13171 cp/semantics.cc:2383
+#: c/c-typeck.cc:13179 cp/semantics.cc:2383
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in output operand outside of a function"
 msgstr "變長類型的宣告出現在所有函式之外"
 
-#: c/c-typeck.cc:13182 cp/semantics.cc:2399
+#: c/c-typeck.cc:13190 cp/semantics.cc:2399
 #, fuzzy, gcc-internal-format
 #| msgid "output operand %d must use %<&%> constraint"
 msgid "output operand outside of a function is not constant"
 msgstr "輸出運算元 %d 必須使用 %<&%> 約束"
 
-#: c/c-typeck.cc:13190 c/c-typeck.cc:13281 cp/semantics.cc:2410
+#: c/c-typeck.cc:13198 c/c-typeck.cc:13289 cp/semantics.cc:2410
 #: cp/semantics.cc:2546
 #, fuzzy, gcc-internal-format
 msgid "%<-%> modifier used inside of a function"
 msgstr "使用的參數 %qD 外側函式內文"
 
-#: c/c-typeck.cc:13247 cp/semantics.cc:2494
+#: c/c-typeck.cc:13255 cp/semantics.cc:2494
 #, fuzzy, gcc-internal-format
 msgid "%<:%> constraint operand is not address of a function or non-automatic variable"
 msgstr "%qE 屬性沒有任何效果於單位本地函式"
 
-#: c/c-typeck.cc:13262 cp/semantics.cc:2509
+#: c/c-typeck.cc:13270 cp/semantics.cc:2509
 #, fuzzy, gcc-internal-format
 #| msgid "variable-size type declared outside of any function"
 msgid "side-effects in input operand outside of a function"
 msgstr "變長類型的宣告出現在所有函式之外"
 
-#: c/c-typeck.cc:13273 cp/semantics.cc:2524 cp/semantics.cc:2538
+#: c/c-typeck.cc:13281 cp/semantics.cc:2524 cp/semantics.cc:2538
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not defined outside of function scope"
 msgid "input operand outside of a function is not constant"
 msgstr "%qD 在函式作用欄位外未被定義"
 
-#: c/c-typeck.cc:13326
+#: c/c-typeck.cc:13334
 #, gcc-internal-format
 msgid "ISO C forbids %<goto *expr;%>"
 msgstr "ISO C++ 不允許 %<goto *expr;%>"
 
-#: c/c-typeck.cc:13332
+#: c/c-typeck.cc:13340
 #, fuzzy, gcc-internal-format
 msgid "computed goto must be pointer type"
 msgstr "引數 %d 的 %qE 必須是指標類型"
 
-#: c/c-typeck.cc:13362 c/gimple-parser.cc:2638 cp/typeck.cc:11447
+#: c/c-typeck.cc:13370 c/gimple-parser.cc:2638 cp/typeck.cc:11445
 #, gcc-internal-format
 msgid "function declared %<noreturn%> has a %<return%> statement"
 msgstr "被宣告為 %<noreturn%> 的函式卻有 %<return%> 敘述"
 
-#: c/c-typeck.cc:13393
+#: c/c-typeck.cc:13401
 #, gcc-internal-format
 msgid "%<return%> with no value, in function returning non-void"
 msgstr "在有回傳值的的函式中，%<return%> 不帶回傳值"
 
-#: c/c-typeck.cc:13406 c/gimple-parser.cc:2648
+#: c/c-typeck.cc:13414 c/gimple-parser.cc:2648
 #, gcc-internal-format
 msgid "%<return%> with a value, in function returning void"
 msgstr "在無回傳值的函式中，%<return%> 帶回傳值"
 
-#: c/c-typeck.cc:13409
+#: c/c-typeck.cc:13417
 #, fuzzy, gcc-internal-format
 msgid "ISO C forbids %<return%> with expression, in function returning void"
 msgstr "ISO C 禁止 %<return%> 與運算式，在中函式回傳虛值"
 
-#: c/c-typeck.cc:13490
+#: c/c-typeck.cc:13498
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of label"
 msgstr "函式回傳局部變數的位址"
 
-#: c/c-typeck.cc:13495
+#: c/c-typeck.cc:13503
 #, fuzzy, gcc-internal-format
 #| msgid "function returns address of local variable"
 msgid "function returns address of nested function referencing local context"
 msgstr "函式回傳局部變數的位址"
 
-#: c/c-typeck.cc:13588 cp/semantics.cc:1945
+#: c/c-typeck.cc:13596 cp/semantics.cc:1945
 #, gcc-internal-format
 msgid "switch quantity not an integer"
 msgstr "switch 敘述中的值不是一個整數"
 
-#: c/c-typeck.cc:13613
+#: c/c-typeck.cc:13621
 #, gcc-internal-format
 msgid "%<long%> switch expression not converted to %<int%> in ISO C"
 msgstr "在 ISO C 中，%<long%> 開關運算式不被轉換為 %<int%>"
 
-#: c/c-typeck.cc:13651 c/c-typeck.cc:13659
+#: c/c-typeck.cc:13659 c/c-typeck.cc:13667
 #, fuzzy, gcc-internal-format
 msgid "case label is not an integer constant expression"
 msgstr "大小寫標貼不是整數常數運算式"
 
-#: c/c-typeck.cc:13665 cp/parser.cc:14672
+#: c/c-typeck.cc:13673 cp/parser.cc:14687
 #, gcc-internal-format
 msgid "case label not within a switch statement"
 msgstr "case 標籤出現在開關敘述外"
 
-#: c/c-typeck.cc:13667
+#: c/c-typeck.cc:13675
 #, gcc-internal-format
 msgid "%<default%> label not within a switch statement"
 msgstr "%<default%> 標籤未出現在 switch 敘述內"
 
-#: c/c-typeck.cc:13743 cp/parser.cc:16761
+#: c/c-typeck.cc:13751 cp/parser.cc:16799
 #, gcc-internal-format
 msgid "break statement not within loop or switch"
 msgstr "break 敘述不在循環或開關敘述內"
 
-#: c/c-typeck.cc:13746 c/c-typeck.cc:13766 cp/decl.cc:4639 cp/parser.cc:16772
-#: cp/parser.cc:16794
+#: c/c-typeck.cc:13754 c/c-typeck.cc:13774 cp/decl.cc:4639 cp/parser.cc:16810
+#: cp/parser.cc:16832
 #, fuzzy, gcc-internal-format
 msgid "invalid exit from OpenMP structured block"
 msgstr "無效的離開從 OpenMP 結構化訊息塊"
 
-#: c/c-typeck.cc:13749 cp/parser.cc:16775
+#: c/c-typeck.cc:13757 cp/parser.cc:16813
 #, fuzzy, gcc-internal-format
 msgid "break statement used with OpenMP for loop"
 msgstr "中斷敘述使用的與 OpenMP 用於迴圈"
 
-#: c/c-typeck.cc:13763 cp/parser.cc:16785
+#: c/c-typeck.cc:13771 cp/parser.cc:16823
 #, gcc-internal-format
 msgid "continue statement not within a loop"
 msgstr "continue 敘述出現在循環以外"
 
-#: c/c-typeck.cc:13813 cp/cp-gimplify.cc:314
+#: c/c-typeck.cc:13821 cp/cp-gimplify.cc:314
 #, gcc-internal-format
 msgid "statement with no effect"
 msgstr "敘述不起作用"
 
-#: c/c-typeck.cc:13857
+#: c/c-typeck.cc:13865
 #, gcc-internal-format
 msgid "expression statement has incomplete type"
 msgstr "運算式敘述類型不完全"
 
-#: c/c-typeck.cc:14148
+#: c/c-typeck.cc:14156
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the pointer operand in %qE must not be NULL"
 msgstr "比較將一律評估做為 %<false%> 用於位址的 %qD 將永不是空值"
 
-#: c/c-typeck.cc:14153
+#: c/c-typeck.cc:14161
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the pointer operand in %qE must not be NULL"
 msgstr "比較將一律評估做為 %<true%> 用於位址的 %qD 將永不是空值"
 
-#: c/c-typeck.cc:14171 c/c-typeck.cc:14209
+#: c/c-typeck.cc:14179 c/c-typeck.cc:14217
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<false%> for the address of %qE will never be NULL"
 msgstr "比較將一律評估做為 %<false%> 用於位址的 %qD 將永不是空值"
 
-#: c/c-typeck.cc:14176 c/c-typeck.cc:14214
+#: c/c-typeck.cc:14184 c/c-typeck.cc:14222
 #, fuzzy, gcc-internal-format
 msgid "the comparison will always evaluate as %<true%> for the address of %qE will never be NULL"
 msgstr "比較將一律評估做為 %<true%> 用於位址的 %qD 將永不是空值"
 
-#: c/c-typeck.cc:14808 c/c-typeck.cc:14978 cp/typeck.cc:6417
+#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6412
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different element types"
 msgstr "比較向量與不同的元件類型"
 
-#: c/c-typeck.cc:14816 c/c-typeck.cc:14986 cp/typeck.cc:6431
+#: c/c-typeck.cc:14824 c/c-typeck.cc:14994 cp/typeck.cc:6426
 #, fuzzy, gcc-internal-format
 msgid "comparing vectors with different number of elements"
 msgstr "比較向量與不同的元件號碼的"
 
-#: c/c-typeck.cc:14831 c/c-typeck.cc:15001 cp/typeck.cc:6449
+#: c/c-typeck.cc:14839 c/c-typeck.cc:15009 cp/typeck.cc:6444
 #, fuzzy, gcc-internal-format
 msgid "comparison between types %qT and %qT"
 msgstr "比較介於類型 %qT 和 %qT"
 
-#: c/c-typeck.cc:14847 c/c-typeck.cc:15011 cp/typeck.cc:6472
+#: c/c-typeck.cc:14855 c/c-typeck.cc:15019 cp/typeck.cc:6467
 #, fuzzy, gcc-internal-format
 msgid "could not find an integer type of the same size as %qT"
 msgstr "找不到介面用於類別 %qE"
 
-#: c/c-typeck.cc:14861 cp/typeck.cc:6088
+#: c/c-typeck.cc:14869 cp/typeck.cc:6083
 #, fuzzy, gcc-internal-format
 #| msgid "comparing floating point with == or != is unsafe"
 msgid "comparing floating-point with %<==%> or %<!=%> is unsafe"
 msgstr "使用 == 或 != 比較浮點數是不安全的"
 
-#: c/c-typeck.cc:14900 c/c-typeck.cc:15052
+#: c/c-typeck.cc:14908 c/c-typeck.cc:15060
 #, fuzzy, gcc-internal-format
 msgid "comparison of pointers to disjoint address spaces"
 msgstr "比較的指標到 disjoint 位址空間"
 
-#: c/c-typeck.cc:14907 c/c-typeck.cc:14913
+#: c/c-typeck.cc:14915 c/c-typeck.cc:14921
 #, gcc-internal-format
 msgid "ISO C forbids comparison of %<void *%> with function pointer"
 msgstr "ISO C 不允許在 %<void *%> 和函式指標間比較"
 
-#: c/c-typeck.cc:14920 c/c-typeck.cc:15062
+#: c/c-typeck.cc:14928 c/c-typeck.cc:15070
 #, gcc-internal-format
 msgid "comparison of distinct pointer types lacks a cast"
 msgstr "比較不相關的指標時缺少類型轉換"
 
-#: c/c-typeck.cc:14933 c/c-typeck.cc:14939 c/c-typeck.cc:15089
-#: c/c-typeck.cc:15095
+#: c/c-typeck.cc:14941 c/c-typeck.cc:14947 c/c-typeck.cc:15097
+#: c/c-typeck.cc:15103
 #, gcc-internal-format
 msgid "comparison between pointer and integer"
 msgstr "比較指標和整數"
 
-#: c/c-typeck.cc:15040
+#: c/c-typeck.cc:15048
 #, gcc-internal-format
 msgid "comparison of complete and incomplete pointers"
 msgstr "在完全和不完全指標間比較"
 
-#: c/c-typeck.cc:15042
+#: c/c-typeck.cc:15050
 #, gcc-internal-format
 msgid "ISO C forbids ordered comparisons of pointers to functions"
 msgstr "ISO C 不允許函式指標間比較大小"
 
-#: c/c-typeck.cc:15047
+#: c/c-typeck.cc:15055
 #, fuzzy, gcc-internal-format
 msgid "ordered comparison of pointer with null pointer"
 msgstr "已排序的比較的指標與空指標"
 
-#: c/c-typeck.cc:15070 c/c-typeck.cc:15073 c/c-typeck.cc:15080
-#: c/c-typeck.cc:15083
+#: c/c-typeck.cc:15078 c/c-typeck.cc:15081 c/c-typeck.cc:15088
+#: c/c-typeck.cc:15091
 #, gcc-internal-format
 msgid "ordered comparison of pointer with integer zero"
 msgstr "指標與整數 0 比較大小"
 
-#: c/c-typeck.cc:15160
+#: c/c-typeck.cc:15168
 #, fuzzy, gcc-internal-format
 msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
 msgstr "隱含轉換從 %qT 到 %qT 到匹配其他運算元的二進位運算式"
 
-#: c/c-typeck.cc:15478
+#: c/c-typeck.cc:15486
 #, gcc-internal-format
 msgid "used array that cannot be converted to pointer where scalar is required"
 msgstr "需要標量時使用了不能被轉換為指標的陣列"
 
-#: c/c-typeck.cc:15482
+#: c/c-typeck.cc:15490
 #, gcc-internal-format
 msgid "used struct type value where scalar is required"
 msgstr "需要標量時使用了結構類型"
 
-#: c/c-typeck.cc:15486
+#: c/c-typeck.cc:15494
 #, gcc-internal-format
 msgid "used union type value where scalar is required"
 msgstr "需要標量時使用了聯合類型"
 
-#: c/c-typeck.cc:15502
+#: c/c-typeck.cc:15510
 #, fuzzy, gcc-internal-format
 msgid "used vector type where scalar is required"
 msgstr "使用的向量型態位置純量被必要項"
 
-#: c/c-typeck.cc:15705 cp/semantics.cc:12555
+#: c/c-typeck.cc:15713 cp/semantics.cc:12576
 #, gcc-internal-format
 msgid "%<#pragma omp cancel%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15716 c/c-typeck.cc:15726 cp/semantics.cc:12566
-#: cp/semantics.cc:12576
+#: c/c-typeck.cc:15724 c/c-typeck.cc:15734 cp/semantics.cc:12587
+#: cp/semantics.cc:12597
 #, fuzzy, gcc-internal-format
 msgid "expected %<cancel%> %<if%> clause modifier"
 msgstr "預期 %<;%>之後類別定義"
 
-#: c/c-typeck.cc:15761 cp/semantics.cc:12611
+#: c/c-typeck.cc:15769 cp/semantics.cc:12632
 #, gcc-internal-format
 msgid "%<#pragma omp cancellation point%> must specify one of %<parallel%>, %<for%>, %<sections%> or %<taskgroup%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:15829 cp/semantics.cc:6066 cp/semantics.cc:9478
+#: c/c-typeck.cc:15837 cp/semantics.cc:6087 cp/semantics.cc:9499
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %qs clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:15833 c/c-typeck.cc:17798 cp/semantics.cc:6070
-#: cp/semantics.cc:9482
+#: c/c-typeck.cc:15841 c/c-typeck.cc:17806 cp/semantics.cc:6091
+#: cp/semantics.cc:9503
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %qs clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:15841
+#: c/c-typeck.cc:15849
 #, fuzzy, gcc-internal-format
 msgid "%<_Atomic%> %qD in %qs clause"
 msgstr "太多 %qs 子句"
 
-#: c/c-typeck.cc:15851 c/c-typeck.cc:17805 c/c-typeck.cc:17959
-#: cp/semantics.cc:6079 cp/semantics.cc:9489 cp/semantics.cc:9678
+#: c/c-typeck.cc:15859 c/c-typeck.cc:17813 c/c-typeck.cc:17967
+#: cp/semantics.cc:6100 cp/semantics.cc:9510 cp/semantics.cc:9699
 #, fuzzy, gcc-internal-format
 msgid "%qD is threadprivate variable in %qs clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:15884 cp/semantics.cc:6113
+#: c/c-typeck.cc:15892 cp/semantics.cc:6134
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "low bound %qE of array section does not have integral type"
 msgstr "陣列 new 的大小必須有整數類型"
 
-#: c/c-typeck.cc:15891 cp/semantics.cc:6120
+#: c/c-typeck.cc:15899 cp/semantics.cc:6141
 #, fuzzy, gcc-internal-format
 #| msgid "size in array new must have integral type"
 msgid "length %qE of array section does not have integral type"
 msgstr "陣列 new 的大小必須有整數類型"
 
-#: c/c-typeck.cc:15914 cp/semantics.cc:6153
+#: c/c-typeck.cc:15922 cp/semantics.cc:6174
 #, fuzzy, gcc-internal-format
 msgid "expected single pointer in %qs clause"
 msgstr "Cray 指標『%s』在中 %s 子句於 %L"
 
-#: c/c-typeck.cc:15932 c/c-typeck.cc:15999 c/c-typeck.cc:16290
-#: cp/semantics.cc:6171 cp/semantics.cc:6238
+#: c/c-typeck.cc:15940 c/c-typeck.cc:16007 c/c-typeck.cc:16298
+#: cp/semantics.cc:6192 cp/semantics.cc:6259
 #, fuzzy, gcc-internal-format
 msgid "zero length array section in %qs clause"
 msgstr "陣列區段在中『%s』呼叫於 %L"
 
-#: c/c-typeck.cc:15951 cp/semantics.cc:6190
+#: c/c-typeck.cc:15959 cp/semantics.cc:6211
 #, gcc-internal-format
 msgid "for unknown bound array type length expression must be specified"
 msgstr ""
 
-#: c/c-typeck.cc:15959 cp/semantics.cc:6198
+#: c/c-typeck.cc:15967 cp/semantics.cc:6219
 #, gcc-internal-format
 msgid "negative low bound in array section in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:15968 c/c-typeck.cc:16092 cp/semantics.cc:6207
-#: cp/semantics.cc:6331
+#: c/c-typeck.cc:15976 c/c-typeck.cc:16100 cp/semantics.cc:6228
+#: cp/semantics.cc:6352
 #, fuzzy, gcc-internal-format
 msgid "negative length in array section in %qs clause"
 msgstr "變數長度陣列被使用"
 
-#: c/c-typeck.cc:15985 cp/semantics.cc:6224
+#: c/c-typeck.cc:15993 cp/semantics.cc:6245
 #, gcc-internal-format
 msgid "low bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16028 cp/semantics.cc:6267
+#: c/c-typeck.cc:16036 cp/semantics.cc:6288
 #, gcc-internal-format
 msgid "length %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16043 cp/semantics.cc:6282
+#: c/c-typeck.cc:16051 cp/semantics.cc:6303
 #, gcc-internal-format
 msgid "high bound %qE above array section size in %qs clause"
 msgstr ""
 
-#: c/c-typeck.cc:16080 cp/semantics.cc:6319
+#: c/c-typeck.cc:16088 cp/semantics.cc:6340
 #, fuzzy, gcc-internal-format
 msgid "for array function parameter length expression must be specified"
 msgstr "用於遞增運算式沒有任何效果"
 
-#: c/c-typeck.cc:16084 cp/semantics.cc:6323
+#: c/c-typeck.cc:16092 cp/semantics.cc:6344
 #, fuzzy, gcc-internal-format
 msgid "for pointer type length expression must be specified"
 msgstr "用於遞增運算式沒有任何效果"
 
-#: c/c-typeck.cc:16112 c/c-typeck.cc:16229 cp/semantics.cc:6350
-#: cp/semantics.cc:6484
+#: c/c-typeck.cc:16120 c/c-typeck.cc:16237 cp/semantics.cc:6371
+#: cp/semantics.cc:6505
 #, fuzzy, gcc-internal-format
 msgid "array section is not contiguous in %qs clause"
 msgstr "複製陣列區段進入 contiguous 區塊於程序條目"
 
-#: c/c-typeck.cc:16122 cp/semantics.cc:6360
+#: c/c-typeck.cc:16130 cp/semantics.cc:6381
 #, fuzzy, gcc-internal-format
 msgid "%qE does not have pointer or array type"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: c/c-typeck.cc:16496 cp/semantics.cc:7539
+#: c/c-typeck.cc:16504 cp/semantics.cc:7560
 #, fuzzy, gcc-internal-format
 #| msgid "throwing NULL, which has integral, not pointer type"
 msgid "iterator %qD has neither integral nor pointer type"
 msgstr "拋出 NULL，它的類型是整數而不是指標"
 
-#: c/c-typeck.cc:16503
+#: c/c-typeck.cc:16511
 #, gcc-internal-format
 msgid "iterator %qD has %<_Atomic%> qualified type"
 msgstr ""
 
-#: c/c-typeck.cc:16509 cp/semantics.cc:7546
+#: c/c-typeck.cc:16517 cp/semantics.cc:7567
 #, fuzzy, gcc-internal-format
 msgid "iterator %qD has const qualified type"
 msgstr "參數 %qD 有不完整型態"
 
-#: c/c-typeck.cc:16522 cp/semantics.cc:7562
+#: c/c-typeck.cc:16530 cp/semantics.cc:7583
 #, fuzzy, gcc-internal-format
 msgid "iterator step with non-integral type"
 msgstr "bit-field %qD 與 non-integral 型態"
 
-#: c/c-typeck.cc:16542 cp/semantics.cc:7598
+#: c/c-typeck.cc:16550 cp/semantics.cc:7619
 #, gcc-internal-format
 msgid "iterator %qD has zero step"
 msgstr ""
 
-#: c/c-typeck.cc:16569
+#: c/c-typeck.cc:16577
 #, gcc-internal-format
 msgid "type of iterator %qD refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16576 cp/semantics.cc:7632
+#: c/c-typeck.cc:16584 cp/semantics.cc:7653
 #, gcc-internal-format
 msgid "begin expression refers to outer iterator %qD"
 msgstr ""
 
-#: c/c-typeck.cc:16582 cp/semantics.cc:7638
+#: c/c-typeck.cc:16590 cp/semantics.cc:7659
 #, fuzzy, gcc-internal-format
 msgid "end expression refers to outer iterator %qD"
 msgstr "無效的運算式用於輸出修飾鍵『%c』"
 
-#: c/c-typeck.cc:16588 cp/semantics.cc:7644
+#: c/c-typeck.cc:16596 cp/semantics.cc:7665
 #, fuzzy, gcc-internal-format
 msgid "step expression refers to outer iterator %qD"
 msgstr "%L 處運算式參照類型錯誤"
 
-#: c/c-typeck.cc:16625 cp/semantics.cc:7692
+#: c/c-typeck.cc:16633 cp/semantics.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "expected pointer in %qs clause"
 msgstr "預期的指標"
 
-#: c/c-typeck.cc:16735 cp/semantics.cc:7865
+#: c/c-typeck.cc:16743 cp/semantics.cc:7886
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<inscan%> and non-%<inscan%> %<reduction%> clauses on the same construct"
 msgstr "尚未支援程式碼模式 %<large%>"
 
-#: c/c-typeck.cc:16757 cp/semantics.cc:7885
+#: c/c-typeck.cc:16765 cp/semantics.cc:7906
 #, fuzzy, gcc-internal-format
 #| msgid "code model %<large%> not supported yet"
 msgid "%<inscan%> %<reduction%> clause with array section"
 msgstr "尚未支援程式碼模式 %<large%>"
 
-#: c/c-typeck.cc:16783 c/c-typeck.cc:16793
+#: c/c-typeck.cc:16791 c/c-typeck.cc:16801
 #, gcc-internal-format
 msgid "%qD in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: c/c-typeck.cc:16813
+#: c/c-typeck.cc:16821
 #, gcc-internal-format
 msgid "%<_Atomic%> %qE in %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:16825
+#: c/c-typeck.cc:16833
 #, fuzzy, gcc-internal-format
 msgid "zero sized type %qT in %qs clause"
 msgstr "假設的大小陣列『%s』在中 %s 子句於 %L"
 
-#: c/c-typeck.cc:16833
+#: c/c-typeck.cc:16841
 #, fuzzy, gcc-internal-format
 msgid "variable sized type %qT in %qs clause"
 msgstr "變數長度陣列 %qE 被使用"
 
-#: c/c-typeck.cc:16877
+#: c/c-typeck.cc:16885
 #, fuzzy, gcc-internal-format
 msgid "%qE has invalid type for %<reduction(%s)%>"
 msgstr "%qE 有無效的型態用於 %<reduction(%s)%>"
 
-#: c/c-typeck.cc:16886 cp/semantics.cc:7404
+#: c/c-typeck.cc:16894 cp/semantics.cc:7425
 #, gcc-internal-format
 msgid "user defined reduction not found for %qE"
 msgstr ""
 
-#: c/c-typeck.cc:16974
+#: c/c-typeck.cc:16982
 #, fuzzy, gcc-internal-format
 msgid "variable length element type in array %<reduction%> clause"
 msgstr "變數長度陣列被使用"
 
-#: c/c-typeck.cc:16992 c/c-typeck.cc:18053 cp/semantics.cc:10367
+#: c/c-typeck.cc:17000 c/c-typeck.cc:18061 cp/semantics.cc:10388
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<nowait%> clause must not be used together with %<copyprivate%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: c/c-typeck.cc:17004 cp/semantics.cc:10435
+#: c/c-typeck.cc:17012 cp/semantics.cc:10456
 #, fuzzy, gcc-internal-format
 msgid "%qE must be %<threadprivate%> for %<copyin%>"
 msgstr "%qE 必須是 %<threadprivate%> 用於 %<copyin%>"
 
-#: c/c-typeck.cc:17019 cp/semantics.cc:7928
+#: c/c-typeck.cc:17027 cp/semantics.cc:7949
 #, gcc-internal-format
 msgid "modifier should not be specified in %<linear%> clause on %<simd%> or %<for%> constructs when not using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: c/c-typeck.cc:17028
+#: c/c-typeck.cc:17036
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with type %qT"
 msgstr ""
 
-#: c/c-typeck.cc:17036
+#: c/c-typeck.cc:17044
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<linear%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17055 cp/semantics.cc:8012
+#: c/c-typeck.cc:17063 cp/semantics.cc:8033
 #, gcc-internal-format
 msgid "%<linear%> clause step %qE is neither constant nor a parameter"
 msgstr ""
 
-#: c/c-typeck.cc:17085 c/c-typeck.cc:17953 c/c-typeck.cc:18225
-#: cp/semantics.cc:8099 cp/semantics.cc:9672 cp/semantics.cc:10063
+#: c/c-typeck.cc:17093 c/c-typeck.cc:17961 c/c-typeck.cc:18233
+#: cp/semantics.cc:8120 cp/semantics.cc:9693 cp/semantics.cc:10084
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %qs"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17102 cp/semantics.cc:8117
+#: c/c-typeck.cc:17110 cp/semantics.cc:8138
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in data-sharing clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17113 cp/semantics.cc:8128
+#: c/c-typeck.cc:17121 cp/semantics.cc:8149
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in reduction clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17127 c/c-typeck.cc:17197 c/c-typeck.cc:17232
-#: c/c-typeck.cc:17363 cp/semantics.cc:8946
+#: c/c-typeck.cc:17135 c/c-typeck.cc:17205 c/c-typeck.cc:17240
+#: c/c-typeck.cc:17371 cp/semantics.cc:8967
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in data clauses"
 msgstr "%qE 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17137 c/c-typeck.cc:17205 c/c-typeck.cc:17701
-#: c/c-typeck.cc:17853 c/c-typeck.cc:17861 c/c-typeck.cc:17877
-#: c/c-typeck.cc:17886 c/c-typeck.cc:17894 cp/semantics.cc:8142
-#: cp/semantics.cc:8152 cp/semantics.cc:8245 cp/semantics.cc:8253
-#: cp/semantics.cc:8300 cp/semantics.cc:9360 cp/semantics.cc:9550
-#: cp/semantics.cc:9558 cp/semantics.cc:9578 cp/semantics.cc:9587
-#: cp/semantics.cc:9595
+#: c/c-typeck.cc:17145 c/c-typeck.cc:17213 c/c-typeck.cc:17709
+#: c/c-typeck.cc:17861 c/c-typeck.cc:17869 c/c-typeck.cc:17885
+#: c/c-typeck.cc:17894 c/c-typeck.cc:17902 cp/semantics.cc:8163
+#: cp/semantics.cc:8173 cp/semantics.cc:8266 cp/semantics.cc:8274
+#: cp/semantics.cc:8321 cp/semantics.cc:9381 cp/semantics.cc:9571
+#: cp/semantics.cc:9579 cp/semantics.cc:9599 cp/semantics.cc:9608
+#: cp/semantics.cc:9616
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in data clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17140 c/c-typeck.cc:17211 c/c-typeck.cc:17897
-#: cp/semantics.cc:8155 cp/semantics.cc:8259 cp/semantics.cc:9598
+#: c/c-typeck.cc:17148 c/c-typeck.cc:17219 c/c-typeck.cc:17905
+#: cp/semantics.cc:8176 cp/semantics.cc:8280 cp/semantics.cc:9619
 #, fuzzy, gcc-internal-format
 msgid "%qD appears both in data and map clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17185 cp/semantics.cc:8232
+#: c/c-typeck.cc:17193 cp/semantics.cc:8253
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %<firstprivate%>"
 msgstr "%qE 並非變數在中子句 %<firstprivate%>"
 
-#: c/c-typeck.cc:17225 cp/semantics.cc:8292
+#: c/c-typeck.cc:17233 cp/semantics.cc:8313
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in clause %<lastprivate%>"
 msgstr "%qE 並非變數在中子句 %<lastprivate%>"
 
-#: c/c-typeck.cc:17244 cp/semantics.cc:8725
+#: c/c-typeck.cc:17252 cp/semantics.cc:8746
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<aligned%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17251
+#: c/c-typeck.cc:17259
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
 msgstr "向量 delete 的引數類型既非指標也非陣列"
 
-#: c/c-typeck.cc:17258
+#: c/c-typeck.cc:17266
 #, gcc-internal-format
 msgid "%<_Atomic%> %qD in %<aligned%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:17265
+#: c/c-typeck.cc:17273
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<aligned%> clauses"
 msgstr "%qE 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17278 cp/semantics.cc:8794
+#: c/c-typeck.cc:17286 cp/semantics.cc:8815
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<nontemporal%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17284
+#: c/c-typeck.cc:17292
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<nontemporal%> clauses"
 msgstr "%qE 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17297 cp/semantics.cc:8833
+#: c/c-typeck.cc:17305 cp/semantics.cc:8854
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a variable in %<allocate%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17303
+#: c/c-typeck.cc:17311
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once in %<allocate%> clauses"
 msgstr "%qE 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17374 cp/semantics.cc:8965
+#: c/c-typeck.cc:17382 cp/semantics.cc:8986
 #, gcc-internal-format
 msgid "allocator %qE must be of %<omp_allocator_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17392 cp/semantics.cc:8986
+#: c/c-typeck.cc:17400 cp/semantics.cc:9007
 #, gcc-internal-format
 msgid "allocator %qE must be either a variable or a predefined allocator"
 msgstr ""
 
-#: c/c-typeck.cc:17406
+#: c/c-typeck.cc:17414
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocator %qE"
 msgstr "名稱「%s」在 %C 處不能做為已定義的運算子"
 
-#: c/c-typeck.cc:17423 cp/semantics.cc:9018
+#: c/c-typeck.cc:17431 cp/semantics.cc:9039
 #, gcc-internal-format
 msgid "memspace modifier %qE must be constant enum of %<omp_memspace_handle_t%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17439 cp/semantics.cc:9038
+#: c/c-typeck.cc:17447 cp/semantics.cc:9059
 #, gcc-internal-format
 msgid "traits array %qE must be defined in same scope as the construct on which the clause appears"
 msgstr ""
 
-#: c/c-typeck.cc:17464 cp/semantics.cc:9062
+#: c/c-typeck.cc:17472 cp/semantics.cc:9083
 #, gcc-internal-format
 msgid "traits array %qE must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17467
+#: c/c-typeck.cc:17475
 #, gcc-internal-format
 msgid "traits array must be of %<const omp_alloctrait_t []%> type"
 msgstr ""
 
-#: c/c-typeck.cc:17476 cp/semantics.cc:9078
+#: c/c-typeck.cc:17484 cp/semantics.cc:9099
 #, fuzzy, gcc-internal-format
 msgid "traits array must be initialized with constants"
 msgstr "陣列必須被初始化的與 brace-enclosed 初始設定式"
 
-#: c/c-typeck.cc:17512 cp/semantics.cc:9115
+#: c/c-typeck.cc:17520 cp/semantics.cc:9136
 #, gcc-internal-format
 msgid "%<depend%> clause with %<depobj%> dependence type on array section"
 msgstr ""
 
-#: c/c-typeck.cc:17527 cp/semantics.cc:9130
+#: c/c-typeck.cc:17535 cp/semantics.cc:9151
 #, gcc-internal-format
 msgid "%<omp_all_memory%> used with %<depend%> kind other than %<out%> or %<inout%>"
 msgstr ""
 
-#: c/c-typeck.cc:17535 cp/semantics.cc:9148
+#: c/c-typeck.cc:17543 cp/semantics.cc:9169
 #, fuzzy, gcc-internal-format
 msgid "%qE is not lvalue expression nor array section in %qs clause"
 msgstr "變數長度陣列被使用"
 
-#: c/c-typeck.cc:17556 cp/semantics.cc:9170
+#: c/c-typeck.cc:17564 cp/semantics.cc:9191
 #, gcc-internal-format
 msgid "%qE does not have %<omp_depend_t%> type in %<depend%> clause with %<depobj%> dependence type"
 msgstr ""
 
-#: c/c-typeck.cc:17566 cp/semantics.cc:9182
+#: c/c-typeck.cc:17574 cp/semantics.cc:9203
 #, gcc-internal-format
 msgid "%qE should not have %<omp_depend_t%> type in %<depend%> clause with dependence type other than %<depobj%>"
 msgstr ""
 
-#: c/c-typeck.cc:17637 cp/semantics.cc:9295
+#: c/c-typeck.cc:17645 cp/semantics.cc:9316
 #, fuzzy, gcc-internal-format
 msgid "array section does not have mappable type in %qs clause"
 msgstr "陣列區段無法允許的在中『%s』呼叫於 %L"
 
-#: c/c-typeck.cc:17657 c/c-typeck.cc:17733 c/c-typeck.cc:17769
-#: cp/semantics.cc:9315 cp/semantics.cc:9394 cp/semantics.cc:9430
+#: c/c-typeck.cc:17665 c/c-typeck.cc:17741 c/c-typeck.cc:17777
+#: cp/semantics.cc:9336 cp/semantics.cc:9415 cp/semantics.cc:9451
 #, fuzzy, gcc-internal-format
 msgid "unsupported map expression %qE"
 msgstr "無效的類型在中定點轉換"
 
-#: c/c-typeck.cc:17697 c/c-typeck.cc:17874 cp/semantics.cc:9356
-#: cp/semantics.cc:9575
+#: c/c-typeck.cc:17705 c/c-typeck.cc:17882 cp/semantics.cc:9377
+#: cp/semantics.cc:9596
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in motion clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17705 c/c-typeck.cc:17880 cp/semantics.cc:9364
-#: cp/semantics.cc:9581
+#: c/c-typeck.cc:17713 c/c-typeck.cc:17888 cp/semantics.cc:9385
+#: cp/semantics.cc:9602
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in map clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17824 c/c-typeck.cc:17966 cp/semantics.cc:9518
-#: cp/semantics.cc:9686
+#: c/c-typeck.cc:17832 c/c-typeck.cc:17974 cp/semantics.cc:9539
+#: cp/semantics.cc:9707
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have a mappable type in %qs clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17949 cp/semantics.cc:9667
+#: c/c-typeck.cc:17957 cp/semantics.cc:9688
 #, fuzzy, gcc-internal-format
 msgid "%qE is neither a variable nor a function name in clause %qs"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17975 cp/semantics.cc:9698
+#: c/c-typeck.cc:17983 cp/semantics.cc:9719
 #, fuzzy, gcc-internal-format
 msgid "%qE appears more than once on the same %<declare target%> directive"
 msgstr "%qE 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:17989 cp/semantics.cc:9714
+#: c/c-typeck.cc:17997 cp/semantics.cc:9735
 #, fuzzy, gcc-internal-format
 msgid "%qD is not an argument in %<uniform%> clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:17992 cp/semantics.cc:9717
+#: c/c-typeck.cc:18000 cp/semantics.cc:9738
 #, fuzzy, gcc-internal-format
 msgid "%qE is not an argument in %<uniform%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: c/c-typeck.cc:18011
+#: c/c-typeck.cc:18019
 #, fuzzy, gcc-internal-format
 msgid "%qs variable is not a pointer"
 msgstr "來源並非指標"
 
-#: c/c-typeck.cc:18018
+#: c/c-typeck.cc:18026
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor an array"
 msgstr "向量 delete 的引數類型既非指標也非陣列"
 
-#: c/c-typeck.cc:18066 c/c-typeck.cc:18172 cp/semantics.cc:10318
+#: c/c-typeck.cc:18074 c/c-typeck.cc:18180 cp/semantics.cc:10339
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<order%> clause must not be used together with %<ordered%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: c/c-typeck.cc:18086 cp/semantics.cc:9222
+#: c/c-typeck.cc:18094 cp/semantics.cc:9243
 #, fuzzy, gcc-internal-format
 msgid "too many %qs clauses on a task construct"
 msgstr "太多 %qs 子句"
 
-#: c/c-typeck.cc:18208 cp/semantics.cc:10031
+#: c/c-typeck.cc:18216 cp/semantics.cc:10052
 #, gcc-internal-format
 msgid "%<inbranch%> clause is incompatible with %<notinbranch%>"
 msgstr ""
 
-#: c/c-typeck.cc:18243 cp/semantics.cc:10125
+#: c/c-typeck.cc:18251 cp/semantics.cc:10146
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in action clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: c/c-typeck.cc:18254 cp/semantics.cc:10139
+#: c/c-typeck.cc:18262 cp/semantics.cc:10160
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take %<void%>"
 msgid "%qD must be of %<omp_interop_t%>"
 msgstr "%qD 必須有 %<void%> 類型"
 
-#: c/c-typeck.cc:18263 cp/semantics.cc:10148
+#: c/c-typeck.cc:18271 cp/semantics.cc:10169
 #, fuzzy, gcc-internal-format
 msgid "%qD shall not be const"
 msgstr "%q#D 不是常數"
 
-#: c/c-typeck.cc:18312 cp/semantics.cc:10506
+#: c/c-typeck.cc:18320 cp/semantics.cc:10527
 #, fuzzy, gcc-internal-format
 msgid "%qE is predetermined %qs for %qs"
 msgstr "%qE 被 predetermined %qs 用於 %qs"
 
-#: c/c-typeck.cc:18322
+#: c/c-typeck.cc:18330
 #, gcc-internal-format
 msgid "%<const%> qualified %qE may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: c/c-typeck.cc:18358 cp/semantics.cc:10259
+#: c/c-typeck.cc:18366 cp/semantics.cc:10280
 #, gcc-internal-format
 msgid "%<simdlen%> clause value is bigger than %<safelen%> clause value"
 msgstr ""
 
-#: c/c-typeck.cc:18370 cp/semantics.cc:10272
+#: c/c-typeck.cc:18378 cp/semantics.cc:10293
 #, gcc-internal-format
 msgid "%<nonmonotonic%> schedule modifier specified together with %<ordered%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18381 c/c-typeck.cc:18389 cp/semantics.cc:10281
-#: cp/semantics.cc:10310
+#: c/c-typeck.cc:18389 c/c-typeck.cc:18397 cp/semantics.cc:10302
+#: cp/semantics.cc:10331
 #, fuzzy, gcc-internal-format
 msgid "%qs clause specified together with %<inscan%> %<reduction%> clause"
 msgstr "%qE 有無效的型態用於 %<reduction%>"
 
-#: c/c-typeck.cc:18437 cp/semantics.cc:10239
+#: c/c-typeck.cc:18445 cp/semantics.cc:10260
 #, gcc-internal-format
 msgid "%<linear%> clause step is a parameter %qD not specified in %<uniform%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18488 cp/semantics.cc:10289
+#: c/c-typeck.cc:18496 cp/semantics.cc:10310
 #, gcc-internal-format
 msgid "%<nogroup%> clause must not be used together with %<reduction%> clause"
 msgstr ""
 
-#: c/c-typeck.cc:18496 cp/semantics.cc:10300
+#: c/c-typeck.cc:18504 cp/semantics.cc:10321
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<grainsize%> clause must not be used together with %<num_tasks%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: c/c-typeck.cc:18504 cp/semantics.cc:10356
+#: c/c-typeck.cc:18512 cp/semantics.cc:10377
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<full%> clause must not be used together with %<partial%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: c/c-typeck.cc:18514 cp/semantics.cc:10329
+#: c/c-typeck.cc:18522 cp/semantics.cc:10350
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<detach%> clause must not be used together with %<mergeable%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: c/c-typeck.cc:18532 cp/semantics.cc:10531
+#: c/c-typeck.cc:18540 cp/semantics.cc:10552
 #, gcc-internal-format
 msgid "the event handle of a %<detach%> clause should not be in a data-sharing clause"
 msgstr ""
 
-#: c/c-typeck.cc:18550 cp/semantics.cc:10602
+#: c/c-typeck.cc:18558 cp/semantics.cc:10623
 #, gcc-internal-format
 msgid "%<depend%> clause requires action clauses with %<targetsync%> interop-type"
 msgstr ""
 
-#: c/c-typeck.cc:18554 cp/semantics.cc:10606
+#: c/c-typeck.cc:18562 cp/semantics.cc:10627
 #, gcc-internal-format
 msgid "%<init%> clause lacks the %<targetsync%> modifier"
 msgstr ""
 
-#: c/c-typeck.cc:18736
+#: c/c-typeck.cc:18744
 #, gcc-internal-format
 msgid "cannot use %<va_arg%> with reverse storage order"
 msgstr ""
 
-#: c/c-typeck.cc:18741
+#: c/c-typeck.cc:18749
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is of incomplete type %qT"
 msgstr "給 %<va_arg%> 的第一個參數的類型不是 %<va_list%>"
 
-#: c/c-typeck.cc:18747
+#: c/c-typeck.cc:18755
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is a function type %qT"
 msgstr "給 %<va_arg%> 的第一個參數的類型不是 %<va_list%>"
 
-#: c/c-typeck.cc:18754 c/c-typeck.cc:18764
+#: c/c-typeck.cc:18762 c/c-typeck.cc:18772
 #, fuzzy, gcc-internal-format
 #| msgid "first argument to %<va_arg%> not of type %<va_list%>"
 msgid "second argument to %<va_arg%> is an array type %qT"
 msgstr "給 %<va_arg%> 的第一個參數的類型不是 %<va_list%>"
 
-#: c/c-typeck.cc:18760
+#: c/c-typeck.cc:18768
 #, fuzzy, gcc-internal-format
 msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
 msgstr "C++需求升級的型態，無法 enum 型態，在中 %<va_arg%>"
@@ -57156,257 +57204,252 @@ msgstr ""
 msgid "no such exception: 0x%x"
 msgstr ""
 
-#: cobol/genapi.cc:353
+#: cobol/genapi.cc:362
 #, gcc-internal-format
 msgid "Probable cause: it was referenced without being defined."
 msgstr ""
 
-#: cobol/genapi.cc:597
+#: cobol/genapi.cc:606
 #, gcc-internal-format
 msgid "That string should not be that long."
 msgstr ""
 
-#: cobol/genapi.cc:1263
+#: cobol/genapi.cc:1272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s should not be null"
 msgstr "%qD 應該被初始化的"
 
-#: cobol/genapi.cc:1828
+#: cobol/genapi.cc:1837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Knows not the variable type %s for %s"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: cobol/genapi.cc:2162
+#: cobol/genapi.cc:2171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: Invalid field type %s:"
 msgstr "%s:%d：無效的狀態檔案；%s"
 
-#: cobol/genapi.cc:4444
+#: cobol/genapi.cc:4622
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for ACCEPT statement."
 msgstr "%C 處 PROGRAM 敘述格式無效"
 
-#: cobol/genapi.cc:5497
+#: cobol/genapi.cc:5675
 #, gcc-internal-format
 msgid "Attempting to send to an input device."
 msgstr ""
 
-#: cobol/genapi.cc:5520
+#: cobol/genapi.cc:5698
 #, fuzzy, gcc-internal-format
 #| msgid "Invalid form of PROGRAM statement at %C"
 msgid "Not valid for DISPLAY statement."
 msgstr "%C 處 PROGRAM 敘述格式無效"
 
-#: cobol/genapi.cc:7790 cobol/genapi.cc:7796 cobol/genapi.cc:7802
+#: cobol/genapi.cc:8069 cobol/genapi.cc:8075 cobol/genapi.cc:8081
 #, gcc-internal-format
 msgid "%<parser_logop()%> was called with variable %s on line %d, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7909
+#: cobol/genapi.cc:8188
 #, gcc-internal-format
 msgid "%<parser_relop%> was called with variable %qs, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:7973
+#: cobol/genapi.cc:8252
 #, gcc-internal-format
 msgid "%<parser_relop()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8018
+#: cobol/genapi.cc:8297
 #, gcc-internal-format
 msgid "%<parser_if()%> was called with variable %s, which is not a FldConditional"
 msgstr ""
 
-#: cobol/genapi.cc:8269
+#: cobol/genapi.cc:8552
 #, gcc-internal-format
 msgid "candidate %s has unimplemented %<CVT_type%> %d(%s)"
 msgstr ""
 
-#: cobol/genapi.cc:8280
+#: cobol/genapi.cc:8563
 #, fuzzy, gcc-internal-format
 msgid "unknown %<setop_t%> code %d"
 msgstr "不明『# pragma externmodel』式樣『%s』(_M)"
 
-#: cobol/genapi.cc:8469
+#: cobol/genapi.cc:8752
 #, gcc-internal-format
 msgid "%s:%d: %u exceeds %<MAXIMUM_UNTILS%> of %d, line %d"
 msgstr ""
 
-#: cobol/genapi.cc:9460
-#, gcc-internal-format, gfc-internal-format
-msgid "%s:%d: ignoring subscripts"
-msgstr ""
-
-#: cobol/genapi.cc:9683 cobol/genapi.cc:10175
+#: cobol/genapi.cc:9962 cobol/genapi.cc:10454
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9808
+#: cobol/genapi.cc:10087
 #, gcc-internal-format
 msgid "%s:%d file %s access mode is %<file_inaccessible_e%> in %s"
 msgstr ""
 
-#: cobol/genapi.cc:9915
+#: cobol/genapi.cc:10194
 #, gcc-internal-format
 msgid "%<parser_file_open%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9920
+#: cobol/genapi.cc:10199
 #, gcc-internal-format
 msgid "%<parser_file_open%> for %s called with NULL %<var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:9926
+#: cobol/genapi.cc:10205
 #, gcc-internal-format, gfc-internal-format
 msgid "EXTEND can only be used where %s is ACCESS MODE SEQUENTIAL"
 msgstr ""
 
-#: cobol/genapi.cc:9986
+#: cobol/genapi.cc:10265
 #, gcc-internal-format
 msgid "%<parser_file_close%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:9991
+#: cobol/genapi.cc:10270
 #, gcc-internal-format
 msgid "%<parser_file_close%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10046
+#: cobol/genapi.cc:10325
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'where' is zero in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10056
+#: cobol/genapi.cc:10335
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *file"
 msgstr ""
 
-#: cobol/genapi.cc:10061
+#: cobol/genapi.cc:10340
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10067
+#: cobol/genapi.cc:10346
 #, gcc-internal-format
 msgid "%<parser_file_read%> called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10072
+#: cobol/genapi.cc:10351
 #, gcc-internal-format
 msgid "%<parser_file_read%> for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10078
+#: cobol/genapi.cc:10357
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/SEQUENTIAL, but %<where >= 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10087
+#: cobol/genapi.cc:10366
 #, gcc-internal-format
 msgid "%s:%d file %s is RELATIVE/RANDOM, but %<where < 0%>"
 msgstr ""
 
-#: cobol/genapi.cc:10131
+#: cobol/genapi.cc:10410
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s 'sequentially' is %d in %s"
 msgstr ""
 
-#: cobol/genapi.cc:10180
+#: cobol/genapi.cc:10459
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<file->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10186
+#: cobol/genapi.cc:10465
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: called with NULL *field"
 msgstr ""
 
-#: cobol/genapi.cc:10191
+#: cobol/genapi.cc:10470
 #, gcc-internal-format
 msgid "%s: for %s called with NULL %<field->var_decl_node%>"
 msgstr ""
 
-#: cobol/genapi.cc:10276
+#: cobol/genapi.cc:10555
 #, gcc-internal-format
 msgid "The file pointer should not be null"
 msgstr ""
 
-#: cobol/genapi.cc:10459
+#: cobol/genapi.cc:10738
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d file %s is INDEXED/SEQUENTIAL, but 'sequentially' is false"
 msgstr ""
 
-#: cobol/genapi.cc:12290
+#: cobol/genapi.cc:12582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%s: asked to sort %s, which is not a table"
 msgstr "%qT 被解析到非類別類型 %qT"
 
 #. Having both or neither violates SORT syntax
-#: cobol/genapi.cc:12422
+#: cobol/genapi.cc:12714
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) USING and input-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12556
+#: cobol/genapi.cc:12848
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) GIVING and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:12978
+#: cobol/genapi.cc:13270
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: syntax error: both (or neither) files and output-proc are specified"
 msgstr ""
 
-#: cobol/genapi.cc:13382
+#: cobol/genapi.cc:13674
 #, gcc-internal-format
 msgid "CALL USING BY CONTENT <temporary> would require REPOSITORY PROTOTYPES."
 msgstr ""
 
-#: cobol/genapi.cc:13653
+#: cobol/genapi.cc:13945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "%s: What in the name of Nero are we doing here?"
 msgstr "名稱「%s」(位於 %C)是一個程序的名稱"
 
-#: cobol/genapi.cc:15043
+#: cobol/genapi.cc:15462
 #, gcc-internal-format
 msgid "In %<parser_move(%s to %s)%>, the move of FldLiteralN to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:15280
+#: cobol/genapi.cc:15699
 #, gcc-internal-format
 msgid "In %<mh_dest_is_float%>(%s to %s), the move of %s to %s is unimplemented"
 msgstr ""
 
-#: cobol/genapi.cc:17171
+#: cobol/genapi.cc:17553
 #, gcc-internal-format, gfc-internal-format
 msgid "LEVEL 01 (%s) OCCURS has insufficient data.memsize"
 msgstr ""
 
-#: cobol/genapi.cc:17209
+#: cobol/genapi.cc:17591
 #, gcc-internal-format
 msgid "%<parser_symbol_add()%> was called with a NULL %<new_var%>"
 msgstr ""
 
-#: cobol/genapi.cc:17239
+#: cobol/genapi.cc:17621
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s is a table, but it improperly has a capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17279
+#: cobol/genapi.cc:17661
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %s is its own ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17284
+#: cobol/genapi.cc:17666
 #, gcc-internal-format
 msgid "%s: %d %qs has NULL ancestor"
 msgstr ""
 
-#: cobol/genapi.cc:17291
+#: cobol/genapi.cc:17673
 #, gcc-internal-format
 msgid "%s(%s) improperly has a non-null %<var_decl_node%>"
 msgstr ""
@@ -57415,73 +57458,83 @@ msgstr ""
 #. During the early stages of implementing cbl_field_t::our_index, there
 #. were execution paths in parse.y and parser.cc that resulted in
 #. our_index not being set.  Those should be gone.
-#: cobol/genapi.cc:17426
+#: cobol/genapi.cc:17808
 #, gcc-internal-format
 msgid "%<our_index%> is NULL under unanticipated circumstances"
 msgstr ""
 
-#: cobol/genapi.cc:17512
+#: cobol/genapi.cc:17894
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: %d %s<%s> improperly has a data.capacity of zero"
 msgstr ""
 
-#: cobol/genapi.cc:17580
+#: cobol/genapi.cc:17962
 #, gcc-internal-format
 msgid "%<bytes_to_allocate%> is zero for %s (symbol number "
 msgstr ""
 
-#: cobol/gengen.cc:360
+#: cobol/gengen.cc:370
 #, gcc-internal-format
 msgid "The given type is NULL, and that is just not fair"
 msgstr ""
 
-#: cobol/gengen.cc:369
+#: cobol/gengen.cc:379
 #, fuzzy, gcc-internal-format
 #| msgid "derived type declaration"
 msgid "The given type is not a declaration or a TYPE"
 msgstr "衍生的類型宣告"
 
-#: cobol/gengen.cc:413
+#: cobol/gengen.cc:423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown type %d"
 msgstr "不明型態名稱 %qE"
 
-#: cobol/gengen.cc:482
+#: cobol/gengen.cc:502
 #, gcc-internal-format
 msgid "Attempting an assignment of differing types."
 msgstr ""
 
-#: cobol/gengen.cc:526
+#: cobol/gengen.cc:651
 #, gcc-internal-format, gfc-internal-format
 msgid "Somebody asked for the field %s.%s, which does not exist"
 msgstr ""
 
-#: cobol/gengen.cc:2159 cobol/gengen.cc:2212 cobol/gengen.cc:3039
-#: cobol/gengen.cc:3094
+#: cobol/gengen.cc:1276
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with %s"
+msgstr "%qD 不是相容與 %qD"
+
+#: cobol/gengen.cc:1294
+#, gcc-internal-format, gfc-internal-format
+msgid "%s:%d: Must not call here with non-%s"
+msgstr ""
+
+#: cobol/gengen.cc:2017 cobol/gengen.cc:2070 cobol/gengen.cc:2897
+#: cobol/gengen.cc:2952
 #, gcc-internal-format
 msgid "You *must* be joking"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2166
+#: cobol/gengen.cc:2024
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_printf()%> again"
 msgstr ""
 
 #. Warning:  This test is not completely reliable, because a garbage
 #. byte could have a valid TREE_CODE.  But it does help.
-#: cobol/gengen.cc:2590 cobol/gengen.cc:2749
+#: cobol/gengen.cc:2448 cobol/gengen.cc:2607
 #, gcc-internal-format
 msgid "You forgot to put a %<NULL_TREE%> at the end of a %<gg_define_function()%> again"
 msgstr ""
 
-#: cobol/gengen.cc:2601 cobol/gengen.cc:2760
+#: cobol/gengen.cc:2459 cobol/gengen.cc:2618
 #, gcc-internal-format, gfc-internal-format
 msgid "%d parameters? Really? Are you insane?"
 msgstr ""
 
-#: cobol/gengen.cc:2882
+#: cobol/gengen.cc:2740
 #, gcc-internal-format
 msgid "Residual context count"
 msgstr ""
@@ -57491,13 +57544,13 @@ msgstr ""
 msgid "%<parser_op()%> doesn%'t know how to evaluate %<%s = %s %c %s%>"
 msgstr ""
 
-#: cobol/genutil.cc:643 cobol/genutil.cc:710
+#: cobol/genutil.cc:640 cobol/genutil.cc:707
 #, fuzzy, gcc-internal-format
 #| msgid "too many input files"
 msgid "Too many subscripts"
 msgstr "輸入檔案太多"
 
-#: cobol/genutil.cc:871
+#: cobol/genutil.cc:868
 #, fuzzy, gcc-internal-format
 msgid "cannot get %<float%> value from %s"
 msgstr "無法讀取 LTO decls 從 %s"
@@ -57514,64 +57567,64 @@ msgstr "使用另一套暫存器名"
 msgid "%s exited with status %d"
 msgstr "%s：%s 以狀態碼 %d 離開\n"
 
-#: cobol/symbols.cc:426
+#: cobol/symbols.cc:434
 msgid "%s:%d: LblNone '%s' has parent #%zu"
 msgstr ""
 
-#: cobol/symbols.cc:1883
+#: cobol/symbols.cc:1900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: wait: %s\n"
 msgid "%s: data item %s #"
 msgstr "%s：等待：%s\n"
 
-#: cobol/symbols.cc:2047
+#: cobol/symbols.cc:2069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: key must be field"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: cobol/symbols.cc:4232
+#: cobol/symbols.cc:4292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %s has invalid encoding"
 msgstr "%s「%s」%s 無效"
 
-#: cobol/symbols.cc:4400 cobol/symbols.cc:4503 cobol/symbols.cc:4533
+#: cobol/symbols.cc:4460 cobol/symbols.cc:4563 cobol/symbols.cc:4593
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: would convert file '%s'\n"
 msgid "%s:%d: could not add '%s'"
 msgstr "%s：將要轉換檔案「%s」\n"
 
-#: cobol/util.cc:1776
+#: cobol/util.cc:1741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s: %s %lu %s %lu"
 msgstr "%s：%s：%s"
 
-#: cobol/util.cc:1791
+#: cobol/util.cc:1756
 #, gcc-internal-format, gfc-internal-format
 msgid "%s: nbytes %lu %s %lu"
 msgstr ""
 
-#: cobol/util.cc:1869
+#: cobol/util.cc:1834
 #, gcc-internal-format, gfc-internal-format
 msgid "%s:%d: type %s, who woulda thunk?"
 msgstr ""
 
-#: cobol/util.cc:2224
+#: cobol/util.cc:2189
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: MOVE %s %s invalid type:"
 msgstr ""
 
-#: cobol/util.cc:2814
+#: cobol/util.cc:2779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s: compiling '%s'\n"
 msgid "%s: regcomp: %s"
 msgstr "%s：正在編譯「%s」\n"
 
-#: cobol/util.cc:2963
+#: cobol/util.cc:2928
 #, gcc-internal-format, gfc-internal-format
 msgid "logic error: missing inode for %s"
 msgstr ""
 
-#: cobol/util.cc:3387
+#: cobol/util.cc:3352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect: recompiling %s\n"
 msgid "failed compiling %s"
@@ -58027,7 +58080,7 @@ msgstr "沒有合適的 %<operator %s%> 給 %qT"
 msgid "%q#D is private within this context"
 msgstr "在此上下文中"
 
-#: cp/call.cc:8447 cp/decl.cc:10339
+#: cp/call.cc:8447 cp/decl.cc:10353
 #, fuzzy, gcc-internal-format
 msgid "declared private here"
 msgstr "宣告的在此"
@@ -58038,7 +58091,7 @@ msgstr "宣告的在此"
 msgid "%q#D is protected within this context"
 msgstr "在此上下文中"
 
-#: cp/call.cc:8453 cp/decl.cc:10340
+#: cp/call.cc:8453 cp/decl.cc:10354
 #, fuzzy, gcc-internal-format
 msgid "declared protected here"
 msgstr "宣告的在此"
@@ -58386,7 +58439,7 @@ msgstr "non-integer 引數 3 在中呼叫到函式 %qE"
 msgid "constructor delegates to itself"
 msgstr "常數參考它自己"
 
-#: cp/call.cc:11924 cp/typeck.cc:10776
+#: cp/call.cc:11924 cp/typeck.cc:10774
 #, fuzzy
 msgid "cannot convert %qH to %qI"
 msgstr "無法轉換 %qT 到 %qT"
@@ -58407,7 +58460,7 @@ msgstr "對 %<%T::%s(%A)%#V%> 的呼叫沒有匹配的函式"
 msgid "call to non-function %qD"
 msgstr "呼叫非函式的 %qD"
 
-#: cp/call.cc:12066 cp/pt.cc:18011 cp/typeck.cc:3666
+#: cp/call.cc:12066 cp/pt.cc:18152 cp/typeck.cc:3666
 #, fuzzy, gcc-internal-format
 msgid "cannot call constructor %<%T::%D%> directly"
 msgstr "無法呼叫建構子 %<%T::%D%>直接"
@@ -59051,7 +59104,7 @@ msgstr "flexible 陣列成員在中否則清空結構"
 msgid "next member %q#D declared here"
 msgstr "  %q+#D 已在此宣告過"
 
-#: cp/class.cc:7967 cp/decl.cc:19542 cp/parser.cc:30588
+#: cp/class.cc:7967 cp/decl.cc:19608 cp/parser.cc:30652
 #, gcc-internal-format
 msgid "redefinition of %q#T"
 msgstr "%q#T 重定義"
@@ -59061,7 +59114,7 @@ msgstr "%q#T 重定義"
 msgid "defining %qT, which previously failed to be complete in a SFINAE context"
 msgstr ""
 
-#: cp/class.cc:7979 cp/decl.cc:20587
+#: cp/class.cc:7979 cp/decl.cc:20653
 #, gcc-internal-format
 msgid "here.  Use %qs for a diagnostic at that point"
 msgstr ""
@@ -59197,7 +59250,7 @@ msgstr "無效的型態用於參數 %d 的 constexpr 函式 %q+#D"
 msgid "lambdas are implicitly %<constexpr%> only in C++17 and later"
 msgstr ""
 
-#: cp/constexpr.cc:274 cp/decl.cc:16470
+#: cp/constexpr.cc:274 cp/decl.cc:16513
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> destructors only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
@@ -59248,7 +59301,7 @@ msgstr ""
 msgid "%qD is not usable as a %<constexpr%> function because:"
 msgstr "%q+D 不是可用做為 constexpr 函式因為："
 
-#: cp/constexpr.cc:1466 cp/constexpr.cc:7964
+#: cp/constexpr.cc:1466 cp/constexpr.cc:7987
 #, gcc-internal-format
 msgid "destroying %qE outside its lifetime"
 msgstr ""
@@ -59284,868 +59337,868 @@ msgstr ""
 msgid "uncaught exception of type %qT"
 msgstr "異常的型態 %qT 將是擷取到"
 
-#: cp/constexpr.cc:1912
+#: cp/constexpr.cc:1908
 #, fuzzy, gcc-internal-format
 msgid "call to %qD function with incorrect number of arguments"
 msgstr "%qD 必須不有可變個數引數數量"
 
-#: cp/constexpr.cc:1930
+#: cp/constexpr.cc:1926
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions pending"
 msgstr "%q+D 宣告時有異常指定"
 
-#: cp/constexpr.cc:2014
+#: cp/constexpr.cc:2010
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "cannot allocate exception: size not constant"
 msgstr "整型運算式 %qE 不是常數"
 
-#: cp/constexpr.cc:2034
+#: cp/constexpr.cc:2030
 #, gcc-internal-format
 msgid "first argument to %qD function not result of %<__cxa_allocate_exception%>"
 msgstr ""
 
-#: cp/constexpr.cc:2065 cp/constexpr.cc:2117
+#: cp/constexpr.cc:2061 cp/constexpr.cc:2113
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "%qD called with no caught exceptions active"
 msgstr "%q+D 宣告時有異常指定"
 
-#: cp/constexpr.cc:2155
+#: cp/constexpr.cc:2151
 #, gcc-internal-format
 msgid "%qD called without %<std::%D%> being defined"
 msgstr ""
 
-#: cp/constexpr.cc:2224
+#: cp/constexpr.cc:2220
 #, fuzzy, gcc-internal-format
 #| msgid "%s does not support %s"
 msgid "%qD called without supportable %qs"
 msgstr "%s 不支援 %s"
 
-#: cp/constexpr.cc:2280
+#: cp/constexpr.cc:2276
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD called with unexpected %qs argument"
 msgstr "%qD 使用時未帶範本參數"
 
-#: cp/constexpr.cc:2308
+#: cp/constexpr.cc:2304
 #, gcc-internal-format
 msgid "%qD called with second argument other than 1 or -1"
 msgstr ""
 
-#: cp/constexpr.cc:2346
+#: cp/constexpr.cc:2342
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %qs call"
 msgstr "錯誤的引數數量到 %<__builtin_complex%>"
 
-#: cp/constexpr.cc:2373
+#: cp/constexpr.cc:2369
 #, gcc-internal-format
 msgid "first %qs call argument should be 0, 1, 2, 16, 17 or 18"
 msgstr ""
 
-#: cp/constexpr.cc:2420
+#: cp/constexpr.cc:2416
 #, gcc-internal-format
 msgid "%qs tag string contains %qc character other than letters, digits or %<_%>"
 msgstr ""
 
-#: cp/constexpr.cc:2454
+#: cp/constexpr.cc:2450
 msgid "constexpr message: %.*s [%r%.*s%R]"
 msgstr ""
 
-#: cp/constexpr.cc:2458
+#: cp/constexpr.cc:2454
 #, fuzzy, gcc-internal-format
 msgid "constexpr message: %.*s"
 msgstr "# pragma 訊息：%s"
 
-#: cp/constexpr.cc:2564 cp/constexpr.cc:4540
+#: cp/constexpr.cc:2573 cp/constexpr.cc:4553
 #: rust/backend/rust-constexpr.cc:3510
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> call flows off the end of the function"
 msgstr "%<constexpr%> 無法用於類型宣告"
 
-#: cp/constexpr.cc:2566 cp/constexpr.cc:2687 cp/constexpr.cc:2696
-#: cp/constexpr.cc:4873 rust/backend/rust-constexpr.cc:3515
+#: cp/constexpr.cc:2575 cp/constexpr.cc:2696 cp/constexpr.cc:2705
+#: cp/constexpr.cc:4886 rust/backend/rust-constexpr.cc:3515
 #: rust/backend/rust-constexpr.cc:3525
 #, fuzzy, gcc-internal-format
 msgid "%q+E is not a constant expression"
 msgstr "%q+E並非常數運算式"
 
-#: cp/constexpr.cc:2856 cp/constexpr.cc:3821 cp/constexpr.cc:4195
-#: cp/constexpr.cc:4260 cp/constexpr.cc:12039
+#: cp/constexpr.cc:2865 cp/constexpr.cc:3830 cp/constexpr.cc:4204
+#: cp/constexpr.cc:4269 cp/constexpr.cc:12081
 #: rust/backend/rust-constexpr.cc:6013
 #, fuzzy, gcc-internal-format
 msgid "call to non-%<constexpr%> function %qD"
 msgstr "呼叫到 non-constexpr 函式 %qD"
 
-#: cp/constexpr.cc:2930 cp/constexpr.cc:7481 cp/constexpr.cc:10199
+#: cp/constexpr.cc:2939 cp/constexpr.cc:7504 cp/constexpr.cc:10241
 #: rust/backend/rust-constexpr.cc:916 rust/backend/rust-constexpr.cc:2576
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer"
 msgstr "提領 %<void *%> 指標"
 
-#: cp/constexpr.cc:3117
+#: cp/constexpr.cc:3126
 #, fuzzy, gcc-internal-format
 msgid "the comparison reduces to %qE"
 msgstr "太多引數到 %qE"
 
-#: cp/constexpr.cc:3120
+#: cp/constexpr.cc:3129
 #, fuzzy, gcc-internal-format
 #| msgid "user-defined %qD always evaluates both arguments"
 msgid "%qE evaluates to false"
 msgstr "使用者定義的 %qD 總是計算所有兩個參數"
 
-#: cp/constexpr.cc:3203
+#: cp/constexpr.cc:3212
 #, gcc-internal-format
 msgid "failed %<assume%> attribute assumption"
 msgstr ""
 
-#: cp/constexpr.cc:3243 cp/constexpr.cc:11984
+#: cp/constexpr.cc:3252 cp/constexpr.cc:12026
 #: rust/backend/rust-constexpr.cc:5982
 #, fuzzy, gcc-internal-format
 #| msgid "call to non-function %qD"
 msgid "call to internal function %qE"
 msgstr "呼叫非函式的 %qD"
 
-#: cp/constexpr.cc:3300 rust/backend/rust-constexpr.cc:2697
+#: cp/constexpr.cc:3309 rust/backend/rust-constexpr.cc:2697
 #, fuzzy, gcc-internal-format
 msgid "modifying a const object %qE is not allowed in a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:3328 rust/backend/rust-constexpr.cc:2700
+#: cp/constexpr.cc:3337 rust/backend/rust-constexpr.cc:2700
 #, fuzzy, gcc-internal-format
 msgid "originally declared %<const%> here"
 msgstr "原本地定義的在此"
 
-#: cp/constexpr.cc:3606 cp/constexpr.cc:3665 cp/constexpr.cc:3698
-#: cp/constexpr.cc:3720
+#: cp/constexpr.cc:3615 cp/constexpr.cc:3674 cp/constexpr.cc:3707
+#: cp/constexpr.cc:3729
 #, gcc-internal-format
 msgid "reference %<dynamic_cast%> failed"
 msgstr ""
 
-#: cp/constexpr.cc:3607
+#: cp/constexpr.cc:3616
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a base type for type %qT"
 msgid "dynamic type %qT of its operand does not have a base class of type %qT"
 msgstr "類型 %qT 不是類型 %qT 的基礎類別"
 
-#: cp/constexpr.cc:3634
+#: cp/constexpr.cc:3643
 #, fuzzy, gcc-internal-format
 msgid "virtual table pointer is used uninitialized"
 msgstr "變數 %D 的型態 %<io%> 必須被 uninitialized"
 
-#: cp/constexpr.cc:3666 cp/constexpr.cc:3699
+#: cp/constexpr.cc:3675 cp/constexpr.cc:3708
 #, gcc-internal-format
 msgid "static type %qT of its operand is a non-public base class of dynamic type %qT"
 msgstr ""
 
-#: cp/constexpr.cc:3722
+#: cp/constexpr.cc:3731
 #, fuzzy, gcc-internal-format
 msgid "%qT is an ambiguous base class of dynamic type %qT of its operand"
 msgstr "  %qT 是模稜兩可的基礎類別的 %qT"
 
-#: cp/constexpr.cc:3725
+#: cp/constexpr.cc:3734
 #, gcc-internal-format
 msgid "dynamic type %qT of its operand does not have an unambiguous public base class %qT"
 msgstr ""
 
 #. virtual_offset is only set for virtual bases, which make the
 #. class non-literal, so we don't need to handle it here.
-#: cp/constexpr.cc:3827
+#: cp/constexpr.cc:3836
 #, fuzzy, gcc-internal-format
 #| msgid "cannot call member function %qD without object"
 msgid "calling constexpr member function %qD through virtual base subobject"
 msgstr "沒有物件無法呼叫成員函式 %qD"
 
-#: cp/constexpr.cc:3907
+#: cp/constexpr.cc:3916
 #, fuzzy, gcc-internal-format
 msgid "couldn%'t throw %qT"
 msgstr "couldn%'t 了解字距微調.osversion %q.*s"
 
-#: cp/constexpr.cc:3982 rust/backend/rust-constexpr.cc:3571
+#: cp/constexpr.cc:3991 rust/backend/rust-constexpr.cc:3571
 #, fuzzy, gcc-internal-format
 msgid "expression %qE does not designate a %<constexpr%> function"
 msgstr "運算式 %qE 不指定 constexpr 函式"
 
-#: cp/constexpr.cc:4065
+#: cp/constexpr.cc:4074
 #, fuzzy, gcc-internal-format
 #| msgid "'o' operand is not constant"
 msgid "cannot allocate array: size not constant"
 msgstr "「o」運算元不是一個常數"
 
-#: cp/constexpr.cc:4098
+#: cp/constexpr.cc:4107
 #, gcc-internal-format
 msgid "array deallocation of object allocated with non-array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4102 cp/constexpr.cc:4125
+#: cp/constexpr.cc:4111 cp/constexpr.cc:4134
 #, fuzzy, gcc-internal-format
 msgid "allocation performed here"
 msgstr "宣告的在此"
 
-#: cp/constexpr.cc:4121
+#: cp/constexpr.cc:4130
 #, gcc-internal-format
 msgid "non-array deallocation of object allocated with array allocation"
 msgstr ""
 
-#: cp/constexpr.cc:4138
+#: cp/constexpr.cc:4147
 #, fuzzy, gcc-internal-format
 msgid "deallocation of already deallocated storage"
 msgstr "試圖配置已經配置的變數"
 
-#: cp/constexpr.cc:4145
+#: cp/constexpr.cc:4154
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD shadows a previous local"
 msgid "deallocation of storage that was not previously allocated"
 msgstr "%qD 的宣告隱藏了先前的一個局部變數"
 
-#: cp/constexpr.cc:4303 rust/backend/rust-constexpr.cc:3626
+#: cp/constexpr.cc:4312 rust/backend/rust-constexpr.cc:3626
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression before its definition is complete"
 msgstr "%qD called 在中常數運算式"
 
-#: cp/constexpr.cc:4310
+#: cp/constexpr.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "%qD called in a constant expression"
 msgstr "%qD called 在中常數運算式"
 
-#: cp/constexpr.cc:4314 rust/backend/rust-constexpr.cc:3640
+#: cp/constexpr.cc:4323 rust/backend/rust-constexpr.cc:3640
 #, fuzzy, gcc-internal-format
 msgid "%qD used before its definition"
 msgstr "%qD 使用的之前它的定義"
 
-#: cp/constexpr.cc:4398 rust/backend/rust-constexpr.cc:3682
+#: cp/constexpr.cc:4417 rust/backend/rust-constexpr.cc:3682
 #, fuzzy, gcc-internal-format
 msgid "call has circular dependency"
 msgstr "呼叫有環狀依存性"
 
-#: cp/constexpr.cc:4409 rust/backend/rust-constexpr.cc:3693
+#: cp/constexpr.cc:4428 rust/backend/rust-constexpr.cc:3693
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> evaluation depth exceeds maximum of %d (use %<-fconstexpr-depth=%> to increase the maximum)"
 msgstr "constexpr 求值深度超出最大值的 %d (使用 -fconstexpr-depth=到增加最大值)"
 
-#: cp/constexpr.cc:4831
+#: cp/constexpr.cc:4844
 #, fuzzy, gcc-internal-format
 msgid "reference to %qD is not a constant expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/constexpr.cc:4834
+#: cp/constexpr.cc:4847
 #, fuzzy, gcc-internal-format
 msgid "pointer to %qD is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:4840
+#: cp/constexpr.cc:4853
 #, gcc-internal-format
 msgid "address of non-static constexpr variable %qD may differ on each invocation of the enclosing function; add %<static%> to give it a constant address"
 msgstr ""
 
-#: cp/constexpr.cc:4916 rust/backend/rust-constexpr.cc:6730
+#: cp/constexpr.cc:4929 rust/backend/rust-constexpr.cc:6730
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is negative"
 msgstr "右移次數為負"
 
-#: cp/constexpr.cc:4923 rust/backend/rust-constexpr.cc:6738
+#: cp/constexpr.cc:4936 rust/backend/rust-constexpr.cc:6738
 #, fuzzy, gcc-internal-format
 #| msgid "right shift count is negative"
 msgid "right operand of shift expression %q+E is greater than or equal to the precision %wu of the left operand"
 msgstr "右移次數為負"
 
-#: cp/constexpr.cc:4946 rust/backend/rust-constexpr.cc:6757
+#: cp/constexpr.cc:4959 rust/backend/rust-constexpr.cc:6757
 #, fuzzy, gcc-internal-format
 #| msgid "left-hand operand of comma expression has no effect"
 msgid "left operand of shift expression %q+E is negative"
 msgstr "逗號運算式的左運算元不起作用"
 
-#: cp/constexpr.cc:4965 rust/backend/rust-constexpr.cc:6776
+#: cp/constexpr.cc:4978 rust/backend/rust-constexpr.cc:6776
 #, fuzzy, gcc-internal-format
 #| msgid "integral expression %qE is not constant"
 msgid "shift expression %q+E overflows"
 msgstr "整型運算式 %qE 不是常數"
 
-#: cp/constexpr.cc:5184 rust/backend/rust-constexpr.cc:3169
+#: cp/constexpr.cc:5197 rust/backend/rust-constexpr.cc:3169
 #, gcc-internal-format
 msgid "arithmetic involving a null pointer in %qE"
 msgstr ""
 
-#: cp/constexpr.cc:5731 rust/backend/rust-constexpr.cc:4619
+#: cp/constexpr.cc:5744 rust/backend/rust-constexpr.cc:4619
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
 msgstr "陣列下標超出陣列邊界"
 
-#: cp/constexpr.cc:5734 rust/backend/rust-constexpr.cc:4624
+#: cp/constexpr.cc:5747 rust/backend/rust-constexpr.cc:4624
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds"
 msgstr "陣列下標超出陣列邊界"
 
-#: cp/constexpr.cc:5739 rust/backend/rust-constexpr.cc:4631
+#: cp/constexpr.cc:5752 rust/backend/rust-constexpr.cc:4631
 #, fuzzy, gcc-internal-format
 msgid "array subscript value %qE is outside the bounds of array type %qT"
 msgstr "陣列下標超出陣列邊界"
 
-#: cp/constexpr.cc:5742 rust/backend/rust-constexpr.cc:4636
+#: cp/constexpr.cc:5755 rust/backend/rust-constexpr.cc:4636
 #, fuzzy, gcc-internal-format
 msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds"
 msgstr "陣列下標超出陣列邊界"
 
-#: cp/constexpr.cc:5956 rust/backend/rust-constexpr.cc:1714
+#: cp/constexpr.cc:5969 rust/backend/rust-constexpr.cc:1714
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized array element"
 msgstr "成員 %qD 缺少初始值設定"
 
-#: cp/constexpr.cc:6022 rust/backend/rust-constexpr.cc:1773
+#: cp/constexpr.cc:6035 rust/backend/rust-constexpr.cc:1773
 #, fuzzy, gcc-internal-format
 #| msgid "dereferencing %<void *%> pointer"
 msgid "dereferencing a null pointer in %qE"
 msgstr "提領 %<void *%> 指標"
 
-#: cp/constexpr.cc:6041 cp/constexpr.cc:6177 cp/constexpr.cc:6189
-#: cp/constexpr.cc:9210 cp/constexpr.cc:9346 cp/constexpr.cc:11934
-#: cp/constexpr.cc:12999 rust/backend/rust-constexpr.cc:1787
+#: cp/constexpr.cc:6054 cp/constexpr.cc:6190 cp/constexpr.cc:6202
+#: cp/constexpr.cc:9243 cp/constexpr.cc:9379 cp/constexpr.cc:11976
+#: cp/constexpr.cc:13041 rust/backend/rust-constexpr.cc:1787
 #: rust/backend/rust-constexpr.cc:2046 rust/backend/rust-constexpr.cc:2296
 #: rust/backend/rust-constexpr.cc:4964 rust/backend/rust-constexpr.cc:5936
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:6049 rust/backend/rust-constexpr.cc:1793
+#: cp/constexpr.cc:6062 rust/backend/rust-constexpr.cc:1793
 #, fuzzy, gcc-internal-format
 msgid "mutable %qD is not usable in a constant expression"
 msgstr "可變的 %qD 不是可用在中常數運算式"
 
-#: cp/constexpr.cc:6083 cp/constexpr.cc:6120 cp/constexpr.cc:8155
+#: cp/constexpr.cc:6096 cp/constexpr.cc:6133 cp/constexpr.cc:8178
 #: rust/backend/rust-constexpr.cc:1823 rust/backend/rust-constexpr.cc:1846
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "accessing uninitialized member %qD"
 msgstr "成員 %qD 缺少初始值設定"
 
-#: cp/constexpr.cc:6085
+#: cp/constexpr.cc:6098
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of active %qD member in constant expression"
 msgstr "存取 %qD 成員以代替初始化的 %qD 成員在中常數運算式"
 
-#: cp/constexpr.cc:6098 cp/constexpr.cc:8150
+#: cp/constexpr.cc:6111 cp/constexpr.cc:8173
 #: rust/backend/rust-constexpr.cc:1825
 #, fuzzy, gcc-internal-format
 msgid "accessing %qD member instead of initialized %qD member in constant expression"
 msgstr "存取 %qD 成員以代替初始化的 %qD 成員在中常數運算式"
 
-#: cp/constexpr.cc:6255
+#: cp/constexpr.cc:6268
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a union type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6258
+#: cp/constexpr.cc:6271
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a union type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6269
+#: cp/constexpr.cc:6282
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6272
+#: cp/constexpr.cc:6285
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6283
+#: cp/constexpr.cc:6296
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a reference type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6286
+#: cp/constexpr.cc:6299
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a reference type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6297
+#: cp/constexpr.cc:6310
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is a pointer to member type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6301
+#: cp/constexpr.cc:6314
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a pointer to member type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6312
+#: cp/constexpr.cc:6325
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT is volatile"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:6315
+#: cp/constexpr.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "%qs is not a constant expression because %qT contains a volatile subobject"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:6473
+#: cp/constexpr.cc:6486
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated on the target"
 msgstr "巢狀的函式不支援於這個目標"
 
-#: cp/constexpr.cc:6482 cp/constexpr.cc:6492
+#: cp/constexpr.cc:6495 cp/constexpr.cc:6505
 #, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the type is too large"
 msgstr ""
 
-#: cp/constexpr.cc:6512
+#: cp/constexpr.cc:6525
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be encoded"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:6559
+#: cp/constexpr.cc:6572
 #, fuzzy, gcc-internal-format
 #| msgid "missing initializer for member %qD"
 msgid "%qs accessing uninitialized byte at offset %d"
 msgstr "成員 %qD 缺少初始值設定"
 
-#: cp/constexpr.cc:6571
+#: cp/constexpr.cc:6584
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be constant evaluated because the argument cannot be interpreted"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:7505
+#: cp/constexpr.cc:7528
 #, fuzzy, gcc-internal-format
 msgid "accessing value of %qT object through a %qT glvalue in a constant expression"
 msgstr "存取值的 %qE 透過 %qT glvalue 在中常數運算式"
 
-#: cp/constexpr.cc:7513
+#: cp/constexpr.cc:7536
 #, fuzzy, gcc-internal-format
 msgid "%qT object created here"
 msgstr "%qD 宣告的在此"
 
-#: cp/constexpr.cc:7516 cp/parser.cc:13134 cp/parser.cc:13145
-#: cp/reflect.cc:8548 cp/semantics.cc:4693 cp/semantics.cc:4709
+#: cp/constexpr.cc:7539 cp/parser.cc:13128 cp/parser.cc:13139
+#: cp/reflect.cc:9077 cp/semantics.cc:4714 cp/semantics.cc:4730
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here"
 msgstr "%q+#D 宣告的在此"
 
 #. Provide a more accurate message for deleted variables.
-#: cp/constexpr.cc:7559 cp/constexpr.cc:7592
+#: cp/constexpr.cc:7582 cp/constexpr.cc:7615
 #, fuzzy, gcc-internal-format
 msgid "use of allocated storage after deallocation in a constant expression"
 msgstr "使用的值的物件被建構在中常數運算式"
 
-#: cp/constexpr.cc:7561 cp/constexpr.cc:7587 cp/constexpr.cc:7594
-#: cp/constexpr.cc:7959 cp/constexpr.cc:11030 cp/constexpr.cc:11043
+#: cp/constexpr.cc:7584 cp/constexpr.cc:7610 cp/constexpr.cc:7617
+#: cp/constexpr.cc:7982 cp/constexpr.cc:11072 cp/constexpr.cc:11085
 #, fuzzy, gcc-internal-format
 msgid "allocated here"
 msgstr "宣告的在此"
 
-#: cp/constexpr.cc:7565
+#: cp/constexpr.cc:7588
 #, gcc-internal-format
 msgid "accessing %qE outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:7585
+#: cp/constexpr.cc:7608
 #, fuzzy, gcc-internal-format
 msgid "the content of uninitialized storage is not usable in a constant expression"
 msgstr "值的 %qD 不是可用在中常數運算式"
 
-#: cp/constexpr.cc:7597
+#: cp/constexpr.cc:7620
 #, fuzzy, gcc-internal-format
 msgid "the value of %qD is not usable in a constant expression"
 msgstr "值的 %qD 不是可用在中常數運算式"
 
-#: cp/constexpr.cc:7605 rust/backend/rust-constexpr.cc:4242
+#: cp/constexpr.cc:7628 rust/backend/rust-constexpr.cc:4242
 #, fuzzy, gcc-internal-format
 msgid "%qD used in its own initializer"
 msgstr "%qD 已用於它的本身初始設定式"
 
-#: cp/constexpr.cc:7610
+#: cp/constexpr.cc:7633
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not const"
 msgstr "%q#D 不是常數"
 
-#: cp/constexpr.cc:7613
+#: cp/constexpr.cc:7636
 #, fuzzy, gcc-internal-format
 msgid "%q#D is volatile"
 msgstr "%q#D 是易變的"
 
-#: cp/constexpr.cc:7618 cp/constexpr.cc:7625
+#: cp/constexpr.cc:7641 cp/constexpr.cc:7648
 #: rust/backend/rust-constexpr.cc:4248 rust/backend/rust-constexpr.cc:4256
 #, fuzzy, gcc-internal-format
 msgid "%qD was not initialized with a constant expression"
 msgstr "%qD 未被初始化的與常數運算式"
 
-#: cp/constexpr.cc:7631 rust/backend/rust-constexpr.cc:4262
+#: cp/constexpr.cc:7654 rust/backend/rust-constexpr.cc:4262
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared %<constexpr%>"
 msgstr "%qD 未被宣告 %<constexpr%>"
 
-#: cp/constexpr.cc:7634 rust/backend/rust-constexpr.cc:4266
+#: cp/constexpr.cc:7657 rust/backend/rust-constexpr.cc:4266
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral or enumeration type"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/constexpr.cc:7957
+#: cp/constexpr.cc:7980
 #, fuzzy, gcc-internal-format
 msgid "modification of allocated storage after deallocation is not a constant expression"
 msgstr "使用的值的物件被建構在中常數運算式"
 
-#: cp/constexpr.cc:7966
+#: cp/constexpr.cc:7989
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE outside its lifetime is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:7973
+#: cp/constexpr.cc:7996
 #, fuzzy, gcc-internal-format
 msgid "destroying %qE from outside current evaluation is not a constant expression"
 msgstr "差異的兩指標運算式並非常數運算式"
 
-#: cp/constexpr.cc:7976
+#: cp/constexpr.cc:7999
 #, fuzzy, gcc-internal-format
 msgid "modification of %qE from outside current evaluation is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:8128
+#: cp/constexpr.cc:8151
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD is not a constant expression before C++20"
 msgstr "無法轉換 %qT 到 %qT 在中初始化"
 
-#: cp/constexpr.cc:8159
+#: cp/constexpr.cc:8182
 #, gcc-internal-format
 msgid "%qD does not implicitly begin its lifetime because %qT does not have a non-deleted trivial default constructor, use %<std::construct_at%> instead"
 msgstr ""
 
-#: cp/constexpr.cc:8166
+#: cp/constexpr.cc:8189
 #, gcc-internal-format
 msgid "initializing %qD requires a member access expression as the left operand of the assignment"
 msgstr ""
 
-#: cp/constexpr.cc:8178 rust/backend/rust-constexpr.cc:2906
+#: cp/constexpr.cc:8201 rust/backend/rust-constexpr.cc:2906
 #, fuzzy, gcc-internal-format
 msgid "change of the active member of a union from %qD to %qD during initialization"
 msgstr "無法轉換 %qT 到 %qT 在中初始化"
 
-#: cp/constexpr.cc:8838 rust/backend/rust-constexpr.cc:5154
+#: cp/constexpr.cc:8871 rust/backend/rust-constexpr.cc:5154
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)"
 msgstr "constexpr 求值深度超出最大值的 %d (使用 -fconstexpr-depth=到增加最大值)"
 
-#: cp/constexpr.cc:8951 rust/backend/rust-constexpr.cc:1041
+#: cp/constexpr.cc:8984 rust/backend/rust-constexpr.cc:1041
 #, fuzzy, gcc-internal-format
 msgid "inline assembly is not a constant expression"
 msgstr "初始設定式元件並非常數運算式"
 
-#: cp/constexpr.cc:8953 rust/backend/rust-constexpr.cc:1042
+#: cp/constexpr.cc:8986 rust/backend/rust-constexpr.cc:1042
 #, gcc-internal-format
 msgid "only unevaluated inline assembly is allowed in a %<constexpr%> function in C++20"
 msgstr ""
 
-#: cp/constexpr.cc:8972
+#: cp/constexpr.cc:9005
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "use of %qD"
 msgstr "錯誤地使用了 %qD"
 
-#: cp/constexpr.cc:8976
+#: cp/constexpr.cc:9009
 #, gcc-internal-format
 msgid "its value can vary between compiler versions or with different %<-mtune%> or %<-mcpu%> flags"
 msgstr ""
 
-#: cp/constexpr.cc:8978
+#: cp/constexpr.cc:9011
 #, gcc-internal-format
 msgid "if this use is part of a public ABI, change it to instead use a constant variable you define"
 msgstr ""
 
-#: cp/constexpr.cc:8980
+#: cp/constexpr.cc:9013
 #, gcc-internal-format, gfc-internal-format
 msgid "the default value for the current CPU tuning is %d bytes"
 msgstr ""
 
-#: cp/constexpr.cc:8982
+#: cp/constexpr.cc:9015
 #, gcc-internal-format
 msgid "you can stabilize this value with %<--param hardware_destructive_interference_size=%d%>, or disable this warning with %<-Wno-interference-size%>"
 msgstr ""
 
-#: cp/constexpr.cc:9094
+#: cp/constexpr.cc:9127
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared with an exception specification"
 msgid "destructor exited with an exception"
 msgstr "%q+D 宣告時有異常指定"
 
-#: cp/constexpr.cc:9172
+#: cp/constexpr.cc:9205
 #, fuzzy, gcc-internal-format
 msgid "value %qE of type %qT is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:9185
+#: cp/constexpr.cc:9218
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)"
 msgstr "constexpr 求值深度超出最大值的 %d (使用 -fconstexpr-depth=到增加最大值)"
 
-#: cp/constexpr.cc:9376
+#: cp/constexpr.cc:9409
 #, gcc-internal-format
 msgid "control passes through definition of %qD with thread storage duration"
 msgstr ""
 
-#: cp/constexpr.cc:9379
+#: cp/constexpr.cc:9412
 #, fuzzy, gcc-internal-format
 msgid "control passes through definition of %qD with static storage duration"
 msgstr "擷取的變數 %qD 與 non-automatic 貯藏體持續時間"
 
-#: cp/constexpr.cc:9447 cp/constexpr.cc:12692
+#: cp/constexpr.cc:9480 cp/constexpr.cc:12734
 #: rust/backend/rust-constexpr.cc:2121 rust/backend/rust-constexpr.cc:6430
 #, fuzzy, gcc-internal-format
 msgid "temporary of non-literal type %qT in a constant expression"
 msgstr "暫時的的 non-literal 型態 %qT 在中常數運算式"
 
-#: cp/constexpr.cc:9672
+#: cp/constexpr.cc:9714
 #, fuzzy, gcc-internal-format
 msgid "uncaught exception exited from %<noexcept%> function %qD"
 msgstr "無效的傳回類型 %qT 的 constexpr 函式 %q+D"
 
-#: cp/constexpr.cc:9676
+#: cp/constexpr.cc:9718
 #, gcc-internal-format
 msgid "destructor exited with an exception after initializing the exception object"
 msgstr ""
 
-#: cp/constexpr.cc:9679
+#: cp/constexpr.cc:9721
 #, gcc-internal-format
 msgid "constructor exited with another exception while entering handler"
 msgstr ""
 
-#: cp/constexpr.cc:10055 cp/constexpr.cc:12162
+#: cp/constexpr.cc:10097 cp/constexpr.cc:12204
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> is not a constant expression"
 msgstr "初始設定式元件並非常數運算式"
 
-#: cp/constexpr.cc:10089 rust/backend/rust-constexpr.cc:2543
+#: cp/constexpr.cc:10131 rust/backend/rust-constexpr.cc:2543
 #, fuzzy, gcc-internal-format
 msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression"
 msgstr "轉換從指標類型 %qT 到算術型式 %qT 在中 constant-expression"
 
-#: cp/constexpr.cc:10144
+#: cp/constexpr.cc:10186
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression because pointed-to type %qT is not similar to %qT"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:10154
+#: cp/constexpr.cc:10196
 #, fuzzy, gcc-internal-format
 #| msgid "  %q+#D declared here"
 msgid "pointed-to object declared here"
 msgstr "  %q+#D 已在此宣告過"
 
-#: cp/constexpr.cc:10162
+#: cp/constexpr.cc:10204
 #, fuzzy, gcc-internal-format
 msgid "cast from %qT is not allowed in a constant expression before C++26"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:10176
+#: cp/constexpr.cc:10218
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression when the class %qT is still incomplete"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:10216 rust/backend/rust-constexpr.cc:2588
+#: cp/constexpr.cc:10258 rust/backend/rust-constexpr.cc:2588
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast<%T>(%E)%> is not a constant expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/constexpr.cc:10375 cp/constexpr.cc:12471 cp/constexpr.cc:12920
+#: cp/constexpr.cc:10417 cp/constexpr.cc:12513 cp/constexpr.cc:12962
 #: rust/backend/rust-constexpr.cc:6324 rust/backend/rust-constexpr.cc:6644
 #, fuzzy, gcc-internal-format
 msgid "expression %qE is not a constant expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/constexpr.cc:10424 cp/constexpr.cc:12964
+#: cp/constexpr.cc:10466 cp/constexpr.cc:13006
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:10545
+#: cp/constexpr.cc:10587
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "address of a call to %qs is not a constant expression"
 msgstr "陣列 %qD 的大小不是一個整數常運算式"
 
-#: cp/constexpr.cc:10595 cp/constexpr.cc:10607
+#: cp/constexpr.cc:10637 cp/constexpr.cc:10649
 #: rust/backend/rust-constexpr.cc:4889
 #, fuzzy, gcc-internal-format
 msgid "statement is not a constant expression"
 msgstr "初始設定式元件並非常數運算式"
 
-#: cp/constexpr.cc:10610
+#: cp/constexpr.cc:10652
 #, fuzzy, gcc-internal-format
 msgid "unexpected expression %qE of kind %s"
 msgstr "未預期的運算式 %qE 的 kind %s"
 
-#: cp/constexpr.cc:10628
+#: cp/constexpr.cc:10670
 #, gcc-internal-format
 msgid "%qE accesses an object outside its lifetime"
 msgstr ""
 
-#: cp/constexpr.cc:10772
+#: cp/constexpr.cc:10814
 #, fuzzy, gcc-internal-format
 #| msgid "'B' operand is not constant"
 msgid "contract condition is not constant"
 msgstr "「B」運算元不是一個常數"
 
-#: cp/constexpr.cc:10778
+#: cp/constexpr.cc:10820
 #, fuzzy, gcc-internal-format
 msgid "contract predicate is false in constant expression"
 msgstr "初始設定式元件並非常數運算式"
 
-#: cp/constexpr.cc:10963
+#: cp/constexpr.cc:11005
 #, fuzzy, gcc-internal-format
 #| msgid "break statement not within loop or switch"
 msgid "%<break%> outside of a loop or %<switch%>"
 msgstr "break 敘述不在循環或開關敘述內"
 
-#: cp/constexpr.cc:10965
+#: cp/constexpr.cc:11007
 #, fuzzy, gcc-internal-format
 msgid "%<continue%> outside of a loop"
 msgstr "%<friend%> 使用的外側的類別"
 
-#: cp/constexpr.cc:10967
+#: cp/constexpr.cc:11009
 #, fuzzy, gcc-internal-format
 #| msgid "%Jjump into statement expression"
 msgid "%<return%> in a statement expression"
 msgstr "%J跳轉至敘述運算式中"
 
-#: cp/constexpr.cc:11008 rust/backend/rust-constexpr.cc:5382
+#: cp/constexpr.cc:11050 rust/backend/rust-constexpr.cc:5382
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:11024
+#: cp/constexpr.cc:11066
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to exception object allocated with %<__cxa_allocate_exception%>"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:11028 rust/backend/rust-constexpr.cc:5407
+#: cp/constexpr.cc:11070 rust/backend/rust-constexpr.cc:5407
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to a result of %<operator new%>"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:11041 rust/backend/rust-constexpr.cc:5419
+#: cp/constexpr.cc:11083 rust/backend/rust-constexpr.cc:5419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because allocated storage has not been deallocated"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:11062 rust/backend/rust-constexpr.cc:5437
+#: cp/constexpr.cc:11104 rust/backend/rust-constexpr.cc:5437
 #, gcc-internal-format
 msgid "immediate evaluation returns address of immediate function %qD"
 msgstr ""
 
-#: cp/constexpr.cc:11066
+#: cp/constexpr.cc:11108
 #, fuzzy, gcc-internal-format
 msgid "constant evaluation returns address of immediate function %qD"
 msgstr "需位址的解構式 %qE"
 
-#: cp/constexpr.cc:11091
+#: cp/constexpr.cc:11133
 #, gcc-internal-format
 msgid "reference into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11096
+#: cp/constexpr.cc:11138
 #, gcc-internal-format
 msgid "pointer into an object of consteval-only type is not a constant expression unless it also has consteval-only type"
 msgstr ""
 
-#: cp/constexpr.cc:11112 rust/backend/rust-constexpr.cc:5391
+#: cp/constexpr.cc:11154 rust/backend/rust-constexpr.cc:5391
 #, gcc-internal-format
 msgid "%qE is not a constant expression because it refers to an incompletely initialized variable"
 msgstr ""
 
-#: cp/constexpr.cc:11163
+#: cp/constexpr.cc:11205
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a constant expression because it initializes a %qT rather than %qT"
 msgstr "%qT 無法型態的完成常數運算式因為它有可變的 sub-objects"
 
-#: cp/constexpr.cc:11870 rust/backend/rust-constexpr.cc:5891
+#: cp/constexpr.cc:11912 rust/backend/rust-constexpr.cc:5891
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT"
 msgstr "從具有類型 %qT 的右值運算式到類型 %qT 中的轉換無效"
 
-#: cp/constexpr.cc:12124
+#: cp/constexpr.cc:12166
 #, fuzzy, gcc-internal-format
 msgid "lambda capture of %qE is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:12127
+#: cp/constexpr.cc:12169
 #, gcc-internal-format
 msgid "because it is used as a glvalue"
 msgstr ""
 
-#: cp/constexpr.cc:12183 rust/backend/rust-constexpr.cc:6117
+#: cp/constexpr.cc:12225 rust/backend/rust-constexpr.cc:6117
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from integer to pointer"
 msgstr "reinterpretcast 從型態 %qT 輸入 %qT 演員陣容暫離限定元(_C)"
 
-#: cp/constexpr.cc:12217 rust/backend/rust-constexpr.cc:6144
+#: cp/constexpr.cc:12259 rust/backend/rust-constexpr.cc:6144
 #, fuzzy, gcc-internal-format
 msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
 msgstr "address-of 物件 %qE 與執行緒本地或自動貯藏體並非常數運算式"
 
-#: cp/constexpr.cc:12407
+#: cp/constexpr.cc:12449
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression is not a constant expression before C++17"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/constexpr.cc:12419
+#: cp/constexpr.cc:12461
 #, fuzzy, gcc-internal-format
 msgid "new-expression is not a constant expression before C++20"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/constexpr.cc:12495
+#: cp/constexpr.cc:12537
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual functions cannot be %<constexpr%> before C++20"
 msgstr "虛函式不能是夥伴"
 
-#: cp/constexpr.cc:12512
+#: cp/constexpr.cc:12554
 #, fuzzy, gcc-internal-format
 msgid "%<typeid%> is not a constant expression because %qE is of polymorphic type"
 msgstr "typeid-expression 並非常數運算式因為 %qE 是的 polymorphic 型態"
 
-#: cp/constexpr.cc:12576
+#: cp/constexpr.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "cast to non-integral type %qT in a constant expression"
 msgstr "暫時的的 non-literal 型態 %qT 在中常數運算式"
 
-#: cp/constexpr.cc:12650
+#: cp/constexpr.cc:12692
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %<constexpr%> context"
 msgstr "%qD 宣告 %<constexpr%> 外側它的類別"
 
-#: cp/constexpr.cc:12658
+#: cp/constexpr.cc:12700
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %<constexpr%> context"
 msgstr "%qD 宣告 %<constexpr%> 外側它的類別"
 
-#: cp/constexpr.cc:12744 rust/backend/rust-constexpr.cc:6478
+#: cp/constexpr.cc:12786 rust/backend/rust-constexpr.cc:6478
 #, fuzzy, gcc-internal-format
 msgid "division by zero is not a constant expression"
 msgstr "除法由零並非 constant-expression"
 
-#: cp/constexpr.cc:12845 rust/backend/rust-constexpr.cc:6578
+#: cp/constexpr.cc:12887 rust/backend/rust-constexpr.cc:6578
 #, fuzzy, gcc-internal-format
 msgid "%<delete[]%> is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:12917
+#: cp/constexpr.cc:12959
 #, fuzzy, gcc-internal-format
 msgid "neither branch of %<if%> is a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/constexpr.cc:12930
+#: cp/constexpr.cc:12972
 #, fuzzy, gcc-internal-format
 msgid "non-constant array initialization"
 msgstr "non-constant 陣列初始化"
 
-#: cp/constexpr.cc:12981
+#: cp/constexpr.cc:13023
 #, fuzzy, gcc-internal-format
 msgid "label definition in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/constexpr.cc:13026 rust/backend/rust-constexpr.cc:6667
+#: cp/constexpr.cc:13068 rust/backend/rust-constexpr.cc:6667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected AST of kind %s"
 msgstr "未預期的 AST 的 kind %s"
@@ -60283,372 +60336,372 @@ msgstr ""
 msgid "the operand %qE is unsatisfied because"
 msgstr ""
 
-#: cp/constraint.cc:3147
+#: cp/constraint.cc:3152
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy assignable"
 msgstr "%qD 並非變數"
 
-#: cp/constraint.cc:3150
+#: cp/constraint.cc:3155
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible"
 msgstr "%q#T 沒有任何 user-provided 預設建構函式"
 
-#: cp/constraint.cc:3153
+#: cp/constraint.cc:3158
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow copy constructible"
 msgstr "%qD 並非變數"
 
-#: cp/constraint.cc:3156
+#: cp/constraint.cc:3161
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy assignable"
 msgstr "%qD 並非變數"
 
-#: cp/constraint.cc:3159
+#: cp/constraint.cc:3164
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible"
 msgstr "%q#T 沒有任何 user-provided 預設建構函式"
 
-#: cp/constraint.cc:3162
+#: cp/constraint.cc:3167
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copy constructible"
 msgstr "%qD 並非變數"
 
-#: cp/constraint.cc:3165
+#: cp/constraint.cc:3170
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible"
 msgstr "  %q+T 有 non-trivial 解構式"
 
-#: cp/constraint.cc:3168
+#: cp/constraint.cc:3173
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have unique object representations, because"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3178
+#: cp/constraint.cc:3183
 #, fuzzy, gcc-internal-format
 msgid "%qT does not have a virtual destructor"
 msgstr "運算式 %qE 不指定 constexpr 函式"
 
-#: cp/constraint.cc:3182
+#: cp/constraint.cc:3187
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an abstract class"
 msgstr "%q#T 並非類別"
 
-#: cp/constraint.cc:3185
+#: cp/constraint.cc:3190
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an aggregate"
 msgstr "%qT 不是一個聚合類型"
 
-#: cp/constraint.cc:3188
+#: cp/constraint.cc:3193
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an aggregate type"
 msgid "%qT is not an array"
 msgstr "%qT 不是一個聚合類型"
 
-#: cp/constraint.cc:3191
+#: cp/constraint.cc:3196
 #, fuzzy, gcc-internal-format
 msgid "%qT is not assignable from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3195 cp/semantics.cc:13521 cp/typeck.cc:3701
+#: cp/constraint.cc:3200 cp/semantics.cc:13542 cp/typeck.cc:3701
 #, gcc-internal-format
 msgid "%qT is not a base of %qT"
 msgstr "%qT 不是 %qT 的基礎類別"
 
-#: cp/constraint.cc:3198
+#: cp/constraint.cc:3203
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a bounded array"
 msgstr "%qD 並非變數"
 
-#: cp/constraint.cc:3201
+#: cp/constraint.cc:3206
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class"
 msgstr "%q#T 並非類別"
 
-#: cp/constraint.cc:3204
+#: cp/constraint.cc:3209
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a const type"
 msgstr "%qT 並非類別型態"
 
-#: cp/constraint.cc:3208
+#: cp/constraint.cc:3213
 #, fuzzy, gcc-internal-format
 msgid "%qT is not default constructible, because"
 msgstr "型態 %qE 沒有任何預設建構函式到呼叫"
 
-#: cp/constraint.cc:3210
+#: cp/constraint.cc:3215
 #, fuzzy, gcc-internal-format
 msgid "%qT is not constructible from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3219
+#: cp/constraint.cc:3224
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructible, because"
 msgstr "%q+T 不是實字因為："
 
-#: cp/constraint.cc:3223
+#: cp/constraint.cc:3228
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an empty class"
 msgstr "%q#T 並非類別"
 
-#: cp/constraint.cc:3226
+#: cp/constraint.cc:3231
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template"
 msgid "%qT is not an enum"
 msgstr "%qT 不是一個範本"
 
-#: cp/constraint.cc:3229
+#: cp/constraint.cc:3234
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a final class"
 msgstr "%q#T 並非類別"
 
-#: cp/constraint.cc:3232
+#: cp/constraint.cc:3237
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a function"
 msgstr "『%s』於 %L 並非函式"
 
-#: cp/constraint.cc:3235
+#: cp/constraint.cc:3240
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not an implicit-lifetime type"
 msgstr "%qT 不是一個範本類型"
 
-#: cp/constraint.cc:3240
+#: cp/constraint.cc:3245
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable, because"
 msgstr "%q+T 不是實字因為："
 
-#: cp/constraint.cc:3242
+#: cp/constraint.cc:3247
 #, fuzzy, gcc-internal-format
 msgid "%qT is not invocable by %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3247
+#: cp/constraint.cc:3252
 #, fuzzy, gcc-internal-format
 msgid "%qT is not layout compatible with %qT, because"
 msgstr "%qD 不是相容與 %qD"
 
-#: cp/constraint.cc:3251
+#: cp/constraint.cc:3256
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a literal type"
 msgstr "%qT 並非類別型態"
 
-#: cp/constraint.cc:3254
+#: cp/constraint.cc:3259
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a member function pointer"
 msgstr "%qD 不是一個成員範本函式"
 
-#: cp/constraint.cc:3257
+#: cp/constraint.cc:3262
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member object pointer"
 msgstr "%qT 不是 %qT 的成員"
 
-#: cp/constraint.cc:3260
+#: cp/constraint.cc:3265
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a member of %qT"
 msgid "%qT is not a member pointer"
 msgstr "%qT 不是 %qT 的成員"
 
-#: cp/constraint.cc:3263
+#: cp/constraint.cc:3268
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow assignable from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3268
+#: cp/constraint.cc:3273
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow default constructible, because"
 msgstr "%q#T 沒有任何 user-provided 預設建構函式"
 
-#: cp/constraint.cc:3270
+#: cp/constraint.cc:3275
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow constructible from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3275
+#: cp/constraint.cc:3280
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow convertible from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3279
+#: cp/constraint.cc:3284
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow destructible, because"
 msgstr "%q+T 不是實字因為："
 
-#: cp/constraint.cc:3285
+#: cp/constraint.cc:3290
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable, because"
 msgstr "%q+T 不是實字因為："
 
-#: cp/constraint.cc:3287
+#: cp/constraint.cc:3292
 #, fuzzy, gcc-internal-format
 msgid "%qT is not nothrow invocable by %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3294
+#: cp/constraint.cc:3299
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT is not an object type"
 msgstr "%qT 不是一個參照物件的類型"
 
-#: cp/constraint.cc:3298
+#: cp/constraint.cc:3303
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not an accessible base of %qT"
 msgid "%qT is not a pointer-interconvertible base of %qT, because"
 msgstr "%qT 是 %qT 的一個不可存取的基礎類別"
 
-#: cp/constraint.cc:3303
+#: cp/constraint.cc:3308
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a POD type"
 msgstr "%qD 並非型態"
 
-#: cp/constraint.cc:3306
+#: cp/constraint.cc:3311
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a pointer"
 msgstr "來源並非指標"
 
-#: cp/constraint.cc:3309
+#: cp/constraint.cc:3314
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a polymorphic type"
 msgstr "%qT 並非類別型態"
 
-#: cp/constraint.cc:3312
+#: cp/constraint.cc:3317
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a reference"
 msgstr "%qT 不是一個命名空間"
 
-#: cp/constraint.cc:3315
+#: cp/constraint.cc:3320
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%q#T is not the same as %q#T"
 msgstr "%qT 不是 %qT 的基礎類別"
 
-#: cp/constraint.cc:3318
+#: cp/constraint.cc:3323
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not a scoped enum"
 msgstr "%qT 不是一個命名空間"
 
-#: cp/constraint.cc:3321
+#: cp/constraint.cc:3326
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard layout type"
 msgstr "%qT 不是一個範本類型"
 
-#: cp/constraint.cc:3324
+#: cp/constraint.cc:3329
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a trivial type"
 msgstr "%qT 並非類別型態"
 
-#: cp/constraint.cc:3327
+#: cp/constraint.cc:3332
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially assignable from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3332
+#: cp/constraint.cc:3337
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially default constructible, because"
 msgstr "%q+D 不是可用做為 constexpr 函式因為："
 
-#: cp/constraint.cc:3334
+#: cp/constraint.cc:3339
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially constructible from %qT, because"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/constraint.cc:3339 cp/tree.cc:5014
+#: cp/constraint.cc:3344 cp/tree.cc:5031
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially copyable"
 msgstr "%q+T 不是實字因為："
 
-#: cp/constraint.cc:3342
+#: cp/constraint.cc:3347
 #, fuzzy, gcc-internal-format
 msgid "%qT is not trivially destructible, because"
 msgstr "%q+T 不是實字因為："
 
-#: cp/constraint.cc:3346
+#: cp/constraint.cc:3351
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an unbounded array"
 msgstr "%qD 並非型態"
 
-#: cp/constraint.cc:3349
+#: cp/constraint.cc:3354
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qT is not a union"
 msgstr "%qD 不是一個成員範本函式"
 
-#: cp/constraint.cc:3352
+#: cp/constraint.cc:3357
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qT is not a virtual base of %qT"
 msgstr "%qT 不是 %qT 的基礎類別"
 
-#: cp/constraint.cc:3355
+#: cp/constraint.cc:3360
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a volatile type"
 msgstr "%qT 不是一個範本類型"
 
-#: cp/constraint.cc:3358
+#: cp/constraint.cc:3363
 #, fuzzy, gcc-internal-format
-msgid "%qT is not consteval-only"
-msgstr "%q#D 不是常數"
+msgid "%qT is not a structural type"
+msgstr "%qT 並非類別型態"
 
-#: cp/constraint.cc:3361
+#: cp/constraint.cc:3367
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot yield a rank"
 msgstr "%qE 不能做為函式"
 
-#: cp/constraint.cc:3364
+#: cp/constraint.cc:3370
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D cannot be declared"
 msgid "%qT and %qT cannot be ordered"
 msgstr "無法宣告 %q+#D"
 
-#: cp/constraint.cc:3367
+#: cp/constraint.cc:3373
 #, fuzzy, gcc-internal-format
 msgid "%qT is not destructurable"
 msgstr "%qD 未被擷取"
 
-#: cp/constraint.cc:3370
+#: cp/constraint.cc:3376
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (direct-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3374
+#: cp/constraint.cc:3380
 #, gcc-internal-format
 msgid "%qT is not a reference that binds to a temporary object of type %qT (copy-initialization)"
 msgstr ""
 
-#: cp/constraint.cc:3378
+#: cp/constraint.cc:3384
 #, fuzzy, gcc-internal-format
 msgid "%qD is not deducible from %qT"
 msgstr "  %qT 未被衍生自 %qT"
 
-#: cp/constraint.cc:3445
+#: cp/constraint.cc:3451
 #, fuzzy, gcc-internal-format
 #| msgid "invalid constant"
 msgid "invalid constraints"
 msgstr "常數無效"
 
-#: cp/constraint.cc:3466
+#: cp/constraint.cc:3472
 #, gcc-internal-format
 msgid "constraint %qE has type %qT, not %<bool%>"
 msgstr ""
 
-#: cp/constraint.cc:3470
+#: cp/constraint.cc:3476
 #, fuzzy, gcc-internal-format
 msgid "the expression %qE evaluated to %<false%>"
 msgstr "noexcept-expression 評估到 %<false%> 因為呼叫到 %qD"
 
-#: cp/constraint.cc:3525
+#: cp/constraint.cc:3531
 #, fuzzy, gcc-internal-format
 #| msgid "-mhard-float not supported"
 msgid "constraints not satisfied"
 msgstr "不支援 -mhard-float"
 
-#: cp/constraint.cc:3542
+#: cp/constraint.cc:3548
 #, gcc-internal-format
 msgid "set %qs to at least %d for more detail"
 msgstr ""
@@ -60680,51 +60733,51 @@ msgstr "asm 宣告因與先前的 rename 衝突而被忽略"
 msgid "previous declaration with fewer contracts here"
 msgstr "%q+#D 的早先宣告有 %qL 連結"
 
-#: cp/contracts.cc:562
+#: cp/contracts.cc:564
 #, gcc-internal-format
 msgid "a value parameter used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:563 cp/contracts.cc:1039
+#: cp/contracts.cc:565 cp/contracts.cc:1041
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "parameter declared here"
 msgstr "範本參數類型 %qT 宣告為 %<friend%>"
 
-#: cp/contracts.cc:593
+#: cp/contracts.cc:595
 #, gcc-internal-format
 msgid "value parameter %qE used in a postcondition must be const"
 msgstr ""
 
-#: cp/contracts.cc:1036
+#: cp/contracts.cc:1038
 #, gcc-internal-format
 msgid "contract postcondition result name shadows a function parameter"
 msgstr ""
 
-#: cp/contracts.cc:1660
+#: cp/contracts.cc:1674
 #, fuzzy, gcc-internal-format
 #| msgid "new declaration %q#D"
 msgid "declaration adds contracts to %q#D"
 msgstr "對 %q#D 的新宣告"
 
-#: cp/contracts.cc:1661
+#: cp/contracts.cc:1675
 #, fuzzy, gcc-internal-format
 msgid "first declared here"
 msgstr "宣告的在此"
 
-#: cp/contracts.cc:1922
+#: cp/contracts.cc:1936
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "constructor does not return a value to test"
 msgstr "函式不回傳字串類型"
 
-#: cp/contracts.cc:1924
+#: cp/contracts.cc:1938
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "destructor does not return a value to test"
 msgstr "函式不回傳字串類型"
 
-#: cp/contracts.cc:1925
+#: cp/contracts.cc:1939
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "function does not return a value to test"
@@ -60800,7 +60853,7 @@ msgstr ""
 msgid "%<return_void%> declared here"
 msgstr "%qD 被宣告在此"
 
-#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4732
+#: cp/coroutines.cc:1039 cp/coroutines.cc:1117 cp/coroutines.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "no type named %q#T in %q#T"
 msgid "no member named %qE in %qT"
@@ -60884,89 +60937,89 @@ msgstr "限定的類型 %qT 不匹配解構函式名 ~%qT"
 msgid "awaitable type %qT is not a structure"
 msgstr "限定的類型 %qT 不匹配解構函式名 ~%qT"
 
-#: cp/coroutines.cc:1500
+#: cp/coroutines.cc:1503
 #, gcc-internal-format
 msgid "%<await_suspend%> must return %<void%>, %<bool%> or a coroutine handle"
 msgstr ""
 
-#: cp/coroutines.cc:1592 cp/coroutines.cc:1678
+#: cp/coroutines.cc:1595 cp/coroutines.cc:1681
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qs cannot be used in an unevaluated context"
 msgstr "%qE 不能做為函式"
 
-#: cp/coroutines.cc:1861
+#: cp/coroutines.cc:1864
 #, fuzzy, gcc-internal-format
 #| msgid "function declared %<noreturn%> has a %<return%> statement"
 msgid "function declared %<noreturn%> has a %<co_return%> statement"
 msgstr "被宣告為 %<noreturn%> 的函式卻有 %<return%> 敘述"
 
-#: cp/coroutines.cc:1898
+#: cp/coroutines.cc:1901
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the align argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%> 的第三個引數必須是一個常數"
 
-#: cp/coroutines.cc:1908
+#: cp/coroutines.cc:1911
 #, fuzzy, gcc-internal-format
 #| msgid "third argument to %<__builtin_prefetch%> must be a constant"
 msgid "the direction argument to %<__builtin_coro_promise%> must be a constant"
 msgstr "%<__builtin_prefetch%> 的第三個引數必須是一個常數"
 
-#: cp/coroutines.cc:2412
+#: cp/coroutines.cc:2426
 #, fuzzy, gcc-internal-format
 msgid "no suspend point info for %qD"
 msgstr "沒有前一個原型用於 %qD"
 
-#: cp/coroutines.cc:2984
+#: cp/coroutines.cc:2999
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate %qE"
 msgid "duplicate info for %qE"
 msgstr "重複的 %qE"
 
-#: cp/coroutines.cc:3642
+#: cp/coroutines.cc:3657
 #, gcc-internal-format
 msgid "assumption ignored because it contains an await-expression"
 msgstr ""
 
-#: cp/coroutines.cc:4149
+#: cp/coroutines.cc:4164
 #, fuzzy, gcc-internal-format
 #| msgid "pointers are not permitted as case values"
 msgid "await expressions are not permitted in handlers"
 msgstr "指標不能做為 case 常數"
 
-#: cp/coroutines.cc:4366
+#: cp/coroutines.cc:4381
 #, gcc-internal-format
 msgid "variable length arrays are not yet supported in coroutines"
 msgstr ""
 
-#: cp/coroutines.cc:4885
+#: cp/coroutines.cc:4900
 #, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function signature %qD"
 msgstr ""
 
-#: cp/coroutines.cc:4892
+#: cp/coroutines.cc:4907
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %qE is not marked %<throw()%> or %<noexcept%>"
 msgstr ""
 
-#: cp/coroutines.cc:4897
+#: cp/coroutines.cc:4912
 #, gcc-internal-format
 msgid "%qE is marked %<throw()%> or %<noexcept%> but no usable %<get_return_object_on_allocation_failure%> is provided by %qT"
 msgstr ""
 
 #. Something is seriously wrong, punt.
-#: cp/coroutines.cc:4928
+#: cp/coroutines.cc:4943
 #, gcc-internal-format
 msgid "%qE is provided by %qT but %<std::nothrow%> cannot be found"
 msgstr ""
 
-#: cp/coroutines.cc:5024
+#: cp/coroutines.cc:5039
 #, fuzzy, gcc-internal-format
 msgid "%qE is provided by %qT but is not usable with the function %qD"
 msgstr "ms_hook_prologue 不是相容與巢狀的函式"
 
-#: cp/coroutines.cc:5298
+#: cp/coroutines.cc:5332
 #, gcc-internal-format
 msgid "no viable conversion from %<void%> provided by %<get_return_object%> to return type %qT"
 msgstr ""
@@ -60992,69 +61045,74 @@ msgstr "%qD 不是一個範本函式"
 msgid "%qs used outside of constant expressions"
 msgstr "%qE 並非常數運算式"
 
-#: cp/cp-gimplify.cc:1291
+#: cp/cp-gimplify.cc:999
+#, fuzzy, gcc-internal-format
+msgid "unexpected %<std::%s%> declaration"
+msgstr "預期的宣告"
+
+#: cp/cp-gimplify.cc:1317
 #, fuzzy, gcc-internal-format
 msgid "taking address of an immediate function %qD"
 msgstr "需位址的解構式 %qE"
 
-#: cp/cp-gimplify.cc:1472
+#: cp/cp-gimplify.cc:1498
 #, fuzzy, gcc-internal-format
 msgid "call to consteval function %qE is not a constant expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/cp-gimplify.cc:2311
+#: cp/cp-gimplify.cc:2337
 #, fuzzy, gcc-internal-format
 msgid "%<throw%> will always call %<terminate%>"
 msgstr "位址的 %qD 將一律評估做為 %<true%>"
 
-#: cp/cp-gimplify.cc:2314
+#: cp/cp-gimplify.cc:2340
 #, fuzzy, gcc-internal-format
 msgid "in C++11 destructors default to %<noexcept%>"
 msgstr "解構式無法 %<constexpr%>"
 
-#: cp/cp-gimplify.cc:2326
+#: cp/cp-gimplify.cc:2352
 #, gcc-internal-format
 msgid "in C++11 this %<throw%> will call %<terminate%> because destructors default to %<noexcept%>"
 msgstr ""
 
-#: cp/cp-gimplify.cc:4061
+#: cp/cp-gimplify.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "ignoring attribute %qE after earlier %qE"
 msgstr "忽略屬性於模板引數 %qT"
 
-#: cp/cp-gimplify.cc:4104
+#: cp/cp-gimplify.cc:4130
 #, fuzzy, gcc-internal-format
 msgid "pack expansion of %qE attribute"
 msgstr "無效的引數的 %qE 屬性"
 
-#: cp/cp-gimplify.cc:4107
+#: cp/cp-gimplify.cc:4133
 #, fuzzy, gcc-internal-format
 #| msgid "parse error in template argument list"
 msgid "use fold expression in the attribute argument instead"
 msgstr "範本引數表語法錯誤"
 
-#: cp/cp-gimplify.cc:4146 cp/cp-gimplify.cc:4158 cp/decl.cc:5053
+#: cp/cp-gimplify.cc:4172 cp/cp-gimplify.cc:4184 cp/decl.cc:5053
 #: cp/method.cc:991
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a type"
 msgstr "%qD 並非型態"
 
-#: cp/cp-gimplify.cc:4164
+#: cp/cp-gimplify.cc:4190
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class type"
 msgstr "%qT 並非類別型態"
 
-#: cp/cp-gimplify.cc:4181
+#: cp/cp-gimplify.cc:4207
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have %<const char *%> type"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/cp-gimplify.cc:4191
+#: cp/cp-gimplify.cc:4217
 #, fuzzy, gcc-internal-format
 msgid "%qD does not have integral type"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/cp-gimplify.cc:4203
+#: cp/cp-gimplify.cc:4229
 #, gcc-internal-format
 msgid "%<std::source_location::__impl%> does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>"
 msgstr ""
@@ -61102,7 +61160,7 @@ msgstr "轉換到 non-const 參考類型 %q#T 從 rvalue 的型態 %qT"
 msgid "conversion from %qH to %qI discards qualifiers"
 msgstr "從 %qT 到 %qT 的轉換丟失了限定資訊"
 
-#: cp/cvt.cc:499 cp/typeck.cc:9185
+#: cp/cvt.cc:499 cp/typeck.cc:9183
 #, gcc-internal-format
 msgid "casting %qT to %qT does not dereference pointer"
 msgstr "從 %qT 轉換到 %qT 並未提領指標"
@@ -61500,7 +61558,7 @@ msgstr "從先前的宣告 %q+F"
 msgid "redeclaration %qD differs in %qs from previous declaration"
 msgstr "重新宣告 %qD 不同在中 %<constexpr%>"
 
-#: cp/decl.cc:1620 cp/decl.cc:18452
+#: cp/decl.cc:1620 cp/decl.cc:18516
 #, fuzzy, gcc-internal-format
 #| msgid "previous declaration %q+D"
 msgid "previous declaration %qD"
@@ -61746,13 +61804,13 @@ msgstr "為參數 %d (屬於 %q#D)指定了預設引數"
 msgid "previous specification in %q#D here"
 msgstr "但先前在 %q+#D 中已有指定"
 
-#: cp/decl.cc:2570 cp/decl.cc:18470
+#: cp/decl.cc:2570 cp/decl.cc:18534
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting exporting for declaration %qD"
 msgstr "相互衝突的宣告 %q#D"
 
-#: cp/decl.cc:2572 cp/decl.cc:18472
+#: cp/decl.cc:2572 cp/decl.cc:18536
 #, fuzzy, gcc-internal-format
 msgid "previously declared here without exporting"
 msgstr "在之前宣告的在此"
@@ -61970,7 +62028,7 @@ msgstr "  略過 %q+#D 的初始化"
 msgid "  enters %<template for%> statement"
 msgstr "需要敘述"
 
-#: cp/decl.cc:5060 cp/parser.cc:8112
+#: cp/decl.cc:5060 cp/parser.cc:8095
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD used without template arguments"
@@ -62018,564 +62076,564 @@ msgstr "%<typename %T::%D%> 名稱 %q#T, 該項並非型態"
 msgid "template parameters do not match template %qD"
 msgstr "範本參數與範本不符"
 
-#: cp/decl.cc:5736
+#: cp/decl.cc:5750
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "%<-faligned-new=%d%> is not a power of two"
 msgstr "要求的對齊邊界不是 2 的某次方"
 
-#: cp/decl.cc:5794
+#: cp/decl.cc:5808
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5798
+#: cp/decl.cc:5812
 #, gcc-internal-format
 msgid "%<--param destructive-interference-size=%d%> is less than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:5811
+#: cp/decl.cc:5825
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is less than %d"
 msgstr ""
 
-#: cp/decl.cc:5816
+#: cp/decl.cc:5830
 #, gcc-internal-format
 msgid "%<--param constructive-interference-size=%d%> is greater than %<--param l1-cache-line-size=%d%>"
 msgstr ""
 
-#: cp/decl.cc:6162
+#: cp/decl.cc:6176
 #, fuzzy, gcc-internal-format
 #| msgid "%q+#D invalid; an anonymous union can only have non-static data members"
 msgid "%q#D invalid; an anonymous union may only have public non-static data members"
 msgstr "%q+#D 無效；匿名聯合只能有非靜態的資料成員"
 
-#: cp/decl.cc:6172 cp/parser.cc:26315
+#: cp/decl.cc:6186 cp/parser.cc:26379
 #, fuzzy, gcc-internal-format
 msgid "this flexibility is deprecated and will be removed"
 msgstr "%<mwords-little-endian%> 被不宜用而將被  移除的在中未來釋出"
 
-#: cp/decl.cc:6201
+#: cp/decl.cc:6215
 #, fuzzy, gcc-internal-format
 #| msgid "anonymous struct not inside named type"
 msgid "anonymous struct with base classes"
 msgstr "匿名結構不在具名類型內"
 
-#: cp/decl.cc:6213
+#: cp/decl.cc:6227
 #, gcc-internal-format
 msgid "member %q+#D with constructor not allowed in anonymous aggregate"
 msgstr "有建構式的成員 %q+#D 不允許在匿名聚合中出現"
 
-#: cp/decl.cc:6216
+#: cp/decl.cc:6230
 #, gcc-internal-format
 msgid "member %q+#D with destructor not allowed in anonymous aggregate"
 msgstr "有構構函式的成員 %q+#D 不允許在匿名聚合中出現"
 
-#: cp/decl.cc:6219
+#: cp/decl.cc:6233
 #, gcc-internal-format
 msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate"
 msgstr "有複製賦值運算子的成員 %q+#D 不能用在聯合中"
 
-#: cp/decl.cc:6238
+#: cp/decl.cc:6252
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in declaration of %q#T"
 msgstr "屬性忽略的在中宣告的 %q#T"
 
-#: cp/decl.cc:6241
+#: cp/decl.cc:6255
 #, fuzzy, gcc-internal-format
 msgid "attribute for %q#T must follow the %qs keyword"
 msgstr "屬性用於 %q#T 必須追隨 %qs 關鍵字"
 
-#: cp/decl.cc:6283
+#: cp/decl.cc:6297
 #, gcc-internal-format
 msgid "multiple types in one declaration"
 msgstr "一個宣告指定了多個類型"
 
-#: cp/decl.cc:6288
+#: cp/decl.cc:6302
 #, gcc-internal-format
 msgid "redeclaration of C++ built-in type %qT"
 msgstr "對 C++ 內建類型 %qT 的重宣告"
 
-#: cp/decl.cc:6305
+#: cp/decl.cc:6319
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> can only be specified for variables or function declarations"
 msgstr "%<auto%> 只能被指定的用於變數或函式宣告"
 
-#: cp/decl.cc:6338
+#: cp/decl.cc:6352
 #, gcc-internal-format
 msgid "missing type-name in typedef-declaration"
 msgstr "typedef 宣告中缺少類型名"
 
-#: cp/decl.cc:6346
+#: cp/decl.cc:6360
 #, gcc-internal-format
 msgid "ISO C++ prohibits anonymous structs"
 msgstr "ISO C++ 不允許匿名結構"
 
-#: cp/decl.cc:6353
+#: cp/decl.cc:6367
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<inline%> can only be specified for functions"
 msgstr "只能為函式指定 %qs"
 
-#: cp/decl.cc:6356
+#: cp/decl.cc:6370
 #, fuzzy, gcc-internal-format
 #| msgid "%qs can only be specified for functions"
 msgid "%<virtual%> can only be specified for functions"
 msgstr "只能為函式指定 %qs"
 
-#: cp/decl.cc:6361
+#: cp/decl.cc:6375
 #, gcc-internal-format
 msgid "%<friend%> can only be specified inside a class"
 msgstr "%<friend%> 只能在類別中指定"
 
-#: cp/decl.cc:6364
+#: cp/decl.cc:6378
 #, gcc-internal-format
 msgid "%<explicit%> can only be specified for constructors"
 msgstr "只能為建構式指定 %<explicit%>"
 
-#: cp/decl.cc:6367
+#: cp/decl.cc:6381
 #, gcc-internal-format
 msgid "a storage class can only be specified for objects and functions"
 msgstr "只能為物件和函式指定存儲類別"
 
-#: cp/decl.cc:6371
+#: cp/decl.cc:6385
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<const%> can only be specified for objects and functions"
 msgstr "只能為物件和函式指定類型限定"
 
-#: cp/decl.cc:6375
+#: cp/decl.cc:6389
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<volatile%> can only be specified for objects and functions"
 msgstr "只能為物件和函式指定類型限定"
 
-#: cp/decl.cc:6379
+#: cp/decl.cc:6393
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers can only be specified for objects and functions"
 msgid "%<__restrict%> can only be specified for objects and functions"
 msgstr "只能為物件和函式指定類型限定"
 
-#: cp/decl.cc:6383
+#: cp/decl.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "a storage class can only be specified for objects and functions"
 msgid "%<__thread%> can only be specified for objects and functions"
 msgstr "只能為物件和函式指定存儲類別"
 
-#: cp/decl.cc:6387
+#: cp/decl.cc:6401
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> was ignored in this declaration"
 msgstr "%<typedef%> 被忽略在中這個宣告"
 
-#: cp/decl.cc:6390 cp/decl.cc:6393 cp/decl.cc:6396
+#: cp/decl.cc:6404 cp/decl.cc:6407 cp/decl.cc:6410
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be used for type declarations"
 msgstr "%<constexpr%> 無法用於類型宣告"
 
-#: cp/decl.cc:6419
+#: cp/decl.cc:6433
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored in explicit instantiation %q#T"
 msgstr "屬性忽略的於模板具現化"
 
-#: cp/decl.cc:6422
+#: cp/decl.cc:6436
 #, fuzzy, gcc-internal-format
 msgid "no attribute can be applied to an explicit instantiation"
 msgstr "只能為類別定義套用 %qE 屬性"
 
-#: cp/decl.cc:6435 cp/decl.cc:14985 cp/decl.cc:16629 cp/parser.cc:17511
-#: cp/parser.cc:23677 cp/parser.cc:31066
+#: cp/decl.cc:6449 cp/decl.cc:15028 cp/decl.cc:16693 cp/parser.cc:17549
+#: cp/parser.cc:23741 cp/parser.cc:31130
 #, fuzzy, gcc-internal-format
 msgid "attribute ignored"
 msgstr "%qE 屬性被忽略"
 
-#: cp/decl.cc:6437 cp/decl.cc:14986
+#: cp/decl.cc:6451 cp/decl.cc:15029
 #, gcc-internal-format
 msgid "an attribute that appertains to a type-specifier is ignored"
 msgstr ""
 
-#: cp/decl.cc:6506
+#: cp/decl.cc:6520
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes applied to class type %qT outside of definition"
 msgstr "忽略屬性套用到類別型態 %qT 外側的定義"
 
 #. A template type parameter or other dependent type.
-#: cp/decl.cc:6510
+#: cp/decl.cc:6524
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
 msgstr "忽略屬性套用到附屬型態 %qT 而無需關聯的宣告"
 
-#: cp/decl.cc:6576 cp/decl2.cc:1277 cp/decl2.cc:1478
+#: cp/decl.cc:6590 cp/decl2.cc:1277 cp/decl2.cc:1478
 #, fuzzy, gcc-internal-format
 msgid "typedef %qD is initialized (use %qs instead)"
 msgstr "typedef %qD 被初始化的 (使用 decltype 做為替代)"
 
-#: cp/decl.cc:6591
+#: cp/decl.cc:6605
 #, gcc-internal-format
 msgid "postconditions with deduced result name types must only appear on function definitions"
 msgstr ""
 
-#: cp/decl.cc:6603
+#: cp/decl.cc:6617
 #, gcc-internal-format
 msgid "declaration of %q#D has %<extern%> and is initialized"
 msgstr "%q#D 宣告有 %<extern%> 並被初始化"
 
-#: cp/decl.cc:6640
+#: cp/decl.cc:6654
 #, fuzzy, gcc-internal-format
 msgid "definition of %q#D is marked %<dllimport%>"
 msgstr "定義的 %q#D 被標記 %<dllimport%>"
 
-#: cp/decl.cc:6667
+#: cp/decl.cc:6681
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "%q+#D is not a static data member of %q#T"
 msgstr "%q#D 不是 %qT 的非靜態資料成員"
 
-#: cp/decl.cc:6676
+#: cp/decl.cc:6690
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member-template declaration of %qD"
 msgstr "%q#D 宣告為範本"
 
-#: cp/decl.cc:6677
+#: cp/decl.cc:6691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid member template declaration %qD"
 msgid "does not match member template declaration here"
 msgstr "無效的成員範本宣告 %qD"
 
-#: cp/decl.cc:6689
+#: cp/decl.cc:6703
 #, gcc-internal-format
 msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>"
 msgstr "ISO C++ 不允許將 %<%T::%D%> 定義為 %<%T::%D%>"
 
-#: cp/decl.cc:6705
+#: cp/decl.cc:6719
 #, gcc-internal-format
 msgid "duplicate initialization of %qD"
 msgstr "ISO C++ 不允許成員 %qD 的初始化"
 
-#: cp/decl.cc:6754
+#: cp/decl.cc:6768
 #, gcc-internal-format
 msgid "declaration of %q#D outside of class is not definition"
 msgstr "出現在類別外的 %q#D 的宣告不是定義"
 
-#: cp/decl.cc:6772
+#: cp/decl.cc:6786
 #, gcc-internal-format
 msgid "block-scope extern declaration %q#D must not be attached to a named module"
 msgstr ""
 
-#: cp/decl.cc:6810
+#: cp/decl.cc:6824
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<thread_local%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:6819
+#: cp/decl.cc:6833
 #, fuzzy, gcc-internal-format
 msgid "%qD defined %<static%> in %qs function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:6886
+#: cp/decl.cc:6900
 #, gcc-internal-format
 msgid "variable %q#D has initializer but incomplete type"
 msgstr "變數 %q#D 有初始值設定，但是類型不完全"
 
-#: cp/decl.cc:6895 cp/decl.cc:8379
+#: cp/decl.cc:6909 cp/decl.cc:8393
 #, gcc-internal-format
 msgid "elements of array %q#D have incomplete type"
 msgstr "陣列 %q#D 的元素類型不完全"
 
-#: cp/decl.cc:6906
+#: cp/decl.cc:6920
 #, gcc-internal-format
 msgid "aggregate %q#D has incomplete type and cannot be defined"
 msgstr "聚合 %q#D 類型不完全，無法被定義"
 
-#: cp/decl.cc:6976
+#: cp/decl.cc:6990
 #, gcc-internal-format
 msgid "%qD declared as reference but not initialized"
 msgstr "%qD 宣告為參照卻未被初始化"
 
-#: cp/decl.cc:7059
+#: cp/decl.cc:7073
 #, fuzzy, gcc-internal-format
 msgid "name used in a GNU-style designated initializer for an array"
 msgstr "名稱已用於 GNU-style 指定的初始設定式用於陣列"
 
-#: cp/decl.cc:7065
+#: cp/decl.cc:7079
 #, gcc-internal-format
 msgid "name %qD used in a GNU-style designated initializer for an array"
 msgstr "名稱 %qD 用在 GNU 風格的陣列指定元素初始值設定中"
 
-#: cp/decl.cc:7085
+#: cp/decl.cc:7099
 #, gcc-internal-format
 msgid "non-trivial designated initializers not supported"
 msgstr "不平凡的代理初始值設定不受支援"
 
-#: cp/decl.cc:7089
+#: cp/decl.cc:7103
 #, fuzzy, gcc-internal-format
 #| msgid "size of array %qD is not an integral constant-expression"
 msgid "C99 designator %qE is not an integral constant-expression"
 msgstr "陣列 %qD 的大小不是一個整數常運算式"
 
-#: cp/decl.cc:7154
+#: cp/decl.cc:7168
 #, gcc-internal-format
 msgid "initializer fails to determine size of %qD"
 msgstr "初始值設定無法決定 %qD 的大小"
 
-#: cp/decl.cc:7161
+#: cp/decl.cc:7175
 #, gcc-internal-format
 msgid "array size missing in %qD"
 msgstr "%qD 缺少陣列大小"
 
-#: cp/decl.cc:7173
+#: cp/decl.cc:7187
 #, gcc-internal-format
 msgid "zero-size array %qD"
 msgstr "大小為 0 的陣列 %qD"
 
-#: cp/decl.cc:7221
+#: cp/decl.cc:7235
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t known"
 msgstr "貯藏大小的 %qD isn%'t 已知"
 
-#: cp/decl.cc:7246
+#: cp/decl.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "storage size of %qD isn%'t constant"
 msgstr "貯藏大小的 %qD isn%'t 常數"
 
-#: cp/decl.cc:7348
+#: cp/decl.cc:7362
 #, fuzzy, gcc-internal-format
 msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "抱歉：語意的內聯函式靜態資料 %q+#D 是錯誤的 (you%'ll 旋緊向上與多重份數)"
 
-#: cp/decl.cc:7352
+#: cp/decl.cc:7366
 #, fuzzy, gcc-internal-format
 msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
 msgstr "抱歉：語意的內聯函式靜態資料 %q+#D 是錯誤的 (you%'ll 旋緊向上與多重份數)"
 
-#: cp/decl.cc:7359
+#: cp/decl.cc:7373
 #, fuzzy, gcc-internal-format
 msgid "you can work around this by removing the initializer"
 msgstr "  您可以解決方法這個由移除初始設定式"
 
-#: cp/decl.cc:7402 rust/backend/rust-tree.cc:3278
+#: cp/decl.cc:7416 rust/backend/rust-tree.cc:3278
 #, fuzzy, gcc-internal-format
 #| msgid "uninitialized const %qD"
 msgid "uninitialized %<const %D%>"
 msgstr "未初始化的常數 %qD"
 
-#: cp/decl.cc:7409 rust/backend/rust-tree.cc:3285
+#: cp/decl.cc:7423 rust/backend/rust-tree.cc:3285
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> function"
 msgstr "uninitialized 成員 %qD 在中 %<constexpr%> 建構子"
 
-#: cp/decl.cc:7418 rust/backend/rust-tree.cc:3294
+#: cp/decl.cc:7432 rust/backend/rust-tree.cc:3294
 #, fuzzy, gcc-internal-format
 msgid "uninitialized variable %qD in %<constexpr%> context"
 msgstr "uninitialized 成員 %qD 在中 %<constexpr%> 建構子"
 
-#: cp/decl.cc:7426
+#: cp/decl.cc:7440
 #, fuzzy, gcc-internal-format
 msgid "%q#T has no user-provided default constructor"
 msgstr "%q#T 沒有任何 user-provided 預設建構函式"
 
-#: cp/decl.cc:7430
+#: cp/decl.cc:7444
 #, fuzzy, gcc-internal-format
 msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
 msgstr "建構子未被 user-provided 因為它是明確的缺席在中類別本體"
 
-#: cp/decl.cc:7433
+#: cp/decl.cc:7447
 #, fuzzy, gcc-internal-format
 msgid "and the implicitly-defined constructor does not initialize %q#D"
 msgstr "和 implicitly-defined 建構子不初始化 %q+#D"
 
-#: cp/decl.cc:7733
+#: cp/decl.cc:7747
 #, gcc-internal-format
 msgid "invalid type %qT as initializer for a vector of type %qT"
 msgstr "無效類型 %qT 做為類型為 %qT 的向量的初始化設定"
 
-#: cp/decl.cc:7805
+#: cp/decl.cc:7819
 #, gcc-internal-format
 msgid "initializer for %qT must be brace-enclosed"
 msgstr "%qT 的初始化設定必須在大括號內"
 
-#: cp/decl.cc:7850
+#: cp/decl.cc:7864
 #, fuzzy, gcc-internal-format
 msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
 msgstr "%<[%E]=%>已用於 GNU-style 指定的初始設定式用於類別 %qT"
 
-#: cp/decl.cc:7867 cp/init.cc:3439 cp/search.cc:1245
+#: cp/decl.cc:7881 cp/init.cc:3439 cp/search.cc:1245
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous"
 msgstr "對成員 %qD 的請求有歧義"
 
-#: cp/decl.cc:7872
+#: cp/decl.cc:7886
 #, gcc-internal-format
 msgid "%qT has no non-static data member named %qD"
 msgstr "%qT 沒具名為 %qD 的非靜態資料成員"
 
-#: cp/decl.cc:7897
+#: cp/decl.cc:7911
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "%qD is not a direct member of %qT"
 msgstr "%qD 不是 %qT 的成員"
 
-#: cp/decl.cc:7953
+#: cp/decl.cc:7967
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for %q#D"
 msgstr "無效的初始設定式用於陣列成員 %q#D"
 
-#: cp/decl.cc:8007
+#: cp/decl.cc:8021
 #, fuzzy, gcc-internal-format
 msgid "C99 designator %qE outside aggregate initializer"
 msgstr "C99 指示項 %qE 外側彙總初始設定式"
 
-#: cp/decl.cc:8046 cp/decl.cc:8337 cp/typeck2.cc:1727 cp/typeck2.cc:2062
+#: cp/decl.cc:8060 cp/decl.cc:8351 cp/typeck2.cc:1727 cp/typeck2.cc:2062
 #: cp/typeck2.cc:2110 cp/typeck2.cc:2157
 #, gcc-internal-format
 msgid "too many initializers for %qT"
 msgstr "%qT 的初始值設定項太多"
 
-#: cp/decl.cc:8089
+#: cp/decl.cc:8103
 #, gcc-internal-format
 msgid "braces around scalar initializer for type %qT"
 msgstr "類型 %qT 的標量初始化帶大括號"
 
-#: cp/decl.cc:8099
+#: cp/decl.cc:8113
 #, fuzzy, gcc-internal-format
 #| msgid "braces around scalar initializer for type %qT"
 msgid "too many braces around scalar initializer for type %qT"
 msgstr "類型 %qT 的標量初始化帶大括號"
 
-#: cp/decl.cc:8233
+#: cp/decl.cc:8247
 #, gcc-internal-format
 msgid "missing braces around initializer for %qT"
 msgstr "%qT 的初始值設定周圍缺少大括號"
 
-#: cp/decl.cc:8367
+#: cp/decl.cc:8381
 #, fuzzy, gcc-internal-format
 msgid "structured binding has incomplete type %qT"
 msgstr "來源是指標到不完整型態"
 
-#: cp/decl.cc:8381
+#: cp/decl.cc:8395
 #, fuzzy, gcc-internal-format
 msgid "elements of array %q#T have incomplete type"
 msgstr "元件的陣列 %q#T 有不完整型態"
 
-#: cp/decl.cc:8394
+#: cp/decl.cc:8408
 #, fuzzy, gcc-internal-format
 msgid "variable-sized compound literal"
 msgstr "variable-sized 複合實字"
 
-#: cp/decl.cc:8450
+#: cp/decl.cc:8464
 #, fuzzy, gcc-internal-format
 msgid "%q#D has incomplete type"
 msgstr "%q#D 有不完整型態"
 
-#: cp/decl.cc:8471
+#: cp/decl.cc:8485
 #, fuzzy, gcc-internal-format
 msgid "scalar object %qD requires one element in initializer"
 msgstr "純量物件 %qD 需求一個元件在中初始設定式"
 
-#: cp/decl.cc:8522
+#: cp/decl.cc:8536
 #, fuzzy, gcc-internal-format
 msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
 msgstr "在中 C++98 %qD 必須被初始化的由建構子，無法由 %<{...}%>"
 
-#: cp/decl.cc:8665
+#: cp/decl.cc:8679
 #, gcc-internal-format
 msgid "array %qD initialized by parenthesized string literal %qE"
 msgstr "陣列 %qD 被有括號的字面字串 %qE 所初始化"
 
-#: cp/decl.cc:8715
+#: cp/decl.cc:8729
 #, gcc-internal-format
 msgid "initializer invalid for static member with constructor"
 msgstr "建構式中對靜態成員的初始化無效"
 
-#: cp/decl.cc:8717
+#: cp/decl.cc:8731
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for static member %qD"
 msgstr "non-constant in-class 初始化無效的用於靜態成員 %qD"
 
-#: cp/decl.cc:8720
+#: cp/decl.cc:8734
 #, fuzzy, gcc-internal-format
 msgid "non-constant in-class initialization invalid for non-inline static member %qD"
 msgstr "non-constant in-class 初始化無效的用於靜態成員 %qD"
 
-#: cp/decl.cc:8725
+#: cp/decl.cc:8739
 #, gcc-internal-format
 msgid "(an out of class initialization is required)"
 msgstr "(需要一個類別外的初始化)"
 
-#: cp/decl.cc:8752 cp/decl.cc:9776 cp/typeck.cc:8281 d/d-codegen.cc:773
+#: cp/decl.cc:8766 cp/decl.cc:9790 cp/typeck.cc:8279 d/d-codegen.cc:773
 #: rust/backend/rust-tree.cc:4770
 #, gcc-internal-format
 msgid "address of explicit register variable %qD requested"
 msgstr "要求明確暫存器變數 %qD 的位址。"
 
-#: cp/decl.cc:8949
+#: cp/decl.cc:8963
 #, fuzzy, gcc-internal-format
 msgid "reference %qD is initialized with itself"
 msgstr "%qD 被初始化的以其本身"
 
-#: cp/decl.cc:9151
+#: cp/decl.cc:9165
 #, fuzzy, gcc-internal-format
 msgid "argument %d of %qE must be of %<omp_interop_t%>"
 msgstr "引數 %d 的 %qE 必須是指標類型"
 
-#: cp/decl.cc:9354
+#: cp/decl.cc:9368
 #, fuzzy, gcc-internal-format
 msgid "could not find variant declaration"
 msgstr "%<[*]%>無法在中宣告"
 
-#: cp/decl.cc:9378
+#: cp/decl.cc:9392
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on constructor %qD"
 msgstr "太少引數到建構子 %q#D"
 
-#: cp/decl.cc:9383
+#: cp/decl.cc:9397
 #, fuzzy, gcc-internal-format
 msgid "%<declare variant%> on destructor %qD"
 msgstr "需位址的解構式 %qE"
 
-#: cp/decl.cc:9388
+#: cp/decl.cc:9402
 #, gcc-internal-format
 msgid "%<declare variant%> on defaulted %qD"
 msgstr ""
 
-#: cp/decl.cc:9393
+#: cp/decl.cc:9407
 #, gcc-internal-format
 msgid "%<declare variant%> on deleted %qD"
 msgstr ""
 
-#: cp/decl.cc:9398
+#: cp/decl.cc:9412
 #, gcc-internal-format
 msgid "%<declare variant%> on virtual %qD"
 msgstr ""
 
-#: cp/decl.cc:9463
+#: cp/decl.cc:9477
 #, gcc-internal-format
 msgid "assignment (not initialization) in declaration"
 msgstr "賦值(不是初始化)出現在宣告中"
 
-#: cp/decl.cc:9484 cp/decl.cc:17028
+#: cp/decl.cc:9498 cp/decl.cc:17092
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++17 does not allow %<register%> storage class specifier"
 msgstr "ISO C++ 不允許指定元素初始值設定"
 
-#: cp/decl.cc:9488 cp/decl.cc:17032
+#: cp/decl.cc:9502 cp/decl.cc:17096
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specified for %qs"
 msgid "%<register%> storage class specifier used"
 msgstr "為 %qs 指定了存儲類別"
 
-#: cp/decl.cc:9533 cp/decl.cc:16995
+#: cp/decl.cc:9547 cp/decl.cc:17059
 #, fuzzy, gcc-internal-format
 msgid "declaration of %q#D has no initializer"
 msgstr "宣告的 %q#D 沒有任何初始設定式"
 
-#: cp/decl.cc:9569
+#: cp/decl.cc:9583
 #, fuzzy, gcc-internal-format
 msgid "initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?"
 msgstr "無效的使用的成員函式 (did 您忘記%<()%>?)"
 
-#: cp/decl.cc:9581
+#: cp/decl.cc:9595
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "deduced type %qT for %qD is incomplete"
@@ -62583,1947 +62641,1958 @@ msgstr "回傳值類型 %q#T 為不完全"
 
 #. [basic.start.main]/3: A program that defines main as deleted
 #. is ill-formed.
-#: cp/decl.cc:9637
+#: cp/decl.cc:9651
 #, fuzzy, gcc-internal-format
 msgid "%<::main%> cannot be deleted"
 msgstr "%qD 無法缺席"
 
-#: cp/decl.cc:9798
+#: cp/decl.cc:9812
 #, gcc-internal-format
 msgid "shadowing previous type declaration of %q#D"
 msgstr "隱藏了早先的類型宣告 %q#D"
 
-#: cp/decl.cc:9841
+#: cp/decl.cc:9855
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can only be applied to a variable with static or thread storage duration"
 msgstr "%qE 屬性只有套用到變數和函式"
 
-#: cp/decl.cc:9850
+#: cp/decl.cc:9864
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> can be applied to structured binding only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:10067
+#: cp/decl.cc:10081
 #, gcc-internal-format
 msgid "function %q#D is initialized like a variable"
 msgstr "函式 %q#D 像變數一樣被初始化"
 
-#: cp/decl.cc:10302
+#: cp/decl.cc:10316
 #, fuzzy, gcc-internal-format
 #| msgid "cannot decompose address"
 msgid "cannot decompose lambda closure type %qT"
 msgstr "無法分解位址"
 
-#: cp/decl.cc:10303
+#: cp/decl.cc:10317
 #, fuzzy, gcc-internal-format
 msgid "lambda declared here"
 msgstr "宣告的在此"
 
-#: cp/decl.cc:10322
+#: cp/decl.cc:10336
 #, fuzzy, gcc-internal-format
 #| msgid "  cannot use obsolete binding at %q+D because it has a destructor"
 msgid "cannot decompose class type %qT because it has an anonymous struct member"
 msgstr "  不能在 %q+D 使用過時的繫結，因為它有解構函式"
 
-#: cp/decl.cc:10325
+#: cp/decl.cc:10339
 #, gcc-internal-format
 msgid "cannot decompose class type %qT because it has an anonymous union member"
 msgstr ""
 
-#: cp/decl.cc:10335
+#: cp/decl.cc:10349
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is an inaccessible base of %qT"
 msgid "cannot decompose inaccessible member %qD of %qT"
 msgstr "%qT 是 %qT 不可存取的基礎類別"
 
-#: cp/decl.cc:10360
+#: cp/decl.cc:10374
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a nested class of %qT"
 msgid "in base class of %qT"
 msgstr "%qT 不是 %qT 的巢狀類別"
 
-#: cp/decl.cc:10368
+#: cp/decl.cc:10382
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10378
+#: cp/decl.cc:10392
 #, gcc-internal-format
 msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members"
 msgstr ""
 
-#: cp/decl.cc:10579 cp/decl.cc:10747
+#: cp/decl.cc:10593 cp/decl.cc:10767
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete type %qT"
 msgstr "來源是指標到不完整型態"
 
-#: cp/decl.cc:10591
+#: cp/decl.cc:10605
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose array of unknown bound %qT"
 msgstr "無法 value-initialize 陣列的不明約束 %qT"
 
-#: cp/decl.cc:10601 cp/decl.cc:10777
+#: cp/decl.cc:10615 cp/decl.cc:10797
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose variable length array %qT"
 msgstr "ISO C90 禁止變數長度陣列 %qE"
 
-#: cp/decl.cc:10614 cp/decl.cc:10884
+#: cp/decl.cc:10628 cp/decl.cc:10904
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot decompose variable length vector %qT"
 msgstr "無法宣告參照 %q#T 的指標"
 
-#: cp/decl.cc:10626 cp/decl.cc:10936
+#: cp/decl.cc:10640 cp/decl.cc:10956
 #, fuzzy, gcc-internal-format
 #| msgid "size of array is not an integral constant-expression"
 msgid "%<std::tuple_size<%T>::value%> is not an integral constant expression"
 msgstr "陣列大小不是一個整數常運算式"
 
-#: cp/decl.cc:10635 cp/decl.cc:11082
+#: cp/decl.cc:10649 cp/decl.cc:11104
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose union type %qT"
 msgstr "無法宣告指標到經資格修飾函數型式 %qT"
 
-#: cp/decl.cc:10641 cp/decl.cc:11087
+#: cp/decl.cc:10655 cp/decl.cc:11109
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member of non-class type %qT"
 msgid "cannot decompose non-array non-class type %qT"
 msgstr "產生非類別類型 %qT 的成員指標"
 
-#: cp/decl.cc:10649 cp/decl.cc:11093
+#: cp/decl.cc:10663 cp/decl.cc:11115
 #, fuzzy, gcc-internal-format
 msgid "structured binding refers to incomplete class type %qT"
 msgstr "來源是的不完整類別型態"
 
-#: cp/decl.cc:10771
+#: cp/decl.cc:10791
 #, fuzzy, gcc-internal-format
 msgid "array initializer for structured binding declaration in condition"
 msgstr "無效的初始設定式用於成員函式 %qD"
 
-#: cp/decl.cc:10787 cp/decl.cc:10944
+#: cp/decl.cc:10807 cp/decl.cc:10964
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%u name provided for structured binding"
 msgid_plural "%u names provided for structured binding"
 msgstr[0] "%qs 指定的用於結構欄位"
 
-#: cp/decl.cc:10791
+#: cp/decl.cc:10811
 #, gcc-internal-format, gfc-internal-format
 msgid "only %u name provided for structured binding"
 msgid_plural "only %u names provided for structured binding"
 msgstr[0] ""
 
-#: cp/decl.cc:10794
+#: cp/decl.cc:10814
 #, gcc-internal-format
 msgid "while %qT decomposes into %wu element"
 msgid_plural "while %qT decomposes into %wu elements"
 msgstr[0] ""
 
-#: cp/decl.cc:10946
+#: cp/decl.cc:10966
 #, gcc-internal-format
 msgid "while %qT decomposes into %E elements"
 msgstr ""
 
-#: cp/decl.cc:11001 cp/decl.cc:11047
+#: cp/decl.cc:11021 cp/decl.cc:11068
 #, gcc-internal-format
 msgid "%<std::tuple_element<%wu, %T>::type%> is %<void%>"
 msgstr ""
 
-#: cp/decl.cc:11007
+#: cp/decl.cc:11027
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding pack %qD"
 msgstr "value-initialization 的函數型式 %qT"
 
-#: cp/decl.cc:11053
+#: cp/decl.cc:11074
 #, fuzzy, gcc-internal-format
 msgid "in initialization of structured binding variable %qD"
 msgstr "value-initialization 的函數型式 %qT"
 
-#: cp/decl.cc:11109
+#: cp/decl.cc:11131
 #, fuzzy, gcc-internal-format
 msgid "cannot decompose class type %qT without non-static data members"
 msgstr "無法套用 %<offsetof%> 到靜態資料成員 %qD"
 
-#: cp/decl.cc:11668
+#: cp/decl.cc:11690
 #, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization"
 msgstr ""
 
-#: cp/decl.cc:11671
+#: cp/decl.cc:11693
 #, fuzzy, gcc-internal-format
 msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
 msgstr "  %q+T 有 non-trivial 解構式"
 
-#: cp/decl.cc:11676
+#: cp/decl.cc:11698
 #, gcc-internal-format
 msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
 msgstr ""
 
-#: cp/decl.cc:11895
+#: cp/decl.cc:11917
 #, fuzzy, gcc-internal-format
 msgid "initializer fails to determine size of %qT"
 msgstr "初始設定式失敗到決定大小的 %qT"
 
-#: cp/decl.cc:11899
+#: cp/decl.cc:11921
 #, fuzzy, gcc-internal-format
 msgid "array size missing in %qT"
 msgstr "陣列大小缺少的在中 %qT"
 
-#: cp/decl.cc:11902
+#: cp/decl.cc:11924
 #, fuzzy, gcc-internal-format
 msgid "zero-size array %qT"
 msgstr "zero-size 陣列 %qT"
 
-#: cp/decl.cc:11918
+#: cp/decl.cc:11940
 #, gcc-internal-format
 msgid "destructor for alien class %qT cannot be a member"
 msgstr "其它類別 %qT 的解構函式不能做為成員"
 
-#: cp/decl.cc:11920
+#: cp/decl.cc:11942
 #, gcc-internal-format
 msgid "constructor for alien class %qT cannot be a member"
 msgstr "其它類別 %qT 的建構式不能做為成員"
 
-#: cp/decl.cc:11946
+#: cp/decl.cc:11968
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> variable"
 msgstr "%qD 宣告的做為 %<virtual%> 變數"
 
-#: cp/decl.cc:11948
+#: cp/decl.cc:11970
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
 msgstr "%<const%> 和 %<volatile%>函式說明符於 %qD 無效的在中變數宣告"
 
-#: cp/decl.cc:11954
+#: cp/decl.cc:11976
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> parameter"
 msgstr "%qD 宣告的做為 %<virtual%> 參數"
 
-#: cp/decl.cc:11957
+#: cp/decl.cc:11979
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> parameter"
 msgstr "%qD 宣告的做為 %<inline%> 參數"
 
-#: cp/decl.cc:11959
+#: cp/decl.cc:11981
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
 msgstr "%<const%> 和 %<volatile%>函式說明符於 %qD 無效的在中參數宣告"
 
-#: cp/decl.cc:11965
+#: cp/decl.cc:11987
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> type"
 msgstr "%qD 宣告的做為 %<virtual%> 型態"
 
-#: cp/decl.cc:11968
+#: cp/decl.cc:11990
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> type"
 msgstr "%qD 宣告的做為 %<inline%> 型態"
 
-#: cp/decl.cc:11970
+#: cp/decl.cc:11992
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
 msgstr "%<const%> 和 %<volatile%>函式說明符於 %qD 無效的在中類型宣告"
 
-#: cp/decl.cc:11976
+#: cp/decl.cc:11998
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as a %<virtual%> field"
 msgstr "%qD 宣告的做為 %<virtual%> 欄位"
 
-#: cp/decl.cc:11979
+#: cp/decl.cc:12001
 #, fuzzy, gcc-internal-format
 msgid "%qD declared as an %<inline%> field"
 msgstr "%qD 宣告的做為 %<inline%> 欄位"
 
-#: cp/decl.cc:11981
+#: cp/decl.cc:12003
 #, fuzzy, gcc-internal-format
 msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
 msgstr "%<const%> 和 %<volatile%>函式說明符於 %qD 無效的在中欄位宣告"
 
-#: cp/decl.cc:11988
+#: cp/decl.cc:12010
 #, gcc-internal-format
 msgid "%q+D declared as a friend"
 msgstr "%q+D 宣告為夥伴"
 
-#: cp/decl.cc:11995
+#: cp/decl.cc:12017
 #, gcc-internal-format
 msgid "%q+D declared with an exception specification"
 msgstr "%q+D 宣告時有異常指定"
 
-#: cp/decl.cc:12027
+#: cp/decl.cc:12049
 #, gcc-internal-format
 msgid "definition of %qD is not in namespace enclosing %qT"
 msgstr "%qD 的定義不在包含 %qT 的命名空間中"
 
-#: cp/decl.cc:12067
+#: cp/decl.cc:12089
 #, gcc-internal-format
 msgid "static member function %q#D declared with type qualifiers"
 msgstr "靜態成員函式 %q#D 的宣告帶有類型限定符"
 
-#: cp/decl.cc:12144
+#: cp/decl.cc:12166
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "function concepts are no longer supported"
 msgstr "具名回傳值不再被支援"
 
-#: cp/decl.cc:12182
+#: cp/decl.cc:12204
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a template function"
 msgid "constraints on a non-templated function"
 msgstr "%qD 不是一個範本函式"
 
-#: cp/decl.cc:12184
+#: cp/decl.cc:12206
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration not in class definition"
 msgid "constrained non-template friend declaration must be a definition"
 msgstr "夥伴宣告不在類別定義內"
 
-#: cp/decl.cc:12191
+#: cp/decl.cc:12213
 #, gcc-internal-format
 msgid "friend function template with constraints that depend on outer template parameters must be a definition"
 msgstr ""
 
-#: cp/decl.cc:12243
+#: cp/decl.cc:12286
 #, gcc-internal-format
 msgid "defining explicit specialization %qD in friend declaration"
 msgstr "在夥伴宣告中定義明確特例化 %qD"
 
-#: cp/decl.cc:12254
+#: cp/decl.cc:12297
 #, gcc-internal-format
 msgid "invalid use of template-id %qD in declaration of primary template"
 msgstr "在基本範本的宣告中對範本識別碼 %qD 的使用無效"
 
-#: cp/decl.cc:12277
+#: cp/decl.cc:12320
 #, gcc-internal-format
 msgid "default arguments are not allowed in declaration of friend template specialization %qD"
 msgstr "夥伴範本特例化 %qD 中不允許出現預設參數"
 
-#: cp/decl.cc:12286
+#: cp/decl.cc:12329
 #, gcc-internal-format
 msgid "%<inline%> is not allowed in declaration of friend template specialization %qD"
 msgstr "%<inline%> 不允許用於夥伴範本特例化 %qD 的宣告"
 
 #. diagnostics::option_id=
-#: cp/decl.cc:12317
+#: cp/decl.cc:12360
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %q#D outside of class is not definition"
 msgid "friend declaration of %qD specifies default arguments and isn%'t a definition"
 msgstr "出現在類別外的 %q#D 的宣告不是定義"
 
-#: cp/decl.cc:12359
+#: cp/decl.cc:12402
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be a template"
 msgstr "不能將 %<::main%> 宣告為一個範本"
 
-#: cp/decl.cc:12362
+#: cp/decl.cc:12405
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be inline"
 msgstr "不能將 %<::main%> 宣告為 inline"
 
-#: cp/decl.cc:12365 cp/decl.cc:12368
+#: cp/decl.cc:12408 cp/decl.cc:12411
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be static"
 msgid "cannot declare %<::main%> to be %qs"
 msgstr "不能將 %<::main%> 宣告為 static"
 
-#: cp/decl.cc:12370
+#: cp/decl.cc:12413
 #, gcc-internal-format
 msgid "cannot declare %<::main%> to be static"
 msgstr "不能將 %<::main%> 宣告為 static"
 
-#: cp/decl.cc:12372
+#: cp/decl.cc:12415
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be inline"
 msgid "cannot declare %<::main%> with a linkage specification other than %<extern \"C++\"%>"
 msgstr "不能將 %<::main%> 宣告為 inline"
 
-#: cp/decl.cc:12377
+#: cp/decl.cc:12420
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot attach %<::main%> to a named module"
 msgstr "不能將 %<::main%> 宣告為一個範本"
 
-#: cp/decl.cc:12378
+#: cp/decl.cc:12421
 #, gcc-internal-format
 msgid "use %<extern \"C++\"%> to attach it to the global module instead"
 msgstr ""
 
-#: cp/decl.cc:12439
+#: cp/decl.cc:12482
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have cv-qualifier"
 msgstr "non-member 函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:12441
+#: cp/decl.cc:12484
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have cv-qualifier"
 msgstr "靜態成員函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:12442
+#: cp/decl.cc:12485
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have cv-qualifier"
 msgstr "靜態成員函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:12447
+#: cp/decl.cc:12490
 #, fuzzy, gcc-internal-format
 msgid "non-member function %qD cannot have ref-qualifier"
 msgstr "non-member 函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:12449
+#: cp/decl.cc:12492
 #, fuzzy, gcc-internal-format
 msgid "static member function %qD cannot have ref-qualifier"
 msgstr "靜態成員函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:12450
+#: cp/decl.cc:12493
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function %qD cannot have ref-qualifier"
 msgstr "靜態成員函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:12456 cp/decl.cc:15506 cp/decl.cc:15516 cp/parser.cc:13446
+#: cp/decl.cc:12499 cp/decl.cc:15549 cp/decl.cc:15559 cp/parser.cc:13440
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "explicit object parameter declared here"
 msgstr "範本參數類型 %qT 宣告為 %<friend%>"
 
-#: cp/decl.cc:12469
+#: cp/decl.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must be declared in the same scope as %qT"
 msgstr "特殊化的 %qD 必須出現於命名空間範圍"
 
-#: cp/decl.cc:12471 cp/decl.cc:12480 cp/typeck.cc:4914
+#: cp/decl.cc:12514 cp/decl.cc:12523 cp/typeck.cc:4909
 #, fuzzy, gcc-internal-format
 msgid "  declared here"
 msgstr "宣告的在此"
 
-#: cp/decl.cc:12478
+#: cp/decl.cc:12521
 #, fuzzy, gcc-internal-format
 msgid "deduction guide %qD must have the same access as %qT"
 msgstr "特殊化的 %qD 必須出現於命名空間範圍"
 
-#: cp/decl.cc:12484
+#: cp/decl.cc:12527
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "deduction guide %qD must not have a function body"
 msgstr "%qD 沒有宣告為一個函式"
 
-#: cp/decl.cc:12498
+#: cp/decl.cc:12541
 #, fuzzy, gcc-internal-format
 msgid "literal operator with C linkage"
 msgstr "實字運算子與 C 鏈結"
 
-#: cp/decl.cc:12508
+#: cp/decl.cc:12551
 #, fuzzy, gcc-internal-format
 msgid "%qD has invalid argument list"
 msgstr "%qD 有無效的引數清單"
 
-#: cp/decl.cc:12516
+#: cp/decl.cc:12559
 #, fuzzy, gcc-internal-format
 msgid "integer suffix %qs shadowed by implementation"
 msgstr "整數字尾 %<%s%>帶陰影由實作"
 
-#: cp/decl.cc:12522
+#: cp/decl.cc:12565
 #, fuzzy, gcc-internal-format
 msgid "floating-point suffix %qs shadowed by implementation"
 msgstr "浮點數字尾 %<%s%>帶陰影由實作"
 
-#: cp/decl.cc:12529
+#: cp/decl.cc:12572
 #, fuzzy, gcc-internal-format
 msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
 msgstr "實字運算子字尾無法前繼的由 %<_%>被保留的用於未來標準化"
 
-#: cp/decl.cc:12534
+#: cp/decl.cc:12577
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a non-member function"
 msgstr "%qD 必須是 non-member 函式"
 
-#: cp/decl.cc:12631
+#: cp/decl.cc:12674
 #, gcc-internal-format
 msgid "%<::main%> must return %<int%>"
 msgstr "%<::main%> 必須回傳 %<int%>"
 
-#: cp/decl.cc:12672
+#: cp/decl.cc:12715
 #, gcc-internal-format
 msgid "definition of implicitly-declared %qD"
 msgstr "隱含宣告的 %qD 的定義"
 
-#: cp/decl.cc:12678
+#: cp/decl.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "definition of explicitly-defaulted %q+D"
 msgstr "定義的 explicitly-defaulted %q+D"
 
-#: cp/decl.cc:12680
+#: cp/decl.cc:12723
 #, fuzzy, gcc-internal-format
 msgid "%q#D explicitly defaulted here"
 msgstr "%q+#D 明確的缺席在此"
 
-#: cp/decl.cc:12700
+#: cp/decl.cc:12743
 #, gcc-internal-format
 msgid "no %q#D member function declared in class %qT"
 msgstr "成員函式 %q#D 未在類別 %qT 中宣告"
 
-#: cp/decl.cc:12906
+#: cp/decl.cc:12949
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare %<::main%> to be a template"
 msgid "cannot declare %<::main%> to be a global variable"
 msgstr "不能將 %<::main%> 宣告為一個範本"
 
-#: cp/decl.cc:12909
+#: cp/decl.cc:12952
 #, gcc-internal-format
 msgid "an entity named %<main%> cannot be declared with C language linkage"
 msgstr ""
 
-#: cp/decl.cc:12918
+#: cp/decl.cc:12961
 #, fuzzy, gcc-internal-format
 msgid "a non-template variable cannot be %<concept%>"
 msgstr "自動變數 %qE 無法 %<threadprivate%>"
 
-#: cp/decl.cc:12921
+#: cp/decl.cc:12964
 #, fuzzy, gcc-internal-format
 msgid "concept must be defined at namespace scope"
 msgstr "特殊化的 %qD 必須出現於命名空間範圍"
 
-#: cp/decl.cc:12924
+#: cp/decl.cc:12967
 #, fuzzy, gcc-internal-format
 #| msgid "named return values are no longer supported"
 msgid "variable concepts are no longer supported"
 msgstr "具名回傳值不再被支援"
 
-#: cp/decl.cc:13045
+#: cp/decl.cc:13088
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of incomplete type"
 msgstr "in-class 初始化的靜態資料成員 %q#D 的不完整型態"
 
-#: cp/decl.cc:13049
+#: cp/decl.cc:13092
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
 msgstr "%<constexpr%> 所需自 in-class 初始化的靜態資料成員 %q#D 的 non-integral 型態"
 
-#: cp/decl.cc:13053
+#: cp/decl.cc:13096
 #, fuzzy, gcc-internal-format
 msgid "in-class initialization of static data member %q#D of non-literal type"
 msgstr "in-class 初始化的靜態資料成員 %q#D 的 non-literal 型態"
 
-#: cp/decl.cc:13064
+#: cp/decl.cc:13107
 #, gcc-internal-format
 msgid "invalid in-class initialization of static data member of non-integral type %qT"
 msgstr "類別中對具有非整數類型 %qT 的靜態資料成員的初始化無效"
 
-#: cp/decl.cc:13069
+#: cp/decl.cc:13112
 #, gcc-internal-format
 msgid "ISO C++ forbids in-class initialization of non-const static member %qD"
 msgstr "ISO C++ 不允許在類別內初始化非常數靜態成員 %qD"
 
-#: cp/decl.cc:13074
+#: cp/decl.cc:13117
 #, gcc-internal-format
 msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT"
 msgstr "ISO C++ 不允許初始化成員常數 %qD，因為它有非整數的類型 %qT"
 
-#: cp/decl.cc:13186
+#: cp/decl.cc:13229
 #, gcc-internal-format
 msgid "size of array %qD has non-integral type %qT"
 msgstr "陣列 %qD 的大小具有非整數類型 %qT"
 
-#: cp/decl.cc:13189
+#: cp/decl.cc:13232
 #, gcc-internal-format
 msgid "size of array has non-integral type %qT"
 msgstr "陣列 %qT 的大小的類型不是整數"
 
-#: cp/decl.cc:13220 cp/decl.cc:13292
+#: cp/decl.cc:13263 cp/decl.cc:13335
 #, gcc-internal-format
 msgid "size of array %qD is not an integral constant-expression"
 msgstr "陣列 %qD 的大小不是一個整數常運算式"
 
-#: cp/decl.cc:13224 cp/decl.cc:13295
+#: cp/decl.cc:13267 cp/decl.cc:13338
 #, gcc-internal-format
 msgid "size of array is not an integral constant-expression"
 msgstr "陣列大小不是一個整數常運算式"
 
-#: cp/decl.cc:13275
+#: cp/decl.cc:13318
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array %qD"
 msgstr "ISO C 不允許大小為 0 的陣列 %qD"
 
-#: cp/decl.cc:13278
+#: cp/decl.cc:13321
 #, gcc-internal-format
 msgid "ISO C++ forbids zero-size array"
 msgstr "ISO C++ 不允許大小為 0 的陣列"
 
-#: cp/decl.cc:13302
+#: cp/decl.cc:13345
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array %qD"
 msgstr "ISO C++禁止變數長度陣列 %qD"
 
-#: cp/decl.cc:13305
+#: cp/decl.cc:13348
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids variable length array"
 msgstr "ISO C++禁止變數長度陣列"
 
-#: cp/decl.cc:13311
+#: cp/decl.cc:13354
 #, fuzzy, gcc-internal-format
 msgid "variable length array %qD is used"
 msgstr "變數長度陣列 %qD 被使用"
 
-#: cp/decl.cc:13314
+#: cp/decl.cc:13357
 #, fuzzy, gcc-internal-format
 msgid "variable length array is used"
 msgstr "變數長度陣列被使用"
 
-#: cp/decl.cc:13366
+#: cp/decl.cc:13409
 #, gcc-internal-format
 msgid "overflow in array dimension"
 msgstr "陣列維數溢出"
 
-#: cp/decl.cc:13426
+#: cp/decl.cc:13469
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "%qD declared as array of template placeholder type %qT"
 msgstr "%q+D 宣告為夥伴"
 
-#: cp/decl.cc:13429
+#: cp/decl.cc:13472
 #, fuzzy, gcc-internal-format
 #| msgid "creating pointer to member reference type %qT"
 msgid "creating array of template placeholder type %qT"
 msgstr "產生參照類型 %qT 的成員指標"
 
-#: cp/decl.cc:13439
+#: cp/decl.cc:13482
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of void"
 msgstr "宣告的 %qD 做為陣列的虛值"
 
-#: cp/decl.cc:13441
+#: cp/decl.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "creating array of void"
 msgstr "建立陣列的虛值"
 
-#: cp/decl.cc:13446
+#: cp/decl.cc:13489
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of functions"
 msgstr "宣告的 %qD 做為陣列的函式"
 
-#: cp/decl.cc:13448
+#: cp/decl.cc:13491
 #, fuzzy, gcc-internal-format
 msgid "creating array of functions"
 msgstr "建立陣列的函式"
 
-#: cp/decl.cc:13453
+#: cp/decl.cc:13496
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of references"
 msgstr "宣告的 %qD 做為陣列的參考"
 
-#: cp/decl.cc:13455
+#: cp/decl.cc:13498
 #, fuzzy, gcc-internal-format
 msgid "creating array of references"
 msgstr "建立陣列的參考"
 
-#: cp/decl.cc:13460
+#: cp/decl.cc:13503
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as array of function members"
 msgstr "宣告的 %qD 做為陣列的函式成員"
 
-#: cp/decl.cc:13463
+#: cp/decl.cc:13506
 #, fuzzy, gcc-internal-format
 msgid "creating array of function members"
 msgstr "建立陣列的函式成員"
 
-#: cp/decl.cc:13481
+#: cp/decl.cc:13524
 #, gcc-internal-format
 msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first"
 msgstr "多維陣列 %qD 的宣告必須至少指定除第一維以外所有維的大小"
 
-#: cp/decl.cc:13485
+#: cp/decl.cc:13528
 #, gcc-internal-format
 msgid "multidimensional array must have bounds for all dimensions except the first"
 msgstr "宣告多維陣列必須至少指定除第一維以外所有維的大小"
 
-#: cp/decl.cc:13499
+#: cp/decl.cc:13542
 #, fuzzy, gcc-internal-format
 msgid "variable-length array of %<auto%>"
 msgstr "變數長度陣列被使用"
 
-#: cp/decl.cc:13597
+#: cp/decl.cc:13640
 #, gcc-internal-format
 msgid "return type specification for constructor invalid"
 msgstr "為建構式指定回傳值無效"
 
-#: cp/decl.cc:13600
+#: cp/decl.cc:13643
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on constructor declaration"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/decl.cc:13611
+#: cp/decl.cc:13654
 #, gcc-internal-format
 msgid "return type specification for destructor invalid"
 msgstr "指定解構函式的回傳類型無效"
 
-#: cp/decl.cc:13614
+#: cp/decl.cc:13657
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on destructor declaration"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/decl.cc:13627
+#: cp/decl.cc:13670
 #, gcc-internal-format
 msgid "return type specified for %<operator %T%>"
 msgstr "為 %<operator %T%> 指定了回傳值"
 
-#: cp/decl.cc:13630
+#: cp/decl.cc:13673
 #, gcc-internal-format
 msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/decl.cc:13639
+#: cp/decl.cc:13682
 #, fuzzy, gcc-internal-format
 #| msgid "return type specification for destructor invalid"
 msgid "return type specified for deduction guide"
 msgstr "指定解構函式的回傳類型無效"
 
-#: cp/decl.cc:13642
+#: cp/decl.cc:13685
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "qualifiers are not allowed on declaration of deduction guide"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/decl.cc:13646
+#: cp/decl.cc:13689
 #, fuzzy, gcc-internal-format
 #| msgid "too many template parameter lists in declaration of %qD"
 msgid "template template parameter %qT in declaration of deduction guide"
 msgstr "%qD 宣告時範本參數表太多"
 
-#: cp/decl.cc:13655
+#: cp/decl.cc:13698
 #, fuzzy, gcc-internal-format
 msgid "%<decl-specifier%> in declaration of deduction guide"
 msgstr "衝突說明符在中宣告的 %qs"
 
-#: cp/decl.cc:13676
+#: cp/decl.cc:13719
 #, gcc-internal-format
 msgid "unnamed variable or field declared void"
 msgstr "無名變數或欄位宣告為 void"
 
-#: cp/decl.cc:13684
+#: cp/decl.cc:13727
 #, gcc-internal-format
 msgid "variable or field declared void"
 msgstr "變數或欄位宣告為 void"
 
-#: cp/decl.cc:13699
+#: cp/decl.cc:13742
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgid "%<inline%> specifier invalid for variable %qD declared at block scope"
 msgstr "在全域作用欄位外為函式 %qs 指定 %<inline%> 無效"
 
-#: cp/decl.cc:13704
+#: cp/decl.cc:13747
 #, fuzzy, gcc-internal-format
 msgid "inline variables are only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:13725
+#: cp/decl.cc:13768
 #, gcc-internal-format
 msgid "anonymous non-C-compatible type given name for linkage purposes by %<typedef%> declaration"
 msgstr ""
 
-#: cp/decl.cc:13742
+#: cp/decl.cc:13785
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it has a base class"
 msgstr "%qD 不是相容與 %qD"
 
-#: cp/decl.cc:13757
+#: cp/decl.cc:13800
 #, gcc-internal-format
 msgid "type is not C-compatible because %qD has default member initializer"
 msgstr ""
 
-#: cp/decl.cc:13787
+#: cp/decl.cc:13830
 #, fuzzy, gcc-internal-format
 msgid "type is not C-compatible because it contains %qD declaration"
 msgstr "%qD 不是相容與 %qD"
 
-#: cp/decl.cc:13858
+#: cp/decl.cc:13901
 #, gcc-internal-format
 msgid "%qT as type rather than plain %<decltype(auto)%>"
 msgstr ""
 
-#: cp/decl.cc:13864
+#: cp/decl.cc:13907
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "%<decltype(auto)%> cannot be cv-qualified"
 msgstr "解構函式不能被 cv 限定"
 
-#: cp/decl.cc:13885
+#: cp/decl.cc:13928
 #, fuzzy
 msgid "%e and %e specified together"
 msgstr "%<signed%> 和 %<unsigned%>指定的一起用於 %qs"
 
-#: cp/decl.cc:14098
+#: cp/decl.cc:14141
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<::%D%>"
 msgstr "無效的使用的限定名稱 %<::%D%>"
 
-#: cp/decl.cc:14101 cp/decl.cc:14123
+#: cp/decl.cc:14144 cp/decl.cc:14166
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%T::%D%>"
 msgstr "無效的使用的限定名稱 %<%T::%D%>"
 
-#: cp/decl.cc:14104
+#: cp/decl.cc:14147
 #, fuzzy, gcc-internal-format
 msgid "invalid use of qualified-name %<%D::%D%>"
 msgstr "無效的使用的限定名稱 %<%D::%D%>"
 
-#: cp/decl.cc:14114
+#: cp/decl.cc:14157
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a class or namespace"
 msgid "%q#T is not a class or namespace"
 msgstr "%qT 既不是類別也不是命名空間"
 
-#: cp/decl.cc:14138
+#: cp/decl.cc:14181
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-function"
 msgid "declaration of %qE as non-function"
 msgstr "%qD 沒有宣告為一個函式"
 
-#: cp/decl.cc:14145
+#: cp/decl.cc:14188
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD as non-member"
 msgid "declaration of %qE as non-member"
 msgstr "%qD 未宣告為成員"
 
-#: cp/decl.cc:14173
+#: cp/decl.cc:14216
 #, gcc-internal-format
 msgid "declarator-id missing; using reserved word %qD"
 msgstr "缺少宣告識別碼：使用了保留字 %qD"
 
-#: cp/decl.cc:14224
+#: cp/decl.cc:14267
 #, fuzzy, gcc-internal-format
 msgid "function definition does not declare parameters"
 msgstr "函式定義不宣告參數"
 
-#: cp/decl.cc:14232 cp/decl.cc:14241 cp/decl.cc:16237
+#: cp/decl.cc:14275 cp/decl.cc:14284 cp/decl.cc:16280
 #, gcc-internal-format
 msgid "declaration of %qD as non-function"
 msgstr "%qD 沒有宣告為一個函式"
 
-#: cp/decl.cc:14249
+#: cp/decl.cc:14292
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as %<typedef%>"
 msgstr "宣告的 %qD 做為 %<typedef%>"
 
-#: cp/decl.cc:14254
+#: cp/decl.cc:14297
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD as parameter"
 msgstr "宣告的 %qD 做為參數"
 
-#: cp/decl.cc:14289
+#: cp/decl.cc:14332
 #, fuzzy, gcc-internal-format
 #| msgid "no classes specified"
 msgid "both %qs and %qs specified"
 msgstr "未指定類別"
 
-#: cp/decl.cc:14296 cp/decl.cc:14303 cp/decl.cc:14310 cp/decl.cc:14317
+#: cp/decl.cc:14339 cp/decl.cc:14346 cp/decl.cc:14353 cp/decl.cc:14360
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot appear in a typedef declaration"
 msgstr "%<constexpr%> 無法出現在中 typedef 宣告"
 
-#: cp/decl.cc:14328
+#: cp/decl.cc:14371
 #, gcc-internal-format
 msgid "can use at most one of the %<constinit%> and %<constexpr%> specifiers"
 msgstr ""
 
-#: cp/decl.cc:14338
+#: cp/decl.cc:14381
 #, gcc-internal-format
 msgid "two or more data types in declaration of %qs"
 msgstr "%qs 的宣告指定了兩個以上的資料類型"
 
-#: cp/decl.cc:14392
+#: cp/decl.cc:14435
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not support plain %<complex%> meaning %<double complex%>"
 msgid "ISO C++ does not support plain %<complex%> meaning %<double complex%>"
 msgstr "ISO C 不支援單獨用 %<complex%> 表示 %<double complex%>"
 
-#: cp/decl.cc:14442 cp/decl.cc:14446 cp/decl.cc:14449
+#: cp/decl.cc:14485 cp/decl.cc:14489 cp/decl.cc:14492
 #, gcc-internal-format
 msgid "ISO C++ forbids declaration of %qs with no type"
 msgstr "ISO C++ 不允許宣告無類型的 %qs"
 
-#: cp/decl.cc:14466
+#: cp/decl.cc:14509
 #, fuzzy, gcc-internal-format
 msgid "%<__int%d%> is not supported by this target"
 msgstr "%<__int128%>未被支援由這個目標"
 
-#: cp/decl.cc:14474
+#: cp/decl.cc:14517
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not support %<__int%d%> for %qs"
 msgstr "ISO C++不支援 %<__int128%>用於 %qs"
 
-#: cp/decl.cc:14537
+#: cp/decl.cc:14580
 #, fuzzy, gcc-internal-format
 #| msgid "no class name specified with %qs"
 msgid "%qs specified with %qT"
 msgstr "%qs 沒有指定類別名"
 
-#: cp/decl.cc:14544
+#: cp/decl.cc:14587
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qs specified with typedef-name %qD"
 msgstr "%<__thread%> 與 %<typedef%> 一起使用"
 
-#: cp/decl.cc:14553
+#: cp/decl.cc:14596
 #, fuzzy, gcc-internal-format
 msgid "%qs specified with %<decltype%>"
 msgstr "預期 %<decltype%>"
 
-#: cp/decl.cc:14555
+#: cp/decl.cc:14598
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qs specified with %<typeof%>"
 msgstr "%<__thread%> 與 %<typedef%> 一起使用"
 
-#: cp/decl.cc:14624
+#: cp/decl.cc:14667
 #, gcc-internal-format
 msgid "complex invalid for %qs"
 msgstr "對 %qs 而言無效的複數"
 
-#: cp/decl.cc:14668
+#: cp/decl.cc:14711
 #, gcc-internal-format
 msgid "missing template argument list after %qE; for deduction, template placeholder must be followed by a simple declarator-id"
 msgstr ""
 
-#: cp/decl.cc:14694
+#: cp/decl.cc:14737
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD cannot be declared both %<virtual%> and %<static%>"
 msgstr "成員 %qD 不能既被宣告為虛函式，又被宣告為靜態函式"
 
-#: cp/decl.cc:14703
+#: cp/decl.cc:14746
 #, fuzzy, gcc-internal-format
 #| msgid "member %qD cannot be declared both virtual and static"
 msgid "member %qD can be declared both %<virtual%> and %<constexpr%> only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "成員 %qD 不能既被宣告為虛函式，又被宣告為靜態函式"
 
-#: cp/decl.cc:14716
+#: cp/decl.cc:14759
 #, gcc-internal-format
 msgid "typedef declaration invalid in parameter declaration"
 msgstr "參數宣告中出現的 typedef 宣告無效"
 
-#: cp/decl.cc:14723
+#: cp/decl.cc:14766
 #, fuzzy, gcc-internal-format
 msgid "storage class specified for template parameter %qs"
 msgstr "貯藏類別指定的用於模板參數 %qs"
 
-#: cp/decl.cc:14733 cp/decl.cc:14913
+#: cp/decl.cc:14776 cp/decl.cc:14956
 #, gcc-internal-format
 msgid "storage class specified for parameter %qs"
 msgstr "為參數 %qs 指定了存儲類別"
 
-#: cp/decl.cc:14741 cp/decl.cc:14750 cp/decl.cc:14756 cp/decl.cc:14762
+#: cp/decl.cc:14784 cp/decl.cc:14793 cp/decl.cc:14799 cp/decl.cc:14805
 #, fuzzy, gcc-internal-format
 msgid "a parameter cannot be declared %qs"
 msgstr "參數無法宣告 %<constexpr%>"
 
-#: cp/decl.cc:14772
+#: cp/decl.cc:14815
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> outside class declaration"
 msgstr "%<virtual%> 外側類別宣告"
 
-#: cp/decl.cc:14782 cp/decl.cc:14785 cp/decl.cc:14791 cp/decl.cc:14802
-#: cp/decl.cc:14814 cp/decl.cc:14824 cp/decl.cc:14828
+#: cp/decl.cc:14825 cp/decl.cc:14828 cp/decl.cc:14834 cp/decl.cc:14845
+#: cp/decl.cc:14857 cp/decl.cc:14867 cp/decl.cc:14871
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot be %qs"
 msgstr "屬性忽略的在中宣告的 %q#T"
 
-#: cp/decl.cc:14788
+#: cp/decl.cc:14831
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:14795 cp/decl.cc:14820
+#: cp/decl.cc:14838 cp/decl.cc:14863
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration can be %qs only in %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:14808
+#: cp/decl.cc:14851
 #, fuzzy, gcc-internal-format
 msgid "%<volatile%>-qualified structured binding is deprecated"
 msgstr "無效的輸入宣告"
 
-#: cp/decl.cc:14832
+#: cp/decl.cc:14875
 #, gcc-internal-format
 msgid "structured binding declaration cannot be C++98 %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14844
+#: cp/decl.cc:14887
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have type %qT"
 msgstr "屬性忽略的在中宣告的 %q#T"
 
-#: cp/decl.cc:14847
+#: cp/decl.cc:14890
 #, gcc-internal-format
 msgid "type must be cv-qualified %<auto%> or reference to cv-qualified %<auto%>"
 msgstr ""
 
-#: cp/decl.cc:14855
+#: cp/decl.cc:14898
 #, fuzzy, gcc-internal-format
 msgid "structured binding declaration cannot have constrained %<auto%> type %qT"
 msgstr "屬性忽略的在中宣告的 %q#T"
 
-#: cp/decl.cc:14885
+#: cp/decl.cc:14928
 #, gcc-internal-format
 msgid "multiple storage classes in declaration of %qs"
 msgstr "%qs 的宣告指定了多個存儲類別"
 
-#: cp/decl.cc:14911
+#: cp/decl.cc:14954
 #, gcc-internal-format
 msgid "storage class specified for %qs"
 msgstr "為 %qs 指定了存儲類別"
 
-#: cp/decl.cc:14925
+#: cp/decl.cc:14968
 #, gcc-internal-format
 msgid "nested function %qs declared %<extern%>"
 msgstr "巢狀函式 %qs 被宣告為 %<extern%>"
 
-#: cp/decl.cc:14930
+#: cp/decl.cc:14973
 #, gcc-internal-format
 msgid "top-level declaration of %qs specifies %<auto%>"
 msgstr "在頂層將 %qs 宣告為 %<auto%>"
 
-#: cp/decl.cc:14938
+#: cp/decl.cc:14981
 #, gcc-internal-format
 msgid "function-scope %qs implicitly auto and declared %<__thread%>"
 msgstr "函式作用欄位的 %qs 隱含為 auto，卻被宣告為 %<__thread%>"
 
-#: cp/decl.cc:14952
+#: cp/decl.cc:14995
 #, gcc-internal-format
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr "為夥伴函式宣告指定了無效的存儲類別"
 
-#: cp/decl.cc:15048
+#: cp/decl.cc:15091
 #, fuzzy, gcc-internal-format
 #| msgid "multiple storage classes in declaration of %qs"
 msgid "unnecessary parentheses in declaration of %qs"
 msgstr "%qs 的宣告指定了多個存儲類別"
 
-#: cp/decl.cc:15054
+#: cp/decl.cc:15097
 #, fuzzy, gcc-internal-format
 #| msgid "Expected left parenthesis"
 msgid "remove parentheses"
 msgstr "需要左圓括號"
 
-#: cp/decl.cc:15121
+#: cp/decl.cc:15164
 #, fuzzy, gcc-internal-format
 msgid "explicit object member function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:15135
+#: cp/decl.cc:15178
 #, fuzzy, gcc-internal-format
 msgid "a function type cannot have an explicit object parameter"
 msgstr "函式『%s』於 %L 無法有初始設定式"
 
-#: cp/decl.cc:15141
+#: cp/decl.cc:15184
 #, fuzzy, gcc-internal-format
 msgid "a pointer to function type cannot have an explicit object parameter"
 msgstr "%qs 函式無法有引數"
 
-#: cp/decl.cc:15145
+#: cp/decl.cc:15188
 #, fuzzy, gcc-internal-format
 msgid "a pointer to member function type cannot have an explicit object parameter"
 msgstr "  成員函數型式 %qT 並非有效模板引數"
 
-#: cp/decl.cc:15153
+#: cp/decl.cc:15196
 #, gcc-internal-format
 msgid "the type of a pointer to explicit object member function is a regular pointer to function type"
 msgstr ""
 
-#: cp/decl.cc:15157
+#: cp/decl.cc:15200
 #, fuzzy, gcc-internal-format
 msgid "the type of an explicit object member function is a regular function type"
 msgstr "類型可能無法被定義在中條件"
 
-#: cp/decl.cc:15178
+#: cp/decl.cc:15221
 #, gcc-internal-format
 msgid "only the first parameter of a member function can be declared as an explicit object parameter"
 msgstr ""
 
-#: cp/decl.cc:15183
+#: cp/decl.cc:15226
 #, fuzzy, gcc-internal-format
 #| msgid "template parameter type %qT declared %<friend%>"
 msgid "valid explicit object parameter declared here"
 msgstr "範本參數類型 %qT 宣告為 %<friend%>"
 
-#: cp/decl.cc:15187
+#: cp/decl.cc:15230
 #, gcc-internal-format
 msgid "requires-clause on return type"
 msgstr ""
 
-#: cp/decl.cc:15208
+#: cp/decl.cc:15251
 #, fuzzy, gcc-internal-format
 msgid "%qs function uses %<auto%> type specifier without trailing return type"
 msgstr "%qs 函式使用 %<auto%> 型態說明符而無需尾隨傳回類型"
 
-#: cp/decl.cc:15212
+#: cp/decl.cc:15255
 #, fuzzy, gcc-internal-format
 msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:15217
+#: cp/decl.cc:15260
 #, fuzzy, gcc-internal-format
 #| msgid "virtual functions cannot be friends"
 msgid "virtual function cannot have deduced return type"
 msgstr "虛函式不能是夥伴"
 
-#: cp/decl.cc:15224
+#: cp/decl.cc:15267
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
 msgstr "%qs 函式與尾隨傳回類型有 %qT 做為它的型態而非普通 %<auto%>"
 
-#: cp/decl.cc:15233
+#: cp/decl.cc:15276
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type has %<decltype(auto)%> as its type rather than plain %<auto%>"
 msgstr "%qs 函式與尾隨傳回類型有 %qT 做為它的型態而非普通 %<auto%>"
 
-#: cp/decl.cc:15238
+#: cp/decl.cc:15281
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<decltype(auto)%>"
 msgstr "無效的使用的 %<auto%>"
 
-#: cp/decl.cc:15245
+#: cp/decl.cc:15288
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type has constrained %<auto%> type specifier rather than plain %<auto%>"
 msgstr "%qs 函式與尾隨傳回類型有 %qT 做為它的型態而非普通 %<auto%>"
 
-#: cp/decl.cc:15251
+#: cp/decl.cc:15294
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of constructor as a template"
 msgid "invalid use of constrained %<auto%> type"
 msgstr "將建構式做為範本用法無效"
 
-#: cp/decl.cc:15263
+#: cp/decl.cc:15306
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "deduced class type %qD in function return type"
 msgstr "忽略函式回傳類型的類型限定"
 
-#: cp/decl.cc:15273
+#: cp/decl.cc:15316
 #, gcc-internal-format
 msgid "deduction guide for %qT must have trailing return type"
 msgstr ""
 
-#: cp/decl.cc:15286
+#: cp/decl.cc:15329
 #, gcc-internal-format
 msgid "trailing return type %qT of deduction guide is not a specialization of %qT"
 msgstr ""
 
-#: cp/decl.cc:15300
+#: cp/decl.cc:15343
 #, fuzzy, gcc-internal-format
 msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:15303
+#: cp/decl.cc:15346
 #, fuzzy, gcc-internal-format
 msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
 msgstr "%qs 函式與尾隨傳回類型無法宣告的與 %<auto%> 型態說明符"
 
-#: cp/decl.cc:15310
+#: cp/decl.cc:15353
 #, fuzzy, gcc-internal-format
 msgid "a conversion function cannot have a trailing return type"
 msgstr "%qs 函式無法有引數"
 
-#: cp/decl.cc:15336
+#: cp/decl.cc:15379
 #, gcc-internal-format
 msgid "%<volatile%>-qualified return type is deprecated"
 msgstr ""
 
-#: cp/decl.cc:15348
+#: cp/decl.cc:15391
 #, gcc-internal-format
 msgid "%qs declared as function returning a function"
 msgstr "%qs 宣告為回傳一個函式的函式"
 
-#: cp/decl.cc:15354
+#: cp/decl.cc:15397
 #, gcc-internal-format
 msgid "%qs declared as function returning an array"
 msgstr "%qs 宣告為回傳一個陣列的函式"
 
-#: cp/decl.cc:15361
+#: cp/decl.cc:15404
 #, fuzzy, gcc-internal-format
 #| msgid "%<noreturn%> function returns non-void value"
 msgid "%<constinit%> on function return type is not allowed"
 msgstr "%<noreturn%> 函式回傳了一個非 void 的回傳值"
 
-#: cp/decl.cc:15394
+#: cp/decl.cc:15437
 #, gcc-internal-format
 msgid "destructor cannot be static member function"
 msgstr "解構函式不能是靜態成員函式"
 
-#: cp/decl.cc:15396
+#: cp/decl.cc:15439
 #, gcc-internal-format
 msgid "constructor cannot be static member function"
 msgstr "建構式不能是靜態成員函式"
 
-#: cp/decl.cc:15401
+#: cp/decl.cc:15444
 #, gcc-internal-format
 msgid "destructors may not be cv-qualified"
 msgstr "解構函式不能被 cv 限定"
 
-#: cp/decl.cc:15402
+#: cp/decl.cc:15445
 #, gcc-internal-format
 msgid "constructors may not be cv-qualified"
 msgstr "建構式不能帶 cv 限定"
 
-#: cp/decl.cc:15410
+#: cp/decl.cc:15453
 #, fuzzy, gcc-internal-format
 #| msgid "destructors may not be cv-qualified"
 msgid "destructors may not be ref-qualified"
 msgstr "解構函式不能被 cv 限定"
 
-#: cp/decl.cc:15411
+#: cp/decl.cc:15454
 #, fuzzy, gcc-internal-format
 #| msgid "constructors may not be cv-qualified"
 msgid "constructors may not be ref-qualified"
 msgstr "建構式不能帶 cv 限定"
 
-#: cp/decl.cc:15429
+#: cp/decl.cc:15472
 #, fuzzy, gcc-internal-format
 #| msgid "constructors cannot be declared virtual"
 msgid "constructors cannot be declared %<virtual%>"
 msgstr "建構式不能被宣告為虛函式"
 
-#: cp/decl.cc:15446
+#: cp/decl.cc:15489
 #, gcc-internal-format
 msgid "virtual functions cannot be friends"
 msgstr "虛函式不能是夥伴"
 
-#: cp/decl.cc:15451
+#: cp/decl.cc:15494
 #, gcc-internal-format
 msgid "friend declaration not in class definition"
 msgstr "夥伴宣告不在類別定義內"
 
-#: cp/decl.cc:15455
+#: cp/decl.cc:15498
 #, fuzzy, gcc-internal-format
 msgid "cannot define friend function %qs in a local class definition"
 msgstr "can%'t 定義朋友函式 %qs 在中區域類別定義"
 
-#: cp/decl.cc:15465
+#: cp/decl.cc:15508
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<::%>"
 msgstr ""
 
-#: cp/decl.cc:15469
+#: cp/decl.cc:15512
 #, gcc-internal-format
 msgid "friend function definition %qs cannot have a name qualified with %<%D::%>"
 msgstr ""
 
-#: cp/decl.cc:15495
+#: cp/decl.cc:15538
 #, fuzzy, gcc-internal-format
 msgid "a non-member function cannot have an explicit object parameter"
 msgstr "non-member 函式 %qD 無法有 cv-qualifier"
 
-#: cp/decl.cc:15503
+#: cp/decl.cc:15546
 #, fuzzy, gcc-internal-format
 msgid "an explicit object member function cannot be %<virtual%>"
 msgstr "模板可能無法是 %<virtual%>"
 
-#: cp/decl.cc:15513
+#: cp/decl.cc:15556
 #, gcc-internal-format
 msgid "an explicit object member function cannot be %<static%>"
 msgstr ""
 
-#: cp/decl.cc:15522
+#: cp/decl.cc:15565
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD cannot be an explicit object member function"
 msgstr "%qD 必須是一個非靜態的成員函式"
 
-#: cp/decl.cc:15545
+#: cp/decl.cc:15588
 #, gcc-internal-format
 msgid "destructors may not have parameters"
 msgstr "解構函式不能有參數"
 
-#: cp/decl.cc:15593
+#: cp/decl.cc:15636
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T"
 msgstr "無法宣告參照 %q#T 的指標"
 
-#: cp/decl.cc:15606 cp/decl.cc:15613
+#: cp/decl.cc:15649 cp/decl.cc:15656
 #, gcc-internal-format
 msgid "cannot declare reference to %q#T"
 msgstr "無法宣告對 %q#T 的參照"
 
-#: cp/decl.cc:15615
+#: cp/decl.cc:15658
 #, gcc-internal-format
 msgid "cannot declare pointer to %q#T member"
 msgstr "無法宣告參照 %q#T 成員的指標"
 
-#: cp/decl.cc:15644
+#: cp/decl.cc:15687
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to qualified function type %qT"
 msgstr "無法宣告參考到經資格修飾函數型式 %qT"
 
-#: cp/decl.cc:15645
+#: cp/decl.cc:15688
 #, fuzzy, gcc-internal-format
 msgid "cannot declare pointer to qualified function type %qT"
 msgstr "無法宣告指標到經資格修飾函數型式 %qT"
 
-#: cp/decl.cc:15718
+#: cp/decl.cc:15761
 #, fuzzy, gcc-internal-format
 msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument"
 msgstr "無法宣告參考到 %q#T, 該項並非 typedef 或模板型態引數"
 
-#: cp/decl.cc:15797
+#: cp/decl.cc:15840
 #, gcc-internal-format
 msgid "template-id %qD used as a declarator"
 msgstr "範本識別碼 %qD 做為宣告"
 
-#: cp/decl.cc:15823
+#: cp/decl.cc:15866
 #, gcc-internal-format
 msgid "member functions are implicitly friends of their class"
 msgstr "成員函式隱含地成為所屬類別的夥伴"
 
-#: cp/decl.cc:15828
+#: cp/decl.cc:15871
 #, gcc-internal-format
 msgid "extra qualification %<%T::%> on member %qs"
 msgstr "有多餘的限定 %<%T::%> 於成員 %qs 上"
 
-#: cp/decl.cc:15858
+#: cp/decl.cc:15901
 #, fuzzy, gcc-internal-format
 #| msgid "cannot define member function %<%T::%s%> within %<%T%>"
 msgid "cannot define member function %<%T::%s%> within %qT"
 msgstr "無法定義成員函式 %<%T::%s%> 於 %<%T%> 之內"
 
-#: cp/decl.cc:15860
+#: cp/decl.cc:15903
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare member function %<%T::%s%> within %<%T%>"
 msgid "cannot declare member function %<%T::%s%> within %qT"
 msgstr "無法宣告成員函式 %<%T::%s%> 於 %<%T%> 之內"
 
-#: cp/decl.cc:15868
+#: cp/decl.cc:15911
 #, gcc-internal-format
 msgid "cannot declare member %<%T::%s%> within %qT"
 msgstr "無法宣告成員 %<%T::%s%> 於 %qT 之內"
 
-#: cp/decl.cc:15922
+#: cp/decl.cc:15965
 #, fuzzy, gcc-internal-format
 msgid "non-parameter %qs cannot be a parameter pack"
 msgstr "non-parameter %qs 無法參數包裝"
 
-#: cp/decl.cc:15931
+#: cp/decl.cc:15974
 #, gcc-internal-format
 msgid "data member may not have variably modified type %qT"
 msgstr "資料成員不能具有可變類型 %qT"
 
-#: cp/decl.cc:15934
+#: cp/decl.cc:15977
 #, gcc-internal-format
 msgid "parameter may not have variably modified type %qT"
 msgstr "參數不能具有可變類型 %qT"
 
-#: cp/decl.cc:15945
+#: cp/decl.cc:15988
 #, fuzzy, gcc-internal-format
 msgid "%<explicit%> outside class declaration"
 msgstr "%<virtual%> 外側類別宣告"
 
-#: cp/decl.cc:15948
+#: cp/decl.cc:15991
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<explicit%> in friend declaration"
 msgstr "%<inline%> 用於空宣告中"
 
-#: cp/decl.cc:15951
+#: cp/decl.cc:15994
 #, fuzzy, gcc-internal-format
 #| msgid "only declarations of constructors can be %<explicit%>"
 msgid "only declarations of constructors and conversion operators can be %<explicit%>"
 msgstr "只有建構式才能被宣告為 %<explicit%>"
 
-#: cp/decl.cc:15961
+#: cp/decl.cc:16004
 #, gcc-internal-format
 msgid "non-member %qs cannot be declared %<mutable%>"
 msgstr "非成員 %qs 不能被宣告為 %<mutable%>"
 
-#: cp/decl.cc:15968
+#: cp/decl.cc:16011
 #, gcc-internal-format
 msgid "non-object member %qs cannot be declared %<mutable%>"
 msgstr "非物件成員 %qs 不能被宣告為 %<mutable%>"
 
-#: cp/decl.cc:15974
+#: cp/decl.cc:16017
 #, gcc-internal-format
 msgid "function %qs cannot be declared %<mutable%>"
 msgstr "函式 %qs 不能被宣告為 %<mutable%>"
 
-#: cp/decl.cc:15980
+#: cp/decl.cc:16023
 #, fuzzy, gcc-internal-format
 #| msgid "static %qs cannot be declared %<mutable%>"
 msgid "%<static%> %qs cannot be declared %<mutable%>"
 msgstr "靜態 %qs 不能被宣告為 %<mutable%>"
 
-#: cp/decl.cc:15986
+#: cp/decl.cc:16029
 #, fuzzy, gcc-internal-format
 #| msgid "const %qs cannot be declared %<mutable%>"
 msgid "%<const%> %qs cannot be declared %<mutable%>"
 msgstr "常數 %qs 不能被宣告為 %<mutable%>"
 
-#: cp/decl.cc:15992
+#: cp/decl.cc:16035
 #, fuzzy, gcc-internal-format
 msgid "reference %qs cannot be declared %<mutable%>"
 msgstr "參考 %qs 無法宣告 %<mutable%>"
 
-#: cp/decl.cc:16008
+#: cp/decl.cc:16051
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a function definition"
 msgstr "類型可能無法被定義在中條件"
 
-#: cp/decl.cc:16011
+#: cp/decl.cc:16054
 #, fuzzy, gcc-internal-format
 msgid "typedef may not be a member function definition"
 msgstr "類型可能無法被定義在中條件"
 
-#: cp/decl.cc:16037
+#: cp/decl.cc:16080
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> not allowed in alias declaration"
 msgstr "%<[*]%>無法在中宣告"
 
-#: cp/decl.cc:16040
+#: cp/decl.cc:16083
 #, fuzzy, gcc-internal-format
 msgid "typedef declared %<auto%>"
 msgstr "typedef 宣告 %<auto%>"
 
-#: cp/decl.cc:16045
+#: cp/decl.cc:16088
 #, gcc-internal-format
 msgid "requires-clause on typedef"
 msgstr ""
 
-#: cp/decl.cc:16049
+#: cp/decl.cc:16092
 #, fuzzy, gcc-internal-format
 msgid "typedef name may not be a nested-name-specifier"
 msgstr "typedef 名稱可能無法是 nested-name-specifier"
 
-#: cp/decl.cc:16075
+#: cp/decl.cc:16118
 #, gcc-internal-format
 msgid "ISO C++ forbids nested type %qD with same name as enclosing class"
 msgstr "ISO C++ 不允許嵌類別的類型 %qD 與其所屬的類別同名"
 
-#: cp/decl.cc:16167
+#: cp/decl.cc:16210
 #, gcc-internal-format
 msgid "%<inline%> specified for friend class declaration"
 msgstr "夥伴函式宣告中出現了 %<inline%>"
 
-#: cp/decl.cc:16175
+#: cp/decl.cc:16218
 #, gcc-internal-format
 msgid "template parameters cannot be friends"
 msgstr "範本參數不能是夥伴"
 
-#: cp/decl.cc:16177
+#: cp/decl.cc:16220
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>"
 msgstr "夥伴宣告需要 class，即 %<friend class %T::%D%>"
 
-#: cp/decl.cc:16181
+#: cp/decl.cc:16224
 #, gcc-internal-format
 msgid "friend declaration requires class-key, i.e. %<friend %#T%>"
 msgstr "夥伴宣告需要 class，即 %<friend %#T%>"
 
-#: cp/decl.cc:16194
+#: cp/decl.cc:16237
 #, gcc-internal-format
 msgid "trying to make class %qT a friend of global scope"
 msgstr "試圖讓 %qT 成為全域欄位的夥伴"
 
-#: cp/decl.cc:16214
+#: cp/decl.cc:16257
 #, gcc-internal-format
 msgid "invalid qualifiers on non-member function type"
 msgstr "非成員函式類型上的限定符無效"
 
-#: cp/decl.cc:16218
+#: cp/decl.cc:16261
 #, gcc-internal-format
 msgid "requires-clause on type-id"
 msgstr ""
 
-#: cp/decl.cc:16228
+#: cp/decl.cc:16271
 #, gcc-internal-format
 msgid "abstract declarator %qT used as declaration"
 msgstr "抽象宣告 %qT 做為宣告"
 
-#: cp/decl.cc:16243
+#: cp/decl.cc:16286
 #, fuzzy, gcc-internal-format
 msgid "requires-clause on declaration of non-function type %qT"
 msgstr "value-initialization 的函數型式 %qT"
 
-#: cp/decl.cc:16262
+#: cp/decl.cc:16305
 #, gcc-internal-format
 msgid "cannot use %<::%> in parameter declaration"
 msgstr "不能在參數宣告中使用 %<::%>"
 
-#: cp/decl.cc:16272 cp/parser.cc:23108
+#: cp/decl.cc:16315 cp/parser.cc:23172
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare parameter %q+D to be of abstract type %qT"
 msgid "cannot declare a parameter with %<decltype(auto)%>"
 msgstr "不能將參數 %q+D 宣告為具有抽象類型 %qT"
 
-#: cp/decl.cc:16279
+#: cp/decl.cc:16322
 #, gcc-internal-format
 msgid "missing template argument list after %qE; template placeholder not permitted in parameter"
 msgstr ""
 
-#: cp/decl.cc:16282
+#: cp/decl.cc:16325
 #, gcc-internal-format
 msgid "or use %<auto%> for an abbreviated function template"
 msgstr ""
 
-#: cp/decl.cc:16288 cp/parser.cc:28184
+#: cp/decl.cc:16331 cp/parser.cc:28248
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<auto%> parameter not permitted in this context"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: cp/decl.cc:16298
+#: cp/decl.cc:16341
 #, fuzzy, gcc-internal-format
 msgid "parameter declared %<auto%>"
 msgstr "參數宣告 %<auto%>"
 
-#: cp/decl.cc:16352 cp/parser.cc:3932
+#: cp/decl.cc:16395 cp/parser.cc:3932
 #, gcc-internal-format
 msgid "invalid use of template-name %qE without an argument list"
 msgstr "使用範本名 %qE 時不帶引數表無效"
 
-#: cp/decl.cc:16356
+#: cp/decl.cc:16399
 #, fuzzy, gcc-internal-format
 msgid "non-static data member declared with placeholder %qT"
 msgstr "非靜態資料成員宣告 %<auto%>"
 
-#: cp/decl.cc:16376
+#: cp/decl.cc:16419
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids zero-size array %qD"
 msgid "ISO C++ forbids flexible array member %qs"
 msgstr "ISO C 不允許大小為 0 的陣列 %qD"
 
-#: cp/decl.cc:16379
+#: cp/decl.cc:16422
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C90 does not support flexible array members"
 msgid "ISO C++ forbids flexible array members"
 msgstr "ISO C90 不允許彈性陣列成員"
 
 #. Something like struct S { int N::j; };
-#: cp/decl.cc:16395
+#: cp/decl.cc:16438
 #, gcc-internal-format
 msgid "invalid use of %<::%>"
 msgstr "錯誤地使用了 %<::%>"
 
-#: cp/decl.cc:16416
+#: cp/decl.cc:16459
 #, fuzzy, gcc-internal-format
 msgid "declaration of function %qD in invalid context"
 msgstr "宣告的函式 %qD 在中無效的語境"
 
-#: cp/decl.cc:16426
+#: cp/decl.cc:16469
 #, fuzzy, gcc-internal-format
 #| msgid "function %qD declared virtual inside a union"
 msgid "function %qD declared %<virtual%> inside a union"
 msgstr "聯合成員函式 %qD 被宣告為虛函式"
 
-#: cp/decl.cc:16436
+#: cp/decl.cc:16479
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot be declared virtual, since it is always static"
 msgid "%qD cannot be declared %<virtual%>, since it is always static"
 msgstr "%qD 不能宣告為虛函式，因為它總是靜態的"
 
-#: cp/decl.cc:16450
+#: cp/decl.cc:16493
 #, gcc-internal-format
 msgid "expected qualified name in friend declaration for destructor %qD"
 msgstr "在解構函式 %qD 中的夥伴宣告需要限定名"
 
-#: cp/decl.cc:16457
+#: cp/decl.cc:16500
 #, gcc-internal-format
 msgid "declaration of %qD as member of %qT"
 msgstr "%qD 宣告為 %qT 的一個成員"
 
-#: cp/decl.cc:16464 cp/decl.cc:16477
+#: cp/decl.cc:16507 cp/decl.cc:16520
 #, fuzzy, gcc-internal-format
 msgid "a destructor cannot be %qs"
 msgstr "解構式無法 %<constexpr%>"
 
-#: cp/decl.cc:16483
+#: cp/decl.cc:16526
 #, fuzzy, gcc-internal-format
 msgid "expected qualified name in friend declaration for constructor %qD"
 msgstr "預期的限定名稱在中朋友宣告用於建構子 %qD"
 
-#: cp/decl.cc:16492
+#: cp/decl.cc:16535
 #, fuzzy, gcc-internal-format
 msgid "a constructor cannot be %<concept%>"
 msgstr "解構式無法 %<constexpr%>"
 
-#: cp/decl.cc:16498
+#: cp/decl.cc:16541
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be a member function"
 msgstr "建構式不能是靜態成員函式"
 
-#: cp/decl.cc:16506 cp/decl.cc:16864
+#: cp/decl.cc:16549 cp/decl.cc:16928
 #, fuzzy, gcc-internal-format
 #| msgid "cannot open %s"
 msgid "%qD cannot be %qs"
 msgstr "無法開啟 %s"
 
-#: cp/decl.cc:16516
+#: cp/decl.cc:16559
 #, fuzzy, gcc-internal-format
 msgid "specialization of variable template %qD declared as function"
 msgstr "局部特化的別名模板 %qD"
 
-#: cp/decl.cc:16519
+#: cp/decl.cc:16562
 #, fuzzy, gcc-internal-format
 msgid "variable template declared here"
 msgstr "原來的型態宣告的在此"
 
-#: cp/decl.cc:16584
+#: cp/decl.cc:16627
 #, fuzzy, gcc-internal-format
 #| msgid "field %qD has incomplete type"
 msgid "field %qD has incomplete type %qT"
 msgstr "欄位 %qD 類型不完全"
 
-#: cp/decl.cc:16589
+#: cp/decl.cc:16632
 #, gcc-internal-format
 msgid "name %qT has incomplete type"
 msgstr "名稱 %qT 類型不完全"
 
-#: cp/decl.cc:16609
+#: cp/decl.cc:16652
 #, gcc-internal-format
 msgid "%qE is neither function nor member function; cannot be declared friend"
 msgstr "%qE 既不是函式也不是成員函式；不能宣告為夥伴"
 
-#: cp/decl.cc:16612
+#: cp/decl.cc:16655
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is neither function nor member function; cannot be declared friend"
 msgid "unnamed field is neither function nor member function; cannot be declared friend"
 msgstr "%qE 既不是函式也不是成員函式；不能宣告為夥伴"
 
-#: cp/decl.cc:16630 cp/parser.cc:23678 cp/parser.cc:31067
+#: cp/decl.cc:16674
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to non-defining friend declaration %qD"
+msgstr "%qE 屬性套用只有到函式"
+
+#: cp/decl.cc:16682
+#, fuzzy, gcc-internal-format
+#| msgid "defining explicit specialization %qD in friend declaration"
+msgid "annotation applied to parameter %qD of non-defining friend declaration"
+msgstr "在夥伴宣告中定義明確特例化 %qD"
+
+#: cp/decl.cc:16694 cp/parser.cc:23742 cp/parser.cc:31131
 #, gcc-internal-format
 msgid "an attribute that appertains to a friend declaration that is not a definition is ignored"
 msgstr ""
 
-#: cp/decl.cc:16680 cp/decl.cc:16691
+#: cp/decl.cc:16744 cp/decl.cc:16755
 #, fuzzy, gcc-internal-format
 msgid "static data member %qE declared %qs"
 msgstr "非靜態資料成員 %qE 宣告 %<constexpr%>"
 
-#: cp/decl.cc:16685
+#: cp/decl.cc:16749
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> static data member %qD must have an initializer"
 msgstr "constexpr 靜態資料成員 %qD 必須有初始設定式"
 
-#: cp/decl.cc:16728 cp/decl.cc:16736 cp/decl.cc:16743 cp/decl.cc:16750
+#: cp/decl.cc:16792 cp/decl.cc:16800 cp/decl.cc:16807 cp/decl.cc:16814
 #, fuzzy, gcc-internal-format
 msgid "non-static data member %qE declared %qs"
 msgstr "非靜態資料成員 %qE 宣告 %<constexpr%>"
 
-#: cp/decl.cc:16802
+#: cp/decl.cc:16866
 #, gcc-internal-format
 msgid "storage class %<auto%> invalid for function %qs"
 msgstr "函式 %qs 的存儲類別 %<auto%> 無效"
 
-#: cp/decl.cc:16805
+#: cp/decl.cc:16869
 #, gcc-internal-format
 msgid "storage class %<register%> invalid for function %qs"
 msgstr "函式 %qs 的存儲類別 %<register%> 無效"
 
-#: cp/decl.cc:16811
+#: cp/decl.cc:16875
 #, gcc-internal-format
 msgid "storage class %<__thread%> invalid for function %qs"
 msgstr "函式 %qs 的存儲類別 %<__thread%> 無效"
 
-#: cp/decl.cc:16815
+#: cp/decl.cc:16879
 #, fuzzy, gcc-internal-format
 msgid "storage class %<thread_local%> invalid for function %qs"
 msgstr "函式 %qs 的存儲類別 %<__thread%> 無效"
 
-#: cp/decl.cc:16820
+#: cp/decl.cc:16884
 #, fuzzy, gcc-internal-format
 msgid "%<constinit%> specifier invalid for function %qs"
 msgstr "對齊指定的用於函式 %qE"
 
-#: cp/decl.cc:16823
+#: cp/decl.cc:16887
 #, fuzzy, gcc-internal-format
 msgid "virt-specifiers in %qs not allowed outside a class definition"
 msgstr "virt-specifiers 在中 %qs 不允許外側類別定義"
 
-#: cp/decl.cc:16835
+#: cp/decl.cc:16899
 #, fuzzy, gcc-internal-format
 #| msgid "%<static%> specified invalid for function %qs declared out of global scope"
 msgid "%<static%> specifier invalid for function %qs declared out of global scope"
 msgstr "在全域作用欄位外為函式 %qs 指定 %<static%> 無效"
 
-#: cp/decl.cc:16839
+#: cp/decl.cc:16903
 #, gcc-internal-format
 msgid "%<inline%> specifier invalid for function %qs declared out of global scope"
 msgstr "在全域作用欄位外為函式 %qs 指定 %<inline%> 無效"
 
-#: cp/decl.cc:16847
+#: cp/decl.cc:16911
 #, gcc-internal-format
 msgid "virtual non-class function %qs"
 msgstr "虛函式 %qs 不是類別成員"
 
-#: cp/decl.cc:16854
+#: cp/decl.cc:16918
 #, fuzzy, gcc-internal-format
 msgid "%qs defined in a non-class scope"
 msgstr "%qs 定義的在中 non-class 範圍"
 
-#: cp/decl.cc:16855
+#: cp/decl.cc:16919
 #, fuzzy, gcc-internal-format
 msgid "%qs declared in a non-class scope"
 msgstr "%qs 宣告的在中 non-class 範圍"
 
-#: cp/decl.cc:16897
+#: cp/decl.cc:16961
 #, gcc-internal-format
 msgid "cannot declare member function %qD to have static linkage"
 msgstr "不能將成員函式 %qD 宣告為有靜態連結"
 
-#: cp/decl.cc:16906
+#: cp/decl.cc:16970
 #, gcc-internal-format
 msgid "cannot declare static function inside another function"
 msgstr "不能在另一個函式中宣告一個靜態函式"
 
-#: cp/decl.cc:16947
+#: cp/decl.cc:17011
 #, gcc-internal-format
 msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member"
 msgstr "與宣告不同，定義靜態資料成員時不能使用 %<static%>"
 
-#: cp/decl.cc:16954
+#: cp/decl.cc:17018
 #, gcc-internal-format
 msgid "static member %qD declared %<register%>"
 msgstr "靜態成員 %qD 宣告為 %<register%>"
 
-#: cp/decl.cc:16960
+#: cp/decl.cc:17024
 #, gcc-internal-format
 msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgstr "不能明確地將成員 %q#D 宣告為有外部連結"
 
-#: cp/decl.cc:16968
+#: cp/decl.cc:17032
 #, fuzzy, gcc-internal-format
 msgid "declaration of %<constexpr%> variable %qD is not a definition"
 msgstr "宣告的 constexpr 變數 %qD 並非定義"
 
-#: cp/decl.cc:16975
+#: cp/decl.cc:17039
 #, fuzzy, gcc-internal-format
 msgid "a variable cannot be declared %<consteval%>"
 msgstr "參數無法宣告 %<constexpr%>"
 
-#: cp/decl.cc:17007
+#: cp/decl.cc:17071
 #, gcc-internal-format
 msgid "%qs initialized and declared %<extern%>"
 msgstr "%qs 已初始化，卻又被宣告為 %<extern%>"
 
-#: cp/decl.cc:17012
+#: cp/decl.cc:17076
 #, gcc-internal-format
 msgid "%qs has both %<extern%> and initializer"
 msgstr "%qs 既有 %<extern%> 又有初始值設定"
 
-#: cp/decl.cc:17214
+#: cp/decl.cc:17278
 #, fuzzy, gcc-internal-format
 msgid "default argument %qE uses %qD"
 msgstr "預設引數 %qE 使用 %qD"
 
-#: cp/decl.cc:17217
+#: cp/decl.cc:17281
 #, gcc-internal-format
 msgid "default argument %qE uses local variable %qD"
 msgstr "預設引數 %qE 使用了局部變數 %qD"
 
-#: cp/decl.cc:17344
+#: cp/decl.cc:17408
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of cv-qualified type %qT in parameter declaration"
 msgstr "在 %q#D 的範本宣告中使用 %<virtual%> 無效"
 
-#: cp/decl.cc:17348
+#: cp/decl.cc:17412
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<virtual%> in template declaration of %q#D"
 msgid "invalid use of type %<void%> in parameter declaration"
 msgstr "在 %q#D 的範本宣告中使用 %<virtual%> 無效"
 
-#: cp/decl.cc:17377
+#: cp/decl.cc:17441
 #, fuzzy, gcc-internal-format
 #| msgid "invalid parameter type %qT"
 msgid "%<volatile%>-qualified parameter is deprecated"
 msgstr "無效的參數類型 %qT"
 
-#: cp/decl.cc:17385
+#: cp/decl.cc:17449
 #, gcc-internal-format
 msgid "parameter %qD invalidly declared method type"
 msgstr "參數 %qD 被無效地被宣告為具有方法類型"
 
-#: cp/decl.cc:17410
+#: cp/decl.cc:17474
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD includes pointer to array of unknown bound %qT"
 msgstr "參數 %qD 包含指標到陣列的不明約束 %qT"
 
-#: cp/decl.cc:17412
+#: cp/decl.cc:17476
 #, fuzzy, gcc-internal-format
 msgid "parameter %qD includes reference to array of unknown bound %qT"
 msgstr "參數 %qD 包含參考到陣列的不明約束 %qT"
 
-#: cp/decl.cc:17695
+#: cp/decl.cc:17759
 #, gcc-internal-format
 msgid "invalid constructor; you probably meant %<%T (const %T&)%>"
 msgstr "無效的建構式：您要的可能是 %<%T (const %T&)%>"
 
-#: cp/decl.cc:17774
+#: cp/decl.cc:17838
 #, gcc-internal-format
 msgid "%qD may not be declared within a namespace"
 msgstr "%qD 不能在命名空間宣告"
 
-#: cp/decl.cc:17781
+#: cp/decl.cc:17845
 #, gcc-internal-format
 msgid "%qD may not be declared as static"
 msgstr "%qD 不能被宣告為靜態的"
 
-#: cp/decl.cc:17839
+#: cp/decl.cc:17903
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must be a nonstatic member function"
 msgid "%qD must be a non-static member function"
 msgstr "%qD 必須是一個非靜態的成員函式"
 
-#: cp/decl.cc:17847
+#: cp/decl.cc:17911
 #, fuzzy, gcc-internal-format
 msgid "%qD must be a member function"
 msgstr "%qD 必須是 non-member 函式"
 
-#: cp/decl.cc:17855
+#: cp/decl.cc:17919
 #, fuzzy, gcc-internal-format
 msgid "%qD may be a static member function only with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/decl.cc:17865
+#: cp/decl.cc:17929
 #, gcc-internal-format
 msgid "%qD must be either a non-static member function or a non-member function"
 msgstr "%qD 必須是一個非靜態成員函式或非成員函式"
 
-#: cp/decl.cc:17875
+#: cp/decl.cc:17939
 #, gcc-internal-format
 msgid "%qD must have an argument of class or enumerated type"
 msgstr "%qD 的引數必須有類別或列舉類型"
 
 #. 13.4.0.3
-#: cp/decl.cc:17906
+#: cp/decl.cc:17970
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ prohibits overloading operator ?:"
 msgid "ISO C++ prohibits overloading %<operator ?:%>"
 msgstr "ISO C++ 不允許多載 ?: 運算子"
 
-#: cp/decl.cc:17916
+#: cp/decl.cc:17980
 #, fuzzy, gcc-internal-format
 msgid "%qD must not have variable number of arguments"
 msgstr "%qD 必須不有可變個數引數數量"
 
-#: cp/decl.cc:17942
+#: cp/decl.cc:18006
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either zero or one argument"
 msgid "%qD must have either zero or one argument"
 msgstr "%qD 必須帶 0 或 1 個引數"
 
-#: cp/decl.cc:17943
+#: cp/decl.cc:18007
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take either one or two arguments"
 msgid "%qD must have either one or two arguments"
 msgstr "%qD 必須帶 1 或 2 個引數"
 
-#: cp/decl.cc:17955
+#: cp/decl.cc:18019
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its argument"
 msgid "postfix %qD must have %<int%> as its argument"
 msgstr "字尾 %qD 必須使用 %<int%> 做為它的參數"
 
-#: cp/decl.cc:17956
+#: cp/decl.cc:18020
 #, fuzzy, gcc-internal-format
 #| msgid "postfix %qD must take %<int%> as its second argument"
 msgid "postfix %qD must have %<int%> as its second argument"
 msgstr "字尾 %qD 必須使用 %<int%> 做為它的第二個參數"
 
-#: cp/decl.cc:17967
+#: cp/decl.cc:18031
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have no arguments"
 msgstr "%qD 帶且僅帶 2 個引數"
 
-#: cp/decl.cc:17968 cp/decl.cc:17978
+#: cp/decl.cc:18032 cp/decl.cc:18042
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly one argument"
 msgid "%qD must have exactly one argument"
 msgstr "%qD 帶且僅帶 1 個引數"
 
-#: cp/decl.cc:17979
+#: cp/decl.cc:18043
 #, fuzzy, gcc-internal-format
 #| msgid "%qD must take exactly two arguments"
 msgid "%qD must have exactly two arguments"
 msgstr "%qD 帶且僅帶 2 個引數"
 
-#: cp/decl.cc:17994
+#: cp/decl.cc:18058
 #, gcc-internal-format
 msgid "%qD cannot have default arguments"
 msgstr "%qD 不能有預設參數"
 
-#: cp/decl.cc:18018
+#: cp/decl.cc:18082
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to %<void%> will never use a type conversion operator"
 msgstr "轉換到虛值將永不使用類型轉換運算子"
 
-#: cp/decl.cc:18025
+#: cp/decl.cc:18089
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a reference to the same type will never use a type conversion operator"
 msgstr "轉換到參考到相同型態將永不使用類型轉換運算子"
 
-#: cp/decl.cc:18027
+#: cp/decl.cc:18091
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to the same type will never use a type conversion operator"
 msgstr "轉換到相同型態將永不使用類型轉換運算子"
 
-#: cp/decl.cc:18036
+#: cp/decl.cc:18100
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator"
 msgstr "轉換到參考到基礎類別將永不使用類型轉換運算子"
 
-#: cp/decl.cc:18038
+#: cp/decl.cc:18102
 #, fuzzy, gcc-internal-format
 msgid "converting %qT to a base class %qT will never use a type conversion operator"
 msgstr "轉換到基礎類別將永不使用類型轉換運算子"
 
-#: cp/decl.cc:18054
+#: cp/decl.cc:18118
 #, gcc-internal-format
 msgid "user-defined %qD always evaluates both arguments"
 msgstr "使用者定義的 %qD 總是計算所有兩個參數"
 
-#: cp/decl.cc:18073
+#: cp/decl.cc:18137
 #, gcc-internal-format
 msgid "prefix %qD should return %qT"
 msgstr "字首 %qD 應當回傳 %qT"
 
-#: cp/decl.cc:18080
+#: cp/decl.cc:18144
 #, gcc-internal-format
 msgid "postfix %qD should return %qT"
 msgstr "字尾 %qD 應當回傳 %qT"
 
-#: cp/decl.cc:18092
+#: cp/decl.cc:18156
 #, gcc-internal-format
 msgid "%qD should return by value"
 msgstr "%qD 應當回傳值而非參照"
 
-#: cp/decl.cc:18149
+#: cp/decl.cc:18213
 #, gcc-internal-format
 msgid "using template type parameter %qT after %qs"
 msgstr "使用範本類型參數 %qT，在 %qs 後"
 
-#: cp/decl.cc:18173
+#: cp/decl.cc:18237
 #, fuzzy, gcc-internal-format
 msgid "using alias template specialization %qT after %qs"
 msgstr "使用別名模板特殊化 %qT 之後 %qs"
 
-#: cp/decl.cc:18176
+#: cp/decl.cc:18240
 #, gcc-internal-format
 msgid "using typedef-name %qD after %qs"
 msgstr "使用 typedef 名 %qD，在 %qs 後"
 
-#: cp/decl.cc:18178
+#: cp/decl.cc:18242
 #, fuzzy, gcc-internal-format
 msgid "%qD has a previous declaration here"
 msgstr "%qD 有前一個宣告在此"
 
-#: cp/decl.cc:18187
+#: cp/decl.cc:18251
 #, gcc-internal-format
 msgid "%qT referred to as %qs"
 msgstr "%qT 做為 %qs 被參照"
 
-#: cp/decl.cc:18188 cp/decl.cc:18196
+#: cp/decl.cc:18252 cp/decl.cc:18260
 #, fuzzy, gcc-internal-format
 #| msgid "%q+T has a previous declaration here"
 msgid "%qT has a previous declaration here"
 msgstr "%q+T 先前在此處有過宣告"
 
-#: cp/decl.cc:18195
+#: cp/decl.cc:18259
 #, gcc-internal-format
 msgid "%qT referred to as enum"
 msgstr "%qT 做為列舉被參照"
@@ -64535,101 +64604,101 @@ msgstr "%qT 做為列舉被參照"
 #. void f(class C);		// No template header here
 #.
 #. then the required template argument is missing.
-#: cp/decl.cc:18210
+#: cp/decl.cc:18274
 #, gcc-internal-format
 msgid "template argument required for %<%s %T%>"
 msgstr "%<%s %T%> 需要範本參數"
 
-#: cp/decl.cc:18253 cp/name-lookup.cc:6471 cp/name-lookup.cc:6605
-#: cp/parser.cc:8122 cp/parser.cc:35474
+#: cp/decl.cc:18317 cp/name-lookup.cc:6511 cp/name-lookup.cc:6645
+#: cp/parser.cc:8105 cp/parser.cc:35534
 #, gcc-internal-format
 msgid "reference to %qD is ambiguous"
 msgstr "對 %qD 的參照有歧義"
 
-#: cp/decl.cc:18263
+#: cp/decl.cc:18327
 #, fuzzy, gcc-internal-format
 msgid "class template %qD redeclared as non-template"
 msgstr "函式模板 %qD redeclared 做為類別模板"
 
-#: cp/decl.cc:18285 cp/name-lookup.cc:6160
+#: cp/decl.cc:18349 cp/name-lookup.cc:6200
 #, gcc-internal-format
 msgid "%qD has the same name as the class in which it is declared"
 msgstr "%qD 與其宣告所在的類別同名"
 
-#: cp/decl.cc:18314 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7813
-#: cp/parser.cc:21303 cp/pt.cc:10235
+#: cp/decl.cc:18378 cp/friend.cc:318 cp/parser.cc:3757 cp/parser.cc:7796
+#: cp/parser.cc:21367 cp/pt.cc:10263
 #, gcc-internal-format
 msgid "%qT is not a template"
 msgstr "%qT 不是一個範本"
 
-#: cp/decl.cc:18319
+#: cp/decl.cc:18383
 #, gcc-internal-format
 msgid "perhaps you want to explicitly add %<%T::%>"
 msgstr ""
 
-#: cp/decl.cc:18424
+#: cp/decl.cc:18488
 #, gcc-internal-format
 msgid "use of enum %q#D without previous declaration"
 msgstr "使用列舉 %q#D 前沒有給出宣告"
 
-#: cp/decl.cc:18451
+#: cp/decl.cc:18515
 #, gcc-internal-format
 msgid "redeclaration of %qT as a non-template"
 msgstr "%qT 重宣告為非範本"
 
-#: cp/decl.cc:18594
+#: cp/decl.cc:18658
 #, gcc-internal-format
 msgid "derived union %qT invalid"
 msgstr "衍生聯合 %qT 無效"
 
-#: cp/decl.cc:18601
+#: cp/decl.cc:18665
 #, gcc-internal-format
 msgid "%qT defined with multiple direct bases"
 msgstr ""
 
-#: cp/decl.cc:18612
+#: cp/decl.cc:18676
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct or virtual base of %qT"
 msgid "%qT defined with direct virtual base"
 msgstr "類型 %qT 不是 %qT 的直接或虛基礎類別"
 
-#: cp/decl.cc:18661
+#: cp/decl.cc:18725
 #, gcc-internal-format
 msgid "base type %qT fails to be a struct or class type"
 msgstr "基礎類別型 %qT 不是結構或類別"
 
-#: cp/decl.cc:18691
+#: cp/decl.cc:18755
 #, gcc-internal-format
 msgid "recursive type %qT undefined"
 msgstr "遞迴的類型 %qT 未定義"
 
-#: cp/decl.cc:18693
+#: cp/decl.cc:18757
 #, gcc-internal-format
 msgid "duplicate base type %qT invalid"
 msgstr "重複的基礎類別型 %qT 無效"
 
-#: cp/decl.cc:18866
+#: cp/decl.cc:18930
 #, fuzzy, gcc-internal-format
 msgid "scoped/unscoped mismatch in enum %q#T"
 msgstr "範圍/unscoped 不匹配在中 enum %q#T"
 
-#: cp/decl.cc:18869 cp/decl.cc:18878 cp/decl.cc:18889 cp/decl.cc:19511
-#: cp/parser.cc:24034
+#: cp/decl.cc:18933 cp/decl.cc:18942 cp/decl.cc:18953 cp/decl.cc:19577
+#: cp/parser.cc:24098
 #, fuzzy, gcc-internal-format
 msgid "previous definition here"
 msgstr "前一個定義在此"
 
-#: cp/decl.cc:18875
+#: cp/decl.cc:18939
 #, fuzzy, gcc-internal-format
 msgid "underlying type mismatch in enum %q#T"
 msgstr "下層的型態不匹配在中 enum %q#T"
 
-#: cp/decl.cc:18886
+#: cp/decl.cc:18950
 #, fuzzy, gcc-internal-format
 msgid "different underlying type in enum %q#T"
 msgstr "不同的下層的輸入 enum %q#T"
 
-#: cp/decl.cc:18961
+#: cp/decl.cc:19025
 #, fuzzy, gcc-internal-format
 msgid "underlying type %qT of %qT must be an integral type"
 msgstr "下層的型態 %<%T%>的 %<%T%>必須是整數類資料類型"
@@ -64638,88 +64707,94 @@ msgstr "下層的型態 %<%T%>的 %<%T%>必須是整數類資料類型"
 #.
 #. IF no integral type can represent all the enumerator values, the
 #. enumeration is ill-formed.
-#: cp/decl.cc:19130
+#: cp/decl.cc:19194
 #, gcc-internal-format
 msgid "no integral type can represent all of the enumerator values for %qT"
 msgstr "沒有一個整數類型可以表示 %qT 的所有列舉值"
 
-#: cp/decl.cc:19318
+#: cp/decl.cc:19384
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD must have integral or unscoped enumeration type"
 msgstr "列舉值值用於 %qD 不是整數常數"
 
-#: cp/decl.cc:19328
+#: cp/decl.cc:19394
 #, fuzzy, gcc-internal-format
 msgid "enumerator value for %qD is not an integer constant"
 msgstr "列舉值值用於 %qD 不是整數常數"
 
-#: cp/decl.cc:19377
+#: cp/decl.cc:19443
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<unsigned long%>"
 msgstr "遞增的列舉值值太大用於 %<unsigned long%>"
 
-#: cp/decl.cc:19378
+#: cp/decl.cc:19444
 #, fuzzy, gcc-internal-format
 msgid "incremented enumerator value is too large for %<long%>"
 msgstr "遞增的列舉值值太大用於 %<unsigned long%>"
 
-#: cp/decl.cc:19389
+#: cp/decl.cc:19455
 #, gcc-internal-format
 msgid "overflow in enumeration values at %qD"
 msgstr "%qD 處列舉值溢出"
 
-#: cp/decl.cc:19409
+#: cp/decl.cc:19475
 #, fuzzy, gcc-internal-format
 msgid "enumerator value %qE is outside the range of underlying type %qT"
 msgstr "列舉值值 %E 太大用於下層的型態 %<%T%>"
 
-#: cp/decl.cc:19509 cp/parser.cc:24032
+#: cp/decl.cc:19575 cp/parser.cc:24096
 #, gcc-internal-format
 msgid "multiple definition of %q#T"
 msgstr "%q#T 多次定義"
 
-#: cp/decl.cc:19583
+#: cp/decl.cc:19649
 #, gcc-internal-format
 msgid "return type %q#T is incomplete"
 msgstr "回傳值類型 %q#T 為不完全"
 
-#: cp/decl.cc:19753 cp/typeck.cc:11632
+#: cp/decl.cc:19819 cp/typeck.cc:11630
 #, gcc-internal-format
 msgid "%<operator=%> should return a reference to %<*this%>"
 msgstr "%<operator=%> 應當回傳一個對 %<*this%> 的參照"
 
-#: cp/decl.cc:20571
+#: cp/decl.cc:20637
 #, fuzzy, gcc-internal-format
 msgid "no return statements in function returning %qT"
 msgstr "在有回傳值的函式中未發現 return 敘述"
 
-#: cp/decl.cc:20573 cp/typeck.cc:11510
+#: cp/decl.cc:20639 cp/typeck.cc:11508
 #, fuzzy, gcc-internal-format
 msgid "only plain %<auto%> return type can be deduced to %<void%>"
 msgstr "由於 %<volatile%>，函式回傳類型不相容"
 
-#: cp/decl.cc:20584
+#: cp/decl.cc:20650
 #, gcc-internal-format
 msgid "defining %qD, which previously failed to be deduced in a SFINAE context"
 msgstr ""
 
-#: cp/decl.cc:20642
+#: cp/decl.cc:20708
 #, fuzzy, gcc-internal-format
 #| msgid "no return statement in function returning non-void"
 msgid "no return statement in %<constexpr%> function returning non-void"
 msgstr "在有回傳值的函式中未發現 return 敘述"
 
-#: cp/decl.cc:20838
+#: cp/decl.cc:20904
 #, gcc-internal-format
 msgid "%qD is already defined in class %qT"
 msgstr "%qD 已在類別 %qT 中定義過"
 
-#: cp/decl.cc:21236
+#: cp/decl.cc:21302
 #, fuzzy, gcc-internal-format
 msgid "using %qs"
 msgstr "封閉任務"
 
-#: cp/decl.cc:21248
+#: cp/decl.cc:21329
+#, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
+msgid "%qs used without %qs declaration"
+msgstr "%q+D 在宣告前使用"
+
+#: cp/decl.cc:21341
 #, fuzzy, gcc-internal-format
 msgid "use of %qD before deduction of %<auto%>"
 msgstr "型態的 %qD 預設值到 %<int%>"
@@ -65166,358 +65241,358 @@ msgstr "重新宣告 %qD 不同在中 %<constexpr%>"
 msgid "use of built-in parameter pack %qD outside of a template"
 msgstr "在範本外使用 %<typename%>"
 
-#: cp/error.cc:3924
+#: cp/error.cc:3931
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d:%d%R"
 msgid "    inlined from %qD at %r%s:%d:%d%R"
 msgstr "    從 %qs (位於 %r%s:%d:%d%R) 內聯"
 
-#: cp/error.cc:3929
+#: cp/error.cc:3936
 #, fuzzy
 #| msgid "    inlined from %qs at %r%s:%d%R"
 msgid "    inlined from %qD at %r%s:%d%R"
 msgstr "    從 %qs (位於 %r%s:%d%R) 內聯"
 
-#: cp/error.cc:3935
+#: cp/error.cc:3942
 #, fuzzy, gcc-internal-format
 #| msgid "    inlined from %qs"
 msgid "    inlined from %qD"
 msgstr "    從 %qs 內聯"
 
-#: cp/error.cc:3961
+#: cp/error.cc:3968
 #, fuzzy, gcc-internal-format
 msgid "In static member function %qD"
 msgstr "在中靜態成員函式 %qs"
 
-#: cp/error.cc:3963
+#: cp/error.cc:3970
 #, fuzzy, gcc-internal-format
 msgid "In copy constructor %qD"
 msgstr "在中複製建構函式 %qs"
 
-#: cp/error.cc:3965
+#: cp/error.cc:3972
 #, fuzzy, gcc-internal-format
 msgid "In constructor %qD"
 msgstr "在中建構子 %qs"
 
-#: cp/error.cc:3967
+#: cp/error.cc:3974
 #, fuzzy, gcc-internal-format
 msgid "In destructor %qD"
 msgstr "在中解構式 %qs"
 
-#: cp/error.cc:3969
+#: cp/error.cc:3976
 #, fuzzy, gcc-internal-format
 msgid "In lambda function"
 msgstr "在中 lambda 函式"
 
-#: cp/error.cc:3971
+#: cp/error.cc:3978
 #, fuzzy, gcc-internal-format
 msgid "In explicit object member function %qD"
 msgstr "在中靜態成員函式 %qs"
 
-#: cp/error.cc:3973
+#: cp/error.cc:3980
 #, fuzzy, gcc-internal-format
 #| msgid "In member function %qs"
 msgid "In member function %qD"
 msgstr "在 %qs 成員函式中"
 
-#: cp/error.cc:3976
+#: cp/error.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "In function %qs"
 msgid "In function %qD"
 msgstr "在函式 %qs 中"
 
-#: cp/error.cc:3992
+#: cp/error.cc:3999
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a type"
 msgstr "%qE 並非型態"
 
-#: cp/error.cc:3994
+#: cp/error.cc:4001
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an expression"
 msgstr "%qE 並非常數運算式"
 
-#: cp/error.cc:3996
+#: cp/error.cc:4003
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a structured binding"
 msgstr "%qs 指定的用於結構欄位"
 
-#: cp/error.cc:3998
+#: cp/error.cc:4005
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a variable"
 msgstr "%qD 並非變數"
 
-#: cp/error.cc:4000
+#: cp/error.cc:4007
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "but %qE is a parameter"
 msgstr "函式參數"
 
-#: cp/error.cc:4002
+#: cp/error.cc:4009
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "but %qE is a function"
 msgstr "%qD 不是一個成員範本函式"
 
-#: cp/error.cc:4004
+#: cp/error.cc:4011
 #, fuzzy, gcc-internal-format
 #| msgid "%q#D is not a non-static data member of %qT"
 msgid "but %qE is a data member"
 msgstr "%q#D 不是 %qT 的非靜態資料成員"
 
-#: cp/error.cc:4006
+#: cp/error.cc:4013
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "but %qE is a function template"
 msgstr "%qD 不是一個函式範本"
 
-#: cp/error.cc:4008
+#: cp/error.cc:4015
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a class template"
 msgstr "%qE 不是一個範本"
 
-#: cp/error.cc:4010
+#: cp/error.cc:4017
 #, fuzzy, gcc-internal-format
 msgid "but %qE is a variable template"
 msgstr "%qD 並非變數"
 
-#: cp/error.cc:4012
+#: cp/error.cc:4019
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is a namespace"
 msgid "but %qE is a namespace"
 msgstr "%qD 是一個命名空間"
 
-#: cp/error.cc:4014
+#: cp/error.cc:4021
 #, fuzzy, gcc-internal-format
 msgid "but %qE is an enumerator"
 msgstr "%qD 不是 enumerator-name"
 
-#: cp/error.cc:4042
+#: cp/error.cc:4049
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "%s%s%sIn instantiation of %<template for%> iteration %E:\n"
 msgstr "  在範本 %qT 的實體化中"
 
-#: cp/error.cc:4045
+#: cp/error.cc:4052
 #, fuzzy
 msgid "%s%s%sIn substitution of %qS:\n"
 msgstr "%s：在中替代的 %qS：\n"
 
-#: cp/error.cc:4046
+#: cp/error.cc:4053
 #, fuzzy, gcc-internal-format
 msgid "%s%s%sIn instantiation of %q#D:\n"
 msgstr "%s：在中實體化的 %q#D：\n"
 
-#: cp/error.cc:4068
+#: cp/error.cc:4075
 #, fuzzy
 msgid "%r%s:%d:%d:%R   "
 msgstr "%s:%d:%d：  "
 
-#: cp/error.cc:4071
+#: cp/error.cc:4078
 #, fuzzy
 msgid "%r%s:%d:%R   "
 msgstr "%s:%d：  "
 
-#: cp/error.cc:4175
+#: cp/error.cc:4182
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %<template for%> iteration %E\n"
 msgstr "遞迴必要項從在此"
 
-#: cp/error.cc:4177
+#: cp/error.cc:4184
 #, gcc-internal-format
 msgid "required from %<template for%> iteration %E\n"
 msgstr ""
 
-#: cp/error.cc:4182
+#: cp/error.cc:4189
 #, fuzzy
 msgid "recursively required by substitution of %qS\n"
 msgstr "遞迴必要項由替代的 %qS\n"
 
-#: cp/error.cc:4183
+#: cp/error.cc:4190
 #, fuzzy
 msgid "required by substitution of %qS\n"
 msgstr "必要項由替代的 %qS\n"
 
-#: cp/error.cc:4188
+#: cp/error.cc:4195
 #, fuzzy, gcc-internal-format
 msgid "recursively required from %q#D\n"
 msgstr "遞迴必要項從 %q#D\n"
 
-#: cp/error.cc:4189
+#: cp/error.cc:4196
 #, fuzzy, gcc-internal-format
 msgid "required from %q#D\n"
 msgstr "必要項從 %q#D\n"
 
-#: cp/error.cc:4196
+#: cp/error.cc:4203
 #, fuzzy, gcc-internal-format
 msgid "recursively required from here\n"
 msgstr "遞迴必要項從在此"
 
-#: cp/error.cc:4197
+#: cp/error.cc:4204
 #, fuzzy, gcc-internal-format
 msgid "required from here\n"
 msgstr "必要項從在此"
 
-#: cp/error.cc:4247
+#: cp/error.cc:4254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "[ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
 msgstr "%s:%d：  [跳過 %d 實體化語境]\n"
 
-#: cp/error.cc:4299
+#: cp/error.cc:4306
 #, fuzzy, gcc-internal-format
 msgid "in %<constexpr%> expansion of %qs"
 msgstr "%s:%d：  在中 constexpr 擴展的 %qs"
 
-#: cp/error.cc:4312
+#: cp/error.cc:4319
 #, fuzzy, gcc-internal-format
 msgid "required by the constraints of %q#D\n"
 msgstr "必要項由替代的 %qS\n"
 
-#: cp/error.cc:4327
+#: cp/error.cc:4334
 #, fuzzy, gcc-internal-format
 msgid "required for the satisfaction of %qE"
 msgstr "必要項由替代的 %qS\n"
 
-#: cp/error.cc:4349
+#: cp/error.cc:4356
 #, fuzzy, gcc-internal-format
 msgid "required for constraint satisfaction\n"
 msgstr "-c 必要項用於 gnat2 why"
 
-#: cp/error.cc:4380
+#: cp/error.cc:4387
 #, gcc-internal-format
 msgid "in requirements with "
 msgstr ""
 
-#: cp/error.cc:4381
+#: cp/error.cc:4388
 #, fuzzy, gcc-internal-format
 #| msgid "%qT referred to as %qs"
 msgid "in requirements "
 msgstr "%qT 做為 %qs 被參照"
 
-#: cp/error.cc:4499
+#: cp/error.cc:4506
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "(no argument)"
 msgstr "沒有參數"
 
-#: cp/error.cc:4593
+#: cp/error.cc:4600
 #, gcc-internal-format
 msgid "[...]"
 msgstr ""
 
-#: cp/error.cc:4945
+#: cp/error.cc:4952
 #, fuzzy, gcc-internal-format
 msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "進階初始設定式只列出可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4950
+#: cp/error.cc:4957
 #, fuzzy, gcc-internal-format
 msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "明確的轉換運算子只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4955
+#: cp/error.cc:4962
 #, fuzzy, gcc-internal-format
 msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4960
+#: cp/error.cc:4967
 #, fuzzy, gcc-internal-format
 msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "lambda 運算式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4965
+#: cp/error.cc:4972
 #, fuzzy, gcc-internal-format
 msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++0x 自動只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4970
+#: cp/error.cc:4977
 #, fuzzy, gcc-internal-format
 msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "範圍的 enums 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4975
+#: cp/error.cc:4982
 #, fuzzy, gcc-internal-format
 msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "缺席和刪除的函式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4981
+#: cp/error.cc:4988
 #, fuzzy, gcc-internal-format
 msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4986
+#: cp/error.cc:4993
 #, fuzzy, gcc-internal-format
 msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "強制變更控制項 (強制變更/最後的) 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4991
+#: cp/error.cc:4998
 #, fuzzy, gcc-internal-format
 msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "非靜態資料成員初始設定式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:4996
+#: cp/error.cc:5003
 #, fuzzy, gcc-internal-format
 msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "使用者定義的實字只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:5001
+#: cp/error.cc:5008
 #, fuzzy, gcc-internal-format
 msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "委派建構子只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:5006
+#: cp/error.cc:5013
 #, fuzzy, gcc-internal-format
 msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "委派建構子只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:5012
+#: cp/error.cc:5019
 #, fuzzy, gcc-internal-format
 msgid "C++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "C++0x 自動只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:5017
+#: cp/error.cc:5024
 #, fuzzy, gcc-internal-format
 msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "使用者定義的實字只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/error.cc:5072
+#: cp/error.cc:5079
 #, gcc-internal-format
 msgid "incomplete type %qT used in nested name specifier"
 msgstr "巢狀名指定中使用了不完全的類型 %qT"
 
-#: cp/error.cc:5077
+#: cp/error.cc:5084
 #, gcc-internal-format
 msgid "reference to %<%T::%D%> is ambiguous"
 msgstr "對 %<%T::%D%> 的參照有歧義"
 
-#: cp/error.cc:5092
+#: cp/error.cc:5099
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of type %qT"
 msgid "%qD is not a member of %qT; did you mean %qs?"
 msgstr "%qD 不是類型 %qT 的成員"
 
-#: cp/error.cc:5096 cp/typeck.cc:3012
+#: cp/error.cc:5103 cp/typeck.cc:3012
 #, gcc-internal-format
 msgid "%qD is not a member of %qT"
 msgstr "%qD 不是 %qT 的成員"
 
-#: cp/error.cc:5118
+#: cp/error.cc:5125
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of type %qT"
 msgid "%qD is not a member of %qD; did you mean %qs?"
 msgstr "%qD 不是類型 %qT 的成員"
 
-#: cp/error.cc:5122 cp/typeck.cc:3641
+#: cp/error.cc:5129 cp/typeck.cc:3648
 #, gcc-internal-format
 msgid "%qD is not a member of %qD"
 msgstr "%qD 不是 %qD 的成員"
 
-#: cp/error.cc:5133
+#: cp/error.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "%<::%D%> has not been declared"
 msgid "%<::%D%> has not been declared; did you mean %qs?"
 msgstr "%<::%D%> 尚未宣告"
 
-#: cp/error.cc:5137
+#: cp/error.cc:5144
 #, gcc-internal-format
 msgid "%<::%D%> has not been declared"
 msgstr "%<::%D%> 尚未宣告"
@@ -65741,7 +65816,7 @@ msgstr ""
 msgid "member %qD is used uninitialized"
 msgstr "成員 %qD 是未初始化的參照"
 
-#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5118 cp/typeck2.cc:1519
+#: cp/init.cc:976 cp/init.cc:2062 cp/init.cc:5232 cp/typeck2.cc:1519
 #, fuzzy, gcc-internal-format
 msgid "array must be initialized with a brace-enclosed initializer"
 msgstr "陣列必須被初始化的與 brace-enclosed 初始設定式"
@@ -65859,7 +65934,7 @@ msgstr "類型 %qT 不是 %qT 的直接或虛基礎類別"
 msgid "type %qT is not a direct base of %qT"
 msgstr "類型 %qT 不是 %qT 的直接基礎類別"
 
-#: cp/init.cc:2383 cp/reflect.cc:2553 cp/semantics.cc:4484
+#: cp/init.cc:2383 cp/reflect.cc:2639 cp/semantics.cc:4484
 #: rust/backend/rust-tree.cc:4192
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class type"
@@ -66055,44 +66130,44 @@ msgstr "偵測到呼叫 delete 運算子時可能出現的問題："
 msgid "neither the destructor nor the class-specific operator %<delete []%> will be called, even if they are declared when the class is defined"
 msgstr "neither 解構式 nor class-specific 運算子刪除將被 called，即使它們被宣告時類別被定義"
 
-#: cp/init.cc:5007
+#: cp/init.cc:5121
 #, gcc-internal-format
 msgid "initializer ends prematurely"
 msgstr "初始值設定在完成之前結束"
 
-#: cp/init.cc:5327
+#: cp/init.cc:5441
 #, gcc-internal-format
 msgid "unknown array size in delete"
 msgstr "delete 時陣列大小不明"
 
-#: cp/init.cc:5364
+#: cp/init.cc:5478
 #, fuzzy, gcc-internal-format
 #| msgid "return type is an incomplete type"
 msgid "operator %<delete%> used on incomplete type"
 msgstr "回傳不完全的類型"
 
-#: cp/init.cc:5379
+#: cp/init.cc:5493
 #, fuzzy, gcc-internal-format
 #| msgid "possible problem detected in invocation of delete operator:"
 msgid "possible problem detected in invocation of %<operator delete%>"
 msgstr "偵測到呼叫 delete 運算子時可能出現的問題："
 
-#: cp/init.cc:5385
+#: cp/init.cc:5499
 #, fuzzy, gcc-internal-format
 msgid "neither the destructor nor the class-specific %<operator delete%> will be called, even if they are declared when the class is defined"
 msgstr "neither 解構式 nor class-specific 運算子刪除將被 called，即使它們被宣告時類別被定義"
 
-#: cp/init.cc:5400
+#: cp/init.cc:5514
 #, fuzzy, gcc-internal-format
 msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
 msgstr "刪除物件的抽象類別型態 %qT 該項有 non-virtual 解構式將造成未定義的行為"
 
-#: cp/init.cc:5405
+#: cp/init.cc:5519
 #, fuzzy, gcc-internal-format
 msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
 msgstr "刪除物件的 polymorphic 類別型態 %qT 該項有 non-virtual 解構式也許造成未定義的行為"
 
-#: cp/init.cc:5719
+#: cp/init.cc:5833
 #, gcc-internal-format
 msgid "type to vector delete is neither pointer or array type"
 msgstr "向量 delete 的引數類型既非指標也非陣列"
@@ -66128,88 +66203,96 @@ msgstr "無效的使用的不完整型態 %q#T"
 msgid "captured structured bindings are a C++20 extension"
 msgstr "無效的輸入宣告"
 
-#: cp/lambda.cc:732
+#. This can happen for code like [&]<auto e> { [:e:]; } where
+#. we can't figure out what the splice will designate while parsing;
+#. we'll only know it after we've substituted the splice, but then
+#. it's too late to capture anything.  This code is ill-formed as
+#. per [expr.prim.splice]/2.1.4.1: The expression is ill-formed if
+#. S is ... a local entity such that ... there is a lambda scope that
+#. intervenes between the expression and the point at which S was
+#. introduced and the expression would be potentially evaluated.
+#: cp/lambda.cc:741
 #, gcc-internal-format
 msgid "trying to capture %qD in instantiation of generic lambda"
 msgstr ""
 
-#: cp/lambda.cc:809
+#: cp/lambda.cc:820
 #, gcc-internal-format
 msgid "implicit capture of %qE via %<[=]%> is deprecated in C++20"
 msgstr ""
 
-#: cp/lambda.cc:811
+#: cp/lambda.cc:822
 #, gcc-internal-format
 msgid "add explicit %<this%> or %<*this%> capture"
 msgstr ""
 
-#: cp/lambda.cc:946
+#: cp/lambda.cc:957
 #, fuzzy, gcc-internal-format
 msgid "%<this%> was not captured for this lambda function"
 msgstr "%<this%> 未被擷取用於這個 lambda 函式"
 
-#: cp/lambda.cc:1630
+#: cp/lambda.cc:1641
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changed in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD 修飾後的名稱將在 GCC 的未來版本中有變化"
 
-#: cp/lambda.cc:1634
+#: cp/lambda.cc:1645
 #, fuzzy, gcc-internal-format
 #| msgid "the mangled name of %qD will change in a future version of GCC"
 msgid "the mangled name of %qT changes in %<-fabi-version=20%> (GCC 15.1)"
 msgstr "%qD 修飾後的名稱將在 GCC 的未來版本中有變化"
 
-#: cp/lambda.cc:1942
+#: cp/lambda.cc:1953
 #, gcc-internal-format
 msgid "%qD is no longer captured in noexcept lambda in ABI v21 (GCC 16)"
 msgstr ""
 
-#: cp/lex.cc:701
+#: cp/lex.cc:704
 #, fuzzy, gcc-internal-format
 #| msgid "invalid #pragma %s"
 msgid "invalid %<#pragma %s%>"
 msgstr "無效的 #pragma %s"
 
-#: cp/lex.cc:709
+#: cp/lex.cc:712
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma vtable%> no longer supported"
 msgstr "#pragma vtable 不再受支援"
 
-#: cp/lex.cc:781
+#: cp/lex.cc:784
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma implementation for %qs appears after file is included"
 msgid "%<#pragma implementation%> for %qs appears after file is included"
 msgstr "檔案在 %qs 的 #pragma implementation 出現前已被包含"
 
-#: cp/lex.cc:809
+#: cp/lex.cc:812
 #, gcc-internal-format
 msgid "%qD not defined"
 msgstr "%qD 未定義"
 
-#: cp/lex.cc:811 cp/parser.cc:3999 cp/parser.cc:34698
+#: cp/lex.cc:814 cp/parser.cc:3999 cp/parser.cc:34758
 #, fuzzy, gcc-internal-format
 msgid "%<requires%> only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "使用者定義的實字只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/lex.cc:824
+#: cp/lex.cc:827
 #, fuzzy, gcc-internal-format
 #| msgid "%qD was not declared in this scope"
 msgid "%qD was not declared in this scope; did you mean %qs?"
 msgstr "%qD 在此作用欄位中尚未宣告"
 
-#: cp/lex.cc:828
+#: cp/lex.cc:831
 #, gcc-internal-format
 msgid "%qD was not declared in this scope"
 msgstr "%qD 在此作用欄位中尚未宣告"
 
-#: cp/lex.cc:871
+#: cp/lex.cc:874
 #, gcc-internal-format
 msgid "there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available"
 msgstr "%qD 的引數不依賴範本參數，所以 %qD 的宣告必須可用"
 
-#: cp/lex.cc:880
+#: cp/lex.cc:883
 #, gcc-internal-format
 msgid "(if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)"
 msgstr "(如果您使用 %<-fpermissive%>，G++ 會接受您的程式碼，但是允許使用未定義的名稱是過時的風格)"
@@ -66219,64 +66302,57 @@ msgstr "(如果您使用 %<-fpermissive%>，G++ 會接受您的程式碼，但
 msgid "  # %E"
 msgstr ""
 
-#: cp/mangle.cc:2738
+#: cp/mangle.cc:2751
 #, fuzzy, gcc-internal-format
 msgid "mangling %<typeof%>, use %<decltype%> instead"
 msgstr "mangling typeof，使用 decltype 做為替代"
 
-#: cp/mangle.cc:2742
+#: cp/mangle.cc:2755
 #, gcc-internal-format
 msgid "use of built-in trait %qT in function signature; use library traits instead"
 msgstr ""
 
-#. TODO Mangle pack indexing
-#. <https://github.com/itanium-cxx-abi/cxx-abi/issues/175>.
-#: cp/mangle.cc:2749
-#, gcc-internal-format
-msgid "mangling type pack index"
-msgstr ""
-
-#: cp/mangle.cc:4014
+#: cp/mangle.cc:4061
 #, gcc-internal-format
 msgid "use of built-in trait %qE in function signature; use library traits instead"
 msgstr ""
 
-#: cp/mangle.cc:4019
+#: cp/mangle.cc:4066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "mangling %C"
 msgstr "mangling %C"
 
-#: cp/mangle.cc:4093
+#: cp/mangle.cc:4140
 #, gcc-internal-format
 msgid "omitted middle operand to %<?:%> operand cannot be mangled"
 msgstr "省略的 %<?:%> 中運算元不能被修飾"
 
-#: cp/mangle.cc:4789
+#: cp/mangle.cc:4886
 #, gcc-internal-format
 msgid "mangled name for %qD will change in C++17 because the exception specification is part of a function type"
 msgstr ""
 
-#: cp/mangle.cc:4835 cp/mangle.cc:5014
+#: cp/mangle.cc:4932 cp/mangle.cc:5111
 #, gcc-internal-format
 msgid "the mangled name of %qD changed between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:4841 cp/mangle.cc:5020
+#: cp/mangle.cc:4938 cp/mangle.cc:5117
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<%s=%d%> (%qD) and %<%s=%d%> (%qD)"
 msgstr ""
 
-#: cp/mangle.cc:5167
+#: cp/mangle.cc:5264
 #, gcc-internal-format
 msgid "the mangled name of a thunk for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5172
+#: cp/mangle.cc:5269
 #, gcc-internal-format
 msgid "the mangled name of %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
 
-#: cp/mangle.cc:5177
+#: cp/mangle.cc:5274
 #, gcc-internal-format
 msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>"
 msgstr ""
@@ -66673,7 +66749,7 @@ msgstr "%q+D 重宣告為沒有外部連結"
 msgid "conflicting language linkage for imported declaration %#qD"
 msgstr "相互衝突的宣告 %q#D"
 
-#: cp/module.cc:12587 cp/module.cc:12715
+#: cp/module.cc:12587 cp/module.cc:12721
 #, fuzzy, gcc-internal-format
 msgid "conflicting type for imported declaration %#qD"
 msgstr "衝突說明符在中宣告的 %qs"
@@ -66690,449 +66766,449 @@ msgstr "相互衝突的宣告 %q#D"
 msgid "conflicting argument types for imported declaration %#qD"
 msgstr "相互衝突的宣告 %q#D"
 
-#: cp/module.cc:12646
+#: cp/module.cc:12648
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<noexcept%> specifier for imported declaration %#qD"
 msgstr "衝突說明符在中宣告的 %qs"
 
-#: cp/module.cc:12665
+#: cp/module.cc:12671
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting return type specified for %q+#D"
 msgid "conflicting deduced return type for imported declaration %#qD"
 msgstr "為 %q+#D 指定了衝突的回傳類型"
 
-#: cp/module.cc:12690
+#: cp/module.cc:12696
 #, fuzzy, gcc-internal-format
 msgid "conflicting %<constexpr%> for imported declaration %#qD"
 msgstr "衝突說明符在中宣告的 %qs"
 
-#: cp/module.cc:12706
+#: cp/module.cc:12712
 #, fuzzy, gcc-internal-format
 #| msgid "conflicting declaration %q#D"
 msgid "conflicting imported declaration %q#D"
 msgstr "相互衝突的宣告 %q#D"
 
-#: cp/module.cc:12732
+#: cp/module.cc:12738
 #, fuzzy, gcc-internal-format
 #| msgid "in declaration %q+D"
 msgid "existing declaration %#qD"
 msgstr "在宣告 %q+D 中"
 
-#: cp/module.cc:12835
+#: cp/module.cc:12841
 #, fuzzy, gcc-internal-format
 #| msgid "no default argument for %qD"
 msgid "conflicting default argument for %#qD"
 msgstr "%qD 沒有預設參數"
 
-#: cp/module.cc:12837 cp/module.cc:12864
+#: cp/module.cc:12843 cp/module.cc:12870
 #, fuzzy, gcc-internal-format
 msgid "existing default declared here"
 msgstr "型態的不匹配欄位宣告的在此"
 
-#: cp/module.cc:12861
+#: cp/module.cc:12867
 #, fuzzy, gcc-internal-format
 #| msgid "default argument missing for parameter %P of %q+#D"
 msgid "conflicting default argument for parameter %P of %#qD"
 msgstr "參數 %P (屬於 %q+#D)缺少預設引數"
 
-#: cp/module.cc:13986
+#: cp/module.cc:13999
 #, fuzzy, gcc-internal-format
 msgid "definition of %qD does not match"
 msgstr "extern 宣告的 %q#D doesn%'t 匹配"
 
-#: cp/module.cc:13988
+#: cp/module.cc:14001
 #, fuzzy, gcc-internal-format
 #| msgid "missing definition"
 msgid "existing definition %qD"
 msgstr "定義缺失"
 
-#: cp/module.cc:14000
+#: cp/module.cc:14013
 #, fuzzy, gcc-internal-format
 msgid "enumerator %qD does not match ..."
 msgstr "extern 宣告的 %q#D doesn%'t 匹配"
 
-#: cp/module.cc:14002
+#: cp/module.cc:14015
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of enumerator %q+D"
 msgid "... this enumerator %qD"
 msgstr "列舉 %q+D 重宣告"
 
-#: cp/module.cc:14008
+#: cp/module.cc:14021
 #, gcc-internal-format
 msgid "additional enumerators beginning with %qD"
 msgstr ""
 
-#: cp/module.cc:14012
+#: cp/module.cc:14025
 #, gcc-internal-format
 msgid "enumeration range differs"
 msgstr ""
 
-#: cp/module.cc:14229
+#: cp/module.cc:14242
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not of type %qT"
 msgid "%qD is an alias of TU-local type %qT"
 msgstr "%qE 的類型不是 %qT"
 
-#: cp/module.cc:14247
+#: cp/module.cc:14260
 #, fuzzy, gcc-internal-format
 msgid "%qD is a specialization of TU-local template %qD"
 msgstr "局部特化的別名模板 %qD"
 
-#: cp/module.cc:14271
+#: cp/module.cc:14284
 #, fuzzy, gcc-internal-format
 #| msgid "%qD redeclared with different access"
 msgid "%qD declared with internal linkage"
 msgstr "%qD 重宣告時有不同的可存取性"
 
-#: cp/module.cc:14289
+#: cp/module.cc:14302
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has no linkage and is declared in an anonymous namespace"
 msgstr "%qD 不能在命名空間宣告"
 
-#: cp/module.cc:14301
+#: cp/module.cc:14314
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qT"
 msgstr "%qD 未被宣告在中 %qD"
 
-#: cp/module.cc:14312
+#: cp/module.cc:14325
 #, fuzzy, gcc-internal-format
 msgid "%qD has no linkage and is declared within TU-local entity %qD"
 msgstr "%qD 未被宣告在中 %qD"
 
-#: cp/module.cc:14344
+#: cp/module.cc:14357
 #, gcc-internal-format
 msgid "%qT has no name and cannot be differentiated from similar lambdas in other TUs"
 msgstr ""
 
-#: cp/module.cc:14353
+#: cp/module.cc:14366
 #, gcc-internal-format
 msgid "%qT has no name and is not defined within a class, function, or initializer"
 msgstr ""
 
-#: cp/module.cc:14389
+#: cp/module.cc:14402
 #, fuzzy, gcc-internal-format
 #| msgid "%qD used without template parameters"
 msgid "%qD has TU-local template argument %qD"
 msgstr "%qD 使用時未帶範本參數"
 
-#: cp/module.cc:14401
+#: cp/module.cc:14414
 #, fuzzy, gcc-internal-format
 msgid "%qD has TU-local template argument %qT"
 msgstr "%qE 並非有效模板引數用於型態 %qT"
 
-#: cp/module.cc:14453
+#: cp/module.cc:14466
 #, gcc-internal-format
 msgid "%qD refers to TU-local object %qD"
 msgstr ""
 
-#: cp/module.cc:14455
+#: cp/module.cc:14468
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD refers to TU-local function %qD"
 msgstr "%qD 不是一個成員範本函式"
 
-#: cp/module.cc:14485 cp/module.cc:14522
+#: cp/module.cc:14498 cp/module.cc:14535
 #, fuzzy, gcc-internal-format
 #| msgid "instantiation of %q+D as type %qT"
 msgid "instantiation exposes TU-local entity %qD"
 msgstr "%q+D 按類型 %qT 實體化"
 
-#: cp/module.cc:15866 cp/module.cc:15876
+#: cp/module.cc:15881 cp/module.cc:15891
 #, gcc-internal-format
 msgid "%qD exposes TU-local entity %qD"
 msgstr ""
 
-#: cp/module.cc:15881
+#: cp/module.cc:15896
 #, gcc-internal-format
 msgid "%qD is also TU-local but has been exposed elsewhere"
 msgstr ""
 
-#: cp/module.cc:15934
+#: cp/module.cc:15949
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD, which may cause issues when instantiating in other TUs"
 msgstr ""
 
-#: cp/module.cc:15944
+#: cp/module.cc:15959
 #, gcc-internal-format
 msgid "%qD refers to TU-local entity %qD and cannot be instantiated in other TUs"
 msgstr ""
 
-#: cp/module.cc:16002
+#: cp/module.cc:16022
 #, gcc-internal-format
 msgid "%qD is declared %<constexpr%> and is initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16009
+#: cp/module.cc:16029
 #, gcc-internal-format
 msgid "%qD is a reference declared %<inline%> and is constant-initialized to a TU-local value"
 msgstr ""
 
-#: cp/module.cc:16640
+#: cp/module.cc:16660
 #, gcc-internal-format
 msgid "recursive lazy load"
 msgstr ""
 
-#: cp/module.cc:16658
+#: cp/module.cc:16678
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "module %qs depends on itself"
 msgstr "在初次使用後明確特例化 %qD"
 
-#: cp/module.cc:16660 cp/module.cc:22766
+#: cp/module.cc:16680 cp/module.cc:22792
 #, fuzzy, gcc-internal-format
 msgid "module %qs declared here"
 msgstr "%qD 宣告的在此"
 
-#: cp/module.cc:17015
+#: cp/module.cc:17035
 #, gcc-internal-format
 msgid "indirect import %qs is not already loaded"
 msgstr ""
 
-#: cp/module.cc:17021
+#: cp/module.cc:17041
 #, gcc-internal-format
 msgid "import %qs has CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20083
+#: cp/module.cc:20103
 #, gcc-internal-format
 msgid "not exporting %<#define %E%> as it is a keyword"
 msgstr ""
 
-#: cp/module.cc:20323
+#: cp/module.cc:20343
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+D was here"
 msgid "macro definitions of %qE corrupted"
 msgstr "%q+D 的上一個定義在此"
 
-#: cp/module.cc:20348 cp/module.cc:20351
+#: cp/module.cc:20368 cp/module.cc:20371
 #, fuzzy, gcc-internal-format
 msgid "inconsistent imported macro definition %qE"
 msgstr "  不一致參數包裝推導與 %qT 和 %qT"
 
-#: cp/module.cc:20357
+#: cp/module.cc:20377
 #, gcc-internal-format
 msgid "%<#undef %E%>"
 msgstr ""
 
-#: cp/module.cc:20359
+#: cp/module.cc:20379
 #, gcc-internal-format
 msgid "%<#define %s%>"
 msgstr ""
 
-#: cp/module.cc:20693
+#: cp/module.cc:20713
 #, fuzzy, gcc-internal-format
 msgid "compiled module file is %qs"
 msgstr "無法刪除模組檔案『%s』：%s"
 
-#: cp/module.cc:20733 cp/module.cc:20738
+#: cp/module.cc:20753 cp/module.cc:20758
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiled module is %sversion %s"
 msgstr "collect2 版本 %s\n"
 
-#: cp/module.cc:20744
+#: cp/module.cc:20764
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "collect2 version %s\n"
 msgid "compiler is %sversion %s%s%s"
 msgstr "collect2 版本 %s\n"
 
-#: cp/module.cc:20774
+#: cp/module.cc:20794
 #, fuzzy, gcc-internal-format
 msgid "module %qs found"
 msgstr "找不到任何 %qs getter"
 
-#: cp/module.cc:20776
+#: cp/module.cc:20796
 #, gcc-internal-format
 msgid "header module expected, module %qs found"
 msgstr ""
 
-#: cp/module.cc:20777
+#: cp/module.cc:20797
 #, gcc-internal-format
 msgid "module %qs expected, header module found"
 msgstr ""
 
-#: cp/module.cc:20794
+#: cp/module.cc:20814
 #, gcc-internal-format
 msgid "module %qs CRC mismatch"
 msgstr ""
 
-#: cp/module.cc:20808
+#: cp/module.cc:20828
 #, gcc-internal-format
 msgid "target & host is %qs:%qs, expected %qs:%qs"
 msgstr ""
 
-#: cp/module.cc:20821
+#: cp/module.cc:20841
 #, gcc-internal-format
 msgid "language dialect differs %qs, expected %qs"
 msgstr ""
 
-#: cp/module.cc:20841
+#: cp/module.cc:20861
 #, fuzzy, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> to enable"
 msgstr "異常處理已停用，使用 -fexceptions 以啟用"
 
-#: cp/module.cc:20843
+#: cp/module.cc:20863
 #, gcc-internal-format
 msgid "module contains OpenMP, use %<-fopenmp%> or %<-fopenmp-simd%> to enable"
 msgstr ""
 
-#: cp/module.cc:20846
+#: cp/module.cc:20866
 #, fuzzy, gcc-internal-format
 msgid "module contains OpenACC, use %<-fopenacc%> to enable"
 msgstr "Coarrays 已停用於 %C, 使用 -fcoarray=以啟用"
 
-#: cp/module.cc:20864
+#: cp/module.cc:20884
 #, fuzzy, gcc-internal-format
 msgid "fixed tree mismatch"
 msgstr "最佳化等級屬性不匹配"
 
-#: cp/module.cc:20956
+#: cp/module.cc:20976
 #, fuzzy, gcc-internal-format
 #| msgid "stack limit expression is not supported"
 msgid "interface partition is not exported"
 msgstr "不支援堆疊限制運算式"
 
-#: cp/module.cc:21531
+#: cp/module.cc:21551
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module cluster %u: %s"
 msgstr "重新命名 %s 到狀態檔案 %s 時失敗 [%s]"
 
-#: cp/module.cc:21570
+#: cp/module.cc:21590
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to read compiled module: %s"
 msgstr "開啟 %s 時失敗"
 
-#: cp/module.cc:21580
+#: cp/module.cc:21600
 #, gcc-internal-format
 msgid "consider using %<-fno-module-lazy%>, increasing %<-param-lazy-modules=%u%> value, or increasing the per-process file descriptor limit"
 msgstr ""
 
-#: cp/module.cc:21585
+#: cp/module.cc:21605
 #, gcc-internal-format
 msgid "imports must be built before being imported"
 msgstr ""
 
-#: cp/module.cc:21588
+#: cp/module.cc:21608
 #, gcc-internal-format
 msgid "returning to the gate for a mechanical issue"
 msgstr ""
 
-#: cp/module.cc:21940
+#: cp/module.cc:21960
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration %q#D"
 msgid "declaring %qD in module %qs conflicts with builtin in global module"
 msgstr "與內建宣告 %q#D 衝突"
 
-#: cp/module.cc:21943
+#: cp/module.cc:21963
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with built-in declaration %q#D"
 msgid "declaration %qD conflicts with builtin"
 msgstr "與內建宣告 %q#D 衝突"
 
-#: cp/module.cc:21949
+#: cp/module.cc:21969
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of namespace %qD conflicts with"
 msgid "redeclaring %qD in module %qs conflicts with import"
 msgstr "命名空間 %qD 的宣告存在衝突，與"
 
-#: cp/module.cc:21952
+#: cp/module.cc:21972
 #, gcc-internal-format
 msgid "redeclaring %qD in global module conflicts with import"
 msgstr ""
 
-#: cp/module.cc:21957
+#: cp/module.cc:21977
 #, gcc-internal-format
 msgid "import declared attached to module %qs"
 msgstr ""
 
-#: cp/module.cc:21961
+#: cp/module.cc:21981
 #, gcc-internal-format
 msgid "import declared in global module"
 msgstr ""
 
-#: cp/module.cc:21967
+#: cp/module.cc:21987
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of template %q#D"
 msgid "conflicting declaration of %qD in module %qs"
 msgstr "範本宣告 %q#D"
 
-#: cp/module.cc:21970
+#: cp/module.cc:21990
 #, fuzzy, gcc-internal-format
 #| msgid "conflicts with new declaration with %qL linkage"
 msgid "conflicting declaration of %qD in global module"
 msgstr "與帶有 %qL 連結的新宣告衝突"
 
-#: cp/module.cc:21975
+#: cp/module.cc:21995
 #, fuzzy, gcc-internal-format
 msgid "previously declared in module %qs"
 msgstr "在之前宣告的在此"
 
-#: cp/module.cc:21979
+#: cp/module.cc:21999
 #, fuzzy, gcc-internal-format
 msgid "previously declared in global module"
 msgstr "在之前宣告的在此"
 
-#: cp/module.cc:22118
+#: cp/module.cc:22144
 #, gcc-internal-format
 msgid "external linkage definition of %qD in header module must be declared %<inline%>"
 msgstr ""
 
-#: cp/module.cc:22133
+#: cp/module.cc:22159
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD not in a namespace surrounding %qD"
 msgid "exporting declaration %qD declared in unnamed namespace"
 msgstr "%qD 的宣告不在包含 %qD 的命名空間中"
 
-#: cp/module.cc:22140
+#: cp/module.cc:22166
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting declaration %qD with internal linkage"
 msgstr "%q+D 重宣告為沒有外部連結"
 
-#: cp/module.cc:22403
+#: cp/module.cc:22429
 #, fuzzy, gcc-internal-format
 #| msgid "creating %s"
 msgid "reading CMI %qs"
 msgstr "建立 %s"
 
-#: cp/module.cc:22590
+#: cp/module.cc:22616
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22591
+#: cp/module.cc:22617
 #, gcc-internal-format
 msgid "failed to load binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22598
+#: cp/module.cc:22624
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22599
+#: cp/module.cc:22625
 #, gcc-internal-format
 msgid "during load of binding %<%E%s%E@%s%>"
 msgstr ""
 
-#: cp/module.cc:22661
+#: cp/module.cc:22687
 #, gcc-internal-format
 msgid "failed to load pendings for %<%E%s%E%>"
 msgstr ""
 
-#: cp/module.cc:22665
+#: cp/module.cc:22691
 #, fuzzy, gcc-internal-format
 msgid "during load of pendings for %<%E%s%E%>"
 msgstr "不明選項用於 -mrecip=%s"
 
-#: cp/module.cc:22713
+#: cp/module.cc:22739
 #, fuzzy, gcc-internal-format
 #| msgid "method definition not in @implementation context"
 msgid "import of %qs within its own implementation unit"
 msgstr "方法定義不在 @implementation 上下文中"
 
-#: cp/module.cc:22715
+#: cp/module.cc:22741
 #, fuzzy, gcc-internal-format
 msgid "module declared here"
 msgstr "宣告的在此"
@@ -67144,111 +67220,111 @@ msgstr "宣告的在此"
 #. module, so we don't want to confuse things by having to think
 #. about whether 'extern "C++" { import foo; }' puts foo's
 #. contents into the global module all of a sudden.
-#: cp/module.cc:22730
+#: cp/module.cc:22756
 #, gcc-internal-format
 msgid "import of named module %qs inside language-linkage block"
 msgstr ""
 
-#: cp/module.cc:22761 cp/module.cc:23299
+#: cp/module.cc:22787 cp/module.cc:23334
 #, fuzzy, gcc-internal-format
 msgid "module already declared"
 msgstr "符號『%s』已經宣告"
 
-#: cp/module.cc:22762 cp/module.cc:23300
+#: cp/module.cc:22788 cp/module.cc:23335
 #, fuzzy, gcc-internal-format
 msgid "module already imported"
 msgstr "符號『%s』已經宣告"
 
-#: cp/module.cc:22767
+#: cp/module.cc:22793
 #, fuzzy, gcc-internal-format
 msgid "module %qs imported here"
 msgstr "%qD 宣告的在此"
 
-#: cp/module.cc:22975
+#: cp/module.cc:23001
 #, gcc-internal-format
 msgid "mismatching compiled module interface: had %qs, got %qs"
 msgstr ""
 
-#: cp/module.cc:22981
+#: cp/module.cc:23007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unknown compiled module interface: %s"
 msgstr "不明標點符號『%c』"
 
-#: cp/module.cc:23085
+#: cp/module.cc:23111
 #, gcc-internal-format
 msgid "cannot determine %<#include%> translation of %s: %s"
 msgstr ""
 
-#: cp/module.cc:23125
+#: cp/module.cc:23160
 #, gcc-internal-format
 msgid "include %qs translated to import"
 msgstr ""
 
-#: cp/module.cc:23127
+#: cp/module.cc:23162
 #, gcc-internal-format
 msgid "import of %qs failed, falling back to include"
 msgstr ""
 
-#: cp/module.cc:23128
+#: cp/module.cc:23163
 #, gcc-internal-format
 msgid "include %qs processed textually"
 msgstr ""
 
-#: cp/module.cc:23507
+#: cp/module.cc:23542
 #, gcc-internal-format
 msgid "C++ modules are incompatible with precompiled headers"
 msgstr ""
 
-#: cp/module.cc:23511
+#: cp/module.cc:23546
 #, fuzzy, gcc-internal-format
 #| msgid "Enable traditional preprocessing"
 msgid "C++ modules are incompatible with traditional preprocessing"
 msgstr "啟用傳統預先處理"
 
-#: cp/module.cc:23543 cp/module.cc:23572
+#: cp/module.cc:23578 cp/module.cc:23607
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param value %qs"
 msgid "invalid header name %qs"
 msgstr "無效的 --param 值 %qs"
 
-#: cp/module.cc:23582
+#: cp/module.cc:23617
 #, fuzzy, gcc-internal-format
 #| msgid "invalid --param value %qs"
 msgid "invalid module name %qs"
 msgstr "無效的 --param 值 %qs"
 
-#: cp/module.cc:23782
+#: cp/module.cc:23817
 #, gcc-internal-format
 msgid "%<-fmodule-only%> used for non-interface"
 msgstr ""
 
-#: cp/module.cc:23822
+#: cp/module.cc:23857
 #, fuzzy, gcc-internal-format
 #| msgid "error writing %qs"
 msgid "writing CMI %qs"
 msgstr "寫入 %qs 時錯誤"
 
-#: cp/module.cc:23837
+#: cp/module.cc:23872
 #, gcc-internal-format
 msgid "not writing module %qs due to errors in template bodies"
 msgstr ""
 
-#: cp/module.cc:23840
+#: cp/module.cc:23875
 #, gcc-internal-format
 msgid "enable %<-Wtemplate-body%> for more details"
 msgstr ""
 
-#: cp/module.cc:23842
+#: cp/module.cc:23877
 #, fuzzy, gcc-internal-format
 msgid "first error in %qD appeared here"
 msgstr "%qD 宣告的在此"
 
-#: cp/module.cc:23906
+#: cp/module.cc:23941
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "failed to write compiled module: %s"
 msgstr "寫入狀態結尾時失敗 [%s]"
 
-#: cp/module.cc:24003
+#: cp/module.cc:24038
 #, fuzzy, gcc-internal-format
 msgid "unknown header kind %qs"
 msgstr "不明 spec 函式 %qs"
@@ -67264,7 +67340,7 @@ msgstr ""
 msgid "ignoring %qD declared here with internal linkage"
 msgstr "函式 %q+D 重宣告為帶有不可內聯屬性"
 
-#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4069 cp/name-lookup.cc:4169
+#: cp/name-lookup.cc:2949 cp/name-lookup.cc:4085 cp/name-lookup.cc:4185
 #, fuzzy, gcc-internal-format
 msgid "name-independent declarations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
@@ -67314,274 +67390,284 @@ msgstr "%q#D 的宣告隱藏了一個參數"
 msgid "declaration of %qD shadows a member of %qT"
 msgstr "%qD 宣告為 %qT 的一個成員"
 
-#: cp/name-lookup.cc:4154
+#: cp/name-lookup.cc:3698
+#, gcc-internal-format
+msgid "annotation applied to block scope extern %qD"
+msgstr ""
+
+#: cp/name-lookup.cc:3705
+#, fuzzy, gcc-internal-format
+msgid "annotation applied to parameter %qD of block scope extern"
+msgstr "宣告用於參數 %qD 但是沒有此類參數"
+
+#: cp/name-lookup.cc:4170
 #, fuzzy, gcc-internal-format
 msgid "friend declaration %qD in local class without prior local declaration"
 msgstr "朋友宣告 %qD 在中區域類別而無需事前宣告"
 
-#: cp/name-lookup.cc:4881
+#: cp/name-lookup.cc:4897
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s(%E) %p %d\n"
 msgid "%s %<%s(%E)%> %p %d"
 msgstr "%s %s(%E) %p %d\n"
 
-#: cp/name-lookup.cc:4884
+#: cp/name-lookup.cc:4900
 #, fuzzy, gcc-internal-format
 #| msgid "%s %s %p %d\n"
 msgid "%s %s %p %d"
 msgstr "%s %s %p %d\n"
 
-#: cp/name-lookup.cc:5483
+#: cp/name-lookup.cc:5515 cp/name-lookup.cc:5519
 #, fuzzy, gcc-internal-format
 msgid "exporting %q#D that does not have external linkage"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/name-lookup.cc:5487
+#: cp/name-lookup.cc:5525
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with no linkage"
 msgstr "%q+#D 宣告的在此"
 
-#: cp/name-lookup.cc:5490
+#: cp/name-lookup.cc:5528
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with internal linkage"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: cp/name-lookup.cc:5493
+#: cp/name-lookup.cc:5531
 #, fuzzy, gcc-internal-format
 msgid "%q#D declared here with module linkage"
 msgstr "%q+#D 宣告的在此"
 
-#: cp/name-lookup.cc:6307
+#: cp/name-lookup.cc:6347
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> names destructor"
 msgid "%<%T%s%D%> names destructor"
 msgstr "%<%T::%D%> 指定了解構函式"
 
-#: cp/name-lookup.cc:6323
+#: cp/name-lookup.cc:6363
 #, gcc-internal-format
 msgid "using-declaration for non-member at class scope"
 msgstr "在類別作用欄位使用非成員的 using 宣告"
 
-#: cp/name-lookup.cc:6331
+#: cp/name-lookup.cc:6371
 #, fuzzy, gcc-internal-format
 msgid "%<using%> with enumeration scope %q#T only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/name-lookup.cc:6347 cp/pt.cc:19528
+#: cp/name-lookup.cc:6387 cp/pt.cc:19669
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a class, namespace, or enumeration"
 msgstr "%qE 並非類別、命名空間，或列舉類型"
 
-#: cp/name-lookup.cc:6357
+#: cp/name-lookup.cc:6397
 #, fuzzy, gcc-internal-format
 #| msgid "template declaration of %q#D"
 msgid "non-member using-declaration names constructor of %qT"
 msgstr "%q#D 宣告為範本"
 
-#: cp/name-lookup.cc:6368 cp/name-lookup.cc:6441
+#: cp/name-lookup.cc:6408 cp/name-lookup.cc:6481
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "using-declaration for member at non-class scope"
 msgstr "在類別作用欄位使用非成員的 using 宣告"
 
-#: cp/name-lookup.cc:6391
+#: cp/name-lookup.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "type %qT is not a direct base of %qT"
 msgid "%qT is not a direct base of %qT"
 msgstr "類型 %qT 不是 %qT 的直接基礎類別"
 
-#: cp/name-lookup.cc:6451
+#: cp/name-lookup.cc:6491
 #, gcc-internal-format
 msgid "did you mean %<using enum %T::%D%>?"
 msgstr ""
 
-#: cp/name-lookup.cc:6463
+#: cp/name-lookup.cc:6503
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared in %qD"
 msgstr "%qD 未被宣告在中 %qD"
 
-#: cp/name-lookup.cc:6479
+#: cp/name-lookup.cc:6519
 #, fuzzy, gcc-internal-format
 #| msgid "declaration of %qD not in a namespace surrounding %qD"
 msgid "using-declaration may not name namespace %qD"
 msgstr "%qD 的宣告不在包含 %qD 的命名空間中"
 
-#: cp/name-lookup.cc:6490
+#: cp/name-lookup.cc:6530
 #, gcc-internal-format
 msgid "%<%T::%D%> names constructor in %qT"
 msgstr "%<%T::%D%> 在 %qT 內指定了建構式"
 
-#: cp/name-lookup.cc:6583
+#: cp/name-lookup.cc:6623
 #, gcc-internal-format
 msgid "declaration of %qD not in a namespace surrounding %qD"
 msgstr "%qD 的宣告不在包含 %qD 的命名空間中"
 
-#: cp/name-lookup.cc:6625
+#: cp/name-lookup.cc:6665
 #, gcc-internal-format
 msgid "explicit qualification in declaration of %qD"
 msgstr "%qD 的宣告中有明確的限定"
 
-#: cp/name-lookup.cc:6635
+#: cp/name-lookup.cc:6675
 #, gcc-internal-format
 msgid "%qD should have been declared inside %qD"
 msgstr "%qD 應當已在 %qD 內部宣告過"
 
-#: cp/name-lookup.cc:6705
+#: cp/name-lookup.cc:6745
 #, fuzzy, gcc-internal-format
 msgid "%qD has not been declared within %qD"
 msgstr "%qD 未被宣告在中 %qD"
 
-#: cp/name-lookup.cc:6707
+#: cp/name-lookup.cc:6747
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared as a friend"
 msgid "only here as a %<friend%>"
 msgstr "%q+D 宣告為夥伴"
 
-#: cp/name-lookup.cc:6762
+#: cp/name-lookup.cc:6802
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute requires a single NTBS argument"
 msgstr "%qD 屬性需要單一 NTBS 引數"
 
-#: cp/name-lookup.cc:6769
+#: cp/name-lookup.cc:6809
 #, fuzzy, gcc-internal-format
 msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
 msgstr "%qD 屬性是無意義的自從成員的匿名命名空間提取本機符號"
 
-#: cp/name-lookup.cc:6780 cp/name-lookup.cc:6808
+#: cp/name-lookup.cc:6820 cp/name-lookup.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on anonymous namespace"
 msgstr "忽略屬性於模板引數 %qT"
 
-#: cp/name-lookup.cc:6786
+#: cp/name-lookup.cc:6826
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qD attribute on non-inline namespace"
 msgstr "忽略屬性於模板引數 %qT"
 
-#: cp/name-lookup.cc:6833 cp/name-lookup.cc:9322
+#: cp/name-lookup.cc:6873 cp/name-lookup.cc:9362
 #, gcc-internal-format
 msgid "%qD attribute directive ignored"
 msgstr "指定 %qD 屬性被忽略"
 
-#: cp/name-lookup.cc:7163
+#: cp/name-lookup.cc:7203
 #, fuzzy, gcc-internal-format
 msgid "maximum limit of %d namespaces searched for %qE"
 msgstr "最大值限制的 %d 命名空間搜尋的用於 %qE"
 
-#: cp/name-lookup.cc:7215
+#: cp/name-lookup.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "suggested alternative:"
 msgid_plural "suggested alternatives:"
 msgstr[0] "建議的替代方案："
 
-#: cp/name-lookup.cc:7221
+#: cp/name-lookup.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "  %qE"
 msgstr "  %qE"
 
-#: cp/name-lookup.cc:7551
+#: cp/name-lookup.cc:7591
 #, gcc-internal-format
 msgid "%<std::%s%> is defined in header %qs; this is probably fixable by adding %<#include %s%>"
 msgstr ""
 
-#: cp/name-lookup.cc:7557
+#: cp/name-lookup.cc:7597
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> is unavailable for static member functions"
 msgid "%<std::%s%> is only available from %s onwards"
 msgstr "靜態成員函式中不能使用 %<this%>"
 
-#: cp/name-lookup.cc:7997
+#: cp/name-lookup.cc:8037
 #, fuzzy, gcc-internal-format
 msgid "the macro %qs had not yet been defined"
 msgstr "weak %q+D 無法定義 %qE"
 
-#: cp/name-lookup.cc:8000
+#: cp/name-lookup.cc:8040
 #, fuzzy, gcc-internal-format
 msgid "it was later defined here"
 msgstr "結構定義的在此"
 
-#: cp/name-lookup.cc:8815
+#: cp/name-lookup.cc:8855
 #, gcc-internal-format
 msgid "declaration of %<std::initializer_list%> does not match %<#include <initializer_list>%>, isn%'t a template"
 msgstr ""
 
-#: cp/name-lookup.cc:9292
+#: cp/name-lookup.cc:9332
 #, fuzzy, gcc-internal-format
 #| msgid "switch %qs is no longer supported"
 msgid "%<strong%> using directive no longer supported"
 msgstr "開關 %qs 不再被支援"
 
-#: cp/name-lookup.cc:9295
+#: cp/name-lookup.cc:9335
 #, gcc-internal-format
 msgid "you can use an inline namespace instead"
 msgstr ""
 
-#: cp/name-lookup.cc:9314
+#: cp/name-lookup.cc:9354
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<omp::%E%> not allowed to be specified in this context"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: cp/name-lookup.cc:9320
+#: cp/name-lookup.cc:9360
 #, fuzzy, gcc-internal-format
 msgid "annotation on using directive"
 msgstr "屬性忽略的於 uninstantiated 型態"
 
 #. We only allow depth 255.
-#: cp/name-lookup.cc:9408
+#: cp/name-lookup.cc:9448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "cannot nest more than %d namespaces"
 msgstr "%qD 不能在命名空間宣告"
 
-#: cp/name-lookup.cc:9533
+#: cp/name-lookup.cc:9573
 #, fuzzy, gcc-internal-format
 msgid "%<namespace %E%> is ambiguous"
 msgstr "『%s』於 %L 是模稜兩可的"
 
-#: cp/name-lookup.cc:9549
+#: cp/name-lookup.cc:9589
 #, gcc-internal-format
 msgid "namespace alias %qD not allowed here, assuming %qD"
 msgstr "這裡不允許命名空間別名 %qD，假定為 %qD"
 
-#: cp/name-lookup.cc:9619
+#: cp/name-lookup.cc:9659
 #, fuzzy, gcc-internal-format
 #| msgid "redeclaration of %q+D with no linkage"
 msgid "exporting namespace %qD with internal linkage"
 msgstr "%q+D 重宣告為沒有外部連結"
 
-#: cp/name-lookup.cc:9621
+#: cp/name-lookup.cc:9661
 #, fuzzy, gcc-internal-format
 #| msgid "%qD may not be declared within a namespace"
 msgid "%qD has internal linkage because it was declared in an unnamed namespace"
 msgstr "%qD 不能在命名空間宣告"
 
-#: cp/name-lookup.cc:9625
+#: cp/name-lookup.cc:9665
 #, fuzzy, gcc-internal-format
 msgid "exporting unnamed namespace"
 msgstr "預期 %<namespace%>"
 
-#: cp/name-lookup.cc:9635
+#: cp/name-lookup.cc:9675
 #, fuzzy, gcc-internal-format
 msgid "inline namespace must be specified at initial definition"
 msgstr "方法屬性必須被指定的於結束只有"
 
-#: cp/name-lookup.cc:9685
+#: cp/name-lookup.cc:9725
 #, fuzzy, gcc-internal-format
 msgid "%s namespace %qD conflicts with reachable definition"
 msgstr "%qD 衝突與使用的函式"
 
-#: cp/name-lookup.cc:9687
+#: cp/name-lookup.cc:9727
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "reachable %s definition here"
 msgstr "前一個定義在此"
 
-#: cp/name-lookup.cc:9730
+#: cp/name-lookup.cc:9770
 #, fuzzy, gcc-internal-format
 #| msgid "XXX entering pop_everything ()\n"
 msgid "XXX entering %<pop_everything ()%>"
 msgstr "XXX 進入 pop_everything ()\n"
 
-#: cp/name-lookup.cc:9739
+#: cp/name-lookup.cc:9779
 #, fuzzy, gcc-internal-format
 #| msgid "XXX leaving pop_everything ()\n"
 msgid "XXX leaving %<pop_everything ()%>"
@@ -67612,7 +67698,7 @@ msgstr "識別碼 %qE 是關鍵字在中 C++11"
 msgid "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true"
 msgstr ""
 
-#: cp/parser.cc:1784 cp/parser.cc:52812
+#: cp/parser.cc:1784 cp/parser.cc:52872
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
@@ -67659,7 +67745,7 @@ msgstr "%<::%E%>未被宣告"
 msgid "request for member %qE in non-class type %qT"
 msgstr "要求用於成員 %qE 在中 non-class 型態 %qT"
 
-#: cp/parser.cc:3594 cp/parser.cc:23969
+#: cp/parser.cc:3594 cp/parser.cc:24033
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> has not been declared"
 msgstr "%<%T::%E%>未被宣告"
@@ -67730,7 +67816,7 @@ msgstr "(%qT 的定義末尾可能缺少一個分號)"
 msgid "%qE is not a class template"
 msgstr "%qE 不是一個範本"
 
-#: cp/parser.cc:3763 cp/parser.cc:21305
+#: cp/parser.cc:3763 cp/parser.cc:21369
 #, gcc-internal-format
 msgid "%qE is not a template"
 msgstr "%qE 不是一個範本"
@@ -68047,1740 +68133,1750 @@ msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 msgid "pack index missing"
 msgstr ""
 
-#: cp/parser.cc:6151 cp/parser.cc:10115
+#: cp/parser.cc:6156 cp/parser.cc:10098
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available with %<-freflection%>"
 msgstr "此多媒體函式只在 fr500 上可用"
 
-#: cp/parser.cc:6261
+#: cp/parser.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type"
 msgstr "預期的函式"
 
-#: cp/parser.cc:6341
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
-msgid "expected a reflection of a function template"
-msgstr "%qD 不是一個函式範本"
-
-#: cp/parser.cc:6439
+#: cp/parser.cc:6422
 #, gcc-internal-format
 msgid "extra %<template%> in a scope splice"
 msgstr ""
 
-#: cp/parser.cc:6448
+#: cp/parser.cc:6431
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "missing %<template%> in a scope splice with template arguments"
 msgstr "非範本 %qD 做為範本"
 
-#: cp/parser.cc:6450
+#: cp/parser.cc:6433
 #, gcc-internal-format
 msgid "%<template%> may only be omitted when the scope splice is preceded by %<typename%>"
 msgstr ""
 
-#: cp/parser.cc:6463
+#: cp/parser.cc:6446
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a class, namespace, or enumeration"
 msgstr "%qE 並非類別、命名空間，或列舉類型"
 
-#: cp/parser.cc:6624
+#: cp/parser.cc:6607
 #, fuzzy, gcc-internal-format
 msgid "fixed-point types not supported in C++"
 msgstr "定點類型不支援在中 C++"
 
-#: cp/parser.cc:6714
+#: cp/parser.cc:6697
 #, gcc-internal-format
 msgid "ISO C++ forbids braced-groups within expressions"
 msgstr "ISO C++ 不允許在運算式中使用大括號組"
 
-#: cp/parser.cc:6726
+#: cp/parser.cc:6709
 #, fuzzy, gcc-internal-format
 msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
 msgstr "statement-expressions 未被允許外側函式 nor 在中 template-argument 清單"
 
-#: cp/parser.cc:6766
+#: cp/parser.cc:6749
 #, fuzzy, gcc-internal-format
 msgid "fold-expressions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "lambda 運算式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:6832 cp/parser.cc:7003 cp/parser.cc:7202 cp/semantics.cc:4857
+#: cp/parser.cc:6815 cp/parser.cc:6986 cp/parser.cc:7185 cp/semantics.cc:4878
 #, fuzzy, gcc-internal-format
 msgid "expected primary-expression"
 msgstr "預期 primary-expression"
 
-#: cp/parser.cc:6865
+#: cp/parser.cc:6848
 #, gcc-internal-format
 msgid "%<this%> may not be used in this context"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: cp/parser.cc:6987
+#: cp/parser.cc:6970
 #, fuzzy, gcc-internal-format
 msgid "a template declaration cannot appear at block scope"
 msgstr "模板宣告無法出現於區塊範圍"
 
-#: cp/parser.cc:7147
+#: cp/parser.cc:7130
 #, fuzzy, gcc-internal-format
 #| msgid "local variable %qD may not appear in this context"
 msgid "parameter %qD may not appear in this context"
 msgstr "局部變數 %qD 不應出現在此上下文中"
 
-#: cp/parser.cc:7148
+#: cp/parser.cc:7131
 #, gcc-internal-format
 msgid "local variable %qD may not appear in this context"
 msgstr "局部變數 %qD 不應出現在此上下文中"
 
-#: cp/parser.cc:7194
+#: cp/parser.cc:7177
 #, fuzzy, gcc-internal-format
 #| msgid "this media function is only available on the fr500"
 msgid "reflection is only available in C++26 with %<-freflection%>"
 msgstr "此多媒體函式只在 fr500 上可用"
 
-#: cp/parser.cc:7231
+#: cp/parser.cc:7214
 #, gcc-internal-format
 msgid "expected %qs keyword before dependent template name"
 msgstr ""
 
-#: cp/parser.cc:7375
+#: cp/parser.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression"
 msgstr "預期 id-expression"
 
-#: cp/parser.cc:7540
+#: cp/parser.cc:7523
 #, fuzzy, gcc-internal-format
 msgid "scope %qT before %<~%> is not a class-name"
 msgstr "範圍 %qT 之前 %<~%>並非 class-name"
 
-#: cp/parser.cc:7550
+#: cp/parser.cc:7533
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<template%> keyword not permitted in destructor name"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: cp/parser.cc:7587 cp/parser.cc:9966
+#: cp/parser.cc:7570 cp/parser.cc:9949
 #, fuzzy, gcc-internal-format
 msgid "%<~auto%> only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "C++0x 自動只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:7601 cp/parser.cc:7605
+#: cp/parser.cc:7584 cp/parser.cc:7588
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "template-id not allowed for destructor in C++20"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/parser.cc:7607 cp/parser.cc:35946
+#: cp/parser.cc:7590 cp/parser.cc:36006
 #, gcc-internal-format
 msgid "remove the %qs"
 msgstr ""
 
-#: cp/parser.cc:7729
+#: cp/parser.cc:7712
 #, gcc-internal-format
 msgid "declaration of %<~%T%> as member of %qT"
 msgstr "%<~%T%> 宣告為 %qT 的一個成員"
 
-#: cp/parser.cc:7744
+#: cp/parser.cc:7727
 #, gcc-internal-format
 msgid "typedef-name %qD used as destructor declarator"
 msgstr "typedef 名 %qD 用於解構函式宣告"
 
-#: cp/parser.cc:7787 cp/parser.cc:26949
+#: cp/parser.cc:7770 cp/parser.cc:27013
 #, fuzzy, gcc-internal-format
 msgid "expected unqualified-id"
 msgstr "預期 unqualified-id"
 
-#: cp/parser.cc:7814 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
+#: cp/parser.cc:7797 cp/typeck.cc:3304 cp/typeck.cc:3307 cp/typeck.cc:3324
 #, gcc-internal-format
 msgid "%qD is not a template"
 msgstr "%qD 不是一個範本"
 
-#: cp/parser.cc:7939
+#: cp/parser.cc:7922
 #, fuzzy, gcc-internal-format
 msgid "found %<:%> in nested-name-specifier, expected %<::%>"
 msgstr "找到 %<:%>在中 nested-name-specifier，預期 %<::%>"
 
-#: cp/parser.cc:8027
+#: cp/parser.cc:8010
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> evaluates to %qT, which is not a class or enumeration type"
 msgstr "decltype 評估到 %qT，該項並非類別或列舉類型型態"
 
-#: cp/parser.cc:8054
+#: cp/parser.cc:8037
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "function template-id %qD in nested-name-specifier"
 msgstr "巢狀名指定中使用了不完全的類型 %qT"
 
-#: cp/parser.cc:8061
+#: cp/parser.cc:8044
 #, fuzzy, gcc-internal-format
 #| msgid "incomplete type %qT used in nested name specifier"
 msgid "concept-id %qD in nested-name-specifier"
 msgstr "巢狀名指定中使用了不完全的類型 %qT"
 
-#: cp/parser.cc:8067
+#: cp/parser.cc:8050
 #, fuzzy, gcc-internal-format
 msgid "variable template-id %qD in nested-name-specifier"
 msgstr "預期 nested-name-specifier"
 
-#: cp/parser.cc:8242
+#: cp/parser.cc:8225
 #, fuzzy, gcc-internal-format
 msgid "expected nested-name-specifier"
 msgstr "預期 nested-name-specifier"
 
-#: cp/parser.cc:8473 cp/parser.cc:11405
+#: cp/parser.cc:8456 cp/parser.cc:11399
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in casts"
 msgstr "類型可能無法被定義在中演員陣容"
 
-#: cp/parser.cc:8561
+#: cp/parser.cc:8544
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a %<typeid%> expression"
 msgstr "類型可能無法被定義在中 %<typeid%> 運算式"
 
-#: cp/parser.cc:8661
+#: cp/parser.cc:8644
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_addressof%>"
 msgstr "錯誤的引數數量到 %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8673 cp/pt.cc:22263
+#: cp/parser.cc:8656 cp/pt.cc:22411
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_launder%>"
 msgstr "錯誤的引數數量到 %<__builtin_complex%>"
 
-#: cp/parser.cc:8686
+#: cp/parser.cc:8669
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_assoc_barrier%>"
 msgstr "錯誤的引數數量到 %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8712
+#: cp/parser.cc:8695
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_shufflevector%>"
 msgstr "錯誤的引數數量到 %<__builtin_shuffle%>"
 
-#: cp/parser.cc:8740 cp/pt.cc:22378
+#: cp/parser.cc:8723 cp/pt.cc:22526
 #, gcc-internal-format
 msgid "call to %<__builtin_operator_new%> does not select replaceable global allocation function"
 msgstr ""
 
-#: cp/parser.cc:8744 cp/pt.cc:22382
+#: cp/parser.cc:8727 cp/pt.cc:22530
 #, fuzzy, gcc-internal-format
 #| msgid "destructor cannot be static member function"
 msgid "call to %<__builtin_operator_delete%> does not select replaceable global deallocation function"
 msgstr "解構函式不能是靜態成員函式"
 
-#: cp/parser.cc:8749 cp/pt.cc:22387
+#: cp/parser.cc:8732 cp/pt.cc:22535
 #, fuzzy, gcc-internal-format
 msgid "selected function declared here"
 msgstr "間接函式 %q+D 無法宣告的 weakref"
 
-#: cp/parser.cc:8883
+#: cp/parser.cc:8866
 #, gcc-internal-format
 msgid "ISO C++ forbids compound-literals"
 msgstr "ISO C++ 不允許複合字面值"
 
-#: cp/parser.cc:8942
+#: cp/parser.cc:8925
 #, gcc-internal-format
 msgid "two consecutive %<[%> shall only introduce an attribute"
 msgstr ""
 
-#: cp/parser.cc:8993
+#: cp/parser.cc:8976
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<__builtin_classify_type%> calls"
 msgstr "類型可能無法被定義在中條件"
 
-#: cp/parser.cc:9391 cp/parser.cc:9420
+#: cp/parser.cc:9374 cp/parser.cc:9403
 #, gcc-internal-format
 msgid "cannot use multidimensional subscript in OpenMP array section"
 msgstr ""
 
-#: cp/parser.cc:9706 cp/typeck.cc:3192
+#: cp/parser.cc:9689 cp/typeck.cc:3192
 #, gcc-internal-format
 msgid "invalid use of %qD"
 msgstr "錯誤地使用了 %qD"
 
-#: cp/parser.cc:9715
+#: cp/parser.cc:9698
 #, fuzzy, gcc-internal-format
 msgid "%<%D::%D%> is not a class member"
 msgstr "%<%D::%D%>並非類別成員"
 
-#: cp/parser.cc:10018
+#: cp/parser.cc:10001
 #, fuzzy, gcc-internal-format
 msgid "non-scalar type"
 msgstr "non-scalar 型態"
 
-#: cp/parser.cc:10076 cp/parser.cc:23417
+#: cp/parser.cc:10059 cp/parser.cc:23481
 #, fuzzy, gcc-internal-format
 msgid "%<template%> must follow a nested-name-specifier"
 msgstr "typedef 名稱可能無法是 nested-name-specifier"
 
+#: cp/parser.cc:10142
+#, fuzzy, gcc-internal-format
+#| msgid "new cannot be applied to a reference type"
+msgid "%<^^%> cannot be applied to a placeholder type"
+msgstr "new 不能用於參照類型"
+
 #. Oy vey, nothing worked.
-#: cp/parser.cc:10203
+#: cp/parser.cc:10197
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to this operand"
 msgstr "Shift 的 non-integer 運算元"
 
-#: cp/parser.cc:10291
+#: cp/parser.cc:10285
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<alignof%> with a non-type"
 msgstr "ISO C++不允許 %<alignof%> 與 non-type"
 
-#: cp/parser.cc:10394
+#: cp/parser.cc:10388
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<noexcept%> expressions"
 msgstr "類型可能無法被定義在中 %<noexcept%> 運算式"
 
-#: cp/parser.cc:10453
+#: cp/parser.cc:10447
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_await%> cannot be used in default arguments"
 msgstr "%qD 不能有預設參數"
 
-#: cp/parser.cc:10680 cp/parser.cc:37264
+#: cp/parser.cc:10674 cp/parser.cc:37324
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %qs expressions"
 msgstr "類型可能無法被定義在中 new-expression"
 
-#: cp/parser.cc:10745
+#: cp/parser.cc:10739
 #, fuzzy, gcc-internal-format
 msgid "%<__builtin_has_attribute%> with dependent argument not supported yet"
 msgstr "__builtin_eh_return 在此目標平臺上不受支援"
 
-#: cp/parser.cc:10831
+#: cp/parser.cc:10825
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-expression"
 msgstr "類型可能無法被定義在中 new-expression"
 
-#: cp/parser.cc:10849
+#: cp/parser.cc:10843
 #, gcc-internal-format
 msgid "array bound forbidden after parenthesized type-id"
 msgstr "括起的類型識別碼後面不能出現陣列邊界"
 
-#: cp/parser.cc:10851
+#: cp/parser.cc:10845
 #, gcc-internal-format
 msgid "try removing the parentheses around the type-id"
 msgstr "請嘗試刪除類型識別碼兩邊的括號"
 
-#: cp/parser.cc:10884
+#: cp/parser.cc:10878
 #, gcc-internal-format
 msgid "initialization of new-expression for type %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/parser.cc:10929
+#: cp/parser.cc:10923
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "expected expression-list or type-id"
 msgstr "需要運算式類型"
 
-#: cp/parser.cc:10958
+#: cp/parser.cc:10952
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a new-type-id"
 msgstr "類型可能無法被定義在中 new-type-id"
 
-#: cp/parser.cc:11006
+#: cp/parser.cc:11000
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on outermost array type in new expression"
 msgstr "屬性忽略的於模板具現化"
 
-#: cp/parser.cc:11102
+#: cp/parser.cc:11096
 #, gcc-internal-format
 msgid "expression in new-declarator must have integral or enumeration type"
 msgstr "new 宣告中的運算式必須具有整數或列舉類型"
 
-#: cp/parser.cc:11508
+#: cp/parser.cc:11502
 #, fuzzy, gcc-internal-format
 #| msgid "use of old-style cast"
 msgid "use of old-style cast to %q#T"
 msgstr "使用舊式的類型轉換"
 
-#: cp/parser.cc:11658
+#: cp/parser.cc:11652
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> operator is treated as two right angle brackets in C++11"
 msgstr "%<>>%>運算子被視為兩正確角度中括號在中 C++11"
 
-#: cp/parser.cc:11661
+#: cp/parser.cc:11655
 #, fuzzy, gcc-internal-format
 msgid "suggest parentheses around %<>>%> expression"
 msgstr "建議 parentheses 周圍 %<>>%>運算式"
 
-#: cp/parser.cc:11895
+#: cp/parser.cc:11889
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow %<?:%> with omitted middle operand"
 msgstr "ISO C++不允許 ?:與省略的中間運算元"
 
-#: cp/parser.cc:12233
+#: cp/parser.cc:12227
 #, gcc-internal-format
 msgid "top-level comma expression in array subscript is deprecated"
 msgstr ""
 
-#: cp/parser.cc:12508
+#: cp/parser.cc:12502
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<__builtin_offsetof%>"
 msgstr "類型可能無法被定義在中條件"
 
-#: cp/parser.cc:12642
+#: cp/parser.cc:12636
 #, gcc-internal-format
 msgid "trailing argument to %<__type_pack_element%> is not a type"
 msgstr ""
 
-#: cp/parser.cc:12743
+#: cp/parser.cc:12737
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in unevaluated context only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda 運算式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:12753
+#: cp/parser.cc:12747
 #, fuzzy, gcc-internal-format
 msgid "lambda-expression in template-argument only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "lambda 運算式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:12954
+#: cp/parser.cc:12948
 #, gcc-internal-format
 msgid "non-local lambda expression cannot have a capture-default"
 msgstr ""
 
-#: cp/parser.cc:12977
+#: cp/parser.cc:12971
 #, fuzzy, gcc-internal-format
 msgid "expected end of capture-list"
 msgstr "預期的結束的 capture-list"
 
-#: cp/parser.cc:12993
+#: cp/parser.cc:12987
 #, fuzzy, gcc-internal-format
 msgid "explicit by-copy capture of %<this%> with by-copy capture default only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:12999 cp/parser.cc:13021 cp/parser.cc:13219
+#: cp/parser.cc:12993 cp/parser.cc:13015 cp/parser.cc:13213
 #, fuzzy, gcc-internal-format
 msgid "already captured %qD in lambda expression"
 msgstr "已經擷取 %qD 在中 lambda 運算式"
 
-#: cp/parser.cc:13015
+#: cp/parser.cc:13009
 #, fuzzy, gcc-internal-format
 msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13035
+#: cp/parser.cc:13029
 #, fuzzy, gcc-internal-format
 msgid "%<this%> cannot be captured by reference"
 msgstr "無法擷取 %qE 由參考"
 
-#: cp/parser.cc:13055
+#: cp/parser.cc:13049
 #, fuzzy, gcc-internal-format
 msgid "pack init-capture only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13066
+#: cp/parser.cc:13060
 #, gcc-internal-format
 msgid "%<&%> should come before %<...%>"
 msgstr ""
 
-#: cp/parser.cc:13096
+#: cp/parser.cc:13090
 #, fuzzy, gcc-internal-format
 msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "lambda 運算式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13105
+#: cp/parser.cc:13099
 #, gcc-internal-format
 msgid "empty initializer for lambda init-capture"
 msgstr ""
 
-#: cp/parser.cc:13130
+#: cp/parser.cc:13124
 #, fuzzy, gcc-internal-format
 msgid "capture of non-variable %qE"
 msgstr "擷取的 non-variable %qD "
 
-#: cp/parser.cc:13141
+#: cp/parser.cc:13135
 #, fuzzy, gcc-internal-format
 msgid "capture of variable %qD with non-automatic storage duration"
 msgstr "擷取的變數 %qD 與 non-automatic 貯藏體持續時間"
 
-#: cp/parser.cc:13179
+#: cp/parser.cc:13173
 #, gcc-internal-format
 msgid "too many %<...%> in lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13190
+#: cp/parser.cc:13184
 #, fuzzy, gcc-internal-format
 msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
 msgstr "明確的 by-copy 擷取的 %qD 冗餘與 by-copy 擷取預設"
 
-#: cp/parser.cc:13195
+#: cp/parser.cc:13189
 #, fuzzy, gcc-internal-format
 msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
 msgstr "明確的 by-reference 擷取的 %qD 冗餘與 by-reference 擷取預設"
 
-#: cp/parser.cc:13287
+#: cp/parser.cc:13281
 #, fuzzy, gcc-internal-format
 msgid "lambda templates are only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13341
+#: cp/parser.cc:13335
 #, fuzzy, gcc-internal-format
 msgid "default argument specified for lambda parameter"
 msgstr "預設引數指定的用於 lambda 參數"
 
-#: cp/parser.cc:13376
+#: cp/parser.cc:13370
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda declaration specifiers only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13406 cp/pt.cc:15307
+#: cp/parser.cc:13400 cp/pt.cc:15428
 #, gcc-internal-format
 msgid "a lambda with captures may not have an explicit object parameter of an unrelated type"
 msgstr ""
 
-#: cp/parser.cc:13419
+#: cp/parser.cc:13413
 #, fuzzy, gcc-internal-format
 msgid "%<mutable%> lambda specifier with explicit object parameter"
 msgstr "預設引數指定的用於 lambda 參數"
 
-#: cp/parser.cc:13428
+#: cp/parser.cc:13422
 #, gcc-internal-format
 msgid "the passed in closure object will not be mutated because it is taken by value"
 msgstr ""
 
-#: cp/parser.cc:13432
+#: cp/parser.cc:13426
 #, gcc-internal-format
 msgid "declare the explicit object parameter as non-const reference instead"
 msgstr ""
 
-#: cp/parser.cc:13436
+#: cp/parser.cc:13430
 #, gcc-internal-format
 msgid "explicit object parameter is already a mutable reference"
 msgstr ""
 
-#: cp/parser.cc:13443
+#: cp/parser.cc:13437
 #, fuzzy, gcc-internal-format
 msgid "%<static%> lambda specifier with explicit object parameter"
 msgstr "預設引數指定的用於 lambda 參數"
 
-#: cp/parser.cc:13461
+#: cp/parser.cc:13455
 #, gcc-internal-format
 msgid "%<static%> lambda specifier with lambda capture"
 msgstr ""
 
-#: cp/parser.cc:13477
+#: cp/parser.cc:13471
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda transaction qualifier only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "進階初始設定式只列出可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13490
+#: cp/parser.cc:13484
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda exception specification only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13508
+#: cp/parser.cc:13502
 #, fuzzy, gcc-internal-format
 msgid "parameter declaration before lambda trailing return type only optional with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:13561
+#: cp/parser.cc:13555
 #, fuzzy, gcc-internal-format
 msgid "%<constexpr%> lambda only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:14364
+#: cp/parser.cc:13752
+#, gcc-internal-format
+msgid "%qE is not implicitly captured by a contract assertion"
+msgstr ""
+
+#: cp/parser.cc:13754
+#, fuzzy, gcc-internal-format
+msgid "%q#E declared here"
+msgstr "%qD 宣告的在此"
+
+#: cp/parser.cc:14379
 #, fuzzy, gcc-internal-format
 msgid "label at end of compound statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:14533 cp/parser.cc:14785
+#: cp/parser.cc:14548 cp/parser.cc:14800
 #, fuzzy, gcc-internal-format
 msgid "attributes at the beginning of statement are ignored"
 msgstr "括起的初始值設定後出現的屬性被忽略"
 
-#: cp/parser.cc:14604
+#: cp/parser.cc:14619
 #, fuzzy, gcc-internal-format
 msgid "expected labeled-statement"
 msgstr "預期 labeled-statement"
 
-#: cp/parser.cc:14653
+#: cp/parser.cc:14668
 #, gcc-internal-format
 msgid "case label %qE not within a switch statement"
 msgstr "case 標籤 %qE 未出現在 switch 敘述中"
 
-#: cp/parser.cc:14681
+#: cp/parser.cc:14696
 #, gcc-internal-format
 msgid "identifier label %qE in %<template for%> body"
 msgstr ""
 
-#: cp/parser.cc:14793
+#: cp/parser.cc:14808
 #, fuzzy, gcc-internal-format
 msgid "need %<typename%> before %qE because %qT is a dependent scope"
 msgstr "需要 %<typename%> 之前 %qE 因為 %qT 是附屬範圍"
 
 #. A::A a;
-#: cp/parser.cc:14799
+#: cp/parser.cc:14814
 #, fuzzy, gcc-internal-format
 msgid "%qE names the constructor, not the type"
 msgstr "%<%T::%E%>名稱建構子，不是型態"
 
-#: cp/parser.cc:14857
+#: cp/parser.cc:14872
 #, fuzzy, gcc-internal-format
 msgid "compound-statement in %<constexpr%> function"
 msgstr "複合陳述在中 constexpr 函式"
 
-#: cp/parser.cc:14921
+#: cp/parser.cc:14936
 #, gcc-internal-format
 msgid "inner loops must be perfectly nested with %<tile%> directive"
 msgstr ""
 
-#: cp/parser.cc:15126
+#: cp/parser.cc:15141
 #, fuzzy, gcc-internal-format
 msgid "%<if constexpr%> only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:15148
+#: cp/parser.cc:15163
 #, fuzzy, gcc-internal-format
 msgid "%<if consteval%> only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:15173 cp/parser.cc:15208
+#: cp/parser.cc:15188 cp/parser.cc:15223
 #, gcc-internal-format
 msgid "%<if consteval%> requires compound statement"
 msgstr ""
 
-#: cp/parser.cc:15250
+#: cp/parser.cc:15265
 #, fuzzy, gcc-internal-format
 msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "委派建構子只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:15418 cp/parser.cc:37776
+#: cp/parser.cc:15433 cp/parser.cc:37836
 #, fuzzy, gcc-internal-format
 msgid "expected selection-statement"
 msgstr "預期 selection-statement"
 
-#: cp/parser.cc:15459
+#: cp/parser.cc:15474
 #, fuzzy, gcc-internal-format
 #| msgid "function returning an array"
 msgid "condition declares an array"
 msgstr "函式回傳了一個陣列"
 
-#: cp/parser.cc:15461
+#: cp/parser.cc:15476
 #, fuzzy, gcc-internal-format
 msgid "condition declares a function"
 msgstr "欄位 %qE 宣告的做為函式"
 
-#: cp/parser.cc:15502
+#: cp/parser.cc:15517
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in conditions"
 msgstr "類型可能無法被定義在中條件"
 
 #. Anything else is an error.
-#: cp/parser.cc:15604 cp/parser.cc:26170 cp/parser.cc:28936
+#: cp/parser.cc:15619 cp/parser.cc:26234 cp/parser.cc:29000
 #, fuzzy, gcc-internal-format
 msgid "expected initializer"
 msgstr "預期的初始設定式"
 
-#: cp/parser.cc:15654
+#: cp/parser.cc:15669
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops with initializer only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "進階初始設定式只列出可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:15960
+#: cp/parser.cc:15976
 #, gcc-internal-format
 msgid "loop variable %qD of type %qT binds to a temporary constructed from type %qT"
 msgstr ""
 
 #. rval
-#: cp/parser.cc:15967
+#: cp/parser.cc:15983
 #, gcc-internal-format
 msgid "use non-reference type %qT to make the copy explicit or %qT to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:15993
+#: cp/parser.cc:16009
 #, fuzzy, gcc-internal-format
 #| msgid "non-local variable %q#D uses local type %qT"
 msgid "loop variable %qD creates a copy from type %qT"
 msgstr "非局部變數 %q#D 使用了局部類型 %qT"
 
-#: cp/parser.cc:15998
+#: cp/parser.cc:16014
 #, gcc-internal-format
 msgid "use reference type to prevent copying"
 msgstr ""
 
-#: cp/parser.cc:16201
+#: cp/parser.cc:16222
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> expression of type %qT has incomplete type"
 msgstr "range-based %<for%> 運算式的型態 %qT 有不完整型態"
 
-#: cp/parser.cc:16312
+#: cp/parser.cc:16333
 #, fuzzy, gcc-internal-format
 msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
 msgstr "不一致開始/結束類型在中 range-based %<for%> 敘述：%qT 和 %qT"
 
-#: cp/parser.cc:16464 cp/parser.cc:37779
+#: cp/parser.cc:16485 cp/parser.cc:37839
 #, fuzzy, gcc-internal-format
 msgid "expected iteration-statement"
 msgstr "預期 iteration-statement"
 
-#: cp/parser.cc:16509
+#: cp/parser.cc:16530
 #, fuzzy, gcc-internal-format
 msgid "alias-declaration in init-statement only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "lambda 運算式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:16526
+#: cp/parser.cc:16547
 #, fuzzy, gcc-internal-format
 msgid "range-based %<for%> loops only available with %<-std=c++11%> or %<-std=gnu++11%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:16572
+#: cp/parser.cc:16593
 #, fuzzy, gcc-internal-format
 msgid "%<template for%> only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:16631
+#: cp/parser.cc:16655
 #, fuzzy, gcc-internal-format
 msgid "designators in %<template for%> initializer"
 msgstr "C99 指示項 %qE 外側彙總初始設定式"
 
-#: cp/parser.cc:16698
+#: cp/parser.cc:16736
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be 'constinit'"
 msgstr "解構式無法 %<constexpr%>"
 
-#: cp/parser.cc:16868
+#: cp/parser.cc:16906
 #, fuzzy, gcc-internal-format
 msgid "%<goto%> in %<constexpr%> function only available with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
 #. Issue a warning about this use of a GNU extension.
-#: cp/parser.cc:16877
+#: cp/parser.cc:16915
 #, gcc-internal-format
 msgid "ISO C++ forbids computed gotos"
 msgstr "ISO C++ 不允許執行時可知的 goto 目的"
 
-#: cp/parser.cc:16896 cp/parser.cc:37782
+#: cp/parser.cc:16934 cp/parser.cc:37842
 #, fuzzy, gcc-internal-format
 msgid "expected jump-statement"
 msgstr "預期 jump-statement"
 
-#: cp/parser.cc:17071
+#: cp/parser.cc:17109
 #, fuzzy, gcc-internal-format
 msgid "expected module-partition"
 msgstr "預期的宣告"
 
-#: cp/parser.cc:17073
+#: cp/parser.cc:17111
 #, fuzzy, gcc-internal-format
 msgid "expected module-name"
 msgstr "預期 template-name"
 
-#: cp/parser.cc:17115
+#: cp/parser.cc:17153
 #, fuzzy, gcc-internal-format
 #| msgid "method declaration not in @interface context"
 msgid "module-declaration not permitted in header-unit"
 msgstr "方法宣告不在@interface 上下文中"
 
-#: cp/parser.cc:17121
+#: cp/parser.cc:17159
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "module-declaration must be at global scope"
 msgstr "在類別作用欄位使用非成員的 using 宣告"
 
-#: cp/parser.cc:17122
+#: cp/parser.cc:17160
 #, fuzzy, gcc-internal-format
 msgid "scope opened here"
 msgstr "聯合定義的在此"
 
-#: cp/parser.cc:17148
+#: cp/parser.cc:17186
 #, fuzzy, gcc-internal-format
 #| msgid "no arguments"
 msgid "private module fragment"
 msgstr "沒有參數"
 
-#: cp/parser.cc:17152
+#: cp/parser.cc:17190
 #, gcc-internal-format
 msgid "private module fragment only permitted in purview of module interface or partition"
 msgstr ""
 
 #. Neither the first declaration, nor in a GMF.
-#: cp/parser.cc:17158
+#: cp/parser.cc:17196
 #, gcc-internal-format
 msgid "module-declaration only permitted as first declaration, or ending a global module fragment"
 msgstr ""
 
-#: cp/parser.cc:17199
+#: cp/parser.cc:17237
 #, gcc-internal-format
 msgid "post-module-declaration imports must be contiguous"
 msgstr ""
 
-#: cp/parser.cc:17201 cp/parser.cc:17210
+#: cp/parser.cc:17239 cp/parser.cc:17248
 #, gcc-internal-format
 msgid "perhaps insert a line break after %<import%>, or other disambiguation, to prevent this being considered a module control-line"
 msgstr ""
 
-#: cp/parser.cc:17209
+#: cp/parser.cc:17247
 #, fuzzy, gcc-internal-format
 #| msgid "using-declaration for non-member at class scope"
 msgid "import-declaration must be at global scope"
 msgstr "在類別作用欄位使用非成員的 using 宣告"
 
-#: cp/parser.cc:17233
+#: cp/parser.cc:17271
 #, gcc-internal-format
 msgid "import specifying a module-partition must appear after a named module-declaration"
 msgstr ""
 
-#: cp/parser.cc:17254
+#: cp/parser.cc:17292
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be include-translated"
 msgstr ""
 
-#: cp/parser.cc:17257
+#: cp/parser.cc:17295
 #, gcc-internal-format
 msgid "post-module-declaration imports must not be from header inclusion"
 msgstr ""
 
-#: cp/parser.cc:17278
+#: cp/parser.cc:17316
 #, gcc-internal-format
 msgid "%qE may only occur after a module interface declaration"
 msgstr ""
 
-#: cp/parser.cc:17286
+#: cp/parser.cc:17324
 #, fuzzy, gcc-internal-format
 msgid "%qE may only occur once in an export declaration"
 msgstr "類型可能無法被定義在中 exception-declarations"
 
-#: cp/parser.cc:17307
+#: cp/parser.cc:17345
 #, gcc-internal-format
 msgid "%<export%> not part of following module-directive"
 msgstr ""
 
-#: cp/parser.cc:17346
+#: cp/parser.cc:17384
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function only allowed in C++11"
 msgstr "ISO C 不支援在函式外使用多餘的 %<;%>"
 
-#: cp/parser.cc:17349
+#: cp/parser.cc:17387
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C does not allow extra %<;%> outside of a function"
 msgid "extra %<;%> outside of a function"
 msgstr "ISO C 不支援在函式外使用多餘的 %<;%>"
 
-#: cp/parser.cc:17358
+#: cp/parser.cc:17396
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct only allowed in C++11"
 msgstr ""
 
-#: cp/parser.cc:17360
+#: cp/parser.cc:17398
 #, gcc-internal-format
 msgid "extra %<;%> inside a struct"
 msgstr ""
 
-#: cp/parser.cc:17368
+#: cp/parser.cc:17406
 #, fuzzy, gcc-internal-format
 msgid "extra %<;%> after in-class function definition"
 msgstr "預期 %<;%>之後類別定義"
 
-#: cp/parser.cc:17539
+#: cp/parser.cc:17577
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "attributes are not permitted in this position"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: cp/parser.cc:17543
+#: cp/parser.cc:17581
 #, fuzzy, gcc-internal-format
 msgid "attributes may be inserted here"
 msgstr "%qE 屬性被忽略"
 
-#: cp/parser.cc:17583
+#: cp/parser.cc:17621
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of non-template %qT"
 msgid "explicit specializations are not permitted here"
 msgstr "明確特例化非範本 %qT"
 
-#: cp/parser.cc:17585 cp/parser.cc:30428
+#: cp/parser.cc:17623 cp/parser.cc:30492
 #, gcc-internal-format
 msgid "a specialization is always exported alongside its primary template"
 msgstr ""
 
-#: cp/parser.cc:17604
+#: cp/parser.cc:17642
 #, fuzzy, gcc-internal-format
 #| msgid "explicit instantiation of non-template %q#D"
 msgid "explicit instantiations are not permitted here"
 msgstr "對非範本 %q#D 的明確實體化"
 
-#: cp/parser.cc:17620
+#: cp/parser.cc:17658
 #, fuzzy, gcc-internal-format
 msgid "export-declarations are not permitted here"
 msgstr "原來的定義出現的在此"
 
-#: cp/parser.cc:17842
+#: cp/parser.cc:17880
 #, fuzzy, gcc-internal-format
 msgid "%<__label__%> not at the beginning of a block"
 msgstr "%<__label__%>無法於起始部分的區塊"
 
-#: cp/parser.cc:18090
+#: cp/parser.cc:18128
 #, gcc-internal-format
 msgid "non-variable %qD in declaration with more than one declarator with placeholder type"
 msgstr ""
 
-#: cp/parser.cc:18109
+#: cp/parser.cc:18147
 #, fuzzy, gcc-internal-format
 msgid "inconsistent deduction for %qT: %qT and then %qT"
 msgstr "不一致推導用於 %qT：%qT 然後 %qT"
 
-#: cp/parser.cc:18130
+#: cp/parser.cc:18168
 #, gcc-internal-format
 msgid "mixing declarations and function-definitions is forbidden"
 msgstr "不能混合宣告和函式定義"
 
-#: cp/parser.cc:18155
+#: cp/parser.cc:18193
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a for-range-declaration"
 msgstr "類型可能無法被定義在中 exception-declarations"
 
-#: cp/parser.cc:18212
+#: cp/parser.cc:18250
 #, gcc-internal-format
 msgid "initializer in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18215
+#: cp/parser.cc:18253
 #, gcc-internal-format
 msgid "multiple declarations in range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:18253
+#: cp/parser.cc:18291
 #, fuzzy, gcc-internal-format
 #| msgid "using %<typename%> outside of template"
 msgid "structured binding pack outside of template"
 msgstr "在範本外使用 %<typename%>"
 
-#: cp/parser.cc:18256
+#: cp/parser.cc:18294
 #, fuzzy, gcc-internal-format
 msgid "multiple packs in structured binding declaration"
 msgstr "預期的宣告"
 
-#: cp/parser.cc:18263
+#: cp/parser.cc:18301
 #, fuzzy, gcc-internal-format
 msgid "structured binding packs only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:18282
+#: cp/parser.cc:18320
 #, fuzzy, gcc-internal-format
 msgid "structured bindings with attributed identifiers only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:18293
+#: cp/parser.cc:18331
 #, fuzzy, gcc-internal-format
 msgid "annotation on structured binding"
 msgstr "value-initialization 的函數型式 %qT"
 
-#: cp/parser.cc:18321
+#: cp/parser.cc:18359
 #, fuzzy, gcc-internal-format
 msgid "structured bindings in conditions only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:18325
+#: cp/parser.cc:18363
 #, fuzzy, gcc-internal-format
 msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "無限制的聯合只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:18405
+#: cp/parser.cc:18443
 #, fuzzy, gcc-internal-format
 msgid "empty structured binding declaration"
 msgstr "預期的宣告"
 
-#: cp/parser.cc:18423
+#: cp/parser.cc:18461
 #, fuzzy, gcc-internal-format
 msgid "invalid initializer for structured binding declaration"
 msgstr "無效的初始設定式用於成員函式 %qD"
 
-#: cp/parser.cc:18449 cp/parser.cc:18454 cp/parser.cc:26151 cp/parser.cc:26156
-#: cp/parser.cc:26160 cp/parser.cc:26164
+#: cp/parser.cc:18487 cp/parser.cc:18492 cp/parser.cc:26215 cp/parser.cc:26220
+#: cp/parser.cc:26224 cp/parser.cc:26228
 #, fuzzy, gcc-internal-format
 msgid "for-range-declaration cannot be %qs"
 msgstr "屬性忽略的在中宣告的 %q#T"
 
-#: cp/parser.cc:18622
+#: cp/parser.cc:18660
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> must be the first specifier in a parameter declaration"
 msgstr "為參數宣告指定了無效的存儲類別"
 
-#: cp/parser.cc:18645
+#: cp/parser.cc:18683
 #, fuzzy, gcc-internal-format
 msgid "%<friend%> used outside of class"
 msgstr "%<friend%> 使用的外側的類別"
 
-#: cp/parser.cc:18683
+#: cp/parser.cc:18721
 #, fuzzy, gcc-internal-format
 msgid "the %<bool%> keyword is not allowed in a C++20 concept definition"
 msgstr "屬性於 %L 未被允許在中類型定義"
 
-#: cp/parser.cc:18686
+#: cp/parser.cc:18724
 #, gcc-internal-format
 msgid "C++20 concept definition syntax is %<concept <name> = <expr>%>"
 msgstr ""
 
-#: cp/parser.cc:18737
+#: cp/parser.cc:18775
 #, fuzzy, gcc-internal-format
 msgid "%<typedef%> specifier conflicts with %qs"
 msgstr "%+D 造成區段型態衝突與 %D"
 
-#: cp/parser.cc:18763
+#: cp/parser.cc:18801
 #, fuzzy, gcc-internal-format
 msgid "%<auto%> changes meaning in C++11; please remove it"
 msgstr "%<auto%> 變更平均在中 C++11; 請移除它"
 
-#: cp/parser.cc:18799
+#: cp/parser.cc:18837
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in condition"
 msgstr "%q+D 無效，在 %q#T 中"
 
-#: cp/parser.cc:18808
+#: cp/parser.cc:18846
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D invalid in %q#T"
 msgid "%qD invalid in lambda"
 msgstr "%q+D 無效，在 %q#T 中"
 
-#: cp/parser.cc:18812
+#: cp/parser.cc:18850
 #, fuzzy, gcc-internal-format
 msgid "%qD only valid in lambda with %<-std=c++23%> or %<-std=gnu++23%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:18894
+#: cp/parser.cc:18932
 #, fuzzy, gcc-internal-format
 msgid "type-specifier invalid in lambda"
 msgstr "decl-specifier 無效的在中條件"
 
-#: cp/parser.cc:18907
+#: cp/parser.cc:18945
 #, gcc-internal-format
 msgid "standard attributes in middle of decl-specifiers"
 msgstr ""
 
-#: cp/parser.cc:18909
+#: cp/parser.cc:18947
 #, gcc-internal-format
 msgid "standard attributes must precede the decl-specifiers to apply to the declaration, or follow them to apply to the type"
 msgstr ""
 
-#: cp/parser.cc:18924
+#: cp/parser.cc:18962
 #, gcc-internal-format
 msgid "class definition may not be declared a friend"
 msgstr "類別定義不能被宣告為夥伴"
 
-#: cp/parser.cc:18997 cp/parser.cc:31672
+#: cp/parser.cc:19035 cp/parser.cc:31736
 #, fuzzy, gcc-internal-format
 msgid "templates may not be %<virtual%>"
 msgstr "模板可能無法是 %<virtual%>"
 
-#: cp/parser.cc:19016
+#: cp/parser.cc:19054
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in explicit-specifier"
 msgstr "類型可能無法被定義在中 exception-specification"
 
-#: cp/parser.cc:19020
+#: cp/parser.cc:19058
 #, fuzzy, gcc-internal-format
 msgid "%<explicit(bool)%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:19088
+#: cp/parser.cc:19126
 #, fuzzy, gcc-internal-format
 msgid "invalid linkage-specification"
 msgstr "無效的連繫規格"
 
-#: cp/parser.cc:19195
+#: cp/parser.cc:19233
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> without a message only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:19223
+#: cp/parser.cc:19261
 #, fuzzy, gcc-internal-format
 msgid "%<static_assert%> with non-string message only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:19440
+#: cp/parser.cc:19487
 #, fuzzy, gcc-internal-format
 msgid "%<decltype(auto)%> type specifier only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "C++0x 自動只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:19453
+#: cp/parser.cc:19500
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in %<decltype%> expressions"
 msgstr "類型可能無法被定義在中 %<decltype%> 運算式"
 
-#: cp/parser.cc:19629
+#: cp/parser.cc:19676
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in a conversion-type-id"
 msgstr "類型可能無法被定義在中 new-type-id"
 
-#: cp/parser.cc:19658 cp/parser.cc:19664
+#: cp/parser.cc:19705 cp/parser.cc:19711
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in conversion operator"
 msgstr "無效的使用的 %<auto%> 在中轉換運算子"
 
-#: cp/parser.cc:19666
+#: cp/parser.cc:19713
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in member template conversion operator can never be deduced"
 msgstr "無效的使用的 %<auto%> 在中轉換運算子"
 
-#: cp/parser.cc:19751
+#: cp/parser.cc:19798
 #, fuzzy, gcc-internal-format
 msgid "only constructors take member initializers"
 msgstr "只有建構子需成員初始設定式"
 
-#: cp/parser.cc:19778
+#: cp/parser.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "cannot expand initializer for member %qD"
 msgstr "無法展開初始設定式用於成員 %<%D%>"
 
-#: cp/parser.cc:19790 cp/pt.cc:29076
+#: cp/parser.cc:19837 cp/pt.cc:29234
 #, fuzzy, gcc-internal-format
 msgid "mem-initializer for %qD follows constructor delegation"
 msgstr "mem-initializer 用於 %qD 追隨建構子 delegation"
 
-#: cp/parser.cc:19802 cp/pt.cc:29088
+#: cp/parser.cc:19849 cp/pt.cc:29246
 #, fuzzy, gcc-internal-format
 msgid "constructor delegation follows mem-initializer for %qD"
 msgstr "建構子 delegation 追隨 mem-initializer 用於 %qD"
 
-#: cp/parser.cc:19854
+#: cp/parser.cc:19901
 #, gcc-internal-format
 msgid "anachronistic old-style base class initializer"
 msgstr "年代錯誤的舊式基礎類別初始值設定"
 
-#: cp/parser.cc:19942
+#: cp/parser.cc:20024
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)"
 msgstr "關鍵字 %<typename%> 不允許用在此上下文中(限定的初始值設定隱含地是一個類型)"
 
-#: cp/parser.cc:20354
+#: cp/parser.cc:20418
 #, fuzzy, gcc-internal-format
 msgid "space between quotes and suffix is deprecated in C++23"
 msgstr "缺少空格介於 %<「」%>和字尾識別碼"
 
-#: cp/parser.cc:20360
+#: cp/parser.cc:20424
 #, fuzzy, gcc-internal-format
 msgid "unexpected keyword; remove space between quotes and suffix identifier"
 msgstr "缺少空格介於 %<「」%>和字尾識別碼"
 
-#: cp/parser.cc:20366
+#: cp/parser.cc:20430
 #, fuzzy, gcc-internal-format
 msgid "expected suffix identifier"
 msgstr "預期的字尾識別碼"
 
-#: cp/parser.cc:20375
+#: cp/parser.cc:20439
 #, fuzzy, gcc-internal-format
 msgid "expected empty string after %<operator%> keyword"
 msgstr "預期的清空字串之後 %<operator%> 關鍵字"
 
-#: cp/parser.cc:20381
+#: cp/parser.cc:20445
 #, fuzzy, gcc-internal-format
 msgid "invalid encoding prefix in literal operator"
 msgstr "無效的運算元在中三進作業"
 
-#: cp/parser.cc:20415
+#: cp/parser.cc:20479
 #, fuzzy, gcc-internal-format
 msgid "expected operator"
 msgstr "預期的運算子"
 
-#: cp/parser.cc:20462
+#: cp/parser.cc:20526
 #, gcc-internal-format
 msgid "keyword %<export%> not implemented, and will be ignored"
 msgstr "關鍵字 %<export%> 未實作，將被忽略"
 
-#: cp/parser.cc:20464
+#: cp/parser.cc:20528
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<export%> not implemented, and will be ignored"
 msgid "keyword %<export%> is deprecated, and is ignored"
 msgstr "關鍵字 %<export%> 未實作，將被忽略"
 
-#: cp/parser.cc:20466
+#: cp/parser.cc:20530
 #, fuzzy, gcc-internal-format
 msgid "keyword %<export%> is enabled with %<-fmodules%>"
 msgstr "-ms2600 未與 -ms 一起使用"
 
-#: cp/parser.cc:20571
+#: cp/parser.cc:20635
 #, fuzzy, gcc-internal-format
 msgid "invalid constrained type parameter"
 msgstr "無效的模板 non-type 參數"
 
-#: cp/parser.cc:20579
+#: cp/parser.cc:20643
 #, fuzzy, gcc-internal-format
 msgid "cv-qualified type parameter"
 msgstr "無效的模板 non-type 參數"
 
-#: cp/parser.cc:20703
+#: cp/parser.cc:20767
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in default template argument"
 msgstr "無效的使用的模板模板參數 %qT"
 
-#: cp/parser.cc:20941 cp/parser.cc:21027 cp/parser.cc:28684
+#: cp/parser.cc:21005 cp/parser.cc:21091 cp/parser.cc:28748
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack %qD cannot have a default argument"
 msgstr "模板參數包裝 %qD 無法有預設引數"
 
-#: cp/parser.cc:20945 cp/parser.cc:21031
+#: cp/parser.cc:21009 cp/parser.cc:21095
 #, fuzzy, gcc-internal-format
 msgid "template parameter packs cannot have default arguments"
 msgstr "模板參數包裝無法有預設引數"
 
-#: cp/parser.cc:21103
+#: cp/parser.cc:21167
 #, fuzzy, gcc-internal-format
 msgid "expected template-id"
 msgstr "預期 template-id"
 
-#: cp/parser.cc:21176
+#: cp/parser.cc:21240
 #, gcc-internal-format
 msgid "%<<::%> cannot begin a template-argument list"
 msgstr "不能以 %<<::%> 開始一個範本引數清單"
 
-#: cp/parser.cc:21180
+#: cp/parser.cc:21244
 #, gcc-internal-format
 msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>"
 msgstr "%<<:%> 是 %<[%> 的另一種拼法。請在 %<<%> 和 %<::%> 間加上空格"
 
-#: cp/parser.cc:21184
+#: cp/parser.cc:21248
 #, fuzzy, gcc-internal-format
 msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
 msgstr "(如果您使用 %<-fpermissive%> G++將接受您的編碼)"
 
-#: cp/parser.cc:21215
+#: cp/parser.cc:21279
 #, fuzzy, gcc-internal-format
 msgid "invalid template-argument-list"
 msgstr "無效的 non-type 模板引數"
 
-#: cp/parser.cc:21216
+#: cp/parser.cc:21280
 #, gcc-internal-format
 msgid "function name as the left hand operand of %<<%> is ill-formed in C++20; wrap the function name in %<()%>"
 msgstr ""
 
-#: cp/parser.cc:21223
+#: cp/parser.cc:21287
 #, fuzzy, gcc-internal-format
 msgid "expected %<(%> after template-argument-list"
 msgstr "預期 template-argument"
 
-#: cp/parser.cc:21350
+#: cp/parser.cc:21414
 #, gcc-internal-format
 msgid "parse error in template argument list"
 msgstr "範本引數表語法錯誤"
 
 #. The name does not name a template.
-#: cp/parser.cc:21435 cp/parser.cc:21627 cp/parser.cc:21836
+#: cp/parser.cc:21499 cp/parser.cc:21691 cp/parser.cc:21900
 #, fuzzy, gcc-internal-format
 msgid "expected template-name"
 msgstr "預期 template-name"
 
-#: cp/parser.cc:21483
+#: cp/parser.cc:21547
 #, gcc-internal-format
 msgid "non-template %qD used as template"
 msgstr "非範本 %qD 做為範本"
 
-#: cp/parser.cc:21485
+#: cp/parser.cc:21549
 #, gcc-internal-format
 msgid "use %<%T::template %D%> to indicate that it is a template"
 msgstr "使用 %<%T::template %D%> 來表示這是一個範本"
 
-#: cp/parser.cc:21700
+#: cp/parser.cc:21764
 #, fuzzy, gcc-internal-format
 msgid "expected parameter pack before %<...%>"
 msgstr "預期的參數包裝之前 %<...%>"
 
-#: cp/parser.cc:21801 cp/parser.cc:21819 cp/parser.cc:22013
+#: cp/parser.cc:21865 cp/parser.cc:21883 cp/parser.cc:22077
 #, fuzzy, gcc-internal-format
 msgid "expected template-argument"
 msgstr "預期 template-argument"
 
-#: cp/parser.cc:21966
+#: cp/parser.cc:22030
 #, fuzzy, gcc-internal-format
 msgid "invalid non-type template argument"
 msgstr "無效的 non-type 模板引數"
 
-#: cp/parser.cc:22004
+#: cp/parser.cc:22068
 #, fuzzy, gcc-internal-format
 msgid "unparenthesized splice expression cannot be used as a template argument"
 msgstr "異動作業運算式無法出現在中 constant-expression"
 
-#: cp/parser.cc:22122
+#: cp/parser.cc:22186
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<inline%> specifier"
 msgstr "明確的實體化不應該使用 %<inline%> 說明符"
 
-#: cp/parser.cc:22126
+#: cp/parser.cc:22190
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<constexpr%> specifier"
 msgstr "明確的實體化不應該使用 %<constexpr%> 說明符"
 
-#: cp/parser.cc:22130
+#: cp/parser.cc:22194
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation shall not use %<consteval%> specifier"
 msgstr "明確的實體化不應該使用 %<constexpr%> 說明符"
 
-#: cp/parser.cc:22191
+#: cp/parser.cc:22255
 #, gcc-internal-format
 msgid "template specialization with C linkage"
 msgstr "特例化範本有 C 連結"
 
-#: cp/parser.cc:22427
+#: cp/parser.cc:22491
 #, fuzzy, gcc-internal-format
 msgid "expected type specifier"
 msgstr "預期的型態說明符"
 
-#: cp/parser.cc:22636
+#: cp/parser.cc:22700
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "缺席和刪除的函式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:22642
+#: cp/parser.cc:22706
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++20%> or %<-fconcepts%>"
 msgstr "缺席和刪除的函式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:22646
+#: cp/parser.cc:22710
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>"
 msgstr "缺席和刪除的函式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:22653 cp/parser.cc:23114
+#: cp/parser.cc:22717 cp/parser.cc:23178
 #, fuzzy, gcc-internal-format
 msgid "use of %<auto%> in template argument"
 msgstr "無效的 non-type 模板引數"
 
-#: cp/parser.cc:22807
+#: cp/parser.cc:22871
 #, fuzzy, gcc-internal-format
 msgid "expected template-id for type"
 msgstr "預期 template-id 用於型態"
 
-#: cp/parser.cc:22957
+#: cp/parser.cc:23021
 #, fuzzy, gcc-internal-format
 msgid "expected type-name"
 msgstr "預期 type-name"
 
-#: cp/parser.cc:23041
+#: cp/parser.cc:23105
 #, fuzzy, gcc-internal-format
 #| msgid "%qE does not name a type"
 msgid "%qE does not constrain a type"
 msgstr "%qE 沒有命名一個類型"
 
-#: cp/parser.cc:23042
+#: cp/parser.cc:23106
 #, fuzzy, gcc-internal-format
 msgid "concept defined here"
 msgstr "聯合定義的在此"
 
-#: cp/parser.cc:23073
+#: cp/parser.cc:23137
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %qD"
 msgid "invalid use of concept-name %qD"
 msgstr "錯誤地使用了 %qD"
 
-#: cp/parser.cc:23089
+#: cp/parser.cc:23153
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%> or %<decltype(auto)%> after %qE"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: cp/parser.cc:23096
+#: cp/parser.cc:23160
 #, gcc-internal-format
 msgid "unexpected placeholder in constrained result type"
 msgstr ""
 
-#: cp/parser.cc:23341
+#: cp/parser.cc:23405
 #, fuzzy, gcc-internal-format
 msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword"
 msgstr "elaborated-type-specifier 用於範圍的 enum 必須不使用 %<%D%>關鍵字"
 
-#: cp/parser.cc:23579
+#: cp/parser.cc:23643
 #, fuzzy, gcc-internal-format
 msgid "declaration %qD does not declare anything"
 msgstr "宣告 %qD 不宣告任何事"
 
-#: cp/parser.cc:23667
+#: cp/parser.cc:23731
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on uninstantiated type"
 msgstr "屬性忽略的於 uninstantiated 型態"
 
-#: cp/parser.cc:23673
+#: cp/parser.cc:23737
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on template instantiation"
 msgstr "屬性忽略的於模板具現化"
 
-#: cp/parser.cc:23685
+#: cp/parser.cc:23749
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
 msgstr "屬性忽略的於 elaborated-type-specifier 該並非前置宣告"
 
-#: cp/parser.cc:23826
+#: cp/parser.cc:23890
 #, fuzzy, gcc-internal-format
 msgid "%qD is an enumeration template"
 msgstr "%qD 是列舉類型模板"
 
-#: cp/parser.cc:23837
+#: cp/parser.cc:23901
 #, fuzzy, gcc-internal-format
 msgid "%qD does not name an enumeration in %qT"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/parser.cc:23852
+#: cp/parser.cc:23916
 #, fuzzy, gcc-internal-format
 msgid "unnamed scoped enum is not allowed"
 msgstr "%<namespace%> 定義未被允許在此"
 
-#: cp/parser.cc:23870
+#: cp/parser.cc:23934
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in enum-base"
 msgstr "類型可能無法被定義在中演員陣容"
 
-#: cp/parser.cc:23916
+#: cp/parser.cc:23980
 #, gcc-internal-format
 msgid "declaration of enumeration with fixed underlying type and no enumerator list is only permitted as a standalone declaration"
 msgstr ""
 
-#: cp/parser.cc:23920
+#: cp/parser.cc:23984
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> or %<{%>"
 msgstr "預期 %<;%>或 %<{%>"
 
-#: cp/parser.cc:23963
+#: cp/parser.cc:24027
 #, fuzzy, gcc-internal-format
 msgid "cannot add an enumerator list to a template instantiation"
 msgstr "無法加入列舉值清單到模板具現化"
 
-#: cp/parser.cc:23977
+#: cp/parser.cc:24041
 #, fuzzy, gcc-internal-format
 #| msgid "friend declaration does not name a class or function"
 msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
 msgstr "夥伴宣告沒有指定類別或函式名"
 
-#: cp/parser.cc:23989 cp/parser.cc:30397
+#: cp/parser.cc:24053 cp/parser.cc:30461
 #, fuzzy, gcc-internal-format
 msgid "declaration of %qD in namespace %qD which does not enclose %qD"
 msgstr "宣告的 %qD 在中命名空間 %qD 該項不封閉 %qD"
 
-#: cp/parser.cc:23994 cp/parser.cc:30402
+#: cp/parser.cc:24058 cp/parser.cc:30466
 #, gcc-internal-format
 msgid "declaration of %qD in %qD which does not enclose %qD"
 msgstr "%qD 宣告出現在 %qD 中，而後者並不包含 %qD"
 
-#: cp/parser.cc:24006 cp/parser.cc:30415
+#: cp/parser.cc:24070 cp/parser.cc:30479
 #, fuzzy, gcc-internal-format
 msgid "extra qualification not allowed"
 msgstr "額外合格不允許"
 
-#: cp/parser.cc:24047
+#: cp/parser.cc:24111
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids empty unnamed enum"
 msgstr "ISO C++禁止遞增 enum"
 
-#: cp/parser.cc:24071
+#: cp/parser.cc:24135
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-specifier without name"
 msgstr "opaque-enum-specifier 而無需名稱"
 
-#: cp/parser.cc:24074
+#: cp/parser.cc:24138
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-specifier must use a simple identifier"
 msgstr "opaque-enum-specifier 必須使用簡單的識別碼"
 
-#: cp/parser.cc:24195
+#: cp/parser.cc:24259
 #, gcc-internal-format
 msgid "unexpanded parameter pack in enumerator in lambda"
 msgstr ""
 
-#: cp/parser.cc:24270
+#: cp/parser.cc:24334
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a namespace-name"
 msgid "%qD is not a namespace-name; did you mean %qs?"
 msgstr "%qD 不是一個命名空間"
 
-#: cp/parser.cc:24274
+#: cp/parser.cc:24338
 #, gcc-internal-format
 msgid "%qD is not a namespace-name"
 msgstr "%qD 不是一個命名空間"
 
-#: cp/parser.cc:24278
+#: cp/parser.cc:24342
 #, fuzzy, gcc-internal-format
 msgid "expected namespace-name"
 msgstr "預期 namespace-name"
 
-#: cp/parser.cc:24339
+#: cp/parser.cc:24403
 #, fuzzy, gcc-internal-format
 msgid "nested inline namespace definitions only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:24351
+#: cp/parser.cc:24415
 #, gcc-internal-format
 msgid "standard attributes on namespaces must precede the namespace name"
 msgstr ""
 
-#: cp/parser.cc:24370
+#: cp/parser.cc:24434
 #, fuzzy, gcc-internal-format
 msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "內聯命名空間只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:24380
+#: cp/parser.cc:24444
 #, fuzzy, gcc-internal-format
 msgid "nested namespace name required"
 msgstr "預期 namespace-name"
 
-#: cp/parser.cc:24385
+#: cp/parser.cc:24449
 #, gcc-internal-format
 msgid "namespace name required"
 msgstr ""
 
-#: cp/parser.cc:24389
+#: cp/parser.cc:24453
 #, fuzzy, gcc-internal-format
 #| msgid "Enumerator cannot have attributes %C"
 msgid "a nested namespace definition cannot have attributes"
 msgstr "列舉量不能有屬性 %C"
 
-#: cp/parser.cc:24392
+#: cp/parser.cc:24456
 #, fuzzy, gcc-internal-format
 #| msgid "Warn when an inlined function cannot be inlined"
 msgid "a nested namespace definition cannot be inline"
 msgstr "當內聯函式無法被內聯時給出警告"
 
-#: cp/parser.cc:24399
+#: cp/parser.cc:24463
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "namespace %qD entered"
 msgstr "命名空間 %qD 做為運算式"
 
-#: cp/parser.cc:24456
+#: cp/parser.cc:24520
 #, fuzzy, gcc-internal-format
 msgid "%<namespace%> definition is not allowed here"
 msgstr "%<namespace%> 定義未被允許在此"
 
-#: cp/parser.cc:24641
+#: cp/parser.cc:24705
 #, fuzzy, gcc-internal-format
 msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "明確的轉換運算子只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:24685
+#: cp/parser.cc:24749
 #, gcc-internal-format
 msgid "a template-id may not appear in a using-declaration"
 msgstr "範本識別碼不允許出現在 using 宣告中"
 
-#: cp/parser.cc:24703
+#: cp/parser.cc:24767
 #, fuzzy, gcc-internal-format
 msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "缺席和刪除的函式只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:24713
+#: cp/parser.cc:24777
 #, fuzzy, gcc-internal-format
 msgid "access declarations are deprecated in favor of using-declarations; suggestion: add the %<using%> keyword"
 msgstr "存取宣告被不宜用在中 favour 的 using-declarations；建議：加入 %<using%> 關鍵字"
 
-#: cp/parser.cc:24759
+#: cp/parser.cc:24823
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++0x 自動只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:24762
+#: cp/parser.cc:24826
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of dependent type %qT"
 msgstr "無效的使用的附屬型態 %qT"
 
-#: cp/parser.cc:24764
+#: cp/parser.cc:24828
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of non-enumeration type %q#T"
 msgstr "%qT 不是列舉類型型態"
 
-#: cp/parser.cc:24766
+#: cp/parser.cc:24830
 #, fuzzy, gcc-internal-format
 msgid "%<using enum%> of incomplete type %qT"
 msgstr "無效的使用的不完整型態 %q#T"
 
-#: cp/parser.cc:24768
+#: cp/parser.cc:24832
 #, gcc-internal-format
 msgid "%<using enum%> of %qT before its enum-specifier"
 msgstr ""
 
-#: cp/parser.cc:24778
+#: cp/parser.cc:24842
 #, fuzzy, gcc-internal-format
 msgid "opaque-enum-declaration here"
 msgstr "與此處早先的宣告 %q+#D 衝突"
 
-#: cp/parser.cc:24848
+#: cp/parser.cc:24912
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in alias template declarations"
 msgstr "類型可能無法被定義在中別名模板宣告"
 
-#: cp/parser.cc:25006
+#: cp/parser.cc:25070
 #, fuzzy, gcc-internal-format
 msgid "expected string-literal or constexpr in parentheses"
 msgstr "預期的介面或指標到介面"
 
-#: cp/parser.cc:25067
+#: cp/parser.cc:25131
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:25088 cp/parser.cc:25106 cp/parser.cc:25121
+#: cp/parser.cc:25152 cp/parser.cc:25170 cp/parser.cc:25185
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "duplicate %<asm%> qualifier %qT"
 msgstr "重複的 cv 限定"
 
-#: cp/parser.cc:25095
+#: cp/parser.cc:25159
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> qualifier %qT ignored outside of function body"
 msgstr "使用的參數 %qD 外側函式內文"
 
-#: cp/parser.cc:25134
+#: cp/parser.cc:25198
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "%qT is not an %<asm%> qualifier"
 msgstr "%qT 不是一個命名空間"
 
-#: cp/parser.cc:25150
+#: cp/parser.cc:25214
 #, fuzzy, gcc-internal-format
 msgid "%<asm%> qualifier outside of function body"
 msgstr "使用的參數 %qD 外側函式內文"
 
-#: cp/parser.cc:25300
+#: cp/parser.cc:25364
 #, fuzzy, gcc-internal-format
 msgid "attributes ignored on %<asm%> declaration"
 msgstr "屬性忽略的在中宣告的 %q#T"
 
-#: cp/parser.cc:25391
+#: cp/parser.cc:25455
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "empty parentheses were disambiguated as a function declaration"
 msgstr "函式宣告中出現參數名卻未指定類型"
 
-#: cp/parser.cc:25402
+#: cp/parser.cc:25466
 #, fuzzy, gcc-internal-format
 msgid "remove parentheses to default-initialize a variable"
 msgstr "parenthesized 初始設定式在中陣列新"
 
-#: cp/parser.cc:25407
+#: cp/parser.cc:25471
 #, gcc-internal-format
 msgid "or replace parentheses with braces to aggregate-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25410
+#: cp/parser.cc:25474
 #, gcc-internal-format
 msgid "or replace parentheses with braces to value-initialize a variable"
 msgstr ""
 
-#: cp/parser.cc:25427 cp/parser.cc:25452
+#: cp/parser.cc:25491 cp/parser.cc:25516
 #, fuzzy, gcc-internal-format
 #| msgid "parameter names (without types) in function declaration"
 msgid "parentheses were disambiguated as a function declaration"
 msgstr "函式宣告中出現參數名卻未指定類型"
 
-#: cp/parser.cc:25439 cp/parser.cc:25460
+#: cp/parser.cc:25503 cp/parser.cc:25524
 #, gcc-internal-format
 msgid "replace parentheses with braces to declare a variable"
 msgstr ""
 
-#: cp/parser.cc:25446
+#: cp/parser.cc:25510
 #, fuzzy, gcc-internal-format
 msgid "add parentheses to declare a variable"
 msgstr "函式 %qD redeclared 做為變數"
 
-#: cp/parser.cc:25516
+#: cp/parser.cc:25580
 #, fuzzy, gcc-internal-format
 #| msgid "Global register variable %qD used in nested function."
 msgid "cannot handle qualified name for variant function"
 msgstr "在巢狀函式中使用了全域暫存器變數 %qD"
 
-#: cp/parser.cc:25525
+#: cp/parser.cc:25589
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "declare variant directives are not allowed on constructors"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/parser.cc:25531
+#: cp/parser.cc:25595
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "declare variant directives are not allowed on destructors"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/parser.cc:25537
+#: cp/parser.cc:25601
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "cannot handle %s identifier name"
 msgstr "%qE 引數不是識別碼"
 
-#: cp/parser.cc:25590
+#: cp/parser.cc:25654
 #, fuzzy, gcc-internal-format
 msgid "no declaration of base function %qs in this scope"
 msgstr "宣告的函式 %qD 在中無效的語境"
 
-#: cp/parser.cc:25632
+#: cp/parser.cc:25696
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "base function is ambiguous"
 msgstr "對 %qD 的參照有歧義"
 
-#: cp/parser.cc:25640
+#: cp/parser.cc:25704
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qs"
 msgstr ""
 
-#: cp/parser.cc:25661
+#: cp/parser.cc:25725
 #, gcc-internal-format
 msgid "variant function must be in the same scope as the base function %qE"
 msgstr ""
 
-#: cp/parser.cc:25668
+#: cp/parser.cc:25732
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on virtual functions"
 msgstr "函式定義中不允許有屬性"
 
-#: cp/parser.cc:25675 cp/parser.cc:26124
+#: cp/parser.cc:25739 cp/parser.cc:26188
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on defaulted functions"
 msgstr "函式定義中不允許有屬性"
 
-#: cp/parser.cc:25682 cp/parser.cc:26131
+#: cp/parser.cc:25746 cp/parser.cc:26195
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on deleted functions"
 msgstr "函式定義中不允許有屬性"
 
-#: cp/parser.cc:25690
+#: cp/parser.cc:25754
 #, fuzzy, gcc-internal-format
 #| msgid "attributes are not allowed on a function-definition"
 msgid "declare variant directives are not allowed on immediate functions"
 msgstr "函式定義中不允許有屬性"
 
-#: cp/parser.cc:25965
+#: cp/parser.cc:26029
 #, fuzzy, gcc-internal-format
 msgid "a function-definition is not allowed here"
 msgstr "function-definition 未被允許在此"
 
-#: cp/parser.cc:25976
+#: cp/parser.cc:26040
 #, fuzzy, gcc-internal-format
 #| msgid "an asm-specification is not allowed on a function-definition"
 msgid "an %<asm%> specification is not allowed on a function-definition"
 msgstr "函式定義中不允許出現 asm 指定"
 
-#: cp/parser.cc:25980
+#: cp/parser.cc:26044
 #, gcc-internal-format
 msgid "attributes are not allowed on a function-definition"
 msgstr "函式定義中不允許有屬性"
 
-#: cp/parser.cc:26066
+#: cp/parser.cc:26130
 #, fuzzy, gcc-internal-format
 msgid "expected constructor, destructor, or type conversion"
 msgstr "預期的建構子、解構式，或類型轉換"
 
-#: cp/parser.cc:26265
+#: cp/parser.cc:26329
 #, fuzzy, gcc-internal-format
 msgid "initializer provided for function"
 msgstr "初始設定式提供的用於函式"
 
-#: cp/parser.cc:26310
+#: cp/parser.cc:26374
 #, gcc-internal-format
 msgid "attributes after parenthesized initializer ignored"
 msgstr "括起的初始值設定後出現的屬性被忽略"
 
-#: cp/parser.cc:26322
+#: cp/parser.cc:26386
 #, fuzzy, gcc-internal-format
 #| msgid "function %q+D redeclared as inline"
 msgid "non-function %qD declared as implicit template"
 msgstr "函式 %q+D 重宣告為內聯的"
 
-#: cp/parser.cc:26870
+#: cp/parser.cc:26934
 #, gcc-internal-format
 msgid "array bound is not an integer constant"
 msgstr "陣列邊界不是一個整數常數"
 
-#: cp/parser.cc:26995
+#: cp/parser.cc:27059
 #, fuzzy, gcc-internal-format
 msgid "cannot define member of dependent typedef %qT"
 msgstr "無法定義成員的附屬 typedef %qT"
 
-#: cp/parser.cc:26999
+#: cp/parser.cc:27063
 #, fuzzy, gcc-internal-format
 msgid "%<%T::%E%> is not a type"
 msgstr "%<%T::%E%>並非型態"
@@ -69789,281 +69885,281 @@ msgstr "%<%T::%E%>並非型態"
 #. here because we do not have enough
 #. information about its original syntactic
 #. form.
-#: cp/parser.cc:27028
+#: cp/parser.cc:27092
 #, fuzzy, gcc-internal-format
 msgid "invalid declarator"
 msgstr "無效的宣告子"
 
-#: cp/parser.cc:27037
+#: cp/parser.cc:27101
 #, gcc-internal-format
 msgid "invalid use of constructor as a template"
 msgstr "將建構式做為範本用法無效"
 
-#: cp/parser.cc:27039
+#: cp/parser.cc:27103
 #, gcc-internal-format
 msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name"
 msgstr "使用 %<%T::%D%> 而不是 %<%T::%D%> 來以限定名指定建構式"
 
 #. But declarations with qualified-ids can't appear in a
 #. function.
-#: cp/parser.cc:27154
+#: cp/parser.cc:27218
 #, fuzzy, gcc-internal-format
 msgid "qualified-id in declaration"
 msgstr "%q+D 在宣告前使用"
 
-#: cp/parser.cc:27179
+#: cp/parser.cc:27243
 #, fuzzy, gcc-internal-format
 msgid "expected declarator"
 msgstr "預期的宣告子"
 
-#: cp/parser.cc:27300
+#: cp/parser.cc:27364
 #, gcc-internal-format
 msgid "%qD is a namespace"
 msgstr "%qD 是一個命名空間"
 
-#: cp/parser.cc:27302
+#: cp/parser.cc:27366
 #, fuzzy, gcc-internal-format
 msgid "cannot form pointer to member of non-class %q#T"
 msgstr "無法表單成員指標的 non-class %q#T"
 
-#: cp/parser.cc:27323
+#: cp/parser.cc:27387
 #, fuzzy, gcc-internal-format
 msgid "expected ptr-operator"
 msgstr "預期 ptr-operator"
 
-#: cp/parser.cc:27384
+#: cp/parser.cc:27448
 #, gcc-internal-format
 msgid "duplicate cv-qualifier"
 msgstr "重複的 cv 限定"
 
-#: cp/parser.cc:27438
+#: cp/parser.cc:27502
 #, fuzzy, gcc-internal-format
 #| msgid "duplicate cv-qualifier"
 msgid "multiple ref-qualifiers"
 msgstr "重複的 cv 限定"
 
-#: cp/parser.cc:27475
+#: cp/parser.cc:27539
 #, gcc-internal-format
 msgid "%qE requires %<-fgnu-tm%>"
 msgstr ""
 
-#: cp/parser.cc:27533
+#: cp/parser.cc:27597
 #, fuzzy, gcc-internal-format
 msgid "duplicate virt-specifier"
 msgstr "重製 virt-specifier"
 
-#: cp/parser.cc:27836
+#: cp/parser.cc:27900
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments after %qE"
 msgstr "在中模板引數用於型態 %qT "
 
-#: cp/parser.cc:27842
+#: cp/parser.cc:27906
 #, fuzzy, gcc-internal-format
 msgid "%qT not permitted in template argument"
 msgstr "不匹配的引數"
 
-#: cp/parser.cc:27845 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
+#: cp/parser.cc:27909 cp/typeck2.cc:425 cp/typeck2.cc:471 cp/typeck2.cc:2624
 #: rust/backend/rust-tree.cc:3924
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qT"
 msgstr "無效的使用的 %qT"
 
-#: cp/parser.cc:27872
+#: cp/parser.cc:27936
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in template arguments"
 msgstr "類型可能無法被定義在中模板引數"
 
-#: cp/parser.cc:27881
+#: cp/parser.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in template argument"
 msgstr "無效的 non-type 模板引數"
 
-#: cp/parser.cc:28008
+#: cp/parser.cc:28072
 #, fuzzy, gcc-internal-format
 msgid "expected type-specifier"
 msgstr "預期 type-specifier"
 
-#: cp/parser.cc:28155
+#: cp/parser.cc:28219
 #, gcc-internal-format
 msgid "omission of %<,%> before varargs %<...%> is deprecated in C++26"
 msgstr ""
 
-#: cp/parser.cc:28362
+#: cp/parser.cc:28426
 #, fuzzy, gcc-internal-format
 msgid "expected %<,%> or %<...%>"
 msgstr "預期 %<,%>或 %<...%>"
 
-#: cp/parser.cc:28440
+#: cp/parser.cc:28504
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in parameter types"
 msgstr "類型可能無法被定義在中參數類型"
 
-#: cp/parser.cc:28564
+#: cp/parser.cc:28628
 #, fuzzy, gcc-internal-format
 #| msgid "storage class specifiers invalid in parameter declarations"
 msgid "%<this%> specifier in template parameter declaration"
 msgstr "為參數宣告指定了無效的存儲類別"
 
-#: cp/parser.cc:28567
+#: cp/parser.cc:28631
 #, gcc-internal-format
 msgid "%<this%> specifier in a requires-expression parameter"
 msgstr ""
 
-#: cp/parser.cc:28627
+#: cp/parser.cc:28691
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter cannot be a function parameter pack"
 msgstr "non-parameter %qs 無法參數包裝"
 
-#: cp/parser.cc:28668
+#: cp/parser.cc:28732
 #, gcc-internal-format
 msgid "default arguments are only permitted for function parameters"
 msgstr "預設參數只允許出現在函式參數中"
 
-#: cp/parser.cc:28686
+#: cp/parser.cc:28750
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %qD cannot have a default argument"
 msgstr "參數包裝 %qD 無法有預設引數"
 
-#: cp/parser.cc:28692
+#: cp/parser.cc:28756
 #, fuzzy, gcc-internal-format
 msgid "template parameter pack cannot have a default argument"
 msgstr "模板參數包裝無法有預設引數"
 
-#: cp/parser.cc:28694
+#: cp/parser.cc:28758
 #, fuzzy, gcc-internal-format
 msgid "parameter pack cannot have a default argument"
 msgstr "參數包裝無法有預設引數"
 
-#: cp/parser.cc:28717
+#: cp/parser.cc:28781
 #, fuzzy, gcc-internal-format
 msgid "an explicit object parameter may not have a default argument"
 msgstr "模板參數包裝無法有預設引數"
 
-#: cp/parser.cc:28841
+#: cp/parser.cc:28905
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> constructor only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "委派建構子只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:28845
+#: cp/parser.cc:28909
 #, fuzzy, gcc-internal-format
 msgid "function-try-block body of %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:29036
+#: cp/parser.cc:29100
 #, gcc-internal-format
 msgid "probably missing a comma or an operator before"
 msgstr ""
 
-#: cp/parser.cc:29198
+#: cp/parser.cc:29262
 #, fuzzy, gcc-internal-format
 msgid "C++ designated initializers only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "進階初始設定式只列出可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:29220
+#: cp/parser.cc:29284
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "ISO C++ does not allow GNU designated initializers"
 msgstr "ISO C++ 不允許指定元素初始值設定"
 
-#: cp/parser.cc:29258
+#: cp/parser.cc:29322
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ does not allow C99 designated initializers"
 msgstr "ISO C++不允許 C99 指定的初始設定式"
 
-#: cp/parser.cc:29272
+#: cp/parser.cc:29336
 #, gcc-internal-format
 msgid "either all initializer clauses should be designated or none of them should be"
 msgstr ""
 
-#: cp/parser.cc:29312
+#: cp/parser.cc:29376
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ does not allow designated initializers"
 msgid "%<...%> not allowed in designated initializer list"
 msgstr "ISO C++ 不允許指定元素初始值設定"
 
-#: cp/parser.cc:29363
+#: cp/parser.cc:29427
 #, gcc-internal-format
 msgid "%<.%s%> designator used multiple times in the same initializer list"
 msgstr ""
 
-#: cp/parser.cc:29419 cp/parser.cc:29553
+#: cp/parser.cc:29483 cp/parser.cc:29617
 #, fuzzy, gcc-internal-format
 msgid "expected class-name"
 msgstr "預期 class-name"
 
-#: cp/parser.cc:29833
+#: cp/parser.cc:29897
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after class definition"
 msgstr "預期 %<;%>之後類別定義"
 
-#: cp/parser.cc:29836
+#: cp/parser.cc:29900
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after struct definition"
 msgstr "預期 %<;%>之後結構定義"
 
-#: cp/parser.cc:29839
+#: cp/parser.cc:29903
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> after union definition"
 msgstr "預期 %<;%>之後聯合定義"
 
-#: cp/parser.cc:30135 cp/parser.cc:37398
+#: cp/parser.cc:30199 cp/parser.cc:37458
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD specifier"
 msgstr "重製 virt-specifier"
 
-#: cp/parser.cc:30346
+#: cp/parser.cc:30410
 #, fuzzy, gcc-internal-format
 msgid "expected %<{%> or %<:%>"
 msgstr "預期 %<{%>或 %<:%>"
 
-#: cp/parser.cc:30358
+#: cp/parser.cc:30422
 #, fuzzy, gcc-internal-format
 msgid "global qualification of class name is invalid"
 msgstr "全域合格的類別名稱無效"
 
-#: cp/parser.cc:30365
+#: cp/parser.cc:30429
 #, fuzzy, gcc-internal-format
 msgid "qualified name does not name a class"
 msgstr "限定名稱不名稱類別"
 
-#: cp/parser.cc:30377
+#: cp/parser.cc:30441
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in class-head-name"
 msgstr "關鍵字 %<typename%> 不能在範本以外使用"
 
-#: cp/parser.cc:30383
+#: cp/parser.cc:30447
 #, gcc-internal-format
 msgid "invalid class name in declaration of %qD"
 msgstr "%qD 的宣告中類別名無效"
 
-#: cp/parser.cc:30426
+#: cp/parser.cc:30490
 #, fuzzy, gcc-internal-format
 #| msgid "defining explicit specialization %qD in friend declaration"
 msgid "declaration of partial specialization in unbraced export-declaration"
 msgstr "在夥伴宣告中定義明確特例化 %qD"
 
-#: cp/parser.cc:30452
+#: cp/parser.cc:30516
 #, gcc-internal-format
 msgid "an explicit instantiation cannot have a definition; use %<template <>%> to declare a specialization"
 msgstr ""
 
-#: cp/parser.cc:30459
+#: cp/parser.cc:30523
 #, gcc-internal-format
 msgid "an explicit specialization must be preceded by %<template <>%>"
 msgstr "明確特例化前必須有 %<template <>%>"
 
-#: cp/parser.cc:30492
+#: cp/parser.cc:30556
 #, fuzzy, gcc-internal-format
 msgid "function template %qD redeclared as a class template"
 msgstr "函式模板 %qD redeclared 做為類別模板"
 
-#: cp/parser.cc:30525
+#: cp/parser.cc:30589
 #, fuzzy, gcc-internal-format
 msgid "could not resolve typename type"
 msgstr "無法解析 typename 型態"
 
-#: cp/parser.cc:30590
+#: cp/parser.cc:30654
 #, fuzzy, gcc-internal-format
 #| msgid "previous definition of %q+#T"
 msgid "previous definition of %q#T"
@@ -70072,275 +70168,275 @@ msgstr "%q+#T 的上一個定義"
 #. In a lambda this should work, but doesn't currently.
 #. We're in a lambda, but it isn't the innermost class.
 #. This should work, but currently doesn't.
-#: cp/parser.cc:30604 cp/pt.cc:4414
+#: cp/parser.cc:30668 cp/pt.cc:4414
 #, gcc-internal-format
 msgid "unexpanded parameter pack in local class in lambda"
 msgstr ""
 
-#: cp/parser.cc:30722 cp/parser.cc:37785
+#: cp/parser.cc:30786 cp/parser.cc:37845
 #, fuzzy, gcc-internal-format
 msgid "expected class-key"
 msgstr "預期 class-key"
 
-#: cp/parser.cc:30747
+#: cp/parser.cc:30811
 #, gcc-internal-format
 msgid "ISO C++ forbids typename key in template template parameter; use %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr ""
 
-#: cp/parser.cc:30751
+#: cp/parser.cc:30815
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%> or %<typename%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: cp/parser.cc:31030
+#: cp/parser.cc:31094
 #, fuzzy, gcc-internal-format
 msgid "in C++03 a class-key must be used when declaring a friend"
 msgstr "在中 C++03 class-key 必須被使用時宣告朋友"
 
-#: cp/parser.cc:31036
+#: cp/parser.cc:31100
 #, fuzzy, gcc-internal-format
 msgid "variadic friends or friend type declarations with multiple types only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:31077
+#: cp/parser.cc:31141
 #, gcc-internal-format
 msgid "friend declaration does not name a class or function"
 msgstr "夥伴宣告沒有指定類別或函式名"
 
-#: cp/parser.cc:31117
+#: cp/parser.cc:31181
 #, gcc-internal-format
 msgid "a storage class on an anonymous aggregate in class scope is not allowed"
 msgstr ""
 
-#: cp/parser.cc:31220
+#: cp/parser.cc:31284
 #, fuzzy, gcc-internal-format
 msgid "default member initializers for bit-fields only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "進階初始設定式只列出可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:31227
+#: cp/parser.cc:31291
 #, fuzzy, gcc-internal-format
 msgid "default member initializer for unnamed bit-field"
 msgstr "對齊指定的用於未命名 bit-field"
 
-#: cp/parser.cc:31240
+#: cp/parser.cc:31304
 #, gcc-internal-format
 msgid "ISO C++ allows bit-field attributes only before the %<:%> token"
 msgstr ""
 
-#: cp/parser.cc:31422
+#: cp/parser.cc:31486
 #, fuzzy, gcc-internal-format
 msgid "bit-field %qD has non-integral type %qT"
 msgstr "bit-field %qD 與 non-integral 型態"
 
-#: cp/parser.cc:31450
+#: cp/parser.cc:31514
 #, gcc-internal-format
 msgid "pure-specifier on function-definition"
 msgstr "函式定義上有 pure 指定"
 
-#: cp/parser.cc:31556
+#: cp/parser.cc:31620
 #, fuzzy, gcc-internal-format
 msgid "stray %<,%> at end of member declaration"
 msgstr "預期 %<;%>於結束的成員宣告"
 
-#: cp/parser.cc:31570
+#: cp/parser.cc:31634
 #, fuzzy, gcc-internal-format
 msgid "expected %<;%> at end of member declaration"
 msgstr "預期 %<;%>於結束的成員宣告"
 
-#: cp/parser.cc:31643
+#: cp/parser.cc:31707
 #, fuzzy, gcc-internal-format
 msgid "%<delete%> reason only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:31666
+#: cp/parser.cc:31730
 #, fuzzy, gcc-internal-format
 msgid "invalid pure specifier (only %<= 0%> is allowed)"
 msgstr "無效的 pure 說明符 (只有 %<=0%>被允許)"
 
-#: cp/parser.cc:31701
+#: cp/parser.cc:31765
 #, fuzzy, gcc-internal-format
 msgid "a brace-enclosed initializer is not allowed here"
 msgstr "brace-enclosed 初始設定式未被允許在此"
 
-#: cp/parser.cc:31848
+#: cp/parser.cc:31912
 #, fuzzy, gcc-internal-format
 msgid "attributes on base specifiers are ignored"
 msgstr "方法屬性必須被指定的於結束"
 
-#: cp/parser.cc:31868
+#: cp/parser.cc:31932
 #, fuzzy, gcc-internal-format
 msgid "%<virtual%> specified more than once in base-specifier"
 msgstr "%<virtual%> 指定的一次以上在中 base-specified"
 
-#: cp/parser.cc:31888
+#: cp/parser.cc:31952
 #, fuzzy, gcc-internal-format
 msgid "more than one access specifier in base-specifier"
 msgstr "超過一個存取說明符在中 base-specified"
 
-#: cp/parser.cc:31945
+#: cp/parser.cc:32009
 #, gcc-internal-format
 msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
 msgstr "關鍵字 %<typename%> 不允許用在此上下文中(基礎類別隱含地是一個類型)"
 
-#: cp/parser.cc:32129 cp/parser.cc:32223
+#: cp/parser.cc:32193 cp/parser.cc:32287
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in an exception-specification"
 msgstr "類型可能無法被定義在中 exception-specification"
 
-#: cp/parser.cc:32231
+#: cp/parser.cc:32295
 #, fuzzy, gcc-internal-format
 msgid "ISO C++17 does not allow dynamic exception specifications"
 msgstr "由於不同的異常規格"
 
-#: cp/parser.cc:32237
+#: cp/parser.cc:32301
 #, fuzzy, gcc-internal-format
 msgid "dynamic exception specifications are deprecated in C++11"
 msgstr "動態異常規格被不宜用在中 C++0x; 使用 %<noexcept%> 做為替代"
 
-#: cp/parser.cc:32281
+#: cp/parser.cc:32345
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %<auto%> in exception-specification"
 msgstr "無效的使用的 %<auto%> 在中轉換運算子"
 
-#: cp/parser.cc:32322
+#: cp/parser.cc:32386
 #, fuzzy, gcc-internal-format
 msgid "%<try%> in %<constexpr%> function only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "C++11 %<constexpr%> 只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:32434
+#: cp/parser.cc:32498
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in exception-declarations"
 msgstr "類型可能無法被定義在中 exception-declarations"
 
-#: cp/parser.cc:32469
+#: cp/parser.cc:32533
 #, fuzzy, gcc-internal-format
 #| msgid "%<inline%> in empty declaration"
 msgid "%<alignas%> on exception declaration"
 msgstr "%<inline%> 用於空宣告中"
 
-#: cp/parser.cc:32548
+#: cp/parser.cc:32612
 #, fuzzy, gcc-internal-format
 #| msgid "%qD cannot have default arguments"
 msgid "%<co_yield%> cannot be used in default arguments"
 msgstr "%qD 不能有預設參數"
 
-#: cp/parser.cc:33019
+#: cp/parser.cc:33083
 #, fuzzy, gcc-internal-format
 msgid "expected attribute argument as balanced token sequence"
 msgstr "預期 %qT 但是引數是的型態 %qT"
 
-#: cp/parser.cc:33165
+#: cp/parser.cc:33229
 #, fuzzy, gcc-internal-format
 #| msgid "%s attribute conflicts with %s attribute at %L"
 msgid "attribute using prefix used together with scoped attribute token"
 msgstr "%s 屬性與 %s 屬性在 %L 處衝突"
 
-#: cp/parser.cc:33179
+#: cp/parser.cc:33243
 #, fuzzy, gcc-internal-format
 msgid "expected an identifier for the attribute name"
 msgstr "需要識別碼或 %<(%>"
 
 #. e.g. [[attr()]].
-#: cp/parser.cc:33321
+#: cp/parser.cc:33385
 #, gcc-internal-format
 msgid "parentheses must be omitted if %qE attribute argument list is empty"
 msgstr ""
 
-#: cp/parser.cc:33356
+#: cp/parser.cc:33420
 #, fuzzy, gcc-internal-format
 msgid "attribute %qs specified multiple times"
 msgstr "%qE 屬性未被支援用於 R8C 目標"
 
-#: cp/parser.cc:33399 cp/parser.cc:33491
+#: cp/parser.cc:33463 cp/parser.cc:33555
 #, gcc-internal-format
 msgid "mixing annotations and attributes in the same list"
 msgstr ""
 
-#: cp/parser.cc:33428
+#: cp/parser.cc:33492
 #, fuzzy, gcc-internal-format
 msgid "expected attribute before %<...%>"
 msgstr "預期的參數包裝之前 %<...%>"
 
-#: cp/parser.cc:33431
+#: cp/parser.cc:33495
 #, fuzzy, gcc-internal-format
 #| msgid "nonnull attribute without arguments on a non-prototype"
 msgid "attribute with no arguments contains no parameter packs"
 msgstr "非空的屬性在非原型中沒有引數"
 
-#: cp/parser.cc:33589
+#: cp/parser.cc:33651
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "expected conditional-expression"
 msgstr "需要運算式"
 
-#: cp/parser.cc:33636
+#: cp/parser.cc:33698
 #, fuzzy, gcc-internal-format
 msgid "%qs is only available with %qs"
 msgstr "%qs 是不相容的與 %qs"
 
-#: cp/parser.cc:33652
+#: cp/parser.cc:33714
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute ignored for %qE"
 msgid "attributes are ignored on %qs"
 msgstr "%qE 屬性為 %qE 所忽略"
 
-#: cp/parser.cc:33768
+#: cp/parser.cc:33829
 #, fuzzy, gcc-internal-format
 msgid "attributes are ignored on function contract specifiers"
 msgstr "屬性忽略的於 uninstantiated 型態"
 
-#: cp/parser.cc:33872
+#: cp/parser.cc:33932
 #, gcc-internal-format
 msgid "contracts are only available with %qs"
 msgstr ""
 
-#: cp/parser.cc:33955
+#: cp/parser.cc:34015
 #, fuzzy, gcc-internal-format
 msgid "annotations only available with %<-std=c++2c%> or %<-std=gnu++2c%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:33986
+#: cp/parser.cc:34046
 #, fuzzy, gcc-internal-format
 msgid "attribute using prefix only available with %<-std=c++17%> or %<-std=gnu++17%>"
 msgstr "C++0x 自動只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/parser.cc:34359 cp/parser.cc:34368
+#: cp/parser.cc:34419 cp/parser.cc:34428
 #, fuzzy, gcc-internal-format
 msgid "expression must be enclosed in parentheses"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/parser.cc:34715
+#: cp/parser.cc:34775
 #, gcc-internal-format
 msgid "missing additional %<requires%> to start a requires-expression"
 msgstr ""
 
-#: cp/parser.cc:34956
+#: cp/parser.cc:35016
 #, gcc-internal-format
 msgid "testing if a concept-id is a valid expression; add %<requires%> to check satisfaction"
 msgstr ""
 
-#: cp/parser.cc:35099
+#: cp/parser.cc:35159
 #, fuzzy, gcc-internal-format
 #| msgid "requested position is not an integer constant"
 msgid "result type is not a plain type-constraint"
 msgstr "要求的位置不是一個整數常數"
 
-#: cp/parser.cc:35108
+#: cp/parser.cc:35168
 #, fuzzy, gcc-internal-format
 msgid "return-type-requirement is not a type-constraint"
 msgstr "要求的對齊不是整數常數"
 
-#: cp/parser.cc:35635
+#: cp/parser.cc:35695
 #, fuzzy, gcc-internal-format
 msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
 msgstr "專用化成員 %<%T::%E%>需求 %<模板<>%>語法specializing member %<%T::%E%> requires %<template<>%> syntax專用化成員 %<%T::%E%>需求 %<模板<>%>語法"
 
-#: cp/parser.cc:35640
+#: cp/parser.cc:35700
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of %<%T::%E%>"
 msgstr "無效的宣告的 %<%T::%E%>"
 
-#: cp/parser.cc:35644
+#: cp/parser.cc:35704
 #, gcc-internal-format
 msgid "too few template-parameter-lists"
 msgstr "範本參數表太少"
@@ -70349,438 +70445,438 @@ msgstr "範本參數表太少"
 #. something like:
 #.
 #. template <class T> template <class U> void S::f();
-#: cp/parser.cc:35651
+#: cp/parser.cc:35711
 #, gcc-internal-format
 msgid "too many template-parameter-lists"
 msgstr "範本參數表太多"
 
-#: cp/parser.cc:35945
+#: cp/parser.cc:36005
 #, fuzzy, gcc-internal-format
 #| msgid "qualifiers are not allowed on declaration of %<operator %T%>"
 msgid "template-id not allowed for constructor in C++20"
 msgstr "%<operator %T%> 的宣告中不能使用限定符"
 
-#: cp/parser.cc:36056
+#: cp/parser.cc:36116
 #, gcc-internal-format
 msgid "named return values are no longer supported"
 msgstr "具名回傳值不再被支援"
 
-#: cp/parser.cc:36233
+#: cp/parser.cc:36293
 #, gcc-internal-format
 msgid "ISO C++ did not adopt string literal operator templates taking an argument pack of characters"
 msgstr ""
 
-#: cp/parser.cc:36242
+#: cp/parser.cc:36302
 #, fuzzy, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%> or single non-type parameter of class type"
 msgstr "實字運算子模板 %qD 有無效的參數清單。 預期 non-type 模板引數包裝 <char...>"
 
-#: cp/parser.cc:36248
+#: cp/parser.cc:36308
 #, fuzzy, gcc-internal-format
 msgid "literal operator template %qD has invalid parameter list; expected non-type template parameter pack %<<char...>%>"
 msgstr "實字運算子模板 %qD 有無效的參數清單。 預期 non-type 模板引數包裝 <char...>"
 
-#: cp/parser.cc:36288
+#: cp/parser.cc:36348
 #, fuzzy, gcc-internal-format
 msgid "invalid declaration of member template in local class"
 msgstr "無效的宣告的成員模板在中區域類別"
 
-#: cp/parser.cc:36298
+#: cp/parser.cc:36358
 #, gcc-internal-format
 msgid "template with C linkage"
 msgstr "C 連結的範本"
 
-#: cp/parser.cc:36318
+#: cp/parser.cc:36378
 #, fuzzy, gcc-internal-format
 msgid "invalid explicit specialization"
 msgstr "無效的明確的特殊化"
 
-#: cp/parser.cc:36428
+#: cp/parser.cc:36488
 #, fuzzy, gcc-internal-format
 msgid "template declaration of %<typedef%>"
 msgstr "模板宣告的 %<typedef%>"
 
-#: cp/parser.cc:36479
+#: cp/parser.cc:36539
 #, fuzzy, gcc-internal-format
 #| msgid "declaration does not declare anything"
 msgid "a class template declaration must not declare anything else"
 msgstr "沒有宣告任何東西"
 
-#: cp/parser.cc:36532
+#: cp/parser.cc:36592
 #, fuzzy, gcc-internal-format
 msgid "explicit template specialization cannot have a storage class"
 msgstr "明確的模板特殊化無法有貯藏類別"
 
-#: cp/parser.cc:36851
+#: cp/parser.cc:36911
 #, fuzzy, gcc-internal-format
 msgid "%<>>%> should be %<> >%> within a nested template argument list"
 msgstr "%<>>%>應該是 %<>>%>在之內巢狀的模板引數清單"
 
-#: cp/parser.cc:36864
+#: cp/parser.cc:36924
 #, gcc-internal-format
 msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgstr "可疑的 %<>>%>，使用 %<>%> 來結束範本引數清單"
 
-#: cp/parser.cc:36895
+#: cp/parser.cc:36955
 #, fuzzy, gcc-internal-format
 #| msgid "spurious %<>>%>, use %<>%> to terminate a template argument list"
 msgid "%qs should be %qs to terminate a template argument list"
 msgstr "可疑的 %<>>%>，使用 %<>%> 來結束範本引數清單"
 
-#: cp/parser.cc:37211
+#: cp/parser.cc:37271
 #, gcc-internal-format
 msgid "%<sizeof...%> argument must be surrounded by parentheses"
 msgstr ""
 
-#: cp/parser.cc:37386
+#: cp/parser.cc:37446
 #, fuzzy, gcc-internal-format
 msgid "invalid use of %qD in linkage specification"
 msgstr "無效的使用的 %qD 在中連繫規格"
 
-#: cp/parser.cc:37401
+#: cp/parser.cc:37461
 #, fuzzy, gcc-internal-format
 msgid "%qD specifier conflicts with %qs"
 msgstr "%+D 造成區段型態衝突與 %D"
 
-#: cp/parser.cc:37413
+#: cp/parser.cc:37473
 #, fuzzy, gcc-internal-format
 msgid "%<__thread%> before %qD"
 msgstr "%<__thread%>之前 %qD"
 
-#: cp/parser.cc:37430
+#: cp/parser.cc:37490
 #, fuzzy, gcc-internal-format
 #| msgid "%<__thread%> used with %<typedef%>"
 msgid "%qD specifier conflicts with %<typedef%>"
 msgstr "%<__thread%> 與 %<typedef%> 一起使用"
 
-#: cp/parser.cc:37539
+#: cp/parser.cc:37599
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 does not support %<long long%>"
 msgstr "ISO C++1998 不支援 %<long long%>"
 
-#: cp/parser.cc:37550
+#: cp/parser.cc:37610
 #, fuzzy, gcc-internal-format
 msgid "both %<__thread%> and %<thread_local%> specified"
 msgstr "宣告中同時使用了 %<short%> 和 %<char%>"
 
-#: cp/parser.cc:37555
+#: cp/parser.cc:37615
 #, fuzzy, gcc-internal-format
 msgid "duplicate %qD"
 msgstr "重複的 %qE"
 
-#: cp/parser.cc:37584
+#: cp/parser.cc:37644
 #, gcc-internal-format
 msgid "duplicate %qs"
 msgstr "重複的 %qs"
 
-#: cp/parser.cc:37636
+#: cp/parser.cc:37696
 #, fuzzy, gcc-internal-format
 msgid "expected %<new%>"
 msgstr "預期 %<new%>"
 
-#: cp/parser.cc:37639
+#: cp/parser.cc:37699
 #, fuzzy, gcc-internal-format
 msgid "expected %<delete%>"
 msgstr "預期 %<delete%>"
 
-#: cp/parser.cc:37642
+#: cp/parser.cc:37702
 #, fuzzy, gcc-internal-format
 msgid "expected %<return%>"
 msgstr "預期 %<return%>"
 
-#: cp/parser.cc:37648
+#: cp/parser.cc:37708
 #, fuzzy, gcc-internal-format
 msgid "expected %<extern%>"
 msgstr "預期 %<extern%>"
 
-#: cp/parser.cc:37651
+#: cp/parser.cc:37711
 #, fuzzy, gcc-internal-format
 msgid "expected %<static_assert%>"
 msgstr "預期 %<static_assert%>"
 
-#: cp/parser.cc:37654
+#: cp/parser.cc:37714
 #, fuzzy, gcc-internal-format
 msgid "expected %<decltype%>"
 msgstr "預期 %<decltype%>"
 
-#: cp/parser.cc:37657
+#: cp/parser.cc:37717
 #, fuzzy, gcc-internal-format
 msgid "expected %<operator%>"
 msgstr "預期 %<operator%>"
 
-#: cp/parser.cc:37660
+#: cp/parser.cc:37720
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%>"
 msgstr "預期 %<class%>"
 
-#: cp/parser.cc:37663
+#: cp/parser.cc:37723
 #, fuzzy, gcc-internal-format
 msgid "expected %<template%>"
 msgstr "預期 %<template%>"
 
-#: cp/parser.cc:37666
+#: cp/parser.cc:37726
 #, fuzzy, gcc-internal-format
 msgid "expected %<namespace%>"
 msgstr "預期 %<namespace%>"
 
-#: cp/parser.cc:37669
+#: cp/parser.cc:37729
 #, fuzzy, gcc-internal-format
 msgid "expected %<using%>"
 msgstr "預期 %<using%>"
 
-#: cp/parser.cc:37672
+#: cp/parser.cc:37732
 #, fuzzy, gcc-internal-format
 msgid "expected %<asm%>"
 msgstr "預期 %<asm%>"
 
-#: cp/parser.cc:37675
+#: cp/parser.cc:37735
 #, fuzzy, gcc-internal-format
 msgid "expected %<try%>"
 msgstr "預期 %<try%>"
 
-#: cp/parser.cc:37678
+#: cp/parser.cc:37738
 #, fuzzy, gcc-internal-format
 msgid "expected %<catch%>"
 msgstr "預期 %<catch%>"
 
-#: cp/parser.cc:37681
+#: cp/parser.cc:37741
 #, fuzzy, gcc-internal-format
 msgid "expected %<throw%>"
 msgstr "預期 %<throw%>"
 
-#: cp/parser.cc:37684
+#: cp/parser.cc:37744
 #, fuzzy, gcc-internal-format
 msgid "expected %<auto%>"
 msgstr "預期 %<catch%>"
 
-#: cp/parser.cc:37687
+#: cp/parser.cc:37747
 #, fuzzy, gcc-internal-format
 msgid "expected %<__label__%>"
 msgstr "預期 %<__label__%>"
 
-#: cp/parser.cc:37690
+#: cp/parser.cc:37750
 #, fuzzy, gcc-internal-format
 msgid "expected %<@try%>"
 msgstr "預期 %<@try%>"
 
-#: cp/parser.cc:37693
+#: cp/parser.cc:37753
 #, fuzzy, gcc-internal-format
 msgid "expected %<@synchronized%>"
 msgstr "預期 %<@synchronized%>"
 
-#: cp/parser.cc:37696
+#: cp/parser.cc:37756
 #, fuzzy, gcc-internal-format
 msgid "expected %<@throw%>"
 msgstr "預期 %<@throw%>"
 
-#: cp/parser.cc:37699
+#: cp/parser.cc:37759
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_atomic%>"
 msgstr "預期 %<__transaction_atomic%>"
 
-#: cp/parser.cc:37702
+#: cp/parser.cc:37762
 #, fuzzy, gcc-internal-format
 msgid "expected %<__transaction_relaxed%>"
 msgstr "預期 %<__transaction_relaxed%>"
 
-#: cp/parser.cc:37705
+#: cp/parser.cc:37765
 #, fuzzy, gcc-internal-format
 msgid "expected %<co_yield%>"
 msgstr "預期 %<@end%>"
 
-#: cp/parser.cc:37737
+#: cp/parser.cc:37797
 #, fuzzy, gcc-internal-format
 msgid "expected %<::%>"
 msgstr "預期 %<::%>"
 
-#: cp/parser.cc:37749
+#: cp/parser.cc:37809
 #, fuzzy, gcc-internal-format
 msgid "expected %<...%>"
 msgstr "預期 %<...%>"
 
-#: cp/parser.cc:37752
+#: cp/parser.cc:37812
 #, fuzzy, gcc-internal-format
 msgid "expected %<*%>"
 msgstr "預期 %<*%>"
 
-#: cp/parser.cc:37755
+#: cp/parser.cc:37815
 #, fuzzy, gcc-internal-format
 msgid "expected %<~%>"
 msgstr "預期 %<~%>"
 
-#: cp/parser.cc:37761
+#: cp/parser.cc:37821
 #, fuzzy, gcc-internal-format
 msgid "expected %<:%> or %<::%>"
 msgstr "預期 %<:%>或 %<::%>"
 
-#: cp/parser.cc:37788
+#: cp/parser.cc:37848
 #, fuzzy, gcc-internal-format
 msgid "expected %<class%>, %<typename%>, or %<template%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: cp/parser.cc:37791
+#: cp/parser.cc:37851
 #, fuzzy, gcc-internal-format
 msgid "expected %<:]%>"
 msgstr "預期 %<:%>"
 
-#: cp/parser.cc:38126
+#: cp/parser.cc:38186
 #, gcc-internal-format
 msgid "redundant enum-key %<enum%s%> in reference to %q#T"
 msgstr ""
 
-#: cp/parser.cc:38280
+#: cp/parser.cc:38340
 #, gcc-internal-format
 msgid "%qs tag used in naming %q#T"
 msgstr "使用了 %qs 標記，在命名 %q#T 時"
 
-#: cp/parser.cc:38285
+#: cp/parser.cc:38345
 #, fuzzy, gcc-internal-format
 msgid "%q#T was previously declared here"
 msgstr "%q#T 是在之前宣告的在此"
 
-#: cp/parser.cc:38406
+#: cp/parser.cc:38466
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare reference to %q#T"
 msgid "redundant class-key %qs in reference to %q#T"
 msgstr "無法宣告對 %q#T 的參照"
 
-#: cp/parser.cc:38564 cp/parser.cc:38598
+#: cp/parser.cc:38624 cp/parser.cc:38658
 #, fuzzy, gcc-internal-format
 msgid "%qT declared with a mismatched class-key %qs"
 msgstr "%qT 宣告的與更大可視性比它的基底 %qT"
 
-#: cp/parser.cc:38571 cp/parser.cc:38604
+#: cp/parser.cc:38631 cp/parser.cc:38664
 #, gcc-internal-format
 msgid "remove the class-key or replace it with %qs"
 msgstr ""
 
-#: cp/parser.cc:38572 cp/parser.cc:38605
+#: cp/parser.cc:38632 cp/parser.cc:38665
 #, fuzzy, gcc-internal-format
 msgid "replace the class-key with %qs"
 msgstr "預期 class-key"
 
-#: cp/parser.cc:38579
+#: cp/parser.cc:38639
 #, fuzzy, gcc-internal-format
 msgid "%qT defined as %qs here"
 msgstr "標貼 %qD 定義的在此"
 
-#: cp/parser.cc:38580
+#: cp/parser.cc:38640
 #, fuzzy, gcc-internal-format
 msgid "%qT first declared as %qs here"
 msgstr "%qD 宣告的在此"
 
-#: cp/parser.cc:38663
+#: cp/parser.cc:38723
 #, gcc-internal-format
 msgid "%qD redeclared with different access"
 msgstr "%qD 重宣告時有不同的可存取性"
 
-#: cp/parser.cc:38684
+#: cp/parser.cc:38744
 #, fuzzy, gcc-internal-format
 msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
 msgstr "做為消歧義的 %<template%> 只能用於範本內"
 
-#: cp/parser.cc:38937
+#: cp/parser.cc:38997
 #, gcc-internal-format
 msgid "file ends in default argument"
 msgstr "檔案在預設參數處結束"
 
-#: cp/parser.cc:39178 cp/parser.cc:40490 cp/parser.cc:40679
+#: cp/parser.cc:39238 cp/parser.cc:40550 cp/parser.cc:40739
 #, gcc-internal-format
 msgid "misplaced %<@%D%> Objective-C++ construct"
 msgstr "位置錯誤的 %<@%D%> Objective-C++ 建構"
 
-#: cp/parser.cc:39249
+#: cp/parser.cc:39309
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message receiver expected"
 msgstr "objective-c++ 訊息引數被預期"
 
-#: cp/parser.cc:39323
+#: cp/parser.cc:39383
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ message argument(s) are expected"
 msgstr "objective-c++ 訊息引數被預期"
 
-#: cp/parser.cc:39354
+#: cp/parser.cc:39414
 #, gcc-internal-format
 msgid "%<@encode%> must specify a type as an argument"
 msgstr "%<@encode%> 必須指定一個類型做為引數"
 
-#: cp/parser.cc:39758
+#: cp/parser.cc:39818
 #, gcc-internal-format
 msgid "invalid Objective-C++ selector name"
 msgstr "無效的 Objective-C++ 選擇子名"
 
-#: cp/parser.cc:39833 cp/parser.cc:39851
+#: cp/parser.cc:39893 cp/parser.cc:39911
 #, fuzzy, gcc-internal-format
 msgid "objective-c++ method declaration is expected"
 msgstr "objective-c++ 方法宣告被預期"
 
-#: cp/parser.cc:39845 cp/parser.cc:39911
+#: cp/parser.cc:39905 cp/parser.cc:39971
 #, fuzzy, gcc-internal-format
 msgid "method attributes must be specified at the end"
 msgstr "方法屬性必須被指定的於結束"
 
-#: cp/parser.cc:39954
+#: cp/parser.cc:40014
 #, fuzzy, gcc-internal-format
 msgid "stray %qs between Objective-C++ methods"
 msgstr "零星的 %qs 介於 Objective-C++ 方法"
 
-#: cp/parser.cc:40151 cp/parser.cc:40158 cp/parser.cc:40165
+#: cp/parser.cc:40211 cp/parser.cc:40218 cp/parser.cc:40225
 #, fuzzy, gcc-internal-format
 msgid "invalid type for instance variable"
 msgstr "無效的型態舉例來說變數"
 
-#: cp/parser.cc:40282
+#: cp/parser.cc:40342
 #, gcc-internal-format
 msgid "identifier expected after %<@protocol%>"
 msgstr "%<@protocol%> 需要識別碼"
 
-#: cp/parser.cc:40455
+#: cp/parser.cc:40515
 #, fuzzy, gcc-internal-format
 msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
 msgstr "屬性可能無法被指定的之前 %<@%D%>Objective-C++ 關鍵字"
 
-#: cp/parser.cc:40462
+#: cp/parser.cc:40522
 #, fuzzy, gcc-internal-format
 msgid "prefix attributes are ignored before %<@%D%>"
 msgstr "前綴屬性被忽略之前 %<@%D%>"
 
-#: cp/parser.cc:40742 cp/parser.cc:40749 cp/parser.cc:40756
+#: cp/parser.cc:40802 cp/parser.cc:40809 cp/parser.cc:40816
 #, fuzzy, gcc-internal-format
 msgid "invalid type for property"
 msgstr "無效的型態用於內容"
 
-#: cp/parser.cc:40918
+#: cp/parser.cc:40978
 #, fuzzy, gcc-internal-format
 msgid "unknown property attribute %qE"
 msgstr "不明內容屬性"
 
-#: cp/parser.cc:42220
+#: cp/parser.cc:42280
 #, fuzzy, gcc-internal-format
 msgid "expected integer expression list"
 msgstr "預期的整數運算式"
 
-#: cp/parser.cc:42237
+#: cp/parser.cc:42297
 #, fuzzy, gcc-internal-format
 msgid "%<wait%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/parser.cc:42993
+#: cp/parser.cc:43053
 #, fuzzy, gcc-internal-format
 msgid "expected %<scalar%>, %<aggregate%>, %<all%>"
 msgstr "預期 %<class%>，%<typename%>，或 %<template%>"
 
-#: cp/parser.cc:43395
+#: cp/parser.cc:43455
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid reduction-identifier"
 msgstr "無效的初始值設定"
 
-#: cp/parser.cc:44089
+#: cp/parser.cc:44149
 #, gcc-internal-format
 msgid "legacy %<%E(%E)%> traits syntax not allowed in %<uses_allocators%> clause when using modifiers"
 msgstr ""
 
-#: cp/parser.cc:44725
+#: cp/parser.cc:44785
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined in iterator type"
 msgstr "類型可能無法被定義在中參數類型"
@@ -70789,179 +70885,179 @@ msgstr "類型可能無法被定義在中參數類型"
 #. check above and add one in semantics.cc (to properly handle templates).
 #. Base this on the allocator/align modifiers check for the 'allocate' clause
 #. in semantics.cc's finish_omp_clauses.
-#: cp/parser.cc:47212
+#: cp/parser.cc:47272
 #, fuzzy, gcc-internal-format
 #| msgid "#pragma vtable no longer supported"
 msgid "%<#pragma omp allocate%> not yet supported"
 msgstr "#pragma vtable 不再受支援"
 
-#: cp/parser.cc:48663
+#: cp/parser.cc:48723
 #, fuzzy, gcc-internal-format
 msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
 msgstr "parenthesized 初始化未被允許在中 OpenMP %<for%> 迴圈"
 
-#: cp/parser.cc:49611
+#: cp/parser.cc:49671
 #, gcc-internal-format
 msgid "%<ordered%> clause with parameter on range-based %<for%> loop"
 msgstr ""
 
-#: cp/parser.cc:49693 cp/pt.cc:19188
+#: cp/parser.cc:49753 cp/pt.cc:19329
 #, fuzzy, gcc-internal-format
 msgid "iteration variable %qD should not be reduction"
 msgstr "迭代變數 %qD 不應為消除"
 
-#: cp/parser.cc:52774
+#: cp/parser.cc:52834
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp declare %s%> followed by %<#pragma omp declare %s%>"
 msgstr "%<# pragma GCC pop_options%>而無需相應 %<# pragma GCC push_options%>"
 
-#: cp/parser.cc:53486
+#: cp/parser.cc:53546
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp dispatch%> must be followed by a direct function call with optional assignment"
 msgstr "%<# pragma align%>必須出現之前宣告的 %D, 忽略"
 
-#: cp/parser.cc:53727
+#: cp/parser.cc:53787
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a C pointer"
 msgstr "%qD 並非變數"
 
-#: cp/parser.cc:53853
+#: cp/parser.cc:53913
 #, gcc-internal-format
 msgid "an %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause"
 msgstr ""
 
-#: cp/parser.cc:53974
+#: cp/parser.cc:54034
 #, gcc-internal-format
 msgid "OpenMP directive other than %<declare simd%> or %<declare variant%> appertains to a declaration"
 msgstr ""
 
-#: cp/parser.cc:54549
+#: cp/parser.cc:54609
 #, fuzzy, gcc-internal-format
 msgid "expected %<target%>"
 msgstr "預期 %<try%>"
 
-#: cp/parser.cc:55146
+#: cp/parser.cc:55206
 #, fuzzy, gcc-internal-format
 #| msgid "invalid initializer"
 msgid "invalid initializer clause"
 msgstr "無效的初始值設定"
 
-#: cp/parser.cc:55177
+#: cp/parser.cc:55237
 #, fuzzy, gcc-internal-format
 msgid "expected id-expression (arguments)"
 msgstr "預期 id-expression"
 
-#: cp/parser.cc:55189
+#: cp/parser.cc:55249
 #, gcc-internal-format
 msgid "one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>"
 msgstr ""
 
-#: cp/parser.cc:55292
+#: cp/parser.cc:55352
 #, fuzzy, gcc-internal-format
 #| msgid "new types may not be defined in a return type"
 msgid "types may not be defined in declare reduction type list"
 msgstr "不能在回傳類型中定義新類型"
 
-#: cp/parser.cc:55312 cp/semantics.cc:7048
+#: cp/parser.cc:55372 cp/semantics.cc:7069
 #, gcc-internal-format
 msgid "predeclared arithmetic type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55316 cp/semantics.cc:7056
+#: cp/parser.cc:55376 cp/semantics.cc:7077
 #, gcc-internal-format
 msgid "function or array type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55319 cp/pt.cc:15198 cp/semantics.cc:7062
+#: cp/parser.cc:55379 cp/pt.cc:15319 cp/semantics.cc:7083
 #, gcc-internal-format
 msgid "reference type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55322 cp/semantics.cc:7068
+#: cp/parser.cc:55382 cp/semantics.cc:7089
 #, gcc-internal-format
 msgid "%<const%>, %<volatile%> or %<__restrict%>-qualified type %qT in %<#pragma omp declare reduction%>"
 msgstr ""
 
-#: cp/parser.cc:55519
+#: cp/parser.cc:55579
 #, fuzzy, gcc-internal-format
 msgid "types may not be defined within %<declare mapper%>"
 msgstr "類型可能無法被定義在中參數類型"
 
-#: cp/parser.cc:55691
+#: cp/parser.cc:55751
 #, fuzzy, gcc-internal-format
 msgid "expected %<simd%>, %<reduction%>, %<target%>, %<mapper%> or %<variant%>"
 msgstr "預期 %<# pragma omp section%>或 %<}%>"
 
-#: cp/parser.cc:56256
+#: cp/parser.cc:56316
 #, gcc-internal-format
 msgid "%<#pragma acc routine%> names a set of overloads"
 msgstr ""
 
-#: cp/parser.cc:56266
+#: cp/parser.cc:56326
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member template function"
 msgid "%qD does not refer to a namespace scope function"
 msgstr "%qD 不是一個成員範本函式"
 
-#: cp/parser.cc:56436 cp/parser.cc:56975
+#: cp/parser.cc:56496 cp/parser.cc:57035
 #, fuzzy, gcc-internal-format
 msgid "OpenMP directives may not appear in %<constexpr%> functions"
 msgstr "複合陳述在中 constexpr 函式"
 
 #. cancel-and-throw is unimplemented.
-#: cp/parser.cc:56647
+#: cp/parser.cc:56707
 #, gcc-internal-format
 msgid "%<atomic_cancel%>"
 msgstr ""
 
-#: cp/parser.cc:56842
+#: cp/parser.cc:56902
 #, fuzzy, gcc-internal-format
 msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
 msgstr "外 %<__transaction_cancel%>無法在之內外 %<__transaction_atomic%>"
 
-#: cp/parser.cc:56845
+#: cp/parser.cc:56905
 #, fuzzy, gcc-internal-format
 msgid "  or a %<transaction_may_cancel_outer%> function"
 msgstr "  或 %<transaction_may_cancel_outer%> 函式"
 
-#: cp/parser.cc:56892
+#: cp/parser.cc:56952
 #, fuzzy, gcc-internal-format
 msgid "malformed %<#pragma GCC pch_preprocess%>"
 msgstr "異常的 # pragma GCC 輔助處理器"
 
-#: cp/parser.cc:57229
+#: cp/parser.cc:57289
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp requires%> may only be used at file or namespace scope"
 msgstr "%<# pragma omp taskyield%>也許會只有被已用於複合陳述"
 
-#: cp/parser.cc:57240
+#: cp/parser.cc:57300
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp assumes%> may only be used at file or namespace scope"
 msgstr "%<# pragma omp taskyield%>也許會只有被已用於複合陳述"
 
-#: cp/parser.cc:57327
+#: cp/parser.cc:57387
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma GCC %s%> must be inside a function"
 msgstr "# pragma GCC 最佳化未被允許內部函式"
 
-#: cp/parser.cc:57469
+#: cp/parser.cc:57529
 #, fuzzy, gcc-internal-format
 #| msgid "inter-module optimizations not implemented for C++"
 msgid "multi-source compilation not implemented for C++"
 msgstr "模組間最佳化淍未為 C++ 實作"
 
-#: cp/parser.cc:57609
+#: cp/parser.cc:57669
 #, fuzzy, gcc-internal-format
 #| msgid "standard conversions are not allowed in this context"
 msgid "placeholder type not allowed in this context"
 msgstr "此上下文中不允許標準轉換"
 
-#: cp/parser.cc:57711
+#: cp/parser.cc:57771
 #, fuzzy, gcc-internal-format
 msgid "implicit templates may not be %<virtual%>"
 msgstr "模板可能無法是 %<virtual%>"
 
-#: cp/parser.cc:57767
+#: cp/parser.cc:57827
 #, gcc-internal-format
 msgid "%<extern \"C\"%> linkage started here"
 msgstr ""
@@ -71452,503 +71548,508 @@ msgstr "使用模板<>用於明確的特殊化"
 msgid "redeclaration of %qD with different constraints"
 msgstr "重新宣告 %qD 不同在中 %<constexpr%>"
 
-#: cp/pt.cc:6454
+#: cp/pt.cc:6386
+#, fuzzy, gcc-internal-format
+msgid "local class in lambda in template parameter list"
+msgstr "貯藏類別指定的用於模板參數 %qs"
+
+#: cp/pt.cc:6461
 #, gcc-internal-format
 msgid "%qT is not a template type"
 msgstr "%qT 不是一個範本類型"
 
-#: cp/pt.cc:6467
+#: cp/pt.cc:6474
 #, gcc-internal-format
 msgid "template specifiers not specified in declaration of %qD"
 msgstr "%qD 的宣告中沒有 template 限定"
 
-#: cp/pt.cc:6479
+#: cp/pt.cc:6486
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "redeclared with %d template parameter"
 msgid_plural "redeclared with %d template parameters"
 msgstr[0] "redeclared 與 %d 模板參數"
 
-#: cp/pt.cc:6483
+#: cp/pt.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "previous declaration %qD used %d template parameter"
 msgid_plural "previous declaration %qD used %d template parameters"
 msgstr[0] "前一個宣告 %q+D 使用 %d 模板參數"
 
-#: cp/pt.cc:6517
+#: cp/pt.cc:6524
 #, gcc-internal-format
 msgid "template parameter %q+#D"
 msgstr "範本參數 %q+#D"
 
-#: cp/pt.cc:6519
+#: cp/pt.cc:6526
 #, gcc-internal-format
 msgid "redeclared here as %q#D"
 msgstr "在這裡又被宣告為 %q#D"
 
-#: cp/pt.cc:6521
+#: cp/pt.cc:6528
 #, fuzzy, gcc-internal-format
 msgid "redeclared here"
 msgstr "宣告的在此"
 
-#: cp/pt.cc:6532
+#: cp/pt.cc:6539
 #, fuzzy, gcc-internal-format
 msgid "declaration of template parameter %q+#D with different constraints"
 msgstr "重新宣告 %qD 不同在中 %<constexpr%>"
 
-#: cp/pt.cc:6535 cp/pt.cc:6563
+#: cp/pt.cc:6542 cp/pt.cc:6570
 #, fuzzy, gcc-internal-format
 msgid "original declaration appeared here"
 msgstr "原來的定義出現的在此"
 
-#: cp/pt.cc:6560
+#: cp/pt.cc:6567
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %q#D with different constraints"
 msgstr "重新宣告 %qD 不同在中 %<constexpr%>"
 
-#: cp/pt.cc:7010 cp/pt.cc:7082
+#: cp/pt.cc:7035 cp/pt.cc:7107
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT"
 msgstr "%qE 並非有效模板引數用於型態 %qT"
 
-#: cp/pt.cc:7013
+#: cp/pt.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "it must be the address of a function with external linkage"
 msgstr "它必須是位址的函式與外部連結"
 
-#: cp/pt.cc:7016
+#: cp/pt.cc:7041
 #, fuzzy, gcc-internal-format
 msgid "it must be the name of a function with external linkage"
 msgstr "它必須是位址的函式與外部連結"
 
-#: cp/pt.cc:7031
+#: cp/pt.cc:7056
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
 msgstr "%qE 並非有效模板引數用於型態 %qT 因為 %qD 沒有任何鏈結"
 
-#: cp/pt.cc:7035
+#: cp/pt.cc:7060
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
 msgstr "%qE 並非有效模板引數用於型態 %qT 因為 %qD 沒有外部連結"
 
-#: cp/pt.cc:7085
+#: cp/pt.cc:7110
 #, fuzzy, gcc-internal-format
 msgid "it must be a pointer-to-member of the form %<&X::Y%>"
 msgstr "它必須是成員指標的形式 %<&X::Y%>"
 
-#: cp/pt.cc:7087
+#: cp/pt.cc:7112
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a member of %qT"
 msgid "because it is a member of %qT"
 msgstr "%qD 不是 %qT 的成員"
 
-#: cp/pt.cc:7156
+#: cp/pt.cc:7182
 #, fuzzy, gcc-internal-format
 msgid "  couldn%'t deduce template parameter %qD"
 msgstr "  無法 deduce 模板參數 %qD"
 
-#: cp/pt.cc:7165
+#: cp/pt.cc:7191
 #, fuzzy, gcc-internal-format
 msgid "  types %qT and %qT have incompatible cv-qualifiers"
 msgstr "  類型 %qT 和 %qT 有不相容的 cv-qualifiers"
 
-#: cp/pt.cc:7174
+#: cp/pt.cc:7200
 #, fuzzy, gcc-internal-format
 msgid "  mismatched types %qT and %qT"
 msgstr "  不匹配的類型 %qT 和 %qT"
 
-#: cp/pt.cc:7183
+#: cp/pt.cc:7209
 #, fuzzy, gcc-internal-format
 msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
 msgstr "  模板參數 %qD 並非參數包裝，但是引數 %qD 是"
 
-#: cp/pt.cc:7194
+#: cp/pt.cc:7220
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match pointer-to-member constant %qE"
 msgstr "  模板引數 %qE 不匹配成員指標常數 %qE"
 
-#: cp/pt.cc:7204
+#: cp/pt.cc:7230
 #, fuzzy, gcc-internal-format
 msgid "  %qE is not equivalent to %qE"
 msgstr "  %qE 不是 equivalent 到 %qE"
 
-#: cp/pt.cc:7213
+#: cp/pt.cc:7239
 #, fuzzy, gcc-internal-format
 msgid "  inconsistent parameter pack deduction with %qT and %qT"
 msgstr "  不一致參數包裝推導與 %qT 和 %qT"
 
-#: cp/pt.cc:7225
+#: cp/pt.cc:7251
 #, fuzzy, gcc-internal-format
 msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
 msgstr "  deduced 衝突類型用於參數 %qT (%qT 和 %qT)"
 
-#: cp/pt.cc:7229
+#: cp/pt.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
 msgstr "  deduced 衝突值用於 non-type 參數 %qE (%qE 和 %qE)"
 
-#: cp/pt.cc:7240
+#: cp/pt.cc:7266
 #, fuzzy, gcc-internal-format
 msgid "  variable-sized array type %qT is not a valid template argument"
 msgstr "  variable-sized 陣列類型 %qT 並非有效模板引數"
 
-#: cp/pt.cc:7251
+#: cp/pt.cc:7277
 #, fuzzy, gcc-internal-format
 msgid "  member function type %qT is not a valid template argument"
 msgstr "  成員函數型式 %qT 並非有效模板引數"
 
-#: cp/pt.cc:7263
+#: cp/pt.cc:7289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects at least %d argument, %d provided"
 msgid_plural "  candidate expects at least %d arguments, %d provided"
 msgstr[0] "  candidate 預期 %d 引數，%d 提供"
 
-#: cp/pt.cc:7268
+#: cp/pt.cc:7294
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "  candidate expects %d argument, %d provided"
 msgid_plural "  candidate expects %d arguments, %d provided"
 msgstr[0] "  candidate 預期 %d 引數，%d 提供"
 
-#: cp/pt.cc:7294
+#: cp/pt.cc:7320
 #, fuzzy, gcc-internal-format
 msgid "  cannot convert %qE (type %qT) to type %qT"
 msgstr "  無法轉換 %qE (型態 %qT) 輸入 %qT"
 
-#: cp/pt.cc:7307
+#: cp/pt.cc:7333
 #, fuzzy, gcc-internal-format
 msgid "  %qT is an ambiguous base class of %qT"
 msgstr "  %qT 是模稜兩可的基礎類別的 %qT"
 
-#: cp/pt.cc:7311
+#: cp/pt.cc:7337
 #, fuzzy, gcc-internal-format
 msgid "  %qT is not derived from %qT"
 msgstr "  %qT 未被衍生自 %qT"
 
-#: cp/pt.cc:7322
+#: cp/pt.cc:7348
 #, fuzzy, gcc-internal-format
 msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
 msgstr "  模板參數的模板模板引數是不一致與其他 deduced 模板引數"
 
-#: cp/pt.cc:7332
+#: cp/pt.cc:7358
 #, fuzzy, gcc-internal-format
 msgid "  cannot deduce a template for %qT from non-template type %qT"
 msgstr "  無法 deduce 模板用於 %qT 從 non-template 型態 %qT"
 
-#: cp/pt.cc:7342
+#: cp/pt.cc:7368
 #, fuzzy, gcc-internal-format
 msgid "  template argument %qE does not match %qE"
 msgstr "  模板引數 %qE 不匹配 %qD"
 
-#: cp/pt.cc:7393
+#: cp/pt.cc:7419
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qE is not a variable or function"
 msgstr "%qE 並非有效模板引數的型態 %qT 因為 %qE 並非變數"
 
-#: cp/pt.cc:7402
+#: cp/pt.cc:7428
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT in C++98 because %qD does not have external linkage"
 msgstr "%qE 並非有效模板引數的型態 %qT 因為 %qD 沒有外部連結"
 
-#: cp/pt.cc:7412
+#: cp/pt.cc:7438
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
 msgstr "%qE 並非有效模板引數的型態 %qT 因為 %qD 沒有任何鏈結"
 
-#: cp/pt.cc:7429
+#: cp/pt.cc:7455
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument"
 msgstr "  variable-sized 陣列類型 %qT 並非有效模板引數"
 
-#: cp/pt.cc:7439
+#: cp/pt.cc:7465
 #, fuzzy, gcc-internal-format
 msgid "the address of the %qT subobject of %qD is not a valid template argument"
 msgstr "  variable-sized 陣列類型 %qT 並非有效模板引數"
 
-#: cp/pt.cc:7446
+#: cp/pt.cc:7472
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD is not a valid template argument because it does not have static storage duration"
 msgstr "%qE 並非有效模板引數的型態 %qT 因為 %qD 沒有外部連結"
 
-#: cp/pt.cc:7469
+#: cp/pt.cc:7495
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
 msgstr "%qD 並非有效模板引數因為 %qD 是變數，不是位址的變數"
 
-#: cp/pt.cc:7473
+#: cp/pt.cc:7499
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
 msgstr "%qD 並非有效模板引數因為 %qD 是變數，不是位址的變數"
 
-#: cp/pt.cc:7610
+#: cp/pt.cc:7638
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
 msgstr "%qE 不是類型 %qT 的有效範本引數，因為字面字串不能用在此上下文中"
 
-#: cp/pt.cc:7777
+#: cp/pt.cc:7805
 #, fuzzy, gcc-internal-format
 msgid "in template argument for type %qT"
 msgstr "在中模板引數用於型態 %qT "
 
-#: cp/pt.cc:7791
+#: cp/pt.cc:7819
 #, fuzzy, gcc-internal-format
 msgid "template argument %qE for type %qT not a compile-time constant"
 msgstr "在中模板引數用於型態 %qT "
 
-#: cp/pt.cc:7877
+#: cp/pt.cc:7905
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
 msgstr "%qE 不是類型 %qT 的有效範本引數，因為 cv 限定衝突"
 
-#: cp/pt.cc:7885
+#: cp/pt.cc:7913
 #, fuzzy, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
 msgstr "%qE 並非有效模板引數用於型態 %qT 因為它不是 lvalue"
 
-#: cp/pt.cc:7903
+#: cp/pt.cc:7931
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
 msgstr "%q#D 並非有效模板引數用於型態 %qT 因為參考變數沒有常數位址"
 
-#: cp/pt.cc:7963
+#: cp/pt.cc:7991
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is a pointer"
 msgstr "%qE 不是類型 %qT 的有效範本引數，因為它是一個指標"
 
-#: cp/pt.cc:7965
+#: cp/pt.cc:7993
 #, gcc-internal-format
 msgid "try using %qE instead"
 msgstr "嘗試使用 %qE 代替"
 
-#: cp/pt.cc:8019 cp/pt.cc:8051
+#: cp/pt.cc:8047 cp/pt.cc:8079
 #, gcc-internal-format
 msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
 msgstr "%qE 不是類型 %qT 的有效範本引數，因為它的類型是 %qT"
 
-#: cp/pt.cc:8645
+#: cp/pt.cc:8673
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes on template argument %qT"
 msgstr "忽略屬性於模板引數 %qT"
 
-#: cp/pt.cc:8661
+#: cp/pt.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "ignoring attributes in template argument %qE"
 msgstr "忽略屬性於模板引數 %qT"
 
-#: cp/pt.cc:8804
+#: cp/pt.cc:8832
 #, fuzzy, gcc-internal-format
 msgid "injected-class-name %qD used as template template argument"
 msgstr "injected-class-name %qD 使用的做為模板模板引數"
 
-#: cp/pt.cc:8833
+#: cp/pt.cc:8861
 #, fuzzy, gcc-internal-format
 msgid "invalid use of destructor %qE as a type"
 msgstr "無效的使用的解構式 %qE 做為型態"
 
-#: cp/pt.cc:8838
+#: cp/pt.cc:8866
 #, gcc-internal-format
 msgid "to refer to a type member of a template parameter, use %<typename %E%>"
 msgstr "需要使用某個範本參數的類型成員時，請使用 %<typename %E%>"
 
-#: cp/pt.cc:8855 cp/pt.cc:8890 cp/pt.cc:8941
+#: cp/pt.cc:8883 cp/pt.cc:8918 cp/pt.cc:8969
 #, gcc-internal-format
 msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgstr "引數 %d 的類型/值不匹配，在 %qD 的範本參數清單中"
 
-#: cp/pt.cc:8863
+#: cp/pt.cc:8891
 #, gcc-internal-format
 msgid "  expected a constant of type %qT, got %qT"
 msgstr "  需要一個 %qT 類型的常數，卻給出了 %qT"
 
-#: cp/pt.cc:8871
+#: cp/pt.cc:8899
 #, fuzzy, gcc-internal-format
 msgid "  ambiguous template argument for non-type template parameter is treated as function type"
 msgstr "預設引數用於模板參數用於類別封閉 %qD"
 
-#: cp/pt.cc:8877
+#: cp/pt.cc:8905
 #, gcc-internal-format
 msgid "  expected a class template, got %qE"
 msgstr "  需要一個類別範本，卻給出了 %qE"
 
-#: cp/pt.cc:8880
+#: cp/pt.cc:8908
 #, gcc-internal-format
 msgid "  expected a type, got %qE"
 msgstr "  需要一個類型，卻給出了 %qE"
 
-#: cp/pt.cc:8895
+#: cp/pt.cc:8923
 #, gcc-internal-format
 msgid "  expected a type, got %qT"
 msgstr "  需要一個類型，卻給出了 %qT"
 
-#: cp/pt.cc:8898
+#: cp/pt.cc:8926
 #, gcc-internal-format
 msgid "  expected a class template, got %qT"
 msgstr "  需要一個類別範本，卻給出了 %qT"
 
-#: cp/pt.cc:8945
+#: cp/pt.cc:8973
 #, fuzzy, gcc-internal-format
 msgid "  expected a template of type %qD, got %qT"
 msgstr "  預期的模板的型態 %qD，得到 %qT"
 
-#: cp/pt.cc:8960
+#: cp/pt.cc:8988
 #, fuzzy, gcc-internal-format
 #| msgid "type/value mismatch at argument %d in template parameter list for %qD"
 msgid "constraint mismatch at argument %d in template parameter list for %qD"
 msgstr "引數 %d 的類型/值不匹配，在 %qD 的範本參數清單中"
 
-#: cp/pt.cc:8963
+#: cp/pt.cc:8991
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "  expected %qD but got %qD"
 msgstr "  需要一個類型，卻給出了 %qE"
 
-#: cp/pt.cc:9050
+#: cp/pt.cc:9078
 #, fuzzy, gcc-internal-format
 #| msgid "could not convert template argument %qE to %qT"
 msgid "could not convert template argument %qE from %qT to %qT"
 msgstr "不能將範本參數從 %qE 轉換到 %qT"
 
-#: cp/pt.cc:9178 cp/pt.cc:9514
+#: cp/pt.cc:9206 cp/pt.cc:9542
 #, gcc-internal-format, gfc-internal-format
 msgid "template argument %d is invalid"
 msgstr "範本參數 %d 無效"
 
-#: cp/pt.cc:9193 cp/pt.cc:9339
+#: cp/pt.cc:9221 cp/pt.cc:9367
 #, gcc-internal-format, gfc-internal-format
 msgid "wrong number of template arguments (%d, should be %d)"
 msgstr "範本參數數目不正確(不應是 %d 個而應是 %d 個)"
 
-#: cp/pt.cc:9335
+#: cp/pt.cc:9363
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "wrong number of template arguments (%d, should be at least %d)"
 msgstr "範本參數數目不正確(不應是 %d 個而應是 %d 個)"
 
-#: cp/pt.cc:9344
+#: cp/pt.cc:9372
 #, fuzzy, gcc-internal-format
 #| msgid "provided for %q+D"
 msgid "provided for %qD"
 msgstr "提供給 %q+D"
 
-#: cp/pt.cc:9370
+#: cp/pt.cc:9398
 #, fuzzy, gcc-internal-format
 msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
 msgstr "預設引數用於模板參數用於類別封閉 %qD"
 
-#: cp/pt.cc:9374
+#: cp/pt.cc:9402
 #, fuzzy, gcc-internal-format
 #| msgid "default argument given for parameter %d of %q#D"
 msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
 msgstr "為參數 %d (屬於 %q#D)指定了預設引數"
 
-#: cp/pt.cc:9475
+#: cp/pt.cc:9503
 #, gcc-internal-format
 msgid "so any instantiation with a non-empty parameter pack would be ill-formed"
 msgstr ""
 
-#: cp/pt.cc:10052
+#: cp/pt.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%q#D is not a function template"
 msgstr "%q#D 並非函式模板"
 
-#: cp/pt.cc:10247
+#: cp/pt.cc:10275
 #, gcc-internal-format
 msgid "non-template type %qT used as a template"
 msgstr "非範本類型 %qT 做為範本"
 
-#: cp/pt.cc:10249
+#: cp/pt.cc:10277
 #, gcc-internal-format
 msgid "for template declaration %q+D"
 msgstr "對於範本宣告 %q+D"
 
-#: cp/pt.cc:10418 cp/pt.cc:23643
+#: cp/pt.cc:10446 cp/pt.cc:23801
 #, fuzzy, gcc-internal-format
 #| msgid "internal consistency failure"
 msgid "template constraint failure for %qD"
 msgstr "內部一致性錯誤"
 
-#: cp/pt.cc:10768
+#: cp/pt.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "use of %qs in template"
 msgid "use of invalid variable template %qE"
 msgstr "在範本中使用 %qs"
 
-#: cp/pt.cc:11508
+#: cp/pt.cc:11536
 #, fuzzy, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "模板具現化深度超出最大值的 %d (使用 -ftemplate-depth=到增加最大值) 替代 %qS"
 
-#: cp/pt.cc:12444
+#: cp/pt.cc:12472
 #, fuzzy, gcc-internal-format
 msgid "score argument must be constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: cp/pt.cc:12453
+#: cp/pt.cc:12481
 #, fuzzy, gcc-internal-format
 msgid "score argument must be non-negative"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: cp/pt.cc:12480
+#: cp/pt.cc:12508
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression or string literal"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/pt.cc:12484
+#: cp/pt.cc:12512
 #, fuzzy, gcc-internal-format
 msgid "property must be constant integer expression"
 msgstr "預期的整數運算式"
 
-#: cp/pt.cc:12713
+#: cp/pt.cc:12741
 #, fuzzy, gcc-internal-format
 #| msgid "  in instantiation of template %qT"
 msgid "instantiating erroneous template"
 msgstr "  在範本 %qT 的實體化中"
 
-#: cp/pt.cc:12714
+#: cp/pt.cc:12742
 #, fuzzy, gcc-internal-format
 #| msgid "%J  first type here"
 msgid "first error appeared here"
 msgstr "%J  第一個類型在這裡"
 
-#: cp/pt.cc:13082
+#: cp/pt.cc:13110
 #, fuzzy, gcc-internal-format
 msgid "flexible array member %qD in union"
 msgstr "flexible 陣列成員在中聯合"
 
-#: cp/pt.cc:13601
+#: cp/pt.cc:13629
 #, gcc-internal-format
 msgid "fold of empty expansion over %O"
 msgstr ""
 
-#: cp/pt.cc:14078
+#: cp/pt.cc:14189
 #, fuzzy, gcc-internal-format
 #| msgid "%qE is not at beginning of declaration"
 msgid "%qE is not the entire pattern of the pack expansion"
 msgstr "%qE 沒有出現在宣告的開頭"
 
-#: cp/pt.cc:14204
+#: cp/pt.cc:14321
 #, fuzzy, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qT"
 msgstr "不匹配的引數包裝長度當展開 %<%T%>"
 
-#: cp/pt.cc:14207
+#: cp/pt.cc:14324
 #, fuzzy, gcc-internal-format
 msgid "mismatched argument pack lengths while expanding %qE"
 msgstr "不匹配的引數包裝長度當展開 %<%E%>"
 
-#: cp/pt.cc:14412
+#: cp/pt.cc:14529
 #, gcc-internal-format
 msgid "cannot index an empty pack"
 msgstr ""
 
-#: cp/pt.cc:14868
+#: cp/pt.cc:14989
 #, fuzzy, gcc-internal-format
 msgid "  when instantiating default argument for call to %qD"
 msgstr "重定義 %q#D 的預設參數"
 
-#: cp/pt.cc:14965
+#: cp/pt.cc:15086
 #, gcc-internal-format
 msgid "creating pointer to member function of non-class type %qT"
 msgstr "產生非類別類型 %qT 的成員函式指標"
 
-#: cp/pt.cc:15976
+#: cp/pt.cc:16097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "mismatched argument pack lengths (%d vs %d)"
 msgstr "不匹配的引數包裝長度當展開 %<%T%>"
@@ -71966,126 +72067,126 @@ msgstr "不匹配的引數包裝長度當展開 %<%T%>"
 #.
 #. is an attempt to declare a variable with function
 #. type.
-#: cp/pt.cc:16178
+#: cp/pt.cc:16332
 #, fuzzy, gcc-internal-format
 msgid "variable %qD has function type"
 msgstr "變數 %qD 有函數型式"
 
-#: cp/pt.cc:16403
+#: cp/pt.cc:16530
 #, gcc-internal-format
 msgid "invalid parameter type %qT"
 msgstr "無效的參數類型 %qT"
 
-#: cp/pt.cc:16405
+#: cp/pt.cc:16532
 #, gcc-internal-format
 msgid "in declaration %q+D"
 msgstr "在宣告 %q+D 中"
 
-#: cp/pt.cc:16532
+#: cp/pt.cc:16659
 #, gcc-internal-format
 msgid "function returning an array"
 msgstr "函式回傳了一個陣列"
 
-#: cp/pt.cc:16534
+#: cp/pt.cc:16661
 #, gcc-internal-format
 msgid "function returning a function"
 msgstr "函式回傳了一個函式"
 
-#: cp/pt.cc:16784
+#: cp/pt.cc:16914
 #, fuzzy, gcc-internal-format
 #| msgid "%<locus%> is not defined as a type"
 msgid "%qE is not usable in a splice type"
 msgstr "%<locus%> 未被定義為一個類型"
 
-#: cp/pt.cc:16786
+#: cp/pt.cc:16916
 #, fuzzy, gcc-internal-format
 msgid "%qE is not usable in a splice scope"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: cp/pt.cc:17367
+#: cp/pt.cc:17508
 #, gcc-internal-format
 msgid "forming reference to void"
 msgstr "形成對 void 的參照"
 
-#: cp/pt.cc:17369
+#: cp/pt.cc:17510
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to reference type %qT"
 msgstr "表單指標到參考類型 %qT"
 
-#: cp/pt.cc:17371
+#: cp/pt.cc:17512
 #, fuzzy, gcc-internal-format
 msgid "forming reference to reference type %qT"
 msgstr "表單參考到參考類型 %qT"
 
-#: cp/pt.cc:17384
+#: cp/pt.cc:17525
 #, fuzzy, gcc-internal-format
 msgid "forming pointer to qualified function type %qT"
 msgstr "無法宣告指標到經資格修飾函數型式 %qT"
 
-#: cp/pt.cc:17387
+#: cp/pt.cc:17528
 #, fuzzy, gcc-internal-format
 msgid "forming reference to qualified function type %qT"
 msgstr "無法宣告參考到經資格修飾函數型式 %qT"
 
-#: cp/pt.cc:17440
+#: cp/pt.cc:17581
 #, gcc-internal-format
 msgid "creating pointer to member of non-class type %qT"
 msgstr "產生非類別類型 %qT 的成員指標"
 
-#: cp/pt.cc:17446
+#: cp/pt.cc:17587
 #, gcc-internal-format
 msgid "creating pointer to member reference type %qT"
 msgstr "產生參照類型 %qT 的成員指標"
 
-#: cp/pt.cc:17452
+#: cp/pt.cc:17593
 #, gcc-internal-format
 msgid "creating pointer to member of type void"
 msgstr "建立參照 void 類型的成員指標"
 
-#: cp/pt.cc:17521
+#: cp/pt.cc:17662
 #, gcc-internal-format
 msgid "creating array of %qT"
 msgstr "產生 %qT 的陣列"
 
-#: cp/pt.cc:17562
+#: cp/pt.cc:17703
 #, fuzzy, gcc-internal-format
 #| msgid "array %q+D assumed to have one element"
 msgid "%qD expanded to more than one element"
 msgstr "假定陣列 %q+D 有一個元素"
 
-#: cp/pt.cc:17569
+#: cp/pt.cc:17710
 #, gcc-internal-format
 msgid "%qD is instantiated for an empty pack"
 msgstr ""
 
-#: cp/pt.cc:17623
+#: cp/pt.cc:17764
 #, gcc-internal-format
 msgid "%qT is not a class, struct, or union type"
 msgstr "%qT 不是類別、結構或聯合類型"
 
-#: cp/pt.cc:17657
+#: cp/pt.cc:17798
 #, gcc-internal-format
 msgid "%qT resolves to %qT, which is not an enumeration type"
 msgstr "%qT 被解析到非列舉類型 %qT"
 
-#: cp/pt.cc:17666
+#: cp/pt.cc:17807
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is is not a class type"
 msgid "%qT resolves to %qT, which is not a non-union class type"
 msgstr "%qT 被解析到非類別類型 %qT"
 
-#: cp/pt.cc:17674
+#: cp/pt.cc:17815
 #, fuzzy, gcc-internal-format
 #| msgid "%qT resolves to %qT, which is not an enumeration type"
 msgid "%qT resolves to %qT, which is not a union type"
 msgstr "%qT 被解析到非列舉類型 %qT"
 
-#: cp/pt.cc:17810
+#: cp/pt.cc:17951
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of a type template"
 msgstr "預期 selection-statement"
 
-#: cp/pt.cc:17844
+#: cp/pt.cc:17985
 #, gcc-internal-format
 msgid "use of %qs in template"
 msgstr "在範本中使用 %qs"
@@ -72093,212 +72194,212 @@ msgstr "在範本中使用 %qs"
 #. Lookup succeeded at parse time, but failed during
 #. instantiation; must be because we're trying to refer to it
 #. while forming its declaration (c++/120204).
-#: cp/pt.cc:18017
+#: cp/pt.cc:18158
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "declaration of %<%T::%D%> depends on itself"
 msgstr "在初次使用後明確特例化 %qD"
 
-#: cp/pt.cc:18173
+#: cp/pt.cc:18314
 #, fuzzy, gcc-internal-format
 msgid "qualifying type %qT does not match destructor name ~%qT"
 msgstr "限定型態 %qT 不匹配解構式名稱 ~%qT"
 
-#: cp/pt.cc:18189
+#: cp/pt.cc:18330
 #, gcc-internal-format
 msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
 msgstr "依賴名 %qE 被解析為非類型，但實體化卻產生了一個類型"
 
-#: cp/pt.cc:18191
+#: cp/pt.cc:18332
 #, gcc-internal-format
 msgid "say %<typename %E%> if a type is meant"
 msgstr "如果您想指定類型，請使用 %<typename %E%>"
 
-#: cp/pt.cc:18277
+#: cp/pt.cc:18418
 #, fuzzy, gcc-internal-format
 msgid "initializer for %q#D expands to an empty list of expressions"
 msgstr "初始設定式元件並非常數運算式"
 
-#: cp/pt.cc:20655 cp/pt.cc:22967
+#: cp/pt.cc:20801 cp/pt.cc:23125
 #, fuzzy, gcc-internal-format
 msgid "invalid use of pack expansion expression"
 msgstr "無效的使用的包裝擴展運算式"
 
-#: cp/pt.cc:20659 cp/pt.cc:22971
+#: cp/pt.cc:20805 cp/pt.cc:23129
 #, fuzzy, gcc-internal-format
 msgid "use %<...%> to expand argument pack"
 msgstr "使用 %<...%>到展開引數包裝"
 
-#: cp/pt.cc:20806
+#: cp/pt.cc:20952
 #, fuzzy, gcc-internal-format
 msgid "empty initializer in lambda init-capture"
 msgstr "ISO C++不允許初始設定式在中 lambda 運算式擷取清單"
 
-#: cp/pt.cc:22178
+#: cp/pt.cc:22326
 #, fuzzy, gcc-internal-format
 msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
 msgstr "%qD 未被宣告在中這個範圍，而找不到任何宣告是由 argument-dependent 查找於點的實體化"
 
-#: cp/pt.cc:22213
+#: cp/pt.cc:22361
 #, fuzzy, gcc-internal-format
 msgid "declarations in dependent base %qT are not found by unqualified lookup"
 msgstr "宣告在中附屬基底 %qT 找不到由資格不符的查找"
 
-#: cp/pt.cc:22218
+#: cp/pt.cc:22366
 #, fuzzy, gcc-internal-format
 msgid "use %<this->%D%> instead"
 msgstr "使用 %<this->%D%>做為替代"
 
-#: cp/pt.cc:22221
+#: cp/pt.cc:22369
 #, fuzzy, gcc-internal-format
 msgid "use %<%T::%D%> instead"
 msgstr "使用 %<%T::%D%>做為替代"
 
-#: cp/pt.cc:22226
+#: cp/pt.cc:22374
 #, fuzzy, gcc-internal-format
 msgid "%qD declared here, later in the translation unit"
 msgstr "%q+D 宣告的在此，稍後在中轉譯單位"
 
-#: cp/pt.cc:22277
+#: cp/pt.cc:22425
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<__builtin_convertvector%>"
 msgstr "錯誤的引數數量到 %<__builtin_choose_expr%>"
 
-#: cp/pt.cc:22304
+#: cp/pt.cc:22452
 #, fuzzy, gcc-internal-format
 msgid "wrong number of arguments to %<assume%> attribute"
 msgstr "錯誤的引數數量指定的用於 %qE 屬性"
 
-#: cp/pt.cc:22552
+#: cp/pt.cc:22710
 #, gcc-internal-format
 msgid "%qT is not a class or namespace"
 msgstr "%qT 既不是類別也不是命名空間"
 
-#: cp/pt.cc:22555
+#: cp/pt.cc:22713
 #, gcc-internal-format
 msgid "%qD is not a class or namespace"
 msgstr "%qD 既不是類別也不是命名空間"
 
-#: cp/pt.cc:22884
+#: cp/pt.cc:23042
 #, gcc-internal-format
 msgid "using invalid field %qD"
 msgstr "使用無效欄位 %qD"
 
-#: cp/pt.cc:23273
+#: cp/pt.cc:23431
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is/uses anonymous type"
 msgid "%qT is/uses unnamed type"
 msgstr "%qT 是/使用了匿名類型"
 
-#: cp/pt.cc:23275
+#: cp/pt.cc:23433
 #, fuzzy, gcc-internal-format
 msgid "template argument for %qD uses local type %qT"
 msgstr "模板引數用於 %qD 使用本地型態 %qT"
 
-#: cp/pt.cc:23285
+#: cp/pt.cc:23443
 #, gcc-internal-format
 msgid "%qT is a variably modified type"
 msgstr "%qT 是一個可變類型"
 
-#: cp/pt.cc:23300
+#: cp/pt.cc:23458
 #, gcc-internal-format
 msgid "integral expression %qE is not constant"
 msgstr "整型運算式 %qE 不是常數"
 
-#: cp/pt.cc:23318
+#: cp/pt.cc:23476
 #, gcc-internal-format
 msgid "  trying to instantiate %qD"
 msgstr "  試圖實體化 %qD"
 
-#: cp/pt.cc:27733
+#: cp/pt.cc:27891
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#T"
 msgstr "%q#T 的類別範本實體化有歧義"
 
-#: cp/pt.cc:27735
+#: cp/pt.cc:27893
 #, fuzzy, gcc-internal-format
 #| msgid "ambiguous class template instantiation for %q#T"
 msgid "ambiguous template instantiation for %q#D"
 msgstr "%q#T 的類別範本實體化有歧義"
 
-#: cp/pt.cc:27741
+#: cp/pt.cc:27899
 #, fuzzy
 msgid "%s %#qS"
 msgstr "%s %+#D"
 
-#: cp/pt.cc:27768 cp/pt.cc:27855
+#: cp/pt.cc:27926 cp/pt.cc:28013
 #, gcc-internal-format
 msgid "explicit instantiation of non-template %q#D"
 msgstr "對非範本 %q#D 的明確實體化"
 
-#: cp/pt.cc:27787
+#: cp/pt.cc:27945
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a static data member of a class template"
 msgstr "%qD 並非靜態資料成員的類別模板"
 
-#: cp/pt.cc:27793 cp/pt.cc:27850
+#: cp/pt.cc:27951 cp/pt.cc:28008
 #, gcc-internal-format
 msgid "no matching template for %qD found"
 msgstr "沒有找到與 %qD 匹配的範本"
 
-#: cp/pt.cc:27798
+#: cp/pt.cc:27956
 #, fuzzy, gcc-internal-format
 msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
 msgstr "型態 %qT 用於明確的實體化 %qD 不匹配宣告的型態 %qT"
 
-#: cp/pt.cc:27806
+#: cp/pt.cc:27964
 #, gcc-internal-format
 msgid "explicit instantiation of %q#D"
 msgstr "對 %q#D 的明確實體化"
 
-#: cp/pt.cc:27842
+#: cp/pt.cc:28000
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#D"
 msgstr "對 %q#D 重複的明確實體化"
 
-#: cp/pt.cc:27865 cp/pt.cc:27932
+#: cp/pt.cc:28023 cp/pt.cc:28090
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
 msgstr "ISO C++1998 禁止使用的 %<extern%> 於明確的實體化"
 
-#: cp/pt.cc:27870 cp/pt.cc:27947
+#: cp/pt.cc:28028 cp/pt.cc:28105
 #, gcc-internal-format
 msgid "storage class %qD applied to template instantiation"
 msgstr "為範本實體化化套用了存儲類型 %qD"
 
-#: cp/pt.cc:27904
+#: cp/pt.cc:28062
 #, fuzzy, gcc-internal-format
 msgid "explicit instantiation of non-class template %qD"
 msgstr "明確的實體化的 non-class 模板 %qD"
 
-#: cp/pt.cc:27907
+#: cp/pt.cc:28065
 #, gcc-internal-format
 msgid "explicit instantiation of non-template type %qT"
 msgstr "明確實體化非範本類型 %qT"
 
-#: cp/pt.cc:27916
+#: cp/pt.cc:28074
 #, gcc-internal-format
 msgid "explicit instantiation of %q#T before definition of template"
 msgstr "%q#T 的明確實體化出現在範本定義之前"
 
-#: cp/pt.cc:27937
+#: cp/pt.cc:28095
 #, gcc-internal-format
 msgid "ISO C++ forbids the use of %qE on explicit instantiations"
 msgstr "ISO C++ 不允許在明確實體化時使用 %qE"
 
-#: cp/pt.cc:27977
+#: cp/pt.cc:28135
 #, gcc-internal-format
 msgid "duplicate explicit instantiation of %q#T"
 msgstr "對 %q#T 重複的明確實體化"
 
-#: cp/pt.cc:28318
+#: cp/pt.cc:28476
 #, fuzzy, gcc-internal-format
 #| msgid "explicit specialization of %qD after first use"
 msgid "exception specification of %qD depends on itself"
 msgstr "在初次使用後明確特例化 %qD"
 
-#: cp/pt.cc:28324
+#: cp/pt.cc:28482
 #, fuzzy, gcc-internal-format
 msgid "exception specification of %qD is not available until end of class definition"
 msgstr "virt-specifiers 在中 %qs 不允許外側類別定義"
@@ -72310,166 +72411,166 @@ msgstr "virt-specifiers 在中 %qs 不允許外側類別定義"
 #. member function or static data member of a class template
 #. shall be present in every translation unit in which it is
 #. explicitly instantiated.
-#: cp/pt.cc:28804
+#: cp/pt.cc:28962
 #, gcc-internal-format
 msgid "explicit instantiation of %qD but no definition available"
 msgstr "明確實體化 %qD 時沒有可用的定義"
 
-#: cp/pt.cc:28850
+#: cp/pt.cc:29008
 #, fuzzy, gcc-internal-format
 msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use %<-ftemplate-depth=%> to increase the maximum)"
 msgstr "模板具現化深度超出最大值的 %d 舉例說明 %q+D, 可能會從虛擬表格產生 (使用 -ftemplate-depth=到增加最大值)"
 
-#: cp/pt.cc:29225
+#: cp/pt.cc:29383
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of deduced class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/pt.cc:29255
+#: cp/pt.cc:29413
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a valid type for a template non-type parameter because it is not structural"
 msgstr "%q#T 並非有效型態用於模板 non-type 參數"
 
-#: cp/pt.cc:29264
+#: cp/pt.cc:29422
 #, fuzzy, gcc-internal-format
 msgid "non-type template parameters of class type only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "尾隨傳回類型只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/pt.cc:29272
+#: cp/pt.cc:29430
 #, fuzzy, gcc-internal-format
 msgid "invalid template non-type parameter"
 msgstr "無效的模板 non-type 參數"
 
-#: cp/pt.cc:29274
+#: cp/pt.cc:29432
 #, fuzzy, gcc-internal-format
 msgid "%q#T is not a valid type for a template non-type parameter"
 msgstr "%q#T 並非有效型態用於模板 non-type 參數"
 
-#: cp/pt.cc:30824
+#: cp/pt.cc:30989
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "keyword %<template%> not allowed in declarator-id"
 msgstr "關鍵字 %<typename%> 不能在範本以外使用"
 
-#: cp/pt.cc:31020
+#: cp/pt.cc:31185
 #, fuzzy, gcc-internal-format
 #| msgid "constructor cannot be static member function"
 msgid "a concept cannot be constrained"
 msgstr "建構式不能是靜態成員函式"
 
-#: cp/pt.cc:31029
+#: cp/pt.cc:31194
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a namespace"
 msgid "concept %qE not in namespace scope"
 msgstr "%qT 不是一個命名空間"
 
-#: cp/pt.cc:31035
+#: cp/pt.cc:31200
 #, fuzzy, gcc-internal-format
 #| msgid "definition of %q#T inside template parameter list"
 msgid "concept %qE has multiple template parameter lists"
 msgstr "在範本參數清單中定義了 %q#T"
 
-#: cp/pt.cc:31079
+#: cp/pt.cc:31244
 #, fuzzy, gcc-internal-format
 msgid "deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>"
 msgstr "deducing 從 brace-enclosed 初始設定式清單需求 # 包含 <initializer_list>"
 
-#: cp/pt.cc:32350
+#: cp/pt.cc:32515
 #, fuzzy, gcc-internal-format
 #| msgid "non-template %qD used as template"
 msgid "non-deducible template %qT used without template arguments"
 msgstr "非範本 %qD 做為範本"
 
-#: cp/pt.cc:32365
+#: cp/pt.cc:32530
 #, fuzzy, gcc-internal-format
 msgid "alias template deduction only available with %<-std=c++20%> or %<-std=gnu++20%>"
 msgstr "variadic 模板只有可用與 -std=c++11 或 -std=gnu++11"
 
-#: cp/pt.cc:32371
+#: cp/pt.cc:32536
 #, fuzzy, gcc-internal-format
 #| msgid "try using %qE instead"
 msgid "use %qD directly instead"
 msgstr "嘗試使用 %qE 代替"
 
-#: cp/pt.cc:32499
+#: cp/pt.cc:32664
 #, gcc-internal-format
 msgid "cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors"
 msgstr ""
 
-#: cp/pt.cc:32506
+#: cp/pt.cc:32671
 #, fuzzy, gcc-internal-format
 msgid "cannot deduce template arguments of %qT, as it has no viable deduction guides"
 msgstr "%qE 並非有效模板引數的型態 %qT 因為 %qD 沒有任何鏈結"
 
-#: cp/pt.cc:32519
+#: cp/pt.cc:32684
 #, fuzzy, gcc-internal-format
 msgid "class template argument deduction failed:"
 msgstr "  模板引數推導/替代失敗："
 
-#: cp/pt.cc:32522
+#: cp/pt.cc:32687
 #, fuzzy, gcc-internal-format
 #| msgid "function not considered for inlining"
 msgid "explicit deduction guides not considered for copy-initialization"
 msgstr "不考慮內聯函式"
 
-#: cp/pt.cc:32537
+#: cp/pt.cc:32702
 #, gcc-internal-format
 msgid "class template argument deduction for %qT failed: explicit deduction guide selected in copy-list-initialization"
 msgstr ""
 
-#: cp/pt.cc:32541
+#: cp/pt.cc:32706
 #, fuzzy, gcc-internal-format
 msgid "explicit deduction guide declared here"
 msgstr "間接函式 %q+D 無法宣告的 weakref"
 
-#: cp/pt.cc:32556
+#: cp/pt.cc:32721
 #, fuzzy, gcc-internal-format
 msgid "%qT may not intend to support class template argument deduction"
 msgstr "  模板引數推導/替代失敗："
 
-#: cp/pt.cc:32558
+#: cp/pt.cc:32723
 #, gcc-internal-format
 msgid "add a deduction guide to suppress this warning"
 msgstr ""
 
-#: cp/pt.cc:32689
+#: cp/pt.cc:32854
 #, gcc-internal-format
 msgid "direct-list-initialization of %<auto%> requires exactly one element"
 msgstr ""
 
-#: cp/pt.cc:32692
+#: cp/pt.cc:32857
 #, gcc-internal-format
 msgid "for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)"
 msgstr ""
 
-#: cp/pt.cc:32752
+#: cp/pt.cc:32917
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce lambda return type from %qE"
 msgstr "無法 deduce %qT 從 %qE"
 
-#: cp/pt.cc:32755
+#: cp/pt.cc:32920
 #, fuzzy, gcc-internal-format
 msgid "unable to deduce %qT from %qE"
 msgstr "無法 deduce %qT 從 %qE"
 
-#: cp/pt.cc:32835
+#: cp/pt.cc:33000
 #, gcc-internal-format
 msgid "placeholder constraints not satisfied"
 msgstr ""
 
-#: cp/pt.cc:32839
+#: cp/pt.cc:33004
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced initializer does not satisfy placeholder constraints"
 msgstr "指令不滿足其約束："
 
-#: cp/pt.cc:32843
+#: cp/pt.cc:33008
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced return type does not satisfy placeholder constraints"
 msgstr "指令不滿足其約束："
 
-#: cp/pt.cc:32847
+#: cp/pt.cc:33012
 #, fuzzy, gcc-internal-format
 #| msgid "insn does not satisfy its constraints:"
 msgid "deduced expression type does not satisfy placeholder constraints"
@@ -72477,369 +72578,427 @@ msgstr "指令不滿足其約束："
 
 #: cp/reflect.cc:130
 #, fuzzy, gcc-internal-format
-#| msgid "new cannot be applied to a reference type"
-msgid "%<^^%> cannot be applied to a placeholder type"
-msgstr "new 不能用於參照類型"
-
-#: cp/reflect.cc:137
-#, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a pack index"
 msgstr "new 不能用於函式類型"
 
-#: cp/reflect.cc:142
+#: cp/reflect.cc:135
 #, fuzzy, gcc-internal-format
 msgid "%<^^%> cannot be applied to a non-type template parameter %qD"
 msgstr "無效的使用的模板模板參數 %qT"
 
-#: cp/reflect.cc:150
+#: cp/reflect.cc:143
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a capture %qD"
 msgstr "new 不能用於函式類型"
 
-#: cp/reflect.cc:157
+#: cp/reflect.cc:150
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied to a local parameter of a requires-expression %qD"
 msgstr ""
 
-#: cp/reflect.cc:173
+#: cp/reflect.cc:166
 #, gcc-internal-format
 msgid "%<^^%> cannot be applied a local entity for which there is an intervening lambda expression"
 msgstr ""
 
-#: cp/reflect.cc:183
+#: cp/reflect.cc:176
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a using-declaration"
 msgstr "new 不能用於函式類型"
 
-#: cp/reflect.cc:189
+#: cp/reflect.cc:182
 #, fuzzy, gcc-internal-format
 #| msgid "new cannot be applied to a function type"
 msgid "%<^^%> cannot be applied to a concept check"
 msgstr "new 不能用於函式類型"
 
-#: cp/reflect.cc:207
+#: cp/reflect.cc:200
 #, gcc-internal-format
 msgid "cannot take the reflection of an overload set"
 msgstr ""
 
-#: cp/reflect.cc:416
+#: cp/reflect.cc:363 cp/reflect.cc:7729
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qT"
+msgstr "引數 %d(屬於 %qE)類型不相容"
+
+#: cp/reflect.cc:476
 #, fuzzy, gcc-internal-format
 msgid "%<std::ranges%> is not a namespace"
 msgstr "%<::%E%>並非類別或命名空間"
 
-#: cp/reflect.cc:459
+#: cp/reflect.cc:519
 #, gcc-internal-format
 msgid "%<reflect_constant_string%> called with %qT rather than %<char%>, %<wchar_t%>, %<char8_t%>, %<char16_t%> or %<char32_t%>"
 msgstr ""
 
-#: cp/reflect.cc:495
+#: cp/reflect.cc:556
 #, fuzzy, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not a structural type"
 msgstr "decltype 評估到 %qT，該項並非類別或列舉類型型態"
 
-#: cp/reflect.cc:509
+#: cp/reflect.cc:570
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not copy constructible"
 msgstr ""
 
-#: cp/reflect.cc:531
+#: cp/reflect.cc:595
+#, gcc-internal-format
+msgid "%<reflect_constant_array%> argument with %qT which is not compatible with %qT %<std::ranges::range_reference_t%>"
+msgstr ""
+
+#: cp/reflect.cc:606
 #, gcc-internal-format
 msgid "%<reflect_constant_array%> argument with %qT which is not constructible from %qT %<std::ranges::range_reference_t%>"
 msgstr ""
 
-#: cp/reflect.cc:660
+#: cp/reflect.cc:746
 #, gcc-internal-format
 msgid "%<std::ranges::data%> or %<std::ranges::size%> are not customization point objects"
 msgstr ""
 
-#: cp/reflect.cc:827
+#: cp/reflect.cc:913
 #, gcc-internal-format
 msgid "missing %<std::ranges::begin%> or %<std::ranges::end%>"
 msgstr ""
 
-#: cp/reflect.cc:845
+#: cp/reflect.cc:931
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::begin(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:852
+#: cp/reflect.cc:938
 #, gcc-internal-format
 msgid "incorrect type %qT of %<std::ranges::end(arg)%>"
 msgstr ""
 
-#: cp/reflect.cc:965
+#: cp/reflect.cc:1051
 #, gcc-internal-format
 msgid "%qD should throw %qs; %<what()%>: %qs"
 msgstr ""
 
-#: cp/reflect.cc:967
+#: cp/reflect.cc:1053
 #, gcc-internal-format
 msgid "exceptions are disabled, treating as non-constant"
 msgstr ""
 
-#: cp/reflect.cc:977
+#: cp/reflect.cc:1063
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t throw %qs"
 msgstr "無法執行「%s」：%s"
 
-#: cp/reflect.cc:1077
+#: cp/reflect.cc:1163
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<std::meta::operators%>"
 msgstr "預期 %<operator%>"
 
-#: cp/reflect.cc:2702
+#: cp/reflect.cc:2788
 #, gcc-internal-format
 msgid "couldn%'t look up %<%D::%D%>"
 msgstr ""
 
-#: cp/reflect.cc:2990
+#: cp/reflect.cc:3078
 #, fuzzy, gcc-internal-format
 #| msgid "couldn't run '%s': %s"
 msgid "couldn%'t look up %qs"
 msgstr "無法執行「%s」：%s"
 
-#: cp/reflect.cc:3144 cp/reflect.cc:3207 cp/reflect.cc:3262 cp/reflect.cc:3342
-#: cp/reflect.cc:6283
+#: cp/reflect.cc:3232 cp/reflect.cc:3295 cp/reflect.cc:3351 cp/reflect.cc:3431
+#: cp/reflect.cc:6555
 #, fuzzy, gcc-internal-format
 #| msgid "  expected a type, got %qE"
 msgid "unexpected return type of %qs"
 msgstr "  需要一個類型，卻給出了 %qE"
 
-#: cp/reflect.cc:3900
+#: cp/reflect.cc:4033
 #, gcc-internal-format
 msgid "%qT must be a cv-unqualified structural type that is not a reference type"
 msgstr ""
 
-#: cp/reflect.cc:3924
+#: cp/reflect.cc:4057
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a pointer-to-object type"
 msgid "%qT must be an object type"
 msgstr "%qT 不是一個參照物件的類型"
 
-#: cp/reflect.cc:3951
+#: cp/reflect.cc:4084
 #, fuzzy, gcc-internal-format
 #| msgid "%qD is not a function template"
 msgid "%qT must be a function type"
 msgstr "%qD 不是一個函式範本"
 
-#: cp/reflect.cc:4832 cp/reflect.cc:4959
+#: cp/reflect.cc:4962 cp/reflect.cc:5089
 #, gcc-internal-format
 msgid "couldn%'t instantiate %<std::%s<%T>%>"
 msgstr ""
 
-#: cp/reflect.cc:5565
+#: cp/reflect.cc:5700
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<data_member_options%> argument"
 msgstr "預期 template-argument"
 
-#: cp/reflect.cc:5934
+#: cp/reflect.cc:6132
 #, fuzzy, gcc-internal-format
 msgid "first %<define_aggregate%> argument is not a class type reflection"
 msgstr "transactionwrap 引數並非函式(_W)"
 
-#: cp/reflect.cc:5942
+#: cp/reflect.cc:6140
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a type alias"
 msgstr ""
 
-#: cp/reflect.cc:5950
+#: cp/reflect.cc:6148
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a cv-qualified class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5958
+#: cp/reflect.cc:6156
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a complete class type reflection"
 msgstr ""
 
-#: cp/reflect.cc:5966
+#: cp/reflect.cc:6164
 #, gcc-internal-format
 msgid "first %<define_aggregate%> argument is a reflection of a class type %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:5979
+#: cp/reflect.cc:6177
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument not a data member description"
 msgstr ""
 
-#: cp/reflect.cc:5987
+#: cp/reflect.cc:6185
 #, gcc-internal-format
 msgid "%<define_aggregate%> argument data member description without complete type"
 msgstr ""
 
-#: cp/reflect.cc:5997
+#: cp/reflect.cc:6195
 #, gcc-internal-format
 msgid "name %qD used in multiple data member descriptions"
 msgstr ""
 
-#: cp/reflect.cc:6006
+#: cp/reflect.cc:6204
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare bit-field %qD with function type"
 msgid "cannot declare bit-field in %<warn_if_not_aligned%> type"
 msgstr "不能將位元段 %qD 宣告為函式類型"
 
-#: cp/reflect.cc:6016
+#: cp/reflect.cc:6214
 #, gcc-internal-format
 msgid "%<define_aggregate%> not evaluated from %<consteval%> block"
 msgstr ""
 
-#: cp/reflect.cc:6037
+#: cp/reflect.cc:6235
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block which encloses %qT being defined"
 msgstr ""
 
-#: cp/reflect.cc:6041 cp/reflect.cc:6124
+#: cp/reflect.cc:6239 cp/reflect.cc:6322
 #, fuzzy, gcc-internal-format
 msgid "%<consteval%> block defined here"
 msgstr "enum 常數定義的在此"
 
-#: cp/reflect.cc:6057 cp/reflect.cc:6116
+#: cp/reflect.cc:6255 cp/reflect.cc:6314
 #, gcc-internal-format
 msgid "%qD intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6061 cp/reflect.cc:6120
+#: cp/reflect.cc:6259 cp/reflect.cc:6318
 #, gcc-internal-format
 msgid "%qT intervenes between %qT scope and %<consteval%> block %<define_aggregate%> is evaluated from"
 msgstr ""
 
-#: cp/reflect.cc:6072 cp/reflect.cc:6108
+#: cp/reflect.cc:6270 cp/reflect.cc:6306
 #, gcc-internal-format
 msgid "%qD intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6076 cp/reflect.cc:6112
+#: cp/reflect.cc:6274 cp/reflect.cc:6310
 #, gcc-internal-format
 msgid "%qT intervenes between %<consteval%> block %<define_aggregate%> is evaluated from and %qT scope"
 msgstr ""
 
-#: cp/reflect.cc:6086
+#: cp/reflect.cc:6284
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6091
+#: cp/reflect.cc:6289
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qD while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6096
+#: cp/reflect.cc:6294
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qD"
 msgstr ""
 
-#: cp/reflect.cc:6101
+#: cp/reflect.cc:6299
 #, gcc-internal-format
 msgid "%<define_aggregate%> evaluated from %<consteval%> block enclosed by %qT while %qT type being defined is enclosed by %qT"
 msgstr ""
 
-#: cp/reflect.cc:6262
+#: cp/reflect.cc:6472
 #, gcc-internal-format
-msgid "%<access_context::current%> used outside of manifestly constant-evaluation"
+msgid "%qs used outside of manifestly constant-evaluation"
 msgstr ""
 
-#: cp/reflect.cc:6313
+#: cp/reflect.cc:6585
 #, fuzzy, gcc-internal-format
 msgid "invalid %<access_context%> argument"
 msgstr "無效的 PHI 引數"
 
-#: cp/reflect.cc:6324
+#: cp/reflect.cc:6596
 #, fuzzy, gcc-internal-format
 msgid "unexpected %<access_context::scope()%>"
 msgstr "預期 %<decltype%>"
 
-#: cp/reflect.cc:6334
+#: cp/reflect.cc:6606
 #, gcc-internal-format
 msgid "unexpected %<access_context::designating_class()%>"
 msgstr ""
 
-#: cp/reflect.cc:7107
+#: cp/reflect.cc:7397
 #, fuzzy, gcc-internal-format
 msgid "unexpected argument to %qs"
 msgstr "未預期的屬性"
 
-#: cp/reflect.cc:7396
+#: cp/reflect.cc:7726
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT type of argument %d, expected %qs"
+msgstr "引數 %d(屬於 %qE)類型不相容"
+
+#: cp/reflect.cc:7799
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qs"
+msgstr "向量類型預期的在中向量 permute 運算式"
+
+#: cp/reflect.cc:7802
+#, fuzzy, gcc-internal-format
+msgid "incorrect %qT return type, expected %qT"
+msgstr "向量類型預期的在中向量 permute 運算式"
+
+#: cp/reflect.cc:7826
 #, fuzzy, gcc-internal-format
 msgid "unknown metafunction %qD"
 msgstr "不明 spec 函式 %qs"
 
-#: cp/reflect.cc:8070
+#: cp/reflect.cc:8523
 #, fuzzy, gcc-internal-format
 msgid "splice argument must be an expression of type %qs"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: cp/reflect.cc:8326
+#: cp/reflect.cc:8530
+#, fuzzy, gcc-internal-format
+#| msgid "cannot disable built-in function %qs"
+msgid "cannot splice a null reflection"
+msgstr "無法停用內建函式 %qs"
+
+#: cp/reflect.cc:8540
+#, fuzzy, gcc-internal-format
+#| msgid "cannot use %<::%> in parameter declaration"
+msgid "cannot use %qD function parameter reflection in a splice expression"
+msgstr "不能在參數宣告中使用 %<::%>"
+
+#: cp/reflect.cc:8544
+#, gcc-internal-format
+msgid "apply %<std::meta::variable_of%> on it before splicing"
+msgstr ""
+
+#: cp/reflect.cc:8803
 #, gcc-internal-format
 msgid "consteval-only variable %qD not declared %<constexpr%> used outside a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8328
+#: cp/reflect.cc:8805
 #, fuzzy, gcc-internal-format
 msgid "add %<constexpr%>"
 msgstr "%qD 未被宣告 %<constexpr%>"
 
-#: cp/reflect.cc:8332
+#: cp/reflect.cc:8809
 #, gcc-internal-format
 msgid "consteval-only expressions are only allowed in a constant-evaluated context"
 msgstr ""
 
-#: cp/reflect.cc:8439
+#: cp/reflect.cc:8949
 #, fuzzy, gcc-internal-format
 msgid "function of consteval-only type must be declared %qs"
 msgstr "內建函式 %qD 需一個引數只有"
 
-#: cp/reflect.cc:8463 cp/reflect.cc:8479
+#: cp/reflect.cc:8975 cp/reflect.cc:8991
 #, fuzzy, gcc-internal-format
 msgid "expected a reflection of an expression"
 msgstr "預期的布林表示式"
 
-#: cp/reflect.cc:8469 cp/reflect.cc:8473
+#: cp/reflect.cc:8981 cp/reflect.cc:8985
 #, fuzzy, gcc-internal-format
 #| msgid "keyword %<typename%> not allowed outside of templates"
 msgid "add %<typename%> to denote a type outside a type-only context"
 msgstr "關鍵字 %<typename%> 不能在範本以外使用"
 
-#: cp/reflect.cc:8492
+#: cp/reflect.cc:9004
 #, fuzzy, gcc-internal-format
 msgid "cannot use constructor or destructor %qD in a splice expression"
 msgstr "預期的建構子、解構式，或類型轉換"
 
-#: cp/reflect.cc:8500
+#: cp/reflect.cc:9012
 #, fuzzy, gcc-internal-format
 #| msgid "use of namespace %qD as expression"
 msgid "cannot use an unnamed bit-field %qD in a splice expression"
 msgstr "命名空間 %qD 做為運算式"
 
-#: cp/reflect.cc:8513
+#: cp/reflect.cc:9025
 #, fuzzy, gcc-internal-format
 #| msgid "cannot explicitly declare member %q#D to have extern linkage"
 msgid "cannot implicitly reference a class member %qD through a splice"
 msgstr "不能明確地將成員 %q#D 宣告為有外部連結"
 
-#: cp/reflect.cc:8527
+#: cp/reflect.cc:9034
+#, fuzzy, gcc-internal-format
+#| msgid "invalid cast to function type %qT"
+msgid "invalid class member access of type template %qE"
+msgstr "向函式類型 %qT 的轉換無效"
+
+#: cp/reflect.cc:9042
+#, fuzzy, gcc-internal-format
+msgid "cannot use %qE to access a class member"
+msgstr "can%'t 使用 %qs 做為 call-used 暫存器"
+
+#: cp/reflect.cc:9056
 #, gcc-internal-format
 msgid "unary %<&%> applied to an anonymous union member %qD that is not a direct member of a named class"
 msgstr ""
 
-#: cp/reflect.cc:8546
+#: cp/reflect.cc:9075
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function in a splice expression"
 msgstr "在包含函式中使用 %<auto%> 變數"
 
-#: cp/reflect.cc:8559
+#: cp/reflect.cc:9088
 #, fuzzy, gcc-internal-format
 msgid "cannot use an annotation %qE in a splice expression"
 msgstr "暫時的的 non-literal 型態 %qT 在中常數運算式"
 
-#: cp/reflect.cc:8568
+#: cp/reflect.cc:9097
 #, fuzzy, gcc-internal-format
 msgid "cannot use a data member specification in a splice expression"
 msgstr "警告關於溢位在中算術運算式"
 
+#: cp/reflect.cc:9114
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a function template"
+msgid "expected a reflection of a function template"
+msgstr "%qD 不是一個函式範本"
+
+#: cp/reflect.cc:9130
+#, gcc-internal-format
+msgid "expected a reflection of a function or variable template"
+msgstr ""
+
 #: cp/rtti.cc:308
 #, fuzzy, gcc-internal-format
 #| msgid "cannot use typeid with -fno-rtti"
@@ -73190,596 +73349,596 @@ msgstr "對限定類型 %qT 的定義無效"
 msgid "invalid base-class specification"
 msgstr "無效的基礎類別"
 
-#: cp/semantics.cc:4666
+#: cp/semantics.cc:4683
 #, fuzzy, gcc-internal-format
 #| msgid "protected member %q+#D in anonymous union"
 msgid "cannot capture member %qD of anonymous union"
 msgstr "匿名聯合中出現保護成員 %q+#D"
 
-#: cp/semantics.cc:4684
+#: cp/semantics.cc:4705
 #, fuzzy, gcc-internal-format
 msgid "%qD is not captured"
 msgstr "%qD 未被擷取"
 
-#: cp/semantics.cc:4688
+#: cp/semantics.cc:4709
 #, gcc-internal-format
 msgid "the lambda has no capture-default"
 msgstr ""
 
-#: cp/semantics.cc:4690
+#: cp/semantics.cc:4711
 #, gcc-internal-format
 msgid "lambda in local class %q+T cannot capture variables from the enclosing context"
 msgstr ""
 
-#: cp/semantics.cc:4706
+#: cp/semantics.cc:4727
 #, fuzzy, gcc-internal-format
 msgid "use of local variable with automatic storage from containing function"
 msgstr "在包含函式中使用 %<auto%> 變數"
 
-#: cp/semantics.cc:4708
+#: cp/semantics.cc:4729
 #, gcc-internal-format
 msgid "use of parameter from containing function"
 msgstr "在包含函式中使用參數"
 
-#: cp/semantics.cc:4841
+#: cp/semantics.cc:4862
 #, fuzzy, gcc-internal-format
 msgid "use of parameter outside function body"
 msgstr "使用的參數 %qD 外側函式內文"
 
-#: cp/semantics.cc:4851
+#: cp/semantics.cc:4872
 #, fuzzy, gcc-internal-format
 msgid "missing template arguments"
 msgstr "不匹配的引數"
 
-#: cp/semantics.cc:4887
+#: cp/semantics.cc:4908
 #, gcc-internal-format
 msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
 msgstr "範本參數 %qD(類型為 %qT)不允許出現在整數運算式中，因為它的類型不是整數或列舉"
 
-#: cp/semantics.cc:4942
+#: cp/semantics.cc:4963
 #, gcc-internal-format
 msgid "use of class template %qT as expression"
 msgstr "將類別範本 %qT 做為運算式"
 
-#: cp/semantics.cc:4950
+#: cp/semantics.cc:4971
 #, gcc-internal-format
 msgid "request for member %qD is ambiguous in multiple inheritance lattice"
 msgstr "在多繼承網格中對 %qD 的存取有歧義"
 
-#: cp/semantics.cc:4978
+#: cp/semantics.cc:4999
 #, gcc-internal-format
 msgid "%qD cannot appear in a constant-expression"
 msgstr "%qD 不能出現在常數運算式中"
 
-#: cp/semantics.cc:5022 cp/semantics.cc:5053
+#: cp/semantics.cc:5043 cp/semantics.cc:5074
 #, gcc-internal-format
 msgid "%qD 'this' required when accessing a member within a constructor precondition or destructor postcondition contract check"
 msgstr ""
 
-#: cp/semantics.cc:5155
+#: cp/semantics.cc:5176
 #, gcc-internal-format
 msgid "type of %qE is unknown"
 msgstr "%qE 的類型不明"
 
-#: cp/semantics.cc:5173 rust/backend/rust-tree.cc:5536
+#: cp/semantics.cc:5194 rust/backend/rust-tree.cc:5536
 #, fuzzy, gcc-internal-format
 msgid "%qT is not an enumeration type"
 msgstr "%qT 不是列舉類型型態"
 
-#: cp/semantics.cc:5200
+#: cp/semantics.cc:5221
 #, fuzzy, gcc-internal-format
 #| msgid "size of array has non-integral type %qT"
 msgid "pack index has non-integral type %qT"
 msgstr "陣列 %qT 的大小的類型不是整數"
 
-#: cp/semantics.cc:5207
+#: cp/semantics.cc:5228
 #, fuzzy, gcc-internal-format
 #| msgid "array bound is not an integer constant"
 msgid "pack index is not an integral constant"
 msgstr "陣列邊界不是一個整數常數"
 
-#: cp/semantics.cc:5215
+#: cp/semantics.cc:5236
 #, fuzzy, gcc-internal-format
 msgid "pack index %qE is negative"
 msgstr "引數的 %s 函式於 %L 是負"
 
-#: cp/semantics.cc:5221
+#: cp/semantics.cc:5242
 #, gcc-internal-format
 msgid "pack index %qE is out of range for pack of length %qd"
 msgstr ""
 
 #. Parameter packs can only be used in templates
-#: cp/semantics.cc:5359
+#: cp/semantics.cc:5380
 #, fuzzy, gcc-internal-format
 msgid "parameter pack %<__bases%> only valid in template declaration"
 msgstr "參數包裝 __bases 只有有效在中模板宣告"
 
-#: cp/semantics.cc:5391
+#: cp/semantics.cc:5412
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
 msgstr "無法套用 %<offsetof%> 到解構式 %<~%T%>"
 
-#: cp/semantics.cc:5405
+#: cp/semantics.cc:5426
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function %qD"
 msgstr "無法套用 %<offsetof%> 到成員函式 %qD"
 
-#: cp/semantics.cc:5409
+#: cp/semantics.cc:5430
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to member function"
 msgstr "無法套用 %<offsetof%> 到成員函式 %qD"
 
-#: cp/semantics.cc:5414
+#: cp/semantics.cc:5435
 #, fuzzy, gcc-internal-format
 msgid "cannot apply %<offsetof%> to an enumerator %qD"
 msgstr "無法套用 %<offsetof%> 到成員函式 %qD"
 
-#: cp/semantics.cc:5425
+#: cp/semantics.cc:5446
 #, gcc-internal-format
 msgid "%<offsetof%> within non-standard-layout type %qT is conditionally-supported"
 msgstr ""
 
-#: cp/semantics.cc:6629
+#: cp/semantics.cc:6650
 #, fuzzy, gcc-internal-format
 msgid "pointer-to-member mapping %qE not supported"
 msgstr "建構子優先等級未被支援"
 
-#: cp/semantics.cc:6824
+#: cp/semantics.cc:6845
 #, fuzzy, gcc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "user defined reduction lookup is ambiguous"
 msgstr "對 %qD 的參照有歧義"
 
-#: cp/semantics.cc:6827
+#: cp/semantics.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%s %#qD"
 msgstr "%s %+#D"
 
-#: cp/semantics.cc:7188
+#: cp/semantics.cc:7209
 #, gcc-internal-format
 msgid "%qE in %<reduction%> clause is a zero size array"
 msgstr ""
 
-#: cp/semantics.cc:7234
+#: cp/semantics.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qE has const type for %<reduction%>"
 msgstr "%qE 有無效的型態用於 %<reduction%>"
 
-#: cp/semantics.cc:7353
+#: cp/semantics.cc:7374
 #, gcc-internal-format
 msgid "user defined reduction with constructor initializer for base class %qT"
 msgstr ""
 
-#: cp/semantics.cc:7427
+#: cp/semantics.cc:7448
 #, gcc-internal-format
 msgid "%qT is not a struct, union or class type in %<#pragma omp declare mapper%>"
 msgstr ""
 
-#: cp/semantics.cc:7433
+#: cp/semantics.cc:7454
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of %<--%> on bool variable %qD"
 msgid "%qT must not be a virtual base class in %<#pragma omp declare mapper%>"
 msgstr "對於 bool 變數 %qD 使用 %<--%> 無效"
 
-#: cp/semantics.cc:7739
+#: cp/semantics.cc:7760
 #, fuzzy, gcc-internal-format
 msgid "expected string literal or constant integer expression instead of %qE"
 msgstr "預期的整數運算式"
 
-#: cp/semantics.cc:7936
+#: cp/semantics.cc:7957
 #, gcc-internal-format
 msgid "modifier other than %<val%> specified in %<linear%> clause on %<simd%> or %<for%> constructs when using OpenMP 5.2 modifiers"
 msgstr ""
 
-#: cp/semantics.cc:7951
+#: cp/semantics.cc:7972
 #, gcc-internal-format
 msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7966
+#: cp/semantics.cc:7987
 #, gcc-internal-format
 msgid "linear clause applied to non-integral non-pointer variable with %qT type"
 msgstr ""
 
-#: cp/semantics.cc:7990
+#: cp/semantics.cc:8011
 #, fuzzy, gcc-internal-format
 msgid "linear step expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8083 cp/semantics.cc:8215 cp/semantics.cc:8275
-#: cp/semantics.cc:8711 cp/semantics.cc:10046
+#: cp/semantics.cc:8104 cp/semantics.cc:8236 cp/semantics.cc:8296
+#: cp/semantics.cc:8732 cp/semantics.cc:10067
 #, gcc-internal-format
 msgid "%<this%> allowed in OpenMP only in %<declare simd%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:8095 cp/semantics.cc:10059
+#: cp/semantics.cc:8116 cp/semantics.cc:10080
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %qs"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/semantics.cc:8228
+#: cp/semantics.cc:8249
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<firstprivate%>"
 msgstr "%qD 並非變數在中子句 %<firstprivate%>"
 
-#: cp/semantics.cc:8288
+#: cp/semantics.cc:8309
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in clause %<lastprivate%>"
 msgstr "%qD 並非變數在中子句 %<lastprivate%>"
 
-#: cp/semantics.cc:8359
+#: cp/semantics.cc:8380
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8373
+#: cp/semantics.cc:8394
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> static value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: cp/semantics.cc:8412
+#: cp/semantics.cc:8433
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8415
+#: cp/semantics.cc:8436
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8419
+#: cp/semantics.cc:8440
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8442
+#: cp/semantics.cc:8463
 #, fuzzy, gcc-internal-format
 msgid "%<gang%> num value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: cp/semantics.cc:8446
+#: cp/semantics.cc:8467
 #, fuzzy, gcc-internal-format
 msgid "%<vector%> length value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: cp/semantics.cc:8451
+#: cp/semantics.cc:8472
 #, fuzzy, gcc-internal-format
 msgid "%<worker%> num value must be positive"
 msgstr "%<num_threads%> 值必須是正值"
 
-#: cp/semantics.cc:8536
+#: cp/semantics.cc:8557
 #, fuzzy, gcc-internal-format
 msgid "schedule chunk size expression must be integral"
 msgstr "排程資料塊大小運算式必須是積分"
 
-#: cp/semantics.cc:8569
+#: cp/semantics.cc:8590
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8583
+#: cp/semantics.cc:8604
 #, fuzzy, gcc-internal-format
 msgid "%qs length expression must be positive constant integer expression"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: cp/semantics.cc:8603
+#: cp/semantics.cc:8624
 #, fuzzy, gcc-internal-format
 msgid "%<async%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8632
+#: cp/semantics.cc:8653
 #, fuzzy, gcc-internal-format
 msgid "%<thread_limit%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:8662
+#: cp/semantics.cc:8683
 #, fuzzy, gcc-internal-format
 msgid "%<device%> id must be integral"
 msgstr "切片結束必須是整數"
 
-#: cp/semantics.cc:8693
+#: cp/semantics.cc:8714
 #, fuzzy, gcc-internal-format
 msgid "%<dist_schedule%> chunk size expression must be integral"
 msgstr "排程資料塊大小運算式必須是積分"
 
-#: cp/semantics.cc:8722
+#: cp/semantics.cc:8743
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<aligned%> clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/semantics.cc:8737
+#: cp/semantics.cc:8758
 #, gcc-internal-format
 msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:8744
+#: cp/semantics.cc:8765
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<aligned%> clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: cp/semantics.cc:8759
+#: cp/semantics.cc:8780
 #, fuzzy, gcc-internal-format
 msgid "%<aligned%> clause alignment expression must be integral"
 msgstr "排程資料塊大小運算式必須是積分"
 
-#: cp/semantics.cc:8790
+#: cp/semantics.cc:8811
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<nontemporal%> clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/semantics.cc:8801
+#: cp/semantics.cc:8822
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<nontemporal%> clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: cp/semantics.cc:8818
+#: cp/semantics.cc:8839
 #, fuzzy, gcc-internal-format
 msgid "%<this%> not allowed in %<allocate%> clause"
 msgstr "%qE 並非變數在中子句 %qs"
 
-#: cp/semantics.cc:8830
+#: cp/semantics.cc:8851
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a variable in %<allocate%> clause"
 msgstr "%qD 並非變數在中子句 %qs"
 
-#: cp/semantics.cc:8839
+#: cp/semantics.cc:8860
 #, fuzzy, gcc-internal-format
 msgid "%qD appears more than once in %<allocate%> clauses"
 msgstr "%qD 出現一次以上在中資料子句"
 
-#: cp/semantics.cc:8955
+#: cp/semantics.cc:8976
 #, gcc-internal-format
 msgid "class member %qE not yet supported in %<uses_allocators%> clause"
 msgstr ""
 
-#: cp/semantics.cc:9000
+#: cp/semantics.cc:9021
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "modifiers cannot be used with predefined allocators"
 msgstr "名稱「%s」在 %C 處不能做為已定義的運算子"
 
-#: cp/semantics.cc:9069
+#: cp/semantics.cc:9090
 #, fuzzy, gcc-internal-format
 msgid "variable length traits arrays are not supported"
 msgstr "變數長度陣列被使用"
 
-#: cp/semantics.cc:9143
+#: cp/semantics.cc:9164
 #, fuzzy, gcc-internal-format
 msgid "%qD is not lvalue expression nor array section in %qs clause"
 msgstr "變數長度陣列被使用"
 
-#: cp/semantics.cc:9660
+#: cp/semantics.cc:9681
 #, fuzzy, gcc-internal-format
 msgid "template %qE in clause %qs"
 msgstr "太多 %qs 子句"
 
-#: cp/semantics.cc:9663
+#: cp/semantics.cc:9684
 #, gcc-internal-format
 msgid "overloaded function name %qE in clause %qs"
 msgstr ""
 
-#: cp/semantics.cc:9733
+#: cp/semantics.cc:9754
 #, fuzzy, gcc-internal-format
 msgid "%<grainsize%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:9763
+#: cp/semantics.cc:9784
 #, fuzzy, gcc-internal-format
 msgid "%<priority%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:9793
+#: cp/semantics.cc:9814
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:9805
+#: cp/semantics.cc:9826
 #, fuzzy, gcc-internal-format
 msgid "%<hint%> expression must be constant integer expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/semantics.cc:9822
+#: cp/semantics.cc:9843
 #, fuzzy, gcc-internal-format
 msgid "%<filter%> expression must be integral"
 msgstr "numthreads 運算式必須是積分(_T)"
 
-#: cp/semantics.cc:9853
+#: cp/semantics.cc:9874
 #, fuzzy, gcc-internal-format
 #| msgid "type to vector delete is neither pointer or array type"
 msgid "%qs variable is neither a pointer nor reference to pointer"
 msgstr "向量 delete 的引數類型既非指標也非陣列"
 
-#: cp/semantics.cc:9863
+#: cp/semantics.cc:9884
 #, gcc-internal-format
 msgid "%qs variable is neither a pointer, nor an array nor reference to pointer or array"
 msgstr ""
 
-#: cp/semantics.cc:9947
+#: cp/semantics.cc:9968
 #, fuzzy, gcc-internal-format
 #| msgid "%<tree%> is not defined as a pointer type"
 msgid "%<tile%> argument needs integral type"
 msgstr "%<tree%> 未被定義為一個指標類型"
 
-#: cp/semantics.cc:10516
+#: cp/semantics.cc:10537
 #, gcc-internal-format
 msgid "%<const%> qualified %qE without %<mutable%> member may appear only in %<shared%> or %<firstprivate%> clauses"
 msgstr ""
 
-#: cp/semantics.cc:10757
+#: cp/semantics.cc:10778
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
 msgstr "%<threadprivate%> %qD 不是檔案，命名空間或區塊範圍變數"
 
-#: cp/semantics.cc:10771
+#: cp/semantics.cc:10792
 #, fuzzy, gcc-internal-format
 msgid "%<threadprivate%> %qE directive not in %qT definition"
 msgstr "%<threadprivate%> %qE 指令無法在中 %qT 定義"
 
-#: cp/semantics.cc:11570
+#: cp/semantics.cc:11591
 #, fuzzy, gcc-internal-format
 msgid "difference between %qE and %qD does not have integer type"
 msgstr "差異介於 %qE 和 %qD 沒有整數類型"
 
-#: cp/semantics.cc:12068
+#: cp/semantics.cc:12089
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp simd%> used with class iteration variable %qE"
 msgstr "%<# pragma omp 基元的 update%>使用兩不同的變數用於記憶體"
 
-#: cp/semantics.cc:12392 cp/semantics.cc:12402
+#: cp/semantics.cc:12413 cp/semantics.cc:12423
 #, fuzzy, gcc-internal-format
 msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
 msgstr "%<# pragma omp 基元的 update%>使用兩不同的變數用於記憶體"
 
-#: cp/semantics.cc:12734
+#: cp/semantics.cc:12755
 #, gcc-internal-format
 msgid "constexpr string must be a string literal or object with %<size%> and %<data%> members"
 msgstr ""
 
-#: cp/semantics.cc:12750
+#: cp/semantics.cc:12771
 #, gcc-internal-format
 msgid "constexpr string %<size()%> must be implicitly convertible to %<std::size_t%>"
 msgstr ""
 
-#: cp/semantics.cc:12768
+#: cp/semantics.cc:12789
 #, gcc-internal-format
 msgid "constexpr string %<data()%> must be implicitly convertible to %<const char*%>"
 msgstr ""
 
-#: cp/semantics.cc:12821
+#: cp/semantics.cc:12842
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<size()%> must be a constant expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/semantics.cc:12830
+#: cp/semantics.cc:12851
 #, gcc-internal-format
 msgid "constexpr string message %<size()%> %qE too large"
 msgstr ""
 
-#: cp/semantics.cc:12848
+#: cp/semantics.cc:12869
 #, gcc-internal-format
 msgid "unhandled return from %<data()%>"
 msgstr ""
 
-#: cp/semantics.cc:12947
+#: cp/semantics.cc:12968
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()[%d]%> must be a constant expression"
 msgstr "運算式 %qE 並非 constant-expression"
 
-#: cp/semantics.cc:12973
+#: cp/semantics.cc:12994
 #, fuzzy, gcc-internal-format
 msgid "constexpr string %<data()%> must be a core constant expression"
 msgstr "隱含轉換從 %qT 到 %qT 到匹配其他運算元的二進位運算式"
 
-#: cp/semantics.cc:13011
+#: cp/semantics.cc:13032
 #, gcc-internal-format
 msgid "could not convert constexpr string from UTF-8 encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13015
+#: cp/semantics.cc:13036
 #, gcc-internal-format
 msgid "could not convert constexpr string from ordinary literal encoding to source character set"
 msgstr ""
 
-#: cp/semantics.cc:13125
+#: cp/semantics.cc:13146
 #, fuzzy, gcc-internal-format
 msgid "static assertion failed: %.*s"
 msgstr "靜態假設失敗：%s"
 
-#: cp/semantics.cc:13141
+#: cp/semantics.cc:13162
 #, fuzzy, gcc-internal-format
 msgid "non-constant condition for static assertion"
 msgstr "non-constant 條件用於靜態假設"
 
-#: cp/semantics.cc:13170
+#: cp/semantics.cc:13191
 #, fuzzy, gcc-internal-format
 msgid "argument to %<decltype%> must be an expression"
 msgstr "引數到 decltype 必須是運算式"
 
-#: cp/semantics.cc:13216
+#: cp/semantics.cc:13237
 #, fuzzy, gcc-internal-format
 msgid "%<decltype%> cannot resolve address of overloaded function"
 msgstr "decltype 無法解析位址的多載化函式"
 
-#: cp/semantics.cc:13491 cp/semantics.cc:13498
+#: cp/semantics.cc:13512 cp/semantics.cc:13519
 #, fuzzy, gcc-internal-format
 msgid "%qT is not a non-union class type"
 msgstr "%qT 並非類別型態"
 
-#: cp/semantics.cc:13509 cp/typeck.cc:1926 cp/typeck.cc:1933
+#: cp/semantics.cc:13530 cp/typeck.cc:1926 cp/typeck.cc:1933
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is not a standard-layout type"
 msgstr "%qT 不是一個範本類型"
 
-#: cp/semantics.cc:13570 rust/backend/rust-tree.cc:5250
+#: cp/semantics.cc:13591 rust/backend/rust-tree.cc:5250
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> needs a single argument"
 msgstr ""
 
-#: cp/semantics.cc:13579 rust/backend/rust-tree.cc:5259
+#: cp/semantics.cc:13600 rust/backend/rust-tree.cc:5259
 #, gcc-internal-format
 msgid "%<__builtin_is_pointer_interconvertible_with_class%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13750 rust/backend/rust-tree.cc:5863
+#: cp/semantics.cc:13771 rust/backend/rust-tree.cc:5863
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> not well defined for anonymous unions"
 msgstr ""
 
-#: cp/semantics.cc:13774 rust/backend/rust-tree.cc:5907
+#: cp/semantics.cc:13795 rust/backend/rust-tree.cc:5907
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_corresponding_member%> needs two arguments"
 msgstr "呼叫 %<__builtin_next_arg%> 時沒有給定引數"
 
-#: cp/semantics.cc:13785 rust/backend/rust-tree.cc:5917
+#: cp/semantics.cc:13806 rust/backend/rust-tree.cc:5917
 #, gcc-internal-format
 msgid "%<__builtin_is_corresponding_member%> argument is not pointer to member"
 msgstr ""
 
-#: cp/semantics.cc:13872
+#: cp/semantics.cc:13893
 #, fuzzy, gcc-internal-format
 #| msgid "%<__builtin_next_arg%> called without an argument"
 msgid "%<__builtin_is_string_literal%> needs a single argument"
 msgstr "呼叫 %<__builtin_next_arg%> 時沒有給定引數"
 
-#: cp/semantics.cc:13884
+#: cp/semantics.cc:13905
 #, gcc-internal-format
 msgid "%<__builtin_is_string_literal%> argument is not %<const char*%>, %<const wchar_t*%>, %<const char8_t*%>, %<const char16_t*%> or %<const char32_t*%>"
 msgstr ""
 
-#: cp/semantics.cc:13999
+#: cp/semantics.cc:14020
 #, gcc-internal-format
 msgid "checking %qs for type %qT with a destructor that cannot be called"
 msgstr ""
 
-#: cp/semantics.cc:14296
+#: cp/semantics.cc:14317
 #, fuzzy, gcc-internal-format
 msgid "%qs argument %qT is a reference"
 msgstr "引數必須是欄位參考"
 
-#: cp/semantics.cc:14467
+#: cp/semantics.cc:14488
 #, fuzzy, gcc-internal-format
 msgid "%qD is not a class or alias template"
 msgstr "%qE 不是一個範本"
 
-#: cp/semantics.cc:14698
+#: cp/semantics.cc:14719
 #, fuzzy, gcc-internal-format
 msgid "operand of fold expression has no unexpanded parameter packs"
 msgstr "第三運算元的條件運算式沒有任何效果"
 
-#: cp/semantics.cc:14758
+#: cp/semantics.cc:14779
 #, fuzzy, gcc-internal-format
 #| msgid "template argument %qE involves template parameter(s)"
 msgid "both arguments in binary fold have unexpanded parameter packs"
 msgstr "範本引數 %qE 混雜了範本參數"
 
-#: cp/semantics.cc:14760
+#: cp/semantics.cc:14781
 #, gcc-internal-format
 msgid "no unexpanded parameter packs in binary fold"
 msgstr ""
 
-#: cp/semantics.cc:14777
+#: cp/semantics.cc:14798
 #, fuzzy, gcc-internal-format
 #| msgid "second argument to %<__builtin_prefetch%> must be a constant"
 msgid "type %qT of argument to %<__builtin_launder%> is not a pointer to object type"
@@ -73788,362 +73947,362 @@ msgstr "%<__builtin_prefetch%> 的第二個引數必須是一個常數"
 #. std::bit_cast for destination ARRAY_TYPE is not possible,
 #. as functions may not return an array, so don't bother trying
 #. to support this (and then deal with VLAs etc.).
-#: cp/semantics.cc:14827
+#: cp/semantics.cc:14848
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is an array type"
 msgstr ""
 
-#: cp/semantics.cc:14833
+#: cp/semantics.cc:14854
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> destination type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14839
+#: cp/semantics.cc:14860
 #, fuzzy, gcc-internal-format
 #| msgid "%<this%> may not be used in this context"
 msgid "%<__builtin_bit_cast%> cannot be used with consteval-only types"
 msgstr "%<this%> 不能用在此上下文中"
 
-#: cp/semantics.cc:14866
+#: cp/semantics.cc:14887
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source type %qT is not trivially copyable"
 msgstr ""
 
-#: cp/semantics.cc:14874
+#: cp/semantics.cc:14895
 #, gcc-internal-format
 msgid "%<__builtin_bit_cast%> source size %qE not equal to destination type size %qE"
 msgstr ""
 
-#: cp/tree.cc:1611 rust/backend/rust-tree.cc:2609
+#: cp/tree.cc:1613 rust/backend/rust-tree.cc:2609
 #, gcc-internal-format
 msgid "%qV qualifiers cannot be applied to %qT"
 msgstr "%qV 限定符不能套用到 %qT 上"
 
-#: cp/tree.cc:4751
+#: cp/tree.cc:4768
 #, gcc-internal-format
 msgid "%<-fabi-version=13%> (GCC 8.2) fixes the calling convention for %qT, which was accidentally changed in 8.1"
 msgstr ""
 
-#: cp/tree.cc:4755
+#: cp/tree.cc:4772
 #, gcc-internal-format
 msgid "%<-fabi-version=12%> (GCC 8.1) accidentally changes the calling convention for %qT"
 msgstr ""
 
-#: cp/tree.cc:4759
+#: cp/tree.cc:4776
 #, fuzzy, gcc-internal-format
 msgid " declared here"
 msgstr "宣告的在此"
 
-#: cp/tree.cc:4764
+#: cp/tree.cc:4781
 #, gcc-internal-format
 msgid "the calling convention for %qT changes in %<-fabi-version=13%> (GCC 8.2)"
 msgstr ""
 
-#: cp/tree.cc:4766
+#: cp/tree.cc:4783
 #, gcc-internal-format
 msgid " because all of its copy and move constructors are deleted"
 msgstr ""
 
-#: cp/tree.cc:5047
+#: cp/tree.cc:5064
 #, fuzzy, gcc-internal-format
 msgid "%qT is a floating-point type"
 msgstr "%qT 不是列舉類型型態"
 
-#: cp/tree.cc:5052
+#: cp/tree.cc:5069
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a template type"
 msgid "%qT is a fixed-point type"
 msgstr "%qT 不是一個範本類型"
 
-#: cp/tree.cc:5083
+#: cp/tree.cc:5100
 #, fuzzy, gcc-internal-format
 #| msgid "%qT is not a base of %qT"
 msgid "%qD does not fill all bits of %q#T"
 msgstr "%qT 不是 %qT 的基礎類別"
 
-#: cp/tree.cc:5091
+#: cp/tree.cc:5108
 #, gcc-internal-format
 msgid "%qD has type %qT that does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5101
+#: cp/tree.cc:5118
 #, fuzzy, gcc-internal-format
 #| msgid "%q#T has pointer data members"
 msgid "%q#T has no data fields"
 msgstr "%q#T 有指標資料成員"
 
-#: cp/tree.cc:5113
+#: cp/tree.cc:5130
 #, gcc-internal-format
 msgid "%<std::nullptr_t%> has padding bits and no value bits"
 msgstr ""
 
-#: cp/tree.cc:5142
+#: cp/tree.cc:5159
 #, gcc-internal-format
 msgid "base %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5154 cp/tree.cc:5164
+#: cp/tree.cc:5171 cp/tree.cc:5181
 #, gcc-internal-format
 msgid "%qD with type %qT does not have unique object representations"
 msgstr ""
 
-#: cp/tree.cc:5190
+#: cp/tree.cc:5207
 #, fuzzy, gcc-internal-format
 msgid "padding occurs between %qD and %qD"
 msgstr "比較介於 %qT 和 %qT"
 
-#: cp/tree.cc:5194
+#: cp/tree.cc:5211
 #, gcc-internal-format
 msgid "unnamed bit-field inserts padding before %qD"
 msgstr ""
 
-#: cp/tree.cc:5198
+#: cp/tree.cc:5215
 #, gcc-internal-format
 msgid "padding occurs before %qD"
 msgstr ""
 
-#: cp/tree.cc:5215
+#: cp/tree.cc:5232
 #, gcc-internal-format
 msgid "padding occurs after %qD"
 msgstr ""
 
-#: cp/tree.cc:5218
+#: cp/tree.cc:5235
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a gcov data file"
 msgid "%qT has padding and no data fields"
 msgstr "%qs 不是一個 gcov 資料檔案"
 
-#: cp/tree.cc:5327
+#: cp/tree.cc:5344
 #, fuzzy, gcc-internal-format
 #| msgid "base class %qT has cv qualifiers"
 msgid "base class %qT is not public"
 msgstr "基礎類別 %qT 有 cv 限定"
 
-#: cp/tree.cc:5330
+#: cp/tree.cc:5347
 #, fuzzy, gcc-internal-format
 msgid "%qD is not public"
 msgstr "%qD 未被擷取"
 
-#: cp/tree.cc:5337
+#: cp/tree.cc:5354
 #, fuzzy, gcc-internal-format
 msgid "%qD is mutable"
 msgstr "%qD 並非變數"
 
-#: cp/tree.cc:5345
+#: cp/tree.cc:5362
 #, fuzzy, gcc-internal-format
 msgid "%qD has a non-structural type"
 msgstr "%qD 並非型態"
 
-#: cp/tree.cc:5368
+#: cp/tree.cc:5385
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or parameters"
 msgstr "只能為類別定義套用 %qE 屬性"
 
-#: cp/tree.cc:5389
+#: cp/tree.cc:5406
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be a string constant"
 msgstr "%qE 屬性引數不是字串常數"
 
-#: cp/tree.cc:5404
+#: cp/tree.cc:5421
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to functions or to class or enumeration types"
 msgstr "只能為類別定義套用 %qE 屬性"
 
-#: cp/tree.cc:5424 cp/tree.cc:5429
+#: cp/tree.cc:5441 cp/tree.cc:5446
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute can only be applied to non-static data members"
 msgstr "只能為類別定義套用 %qE 屬性"
 
-#: cp/tree.cc:5435
+#: cp/tree.cc:5452
 #, fuzzy, gcc-internal-format
 #| msgid "%qE attribute can only be applied to class definitions"
 msgid "%qE attribute cannot be applied to a bit-field"
 msgstr "只能為類別定義套用 %qE 屬性"
 
-#: cp/tree.cc:5455
+#: cp/tree.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute takes no arguments"
 msgstr "%qE 屬性沒有任何效果"
 
-#: cp/tree.cc:5459
+#: cp/tree.cc:5476
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ %qE attribute does not apply to functions; treating as %<[[gnu::%E]]%>"
 msgstr "%qE 屬性不套用輸入"
 
-#: cp/tree.cc:5482
+#: cp/tree.cc:5499
 #, fuzzy, gcc-internal-format
 #| msgid "invalid function declaration"
 msgid "%<alignas%> on function declaration"
 msgstr "無效的函式宣告"
 
-#: cp/tree.cc:5485
+#: cp/tree.cc:5502
 #, fuzzy, gcc-internal-format
 msgid "%<alignas%> on enumerated type"
 msgstr "%qT 不是列舉類型型態"
 
-#: cp/tree.cc:5488
+#: cp/tree.cc:5505
 #, gcc-internal-format
 msgid "%<alignas%> on a type other than class"
 msgstr ""
 
-#: cp/tree.cc:5490
+#: cp/tree.cc:5507
 #, fuzzy, gcc-internal-format
 #| msgid "%<__alignof%> applied to a bit-field"
 msgid "%<alignas%> on bit-field"
 msgstr "將 %<__alignof%> 用於位元段"
 
-#: cp/tree.cc:5493
+#: cp/tree.cc:5510
 #, gcc-internal-format
 msgid "%<alignas%> on a type alias"
 msgstr ""
 
-#: cp/tree.cc:5510 cp/tree.cc:5528
+#: cp/tree.cc:5527 cp/tree.cc:5545
 #, fuzzy, gcc-internal-format
 msgid "%qE on a type other than class or enumeration definition"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/tree.cc:5512 cp/tree.cc:5530
+#: cp/tree.cc:5529 cp/tree.cc:5547
 #, fuzzy, gcc-internal-format
 msgid "%qE on unnamed bit-field"
 msgstr "對齊指定的用於未命名 bit-field"
 
-#: cp/tree.cc:5534
+#: cp/tree.cc:5551
 #, gcc-internal-format
 msgid "%qE on %<case%> or %<default%> label"
 msgstr ""
 
-#: cp/tree.cc:5548
+#: cp/tree.cc:5565
 #, fuzzy, gcc-internal-format
 msgid "%qE on declaration other than parameter or automatic variable"
 msgstr "%qE 屬性沒有任何效果於單位本地函式"
 
-#: cp/tree.cc:5643
+#: cp/tree.cc:5660
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is not an integer constant"
 msgid "requested %<init_priority%> is not an integer constant"
 msgstr "請求的 init_priority 不是一個整數常數"
 
-#: cp/tree.cc:5665
+#: cp/tree.cc:5682
 #, gcc-internal-format
 msgid "can only use %qE attribute on file-scope definitions of objects of class type"
 msgstr "只能將 %qE 屬性用於某個類別的物件的檔案作用欄位定義"
 
-#: cp/tree.cc:5673
+#: cp/tree.cc:5690
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is out of range"
 msgid "requested %<init_priority%> %i is out of range [0, %i]"
 msgstr "請求的 init_priority 越界"
 
-#: cp/tree.cc:5686
+#: cp/tree.cc:5703
 #, fuzzy, gcc-internal-format
 #| msgid "requested init_priority is reserved for internal use"
 msgid "requested %<init_priority%> %i is reserved for internal use"
 msgstr "請求的 init_priority 保留為內部使用"
 
-#: cp/tree.cc:5717
+#: cp/tree.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "redeclaration of %qD adds abi tag %qE"
 msgstr "%qD 宣告為 %qT 的一個成員"
 
-#: cp/tree.cc:5737
+#: cp/tree.cc:5754
 #, fuzzy, gcc-internal-format
 msgid "the %qE attribute requires arguments"
 msgstr "%qD 屬性需要單一 NTBS 引數"
 
-#: cp/tree.cc:5748
+#: cp/tree.cc:5765
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must be narrow string literals"
 msgstr "引數的 %qE 屬性並非字串常數"
 
-#: cp/tree.cc:5762 cp/tree.cc:5776
+#: cp/tree.cc:5779 cp/tree.cc:5793
 #, fuzzy, gcc-internal-format
 msgid "arguments to the %qE attribute must contain valid identifiers"
 msgstr "引數的 %qE 屬性並非字串常數"
 
-#: cp/tree.cc:5764
+#: cp/tree.cc:5781
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid first character for an identifier"
 msgstr "%<%T::%D%> 不是一個有效的宣告"
 
-#: cp/tree.cc:5778
+#: cp/tree.cc:5795
 #, fuzzy, gcc-internal-format
 #| msgid "%<%T::%D%> is not a valid declarator"
 msgid "%<%c%> is not a valid character in an identifier"
 msgstr "%<%T::%D%> 不是一個有效的宣告"
 
-#: cp/tree.cc:5802
+#: cp/tree.cc:5819
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-class, non-enum type %qT"
 msgstr "%qE 屬性在不是類別的類型上被忽略"
 
-#: cp/tree.cc:5808
+#: cp/tree.cc:5825
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to %qT after its definition"
 msgstr "忽略屬性套用到 %qT 之後定義"
 
-#: cp/tree.cc:5815
+#: cp/tree.cc:5832
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template instantiation %qT"
 msgstr "忽略屬性套用到 %qT 之後定義"
 
-#: cp/tree.cc:5822
+#: cp/tree.cc:5839
 #, fuzzy, gcc-internal-format
 msgid "ignoring %qE attribute applied to template specialization %qT"
 msgstr "忽略屬性套用到 %qT 之後定義"
 
-#: cp/tree.cc:5844
+#: cp/tree.cc:5861
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to non-function, non-variable %qD"
 msgstr "%qE 屬性套用只有到函式"
 
-#: cp/tree.cc:5850
+#: cp/tree.cc:5867
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute applied to extern \"C\" declaration %qD"
 msgstr "%qE 屬性套用只有到函式"
 
-#: cp/tree.cc:5872
+#: cp/tree.cc:5889
 #, fuzzy, gcc-internal-format
 msgid "%qE attribute argument must be an expression that evaluates to true or false"
 msgstr "%qE 屬性引數不是字串常數"
 
-#: cp/tree.cc:5898
+#: cp/tree.cc:5915
 #, fuzzy, gcc-internal-format
 #| msgid "Warn about implicit function declarations"
 msgid "annotation on a type other than class or enumeration definition"
 msgstr "對隱含函式宣告給出警告"
 
-#: cp/tree.cc:5905
+#: cp/tree.cc:5922
 #, fuzzy, gcc-internal-format
 msgid "annotation applied to a label"
 msgstr "%qE 屬性只有套用到變數"
 
-#: cp/tree.cc:5911
+#: cp/tree.cc:5928
 #, fuzzy, gcc-internal-format
 msgid "annotation on unnamed bit-field"
 msgstr "對齊指定的用於未命名 bit-field"
 
-#: cp/tree.cc:5917
+#: cp/tree.cc:5934
 #, fuzzy, gcc-internal-format
 #| msgid "function parameter"
 msgid "annotation on void parameter"
 msgstr "函式參數"
 
-#: cp/tree.cc:5926
+#: cp/tree.cc:5950
 #, fuzzy, gcc-internal-format
 msgid "annotation does not have structural type"
 msgstr "%qD 沒有積分或列舉類型型態"
 
-#: cp/tree.cc:5941
+#: cp/tree.cc:5965
 #, fuzzy, gcc-internal-format
 #| msgid "function does not return string type"
 msgid "annotation does not have copy constructible type"
 msgstr "函式不回傳字串類型"
 
-#: cp/tree.cc:6915 rust/backend/rust-tree.cc:3189
+#: cp/tree.cc:6938 rust/backend/rust-tree.cc:3189
 #, fuzzy, gcc-internal-format
 #| msgid "lang_* check: failed in %s, at %s:%d"
 msgid "%<lang_*%> check: failed in %s, at %s:%d"
@@ -74348,835 +74507,841 @@ msgstr ""
 msgid "%q#T has no member named %qE; did you mean %qE?"
 msgstr "%qT 沒具名為 %qE 的成員"
 
-#: cp/typeck.cc:3592 cp/typeck.cc:3629
+#: cp/typeck.cc:3592 cp/typeck.cc:3636
 #, gcc-internal-format
 msgid "%<%D::%D%> is not a member of %qT"
 msgstr "%<%D::%D%> 不是 %qT 的成員"
 
-#: cp/typeck.cc:3786
+#: cp/typeck.cc:3605
+#, fuzzy, gcc-internal-format
+#| msgid "%qD is not a member of %qT"
+msgid "%q#D is not a member of %qT"
+msgstr "%qD 不是 %qT 的成員"
+
+#: cp/typeck.cc:3781
 #, gcc-internal-format
 msgid "%qD is not a member template function"
 msgstr "%qD 不是一個成員範本函式"
 
-#: cp/typeck.cc:4052
+#: cp/typeck.cc:4047
 #, gcc-internal-format
 msgid "%qT is not a pointer-to-object type"
 msgstr "%qT 不是一個參照物件的類型"
 
-#: cp/typeck.cc:4086
+#: cp/typeck.cc:4081
 #, fuzzy, gcc-internal-format
 msgid "invalid use of array indexing on pointer to member"
 msgstr "無效的使用的陣列索引於成員指標"
 
-#: cp/typeck.cc:4089
+#: cp/typeck.cc:4084
 #, fuzzy, gcc-internal-format
 msgid "invalid use of unary %<*%> on pointer to member"
 msgstr "無效的使用的一元 %<*%>於成員指標"
 
-#: cp/typeck.cc:4092
+#: cp/typeck.cc:4087
 #, fuzzy, gcc-internal-format
 msgid "invalid use of implicit conversion on pointer to member"
 msgstr "無效的使用的隱含轉換於成員指標"
 
-#: cp/typeck.cc:4096
+#: cp/typeck.cc:4091
 #, gcc-internal-format
 msgid "left hand operand of %<->*%> must be a pointer to class, but is a pointer to member of type %qT"
 msgstr ""
 
-#: cp/typeck.cc:4161
+#: cp/typeck.cc:4156
 #, gcc-internal-format
 msgid "subscript missing in array reference"
 msgstr "陣列參照缺少下標"
 
-#: cp/typeck.cc:4322
+#: cp/typeck.cc:4317
 #, gcc-internal-format
 msgid "subscripting array declared %<register%>"
 msgstr "按下標存取宣告為 %<register%> 的陣列"
 
-#: cp/typeck.cc:4361
+#: cp/typeck.cc:4356
 #, gcc-internal-format
 msgid "subscripted value is neither array nor pointer"
 msgstr "下標運算的左運算元既非陣列也非指標"
 
-#: cp/typeck.cc:4433
+#: cp/typeck.cc:4428
 #, gcc-internal-format
 msgid "object missing in use of %qE"
 msgstr "使用 %qE 時缺少物件"
 
-#: cp/typeck.cc:4685
+#: cp/typeck.cc:4680
 #, fuzzy, gcc-internal-format
 msgid "no default version in scope"
 msgstr "non-trivial 轉換於指派"
 
-#: cp/typeck.cc:4694
+#: cp/typeck.cc:4689
 #, gcc-internal-format
 msgid "ISO C++ forbids calling %<::main%> from within program"
 msgstr "ISO C++ 不允許在程式裡呼叫 %<::main%>"
 
-#: cp/typeck.cc:4715
+#: cp/typeck.cc:4710
 #, fuzzy, gcc-internal-format
 msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
 msgstr "必須使用 %<.*%>或 %<->*%> 到呼叫成員指標函式在中 %<%E (...)%>，例如： %<(...->* %E) (...)%>"
 
-#: cp/typeck.cc:4732
+#: cp/typeck.cc:4727
 #, fuzzy, gcc-internal-format
 #| msgid "%qE cannot be used as a function"
 msgid "%qT cannot be used as a function"
 msgstr "%qE 不能做為函式"
 
-#: cp/typeck.cc:4736
+#: cp/typeck.cc:4731
 #, gcc-internal-format
 msgid "%qE cannot be used as a function"
 msgstr "%qE 不能做為函式"
 
-#: cp/typeck.cc:4739
+#: cp/typeck.cc:4734
 #, fuzzy, gcc-internal-format
 msgid "%qD cannot be used as a function"
 msgstr "%qE 不能做為函式"
 
-#: cp/typeck.cc:4742
+#: cp/typeck.cc:4737
 #, fuzzy, gcc-internal-format
 msgid "expression cannot be used as a function"
 msgstr "%qE 不能做為函式"
 
-#: cp/typeck.cc:4804
+#: cp/typeck.cc:4799
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to constructor %q#D"
 msgstr "太多引數到建構子 %q#D"
 
-#: cp/typeck.cc:4805
+#: cp/typeck.cc:4800
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to constructor %q#D"
 msgstr "太少引數到建構子 %q#D"
 
-#: cp/typeck.cc:4810
+#: cp/typeck.cc:4805
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to member function %q#D"
 msgstr "太多引數到成員函式 %q#D"
 
-#: cp/typeck.cc:4811
+#: cp/typeck.cc:4806
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to member function %q#D"
 msgstr "太少引數到成員函式 %q#D"
 
-#: cp/typeck.cc:4817
+#: cp/typeck.cc:4812
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to function %q#D"
 msgstr "太多引數到函式 %q#D"
 
-#: cp/typeck.cc:4818
+#: cp/typeck.cc:4813
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to function %q#D"
 msgstr "太少引數到函式 %q#D"
 
-#: cp/typeck.cc:4828
+#: cp/typeck.cc:4823
 #, fuzzy, gcc-internal-format
 msgid "too many arguments to method %q#D"
 msgstr "太多引數到方法 %q#D"
 
-#: cp/typeck.cc:4829
+#: cp/typeck.cc:4824
 #, fuzzy, gcc-internal-format
 msgid "too few arguments to method %q#D"
 msgstr "太少引數到方法 %q#D"
 
-#: cp/typeck.cc:4832
+#: cp/typeck.cc:4827
 #, gcc-internal-format
 msgid "too many arguments to function"
 msgstr "給予函式的引數太多"
 
-#: cp/typeck.cc:4833
+#: cp/typeck.cc:4828
 #, gcc-internal-format
 msgid "too few arguments to function"
 msgstr "給予函式的引數太少"
 
-#: cp/typeck.cc:4911
+#: cp/typeck.cc:4906
 #, gcc-internal-format
 msgid "parameter %P of %qD has incomplete type %qT"
 msgstr "參數 %P (屬於 %qD)的類型 %qT 不完全"
 
-#: cp/typeck.cc:4917
+#: cp/typeck.cc:4912
 #, gcc-internal-format
 msgid "parameter %P has incomplete type %qT"
 msgstr "參數 %P 的類型 %qT 不完全"
 
-#: cp/typeck.cc:5231
+#: cp/typeck.cc:5226
 #, fuzzy, gcc-internal-format
 msgid "the address %qE will never be NULL"
 msgstr "位址的 %qD 將永不是空值"
 
-#: cp/typeck.cc:5278
+#: cp/typeck.cc:5273
 #, fuzzy, gcc-internal-format
 msgid "the address of %qD will never be NULL"
 msgstr "位址的 %qD 將永不是空值"
 
-#: cp/typeck.cc:5293
+#: cp/typeck.cc:5288
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qE will never be NULL"
 msgstr "比較將一律評估做為 %<true%> 用於位址的 %qD 將永不是空值"
 
-#: cp/typeck.cc:5296
+#: cp/typeck.cc:5291
 #, gcc-internal-format
 msgid "comparing the result of pointer addition %qE and NULL"
 msgstr ""
 
-#: cp/typeck.cc:5311
+#: cp/typeck.cc:5306
 #, fuzzy, gcc-internal-format
 msgid "the compiler can assume that the address of %qD will never be NULL"
 msgstr "比較將一律評估做為 %<true%> 用於位址的 %qD 將永不是空值"
 
-#: cp/typeck.cc:5370
+#: cp/typeck.cc:5365
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT"
 msgstr "運算元到 ?:有不同的類型 %qT 和 %qT"
 
-#: cp/typeck.cc:5373
+#: cp/typeck.cc:5368
 #, fuzzy, gcc-internal-format
 msgid "bitwise operation between different enumeration types %qT and %qT is deprecated"
 msgstr "轉換介於明確的指標類型 %qT 和 %qT lacks 演員陣容"
 
-#: cp/typeck.cc:5379
+#: cp/typeck.cc:5374
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT"
 msgstr "相同權威的型態節點用於不同的類型 %T 和 %T"
 
-#: cp/typeck.cc:5382
+#: cp/typeck.cc:5377
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between different enumeration types %qT and %qT is deprecated"
 msgstr "比較介於明確的指標類型 %qT 和 %qT lacks 演員陣容"
 
-#: cp/typeck.cc:5419
+#: cp/typeck.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT"
 msgstr "複雜引數必須有浮點型態"
 
-#: cp/typeck.cc:5422
+#: cp/typeck.cc:5417
 #, fuzzy, gcc-internal-format
 #| msgid "cast from function call of type %qT to non-matching type %qT"
 msgid "comparison of floating-point type %qT with enumeration type %qT"
 msgstr "從類型為 %qT 的函式呼叫轉換到不匹配的類型 %qT"
 
-#: cp/typeck.cc:5425
+#: cp/typeck.cc:5420
 #, gcc-internal-format
 msgid "comparison of enumeration type %qT with floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5429
+#: cp/typeck.cc:5424
 #, fuzzy, gcc-internal-format
 msgid "comparison of floating-point type %qT with enumeration type %qT is deprecated"
 msgstr "轉換從指標類型 %qT 到算術型式 %qT 在中 constant-expression"
 
-#: cp/typeck.cc:5438
+#: cp/typeck.cc:5433
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT"
 msgstr ""
 
-#: cp/typeck.cc:5441
+#: cp/typeck.cc:5436
 #, fuzzy, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT"
 msgstr "不相容的類型時指派輸入 %qT 從型態 %qT"
 
-#: cp/typeck.cc:5444
+#: cp/typeck.cc:5439
 #, gcc-internal-format
 msgid "arithmetic between enumeration type %qT and floating-point type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5448
+#: cp/typeck.cc:5443
 #, gcc-internal-format
 msgid "arithmetic between floating-point type %qT and enumeration type %qT is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:5583 cp/typeck.cc:5595
+#: cp/typeck.cc:5578 cp/typeck.cc:5590
 #, gcc-internal-format
 msgid "assuming cast to type %qT from overloaded function"
 msgstr "假定從多載函式轉換到類型 %qT"
 
-#: cp/typeck.cc:5709
+#: cp/typeck.cc:5704
 #, gcc-internal-format
 msgid "NULL used in arithmetic"
 msgstr "算術運算式中使用了 NULL"
 
-#: cp/typeck.cc:6179 cp/typeck.cc:6188 cp/typeck.cc:6504 cp/typeck.cc:6513
+#: cp/typeck.cc:6174 cp/typeck.cc:6183 cp/typeck.cc:6499 cp/typeck.cc:6508
 #, gcc-internal-format
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr "ISO C++ 不允許比較指標和整數的值"
 
-#: cp/typeck.cc:6419 cp/typeck.cc:6433
+#: cp/typeck.cc:6414 cp/typeck.cc:6428
 #, fuzzy, gcc-internal-format
 msgid "operand types are %qT and %qT"
 msgstr "沒具名為 %q#T 的類型，在%q#T 中 "
 
-#: cp/typeck.cc:6456
+#: cp/typeck.cc:6451
 #, gcc-internal-format
 msgid "three-way comparison of vectors"
 msgstr ""
 
-#: cp/typeck.cc:6496
+#: cp/typeck.cc:6491
 #, fuzzy, gcc-internal-format
 #| msgid "ordered comparison of pointer with integer zero"
 msgid "ordered comparison of pointer with integer zero (%qT and %qT)"
 msgstr "指標與整數 0 比較大小"
 
-#: cp/typeck.cc:6543
+#: cp/typeck.cc:6538
 #, fuzzy, gcc-internal-format
 #| msgid "unordered comparison on non-floating point argument"
 msgid "unordered comparison on non-floating-point argument"
 msgstr "非浮點引數間的無效比較"
 
-#: cp/typeck.cc:6609
+#: cp/typeck.cc:6604
 #, fuzzy
 msgid "implicit conversion from %qH to %qI to match other operand of binary expression"
 msgstr "隱含轉換從 %qT 到 %qT 到匹配其他運算元的二進位運算式"
 
-#: cp/typeck.cc:6718
+#: cp/typeck.cc:6713
 #, gcc-internal-format
 msgid "invalid operands of types %qT and %qT to binary %qO"
 msgstr "運算元類型 %qT 和 %qT 對二進位 %qO 而言無效"
 
-#: cp/typeck.cc:7119
+#: cp/typeck.cc:7114
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer of type %<void *%> in subtraction"
 msgstr "ISO C++ 不允許在減法中使用類型為 %<void *%> 的指標"
 
-#: cp/typeck.cc:7127
+#: cp/typeck.cc:7122
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a function in subtraction"
 msgstr "ISO C++ 不允許在減法中使用函式指標"
 
-#: cp/typeck.cc:7135
+#: cp/typeck.cc:7130
 #, gcc-internal-format
 msgid "ISO C++ forbids using pointer to a method in subtraction"
 msgstr "ISO C++ 不允許在減法中使用參照方法的指標"
 
-#: cp/typeck.cc:7188
+#: cp/typeck.cc:7183
 #, gcc-internal-format
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr "在指標算術中使用參照不完全類型的指標無效"
 
-#: cp/typeck.cc:7265
+#: cp/typeck.cc:7260
 #, fuzzy, gcc-internal-format
 msgid "taking address of constructor %qD"
 msgstr "需位址的建構子 %qE"
 
-#: cp/typeck.cc:7266
+#: cp/typeck.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "taking address of destructor %qD"
 msgstr "需位址的解構式 %qE"
 
-#: cp/typeck.cc:7283
+#: cp/typeck.cc:7278
 #, gcc-internal-format
 msgid "invalid use of %qE to form a pointer-to-member-function"
 msgstr "用 %qE 形成成員函式指標的用法無效。"
 
-#: cp/typeck.cc:7286
+#: cp/typeck.cc:7281
 #, gcc-internal-format
 msgid "  a qualified-id is required"
 msgstr "  需要一個限定的識別碼"
 
-#: cp/typeck.cc:7293
+#: cp/typeck.cc:7288
 #, fuzzy, gcc-internal-format
 msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
 msgstr "parentheses 周圍 %qE 無法用來表單成員函式指標"
 
-#: cp/typeck.cc:7488
+#: cp/typeck.cc:7483
 #, gcc-internal-format
 msgid "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%>"
 msgstr "ISO C++ 不允許透過提取一個未限定的或帶括號的非靜態成員函式的位址來形成一個成員函式指標。請使用 %<&%T::%D%>"
 
-#: cp/typeck.cc:7494
+#: cp/typeck.cc:7489
 #, fuzzy, gcc-internal-format
 #| msgid "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%>"
 msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to explicit object member function"
 msgstr "ISO C++ 不允許透過提取一個未限定的或帶括號的非靜態成員函式的位址來形成一個成員函式指標。請使用 %<&%T::%D%>"
 
-#: cp/typeck.cc:7500
+#: cp/typeck.cc:7495
 #, gcc-internal-format
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgstr "ISO C++ 不允許透過取已繫結的成員函式的位址來建構成員函式指標。請改用 %<&%T::%D%>"
 
-#: cp/typeck.cc:7506
+#: cp/typeck.cc:7501
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>"
 msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to explicit object member function"
 msgstr "ISO C++ 不允許透過取已繫結的成員函式的位址來建構成員函式指標。請改用 %<&%T::%D%>"
 
-#: cp/typeck.cc:7511
+#: cp/typeck.cc:7506
 #, fuzzy, gcc-internal-format
 #| msgid "(a pointer to member can only be formed with %<&%E%>)"
 msgid "a pointer to explicit object member function can only be formed with %<&%T::%D%>"
 msgstr "(成員指標只能用 %<&%E%> 構成)"
 
 #. Make this a permerror because we used to accept it.
-#: cp/typeck.cc:7544
+#: cp/typeck.cc:7539
 #, fuzzy, gcc-internal-format
 #| msgid "taking address of temporary"
 msgid "taking address of rvalue"
 msgstr "取臨時變數的位址"
 
-#: cp/typeck.cc:7561
+#: cp/typeck.cc:7556
 #, gcc-internal-format
 msgid "ISO C++ forbids taking address of function %<::main%>"
 msgstr "ISO C++ 不允許取函式 %<::main%> 的位址"
 
-#: cp/typeck.cc:7619
+#: cp/typeck.cc:7614
 #, gcc-internal-format
 msgid "cannot create pointer to reference member %qD"
 msgstr "不能建立參照參照成員 %qD 的指標"
 
-#: cp/typeck.cc:7654 cp/typeck.cc:8247 rust/backend/rust-tree.cc:4739
+#: cp/typeck.cc:7649 cp/typeck.cc:8241 rust/backend/rust-tree.cc:4739
 #, fuzzy, gcc-internal-format
 #| msgid "cannot take address of bit-field %qD"
 msgid "attempt to take address of bit-field"
 msgstr "無法取得位元段 %qD 的位址"
 
-#: cp/typeck.cc:7821
+#: cp/typeck.cc:7816
 #, fuzzy, gcc-internal-format
 msgid "%<~%> on an expression of type %<bool%>"
 msgstr "需位址的運算式的型態 %<void%>"
 
-#: cp/typeck.cc:7822
+#: cp/typeck.cc:7817
 #, gcc-internal-format
 msgid "did you mean to use logical not (%<!%>)?"
 msgstr ""
 
-#: cp/typeck.cc:7966
+#: cp/typeck.cc:7960
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing an enum"
 msgstr "ISO C++禁止遞增 enum"
 
-#: cp/typeck.cc:7967
+#: cp/typeck.cc:7961
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing an enum"
 msgstr "ISO C++禁止遞減 enum"
 
-#: cp/typeck.cc:7983
+#: cp/typeck.cc:7977
 #, fuzzy, gcc-internal-format
 msgid "cannot increment a pointer to incomplete type %qT"
 msgstr "無法遞增指標到不完整型態 %qT"
 
-#: cp/typeck.cc:7985
+#: cp/typeck.cc:7979
 #, fuzzy, gcc-internal-format
 msgid "cannot decrement a pointer to incomplete type %qT"
 msgstr "無法遞減指標到不完整型態 %qT"
 
-#: cp/typeck.cc:7997
+#: cp/typeck.cc:7991
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids incrementing a pointer of type %qT"
 msgstr "ISO C++禁止遞增指標的型態 %qT"
 
-#: cp/typeck.cc:7999
+#: cp/typeck.cc:7993
 #, fuzzy, gcc-internal-format
 msgid "ISO C++ forbids decrementing a pointer of type %qT"
 msgstr "ISO C++禁止遞減指標的型態 %qT"
 
-#: cp/typeck.cc:8039
+#: cp/typeck.cc:8033
 #, gcc-internal-format
 msgid "%qs expression of %<volatile%>-qualified type is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8052
+#: cp/typeck.cc:8046
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator--%> is forbidden"
 msgstr ""
 
-#: cp/typeck.cc:8062
+#: cp/typeck.cc:8056
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is forbidden in C++17"
 msgstr ""
 
-#: cp/typeck.cc:8070
+#: cp/typeck.cc:8064
 #, gcc-internal-format
 msgid "use of an operand of type %qT in %<operator++%> is deprecated"
 msgstr ""
 
-#: cp/typeck.cc:8259 rust/backend/rust-tree.cc:4751
+#: cp/typeck.cc:8253 rust/backend/rust-tree.cc:4751
 #, gcc-internal-format
 msgid "cannot take the address of %<this%>, which is an rvalue expression"
 msgstr "無法取右值運算式 %<this%> 的位址"
 
-#: cp/typeck.cc:8286 rust/backend/rust-tree.cc:4777
+#: cp/typeck.cc:8284 rust/backend/rust-tree.cc:4777
 #, gcc-internal-format
 msgid "address requested for %qD, which is declared %<register%>"
 msgstr "請求宣告為 %<register%> 的 %qD 的位址"
 
-#: cp/typeck.cc:8357
+#: cp/typeck.cc:8355
 #, fuzzy, gcc-internal-format
 msgid "list-initializer for non-class type must not be parenthesized"
 msgstr "list-initializer 用於 non-class 型態必須不被 parenthesized"
 
-#: cp/typeck.cc:8369
+#: cp/typeck.cc:8367
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in initializer"
 msgstr "運算式清單視為複合式表示式在中初始設定式"
 
-#: cp/typeck.cc:8373
+#: cp/typeck.cc:8371
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in mem-initializer"
 msgstr "運算式清單視為複合式表示式在中 mem-initializer"
 
-#: cp/typeck.cc:8377
+#: cp/typeck.cc:8375
 #, fuzzy, gcc-internal-format
 msgid "expression list treated as compound expression in functional cast"
 msgstr "運算式清單視為複合式表示式在中 functional 演員陣容"
 
-#: cp/typeck.cc:8415
+#: cp/typeck.cc:8413
 #, gcc-internal-format, gfc-internal-format
 msgid "%s expression list treated as compound expression"
 msgstr "%s 運算式清單被看作複合運算式"
 
-#: cp/typeck.cc:8518
+#: cp/typeck.cc:8516
 #, fuzzy, gcc-internal-format
 msgid "no context to resolve type of %qE"
 msgstr "沒有語境到解析型態的 %qE"
 
-#: cp/typeck.cc:8555
+#: cp/typeck.cc:8553
 #, fuzzy, gcc-internal-format
 msgid "cast from type %qT to type %qT casts away qualifiers"
 msgstr "演員陣容從型態 %qT 輸入 %qT 演員陣容暫離限定元"
 
-#: cp/typeck.cc:8561
+#: cp/typeck.cc:8559
 #, fuzzy, gcc-internal-format
 msgid "%<static_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "staticcast 從型態 %qT 輸入 %qT 演員陣容暫離限定元(_C)"
 
-#: cp/typeck.cc:8568
+#: cp/typeck.cc:8566
 #, fuzzy, gcc-internal-format
 msgid "%<reinterpret_cast%> from type %qT to type %qT casts away qualifiers"
 msgstr "reinterpretcast 從型態 %qT 輸入 %qT 演員陣容暫離限定元(_C)"
 
-#: cp/typeck.cc:8594
+#: cp/typeck.cc:8592
 #, fuzzy, gcc-internal-format
 msgid "useless cast to type %q#T"
 msgstr "%qT 使用了局部類型 %qT"
 
-#: cp/typeck.cc:8608
+#: cp/typeck.cc:8606
 #, fuzzy, gcc-internal-format
 #| msgid "type qualifiers ignored on function return type"
 msgid "type qualifiers ignored on cast result type"
 msgstr "忽略函式回傳類型的類型限定"
 
-#: cp/typeck.cc:9057
+#: cp/typeck.cc:9055
 #, fuzzy, gcc-internal-format
 #| msgid "invalid static_cast from type %qT to type %qT"
 msgid "invalid %<static_cast%> from type %qT to type %qT"
 msgstr "從類型 %qT 到類型 %qT 中的 static_cast 無效"
 
-#: cp/typeck.cc:9063 cp/typeck.cc:9069 cp/typeck.cc:10808
+#: cp/typeck.cc:9061 cp/typeck.cc:9067 cp/typeck.cc:10806
 #, fuzzy, gcc-internal-format
 #| msgid "return type %q#T is incomplete"
 msgid "class type %qT is incomplete"
 msgstr "回傳值類型 %q#T 為不完全"
 
-#: cp/typeck.cc:9097
+#: cp/typeck.cc:9095
 #, fuzzy
 #| msgid "converting from %qT to %qT"
 msgid "converting from %qH to %qI"
 msgstr "從 %qT 轉換到 %qT"
 
-#: cp/typeck.cc:9172
+#: cp/typeck.cc:9170
 #, fuzzy, gcc-internal-format
 #| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
 msgid "invalid cast of a prvalue expression of type %qT to type %qT"
 msgstr "從具有類型 %qT 的右值運算式到類型 %qT 中的轉換無效"
 
-#: cp/typeck.cc:9242
+#: cp/typeck.cc:9240
 #, fuzzy
 #| msgid "cast from %qT to %qT loses precision"
 msgid "cast from %qH to %qI loses precision"
 msgstr "從 %qT 到 %qT 的轉換損失精度"
 
-#: cp/typeck.cc:9267
+#: cp/typeck.cc:9265
 msgid "cast between incompatible function types from %qH to %qI"
 msgstr ""
 
-#: cp/typeck.cc:9278
+#: cp/typeck.cc:9276
 #, fuzzy
 msgid "cast between incompatible pointer to member types from %qH to %qI"
 msgstr "比較介於明確的成員指標類型 %qT 和 %qT lacks 演員陣容"
 
-#: cp/typeck.cc:9299 cp/typeck.cc:9489
+#: cp/typeck.cc:9297 cp/typeck.cc:9487
 #, fuzzy
 #| msgid "cast from %qT to %qT increases required alignment of target type"
 msgid "cast from %qH to %qI increases required alignment of target type"
 msgstr "從 %qT 到 %qT 的轉換增大了目的類型的對齊需求"
 
-#: cp/typeck.cc:9316
+#: cp/typeck.cc:9314
 #, fuzzy, gcc-internal-format
 #| msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
 msgid "casting between pointer-to-function and pointer-to-object is conditionally-supported"
 msgstr "ISO C++ 不允許在函式指標和物件指標間進行轉換"
 
-#: cp/typeck.cc:9330
+#: cp/typeck.cc:9328
 #, gcc-internal-format
 msgid "invalid cast from type %qT to type %qT"
 msgstr "從類型 %qT 到類型 %qT 的轉換無效"
 
-#: cp/typeck.cc:9403
+#: cp/typeck.cc:9401
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgid "invalid use of %<const_cast%> with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type"
 msgstr "在類型 %qT 上使用 const_cast 無效，因為它既不是指標，也不是參照，也不是資料成員指標"
 
-#: cp/typeck.cc:9412
+#: cp/typeck.cc:9410
 #, fuzzy, gcc-internal-format
 #| msgid "invalid use of const_cast with type %qT, which is a pointer or reference to a function type"
 msgid "invalid use of %<const_cast%> with type %qT, which is a pointer or reference to a function type"
 msgstr "在類型 %qT 上使用 const_cast 無效，因為它是一個指標函式類型的指標或參照"
 
-#: cp/typeck.cc:9454
+#: cp/typeck.cc:9452
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast of an rvalue of type %qT to type %qT"
 msgid "invalid %<const_cast%> of an rvalue of type %qT to type %qT"
 msgstr "從類型 %qT 到類型 %qT 中的 const_cast 無效"
 
-#: cp/typeck.cc:9524
+#: cp/typeck.cc:9522
 #, fuzzy, gcc-internal-format
 #| msgid "invalid const_cast from type %qT to type %qT"
 msgid "invalid %<const_cast%> from type %qT to type %qT"
 msgstr "從類型 %qT 到類型 %qT 中的 const_cast 無效"
 
-#: cp/typeck.cc:9625 cp/typeck.cc:9634
+#: cp/typeck.cc:9623 cp/typeck.cc:9632
 #, gcc-internal-format
 msgid "ISO C++ forbids casting to an array type %qT"
 msgstr "ISO C++ 不允許轉換為陣列類型 %qT"
 
-#: cp/typeck.cc:9643
+#: cp/typeck.cc:9641
 #, gcc-internal-format
 msgid "invalid cast to function type %qT"
 msgstr "向函式類型 %qT 的轉換無效"
 
-#: cp/typeck.cc:9759
+#: cp/typeck.cc:9757
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert %qE from type %qT to type %qT"
 msgid "moving %qE of type %qT to itself"
 msgstr "無法將 %qE 從類型 %qT 轉換到類型 %qT"
 
-#: cp/typeck.cc:10039
+#: cp/typeck.cc:10037
 #, gcc-internal-format
 msgid "  in evaluation of %<%Q(%#T, %#T)%>"
 msgstr "  在求 %<%Q(%#T, %#T)%> 值時"
 
-#: cp/typeck.cc:10100
+#: cp/typeck.cc:10098
 #, fuzzy, gcc-internal-format
 msgid "assigning to an array from an initializer list"
 msgstr "指派到陣列從初始設定式清單"
 
-#: cp/typeck.cc:10127
+#: cp/typeck.cc:10125
 #, gcc-internal-format
 msgid "incompatible types in assignment of %qT to %qT"
 msgstr "將 %qT 賦值給 %qT 時類型不相容"
 
-#: cp/typeck.cc:10143
+#: cp/typeck.cc:10141
 #, fuzzy, gcc-internal-format
 msgid "array used as initializer"
 msgstr "陣列使用的做為初始設定式"
 
-#: cp/typeck.cc:10145
+#: cp/typeck.cc:10143
 #, fuzzy, gcc-internal-format
 msgid "invalid array assignment"
 msgstr "無效的陣列指派"
 
-#: cp/typeck.cc:10281
+#: cp/typeck.cc:10279
 #, gcc-internal-format
 msgid "   in pointer to member function conversion"
 msgstr "  在成員函式指標轉換中"
 
-#: cp/typeck.cc:10295
+#: cp/typeck.cc:10293
 #, gcc-internal-format
 msgid "pointer to member conversion via virtual base %qT"
 msgstr "成員指標轉換經由虛基礎類別 %qT"
 
-#: cp/typeck.cc:10343 cp/typeck.cc:10362
+#: cp/typeck.cc:10341 cp/typeck.cc:10360
 #, gcc-internal-format
 msgid "   in pointer to member conversion"
 msgstr "  在成員指標轉換中"
 
-#: cp/typeck.cc:10443
+#: cp/typeck.cc:10441
 #, gcc-internal-format
 msgid "invalid conversion to type %qT from type %qT"
 msgstr "到類型 %qT 的轉換無效，從類型 %qT"
 
-#: cp/typeck.cc:10767
+#: cp/typeck.cc:10765
 #, fuzzy
 msgid "cannot convert %qH to %qI in default argument"
 msgstr "無法轉換 %qT 到 %qT 在中預設引數"
 
-#: cp/typeck.cc:10772
+#: cp/typeck.cc:10770
 #, fuzzy
 msgid "cannot convert %qH to %qI in argument passing"
 msgstr "無法轉換 %qT 到 %qT 在中引數傳遞"
 
-#: cp/typeck.cc:10781
+#: cp/typeck.cc:10779
 #, fuzzy
 msgid "cannot convert %qH to %qI in initialization"
 msgstr "無法轉換 %qT 到 %qT 在中初始化"
 
-#: cp/typeck.cc:10785
+#: cp/typeck.cc:10783
 #, fuzzy
 msgid "cannot convert %qH to %qI in return"
 msgstr "無法轉換 %qT 到 %qT 在中回傳"
 
-#: cp/typeck.cc:10790
+#: cp/typeck.cc:10788
 #, fuzzy
 msgid "cannot convert %qH to %qI in assignment"
 msgstr "無法轉換 %qT 到 %qT 在中指派"
 
-#: cp/typeck.cc:10826
+#: cp/typeck.cc:10824
 #, fuzzy, gcc-internal-format
 msgid "parameter %qP of %qD might be a candidate for a format attribute"
 msgstr "參數 %qP 的 %qD 也許是 candidate 用於格式屬性"
 
-#: cp/typeck.cc:10830
+#: cp/typeck.cc:10828
 #, fuzzy, gcc-internal-format
 msgid "parameter might be a candidate for a format attribute"
 msgstr "參數也許是 candidate 用於格式屬性"
 
-#: cp/typeck.cc:10835
+#: cp/typeck.cc:10833
 #, fuzzy, gcc-internal-format
 msgid "target of conversion might be a candidate for a format attribute"
 msgstr "目標的轉換也許是 candidate 用於格式屬性"
 
-#: cp/typeck.cc:10840
+#: cp/typeck.cc:10838
 #, fuzzy, gcc-internal-format
 msgid "target of initialization might be a candidate for a format attribute"
 msgstr "目標的初始化也許是 candidate 用於格式屬性"
 
-#: cp/typeck.cc:10850
+#: cp/typeck.cc:10848
 #, fuzzy, gcc-internal-format
 msgid "left-hand side of assignment might be a candidate for a format attribute"
 msgstr "left-hand 側邊的指派也許是 candidate 用於格式屬性"
 
-#: cp/typeck.cc:10936
+#: cp/typeck.cc:10934
 #, fuzzy, gcc-internal-format
 #| msgid "in passing argument %P of %q+D"
 msgid "in passing argument %P of %qD"
 msgstr "在傳遞引數 %P (屬於 %q+D)"
 
-#: cp/typeck.cc:11022
+#: cp/typeck.cc:11020
 #, gcc-internal-format
 msgid "returning reference to temporary"
 msgstr "回傳臨時變數的參照"
 
-#: cp/typeck.cc:11025
+#: cp/typeck.cc:11023
 #, fuzzy, gcc-internal-format
 #| msgid "returning reference to temporary"
 msgid "returning pointer to temporary"
 msgstr "回傳臨時變數的參照"
 
-#: cp/typeck.cc:11028
+#: cp/typeck.cc:11026
 #, gcc-internal-format
 msgid "returning temporary %<initializer_list%> does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11063
+#: cp/typeck.cc:11061
 #, fuzzy, gcc-internal-format
 #| msgid "reference to local variable %q+D returned"
 msgid "reference to local variable %qD returned"
 msgstr "回傳了對局部變數的 %q+D 的參照"
 
-#: cp/typeck.cc:11067
+#: cp/typeck.cc:11065
 #, gcc-internal-format
 msgid "returning local %<initializer_list%> variable %qD does not extend the lifetime of the underlying array"
 msgstr ""
 
-#: cp/typeck.cc:11073
+#: cp/typeck.cc:11071
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of label %qD returned"
 msgstr "回傳了局部變數的 %q+D 的位址"
 
-#: cp/typeck.cc:11077
+#: cp/typeck.cc:11075
 #, fuzzy, gcc-internal-format
 #| msgid "address of local variable %q+D returned"
 msgid "address of local variable %qD returned"
 msgstr "回傳了局部變數的 %q+D 的位址"
 
-#: cp/typeck.cc:11337
+#: cp/typeck.cc:11335
 #, gcc-internal-format
 msgid "moving a temporary object prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11338 cp/typeck.cc:11354 cp/typeck.cc:11379 cp/typeck.cc:11416
+#: cp/typeck.cc:11336 cp/typeck.cc:11352 cp/typeck.cc:11377 cp/typeck.cc:11414
 #, gcc-internal-format
 msgid "remove %<std::move%> call"
 msgstr ""
 
-#: cp/typeck.cc:11352
+#: cp/typeck.cc:11350
 #, gcc-internal-format
 msgid "moving a local object in a return statement prevents copy elision"
 msgstr ""
 
-#: cp/typeck.cc:11378 cp/typeck.cc:11413
+#: cp/typeck.cc:11376 cp/typeck.cc:11411
 #, fuzzy, gcc-internal-format
 msgid "redundant move in return statement"
 msgstr "太多值在中回傳敘述"
 
-#: cp/typeck.cc:11415
+#: cp/typeck.cc:11413
 #, fuzzy, gcc-internal-format
 msgid "redundant move in initialization"
 msgstr "太多值在中回傳敘述"
 
-#: cp/typeck.cc:11453
+#: cp/typeck.cc:11451
 #, gcc-internal-format
 msgid "returning a value from a destructor"
 msgstr "解構函式回傳值"
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.cc:11465
+#: cp/typeck.cc:11463
 #, gcc-internal-format
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr "不能從建構式的異常處理中回傳"
 
 #. You can't return a value from a constructor.
-#: cp/typeck.cc:11468
+#: cp/typeck.cc:11466
 #, gcc-internal-format
 msgid "returning a value from a constructor"
 msgstr "建構式回傳值"
 
-#: cp/typeck.cc:11508 cp/typeck.cc:11554
+#: cp/typeck.cc:11506 cp/typeck.cc:11552
 #, gcc-internal-format
 msgid "return-statement with no value, in function returning %qT"
 msgstr "在回傳 %qT 的函式中，回傳敘述不帶回傳值"
 
-#: cp/typeck.cc:11516
+#: cp/typeck.cc:11514
 #, fuzzy, gcc-internal-format
 msgid "returning initializer list"
 msgstr "<brace-enclosed initializer list>"
 
-#: cp/typeck.cc:11535
+#: cp/typeck.cc:11533
 #, fuzzy, gcc-internal-format
 msgid "inconsistent types %qT and %qT deduced for lambda return type"
 msgstr "不一致類型 %qT 和 %qT deduced 用於 lambda 傳回類型"
 
-#: cp/typeck.cc:11538
+#: cp/typeck.cc:11536
 #, fuzzy, gcc-internal-format
 msgid "inconsistent deduction for auto return type: %qT and then %qT"
 msgstr "不一致推導用於 %qT：%qT 然後 %qT"
 
-#: cp/typeck.cc:11575
+#: cp/typeck.cc:11573
 #, fuzzy, gcc-internal-format
 #| msgid "return-statement with no value, in function returning %qT"
 msgid "return-statement with a value, in function returning %qT"
 msgstr "在回傳 %qT 的函式中，回傳敘述不帶回傳值"
 
-#: cp/typeck.cc:11604
+#: cp/typeck.cc:11602
 #, fuzzy, gcc-internal-format
 #| msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)"
 msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or %<-fcheck-new%> is in effect)"
 msgstr "%<operator new%> 不能回傳 NULL，除非它被宣告為 %<throw()%> (或 -fcheck-new 起作用)"
 
-#: cp/typeck.cc:11693
+#: cp/typeck.cc:11691
 #, fuzzy, gcc-internal-format
 #| msgid "invalid covariant return type for %q+#D"
 msgid "not eliding copy on return from %qD"
 msgstr "%q+#D 的協變回傳類型無效"
 
-#: cp/typeck.cc:11705
+#: cp/typeck.cc:11703
 #, gcc-internal-format
 msgid "not eliding copy on return in %qD"
 msgstr ""
 
-#: cp/typeck.cc:12297
+#: cp/typeck.cc:12295
 #, fuzzy, gcc-internal-format
 msgid "using rvalue as lvalue"
 msgstr "使用暫時的做為 lvalue"
@@ -75600,18 +75765,18 @@ msgstr ""
 msgid "unable to open log file %<vtv_count_data.log%>: %m"
 msgstr ""
 
-#: d/d-attribs.cc:375 d/d-attribs.cc:392
+#: d/d-attribs.cc:378 d/d-attribs.cc:395
 #, fuzzy, gcc-internal-format
 msgid "unknown attribute %qs"
 msgstr "不明內容屬性"
 
-#: d/d-attribs.cc:1153
+#: d/d-attribs.cc:1156
 #, fuzzy, gcc-internal-format
 #| msgid "%q+D declared inline after being called"
 msgid "%q+D declared weak after being used"
 msgstr "%q+D 的內聯宣告出現在其被呼叫之後"
 
-#: d/d-attribs.cc:1533
+#: d/d-attribs.cc:1553
 #, gcc-internal-format
 msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<simd%> attribute"
 msgstr ""
@@ -75637,46 +75802,46 @@ msgstr "成員 %qD 缺少初始值設定"
 msgid "the address of %qD will never be %<null%>"
 msgstr "位址的 %qD 將永不是空值"
 
-#: d/d-codegen.cc:2291
+#: d/d-codegen.cc:2296
 #, gcc-internal-format
 msgid "need %<this%> to access member %qE"
 msgstr ""
 
-#: d/d-codegen.cc:2446
+#: d/d-codegen.cc:2456
 #, gcc-internal-format
 msgid "tried to perform floating-point modulo division on %qT"
 msgstr ""
 
-#: d/d-codegen.cc:2497
+#: d/d-codegen.cc:2507
 #, fuzzy, gcc-internal-format
 #| msgid "cannot declare pointer to %q#T"
 msgid "cannot get frame pointer to %qs"
 msgstr "無法宣告參照 %q#T 的指標"
 
 #. Should instead error on line that references `fd'.
-#: d/d-codegen.cc:2523
+#: d/d-codegen.cc:2533
 #, fuzzy, gcc-internal-format
 #| msgid "Store function names in object code"
 msgid "nested function missing body"
 msgstr "在目的檔案中存儲函式名"
 
-#: d/d-codegen.cc:2565
+#: d/d-codegen.cc:2575
 #, fuzzy, gcc-internal-format
 msgid "%qs is a nested function and cannot be accessed from %qs"
 msgstr "間接函式 %q+D 無法宣告的 weak"
 
-#: d/d-codegen.cc:2874
+#: d/d-codegen.cc:2884
 #, gcc-internal-format
 msgid "variable %qs has scoped destruction, cannot build closure"
 msgstr ""
 
-#: d/d-codegen.cc:2882
+#: d/d-codegen.cc:2892
 #, fuzzy, gcc-internal-format
 #| msgid "register variable %qs used in nested function"
 msgid "explicit register variable %qs cannot be used in nested function"
 msgstr "巢狀函式中使用了暫存器變數 %qs"
 
-#: d/d-codegen.cc:3107
+#: d/d-codegen.cc:3117
 #, fuzzy, gcc-internal-format
 msgid "forward reference to frame of %qs"
 msgstr "表單參考到參考類型 %qT"
@@ -75763,36 +75928,36 @@ msgstr "%<#pragma align%> 指定的對齊邊界無效，忽略"
 msgid "bad argument for %<-fversion=%>: %qs"
 msgstr "%<#pragma align%> 指定的對齊邊界無效，忽略"
 
-#: d/d-lang.cc:993
+#: d/d-lang.cc:997
 #, fuzzy, gcc-internal-format
 #| msgid "can't open %s for writing: %m"
 msgid "unable to open %s for writing: %m"
 msgstr "無法為寫入開啟 %s：%m"
 
-#: d/d-lang.cc:1000
+#: d/d-lang.cc:1004
 #, fuzzy, gcc-internal-format
 #| msgid "opening output file %s: %m"
 msgid "writing output file %s: %m"
 msgstr "開啟輸出檔案 %s：%m"
 
-#: d/d-lang.cc:1020
+#: d/d-lang.cc:1024
 #, fuzzy, gcc-internal-format
 #| msgid "can%'t open %s for writing: %m"
 msgid "unable to open %s for reading: %m"
 msgstr "can%'t 開啟 %s 用於讀取：%m"
 
-#: d/d-lang.cc:1045
+#: d/d-lang.cc:1049
 #, fuzzy, gcc-internal-format
 #| msgid "opening dependency file %s: %m"
 msgid "reading ddoc file %s: %m"
 msgstr "開啟依賴檔案 %s：%m"
 
-#: d/d-lang.cc:1104
+#: d/d-lang.cc:1108
 #, gcc-internal-format
 msgid "%<-fonly=%> argument is different from first input file name"
 msgstr ""
 
-#: d/d-lang.cc:1289
+#: d/d-lang.cc:1293
 #, gcc-internal-format
 msgid "unable to resolve forward reference in definition"
 msgstr ""
@@ -75894,7 +76059,7 @@ msgstr "不明 TLS 式樣 %qs"
 msgid "%qs is not an associative array"
 msgstr "%qD 並非變數"
 
-#: d/expr.cc:1568 d/expr.cc:1951
+#: d/expr.cc:1568 d/expr.cc:1949
 #, gcc-internal-format
 msgid "need %<this%> to access member %qs"
 msgstr ""
@@ -75909,23 +76074,23 @@ msgstr "%qD 是正常非靜態函式"
 msgid "%qs is not a field, but a %qs"
 msgstr "%qs 無效用於 %qs"
 
-#: d/expr.cc:1977
+#: d/expr.cc:1975
 #, fuzzy, gcc-internal-format
 msgid "recursive reference %qs"
 msgstr "遞迴必要項從 %q#D\n"
 
-#: d/expr.cc:1997 d/expr.cc:2837
+#: d/expr.cc:1995 d/expr.cc:2872
 #, fuzzy, gcc-internal-format
 #| msgid "overflow in constant expression"
 msgid "non-constant expression %qs"
 msgstr "常數運算式溢出"
 
-#: d/expr.cc:2804
+#: d/expr.cc:2839
 #, fuzzy, gcc-internal-format
 msgid "%qs is not an expression"
 msgstr "%qE 並非常數運算式"
 
-#: d/expr.cc:2811
+#: d/expr.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "type %qs is not an expression"
 msgstr "%qE 並非常數運算式"
@@ -76022,17 +76187,17 @@ msgstr ""
 msgid "D inline assembler statements are not supported in GDC."
 msgstr ""
 
-#: d/typeinfo.cc:1454
+#: d/typeinfo.cc:1451
 #, gcc-internal-format
 msgid "expression %qs requires %<object.TypeInfo%> and cannot be used with %<-fno-rtti%>"
 msgstr ""
 
-#: d/typeinfo.cc:1458
+#: d/typeinfo.cc:1455
 #, fuzzy, gcc-internal-format
 msgid "%<object.TypeInfo%> cannot be used with %<-fno-rtti%>"
 msgstr "%<dynamic_cast%> 無法允許的與 -fno-rtti"
 
-#: d/typeinfo.cc:1482
+#: d/typeinfo.cc:1479
 #, gcc-internal-format
 msgid "%<object.TypeInfo%> could not be found, but is implicitly used"
 msgstr ""
@@ -76364,8 +76529,8 @@ msgstr "%C 處的任何參照都不能多於 %d 維"
 
 #: fortran/array.cc:335 fortran/array.cc:823 fortran/match.cc:1917
 #: fortran/match.cc:3927 fortran/match.cc:4414 fortran/match.cc:4610
-#: fortran/simplify.cc:3386 fortran/simplify.cc:3416 fortran/simplify.cc:7040
-#: fortran/simplify.cc:9341
+#: fortran/simplify.cc:3390 fortran/simplify.cc:3420 fortran/simplify.cc:7044
+#: fortran/simplify.cc:9345
 #, fuzzy, gcc-internal-format
 msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
 msgstr "Coarrays 已停用於 %C, 使用 -fcoarray=以啟用"
@@ -76650,7 +76815,7 @@ msgstr "non-parameter %qs 無法參數包裝"
 msgid "Arguments of %qs at %L and %L cannot both be BOZ literal constants"
 msgstr "『我』於 %L 和『J』於 %L 無法兩者是 BOZ 實字常數"
 
-#: fortran/check.cc:123 fortran/resolve.cc:13082
+#: fortran/check.cc:123 fortran/resolve.cc:13160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid use of BOZ literal constant at %L"
 msgstr "無效的 exponent-letter『q』在中 real-literal-constant 於 %C"
@@ -76735,7 +76900,7 @@ msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須為實數型
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須為 INTEGER 或 PROCEDURE"
 
-#: fortran/check.cc:742 fortran/check.cc:8465
+#: fortran/check.cc:742 fortran/check.cc:8466
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
 msgid "%qs argument of %qs intrinsic at %L must be a constant"
@@ -76890,7 +77055,7 @@ msgstr "%C 處 ENTRY 敘述不能出現在被包含的程序中"
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
 msgstr "「%s」和「%s」引數(屬於「%s」內建函式)在 %L 處類型必須相同"
 
-#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4159
+#: fortran/check.cc:1564 fortran/check.cc:1597 fortran/check.cc:4160
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different type kinds at %L"
 msgstr "擴充：%L 處類型種別不同"
@@ -76907,7 +77072,7 @@ msgstr "%L 的 NULL 指標不能做為內建函式「%s」的引數"
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個 POINTER"
 
-#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4954
+#: fortran/check.cc:1651 fortran/check.cc:1686 fortran/check.cc:4955
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
@@ -77053,8 +77218,8 @@ msgid "The errmsg= argument at %L must be a default-kind character variable"
 msgstr "STAT=引數於 %L 必須是純量整數變數"
 
 #: fortran/check.cc:2474 fortran/check.cc:2774 fortran/check.cc:3886
-#: fortran/check.cc:6763 fortran/check.cc:6814 fortran/check.cc:6844
-#: fortran/check.cc:6862 fortran/check.cc:7162
+#: fortran/check.cc:6764 fortran/check.cc:6815 fortran/check.cc:6845
+#: fortran/check.cc:6863 fortran/check.cc:7163
 #, fuzzy, gcc-internal-format
 msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
 msgstr "Coarrays 已停用於 %C, 使用 -fcoarray=以啟用"
@@ -77155,9 +77320,9 @@ msgid "BOZ constant at %L cannot appear in the COMPLEX intrinsic subprogram"
 msgstr "%C 處的 ENTRY 敘述不能出現在巢狀的子程式中"
 
 #: fortran/check.cc:2800 fortran/check.cc:3527 fortran/check.cc:3610
-#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5599
-#: fortran/check.cc:5744 fortran/check.cc:5822 fortran/check.cc:7148
-#: fortran/check.cc:7280
+#: fortran/check.cc:3872 fortran/check.cc:3921 fortran/check.cc:5600
+#: fortran/check.cc:5745 fortran/check.cc:5823 fortran/check.cc:7149
+#: fortran/check.cc:7281
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with KIND argument at %L"
 msgstr "Fortran 2003:『%s』intrinsic 與 KIND 引數於 %L"
@@ -77172,13 +77337,13 @@ msgstr "『%s』引數的『%s』intrinsic 於 %L 有無效的形狀在中尺寸
 msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
 msgstr "『%s』引數的 intrinsic『%s』於 %L 的必須有分級 %d 或是純量"
 
-#: fortran/check.cc:2984 fortran/check.cc:4271 fortran/check.cc:4279
+#: fortran/check.cc:2984 fortran/check.cc:4272 fortran/check.cc:4280
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須為數字或 LOGICAL 型"
 
-#: fortran/check.cc:2992 fortran/check.cc:4289
+#: fortran/check.cc:2992 fortran/check.cc:4290
 #, fuzzy, gcc-internal-format
 msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
 msgstr "引數類型的『%s』intrinsic 於 %L 必須匹配 (%s/%s)"
@@ -77277,636 +77442,636 @@ msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個常
 msgid "Intrinsic %qs at %L must have at least two arguments"
 msgstr "內建函式「%s」 於 %L 處必須有至少兩個引數"
 
-#: fortran/check.cc:4111
+#: fortran/check.cc:4112
 #, fuzzy, gcc-internal-format
 msgid "Missing %qs argument to the %s intrinsic at %L"
 msgstr "缺少引數到『%s』於 %C"
 
-#: fortran/check.cc:4126
+#: fortran/check.cc:4127
 #, fuzzy, gcc-internal-format
 msgid "Duplicate argument %qs at %L to intrinsic %s"
 msgstr "引數『%s』和『%s』用於 intrinsic %s"
 
-#: fortran/check.cc:4131
+#: fortran/check.cc:4132
 #, fuzzy, gcc-internal-format
 msgid "Unknown argument %qs at %L to intrinsic %s"
 msgstr "引數『%s』和『%s』用於 intrinsic %s"
 
-#: fortran/check.cc:4156
+#: fortran/check.cc:4157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different character kinds at %L"
 msgstr "擴充：%L 處類型種別不同"
 
-#: fortran/check.cc:4165
+#: fortran/check.cc:4166
 #, fuzzy, gcc-internal-format
 msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
 msgstr "『a%d』引數的『%s』intrinsic 於 %L 必須是 %s(%d)"
 
-#: fortran/check.cc:4196
+#: fortran/check.cc:4197
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with CHARACTER argument at %L"
 msgstr "Fortran 2003:『%s』intrinsic 與字元引數於 %L"
 
-#: fortran/check.cc:4208
+#: fortran/check.cc:4209
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL, CHARACTER or UNSIGNED"
 msgstr "『a1』引數的『%s』intrinsic 於 %L 必須是整數，真實或字元"
 
-#: fortran/check.cc:4218
+#: fortran/check.cc:4219
 #, fuzzy, gcc-internal-format
 msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
 msgstr "『a1』引數的『%s』intrinsic 於 %L 必須是整數，真實或字元"
 
-#: fortran/check.cc:4303
+#: fortran/check.cc:4304
 #, fuzzy, gcc-internal-format
 msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
 msgstr "不同的形狀於尺寸 1 用於引數『%s』和『%s』於 %L 用於 intrinsic matmul"
 
-#: fortran/check.cc:4322
+#: fortran/check.cc:4323
 #, fuzzy, gcc-internal-format
 msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
 msgstr "不同的形狀於尺寸 2 用於引數『%s』和尺寸 1 用於引數『%s』於 %L 用於 intrinsic matmul"
 
-#: fortran/check.cc:4331
+#: fortran/check.cc:4332
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2"
 msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)的秩必須為 1 或 2"
 
-#: fortran/check.cc:4509
+#: fortran/check.cc:4510
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be conformable with '%s' argument"
 msgid "Argument %qs of %qs intrinsic at %L must be in type conformance to argument %qs at %L"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須與「%s」引數相容"
 
-#: fortran/check.cc:4643
+#: fortran/check.cc:4644
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER or UNSIGNED"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須為整數型或實數型"
 
-#: fortran/check.cc:4651 fortran/check.cc:8385 fortran/check.cc:8400
+#: fortran/check.cc:4652 fortran/check.cc:8386 fortran/check.cc:8401
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須是整數"
 
-#: fortran/check.cc:4766
+#: fortran/check.cc:4767
 #, gcc-internal-format, gfc-internal-format
 msgid "STAT= or ERRMSG= at %L not supported"
 msgstr ""
 
-#: fortran/check.cc:4778
+#: fortran/check.cc:4779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:4789
+#: fortran/check.cc:4790
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:4796
+#: fortran/check.cc:4797
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
 msgstr "到引數在中 MOVE_ALLOC 於 %L 必須是 polymorphic 如果從是 polymorphic"
 
-#: fortran/check.cc:4807
+#: fortran/check.cc:4808
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
 msgstr "『%s』和『%s』引數的『%s』intrinsic 於 %L 必須有同級 %d/%d"
 
-#: fortran/check.cc:4816
+#: fortran/check.cc:4817
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
 msgstr "『%s』和『%s』引數的『%s』intrinsic 於 %L 必須有同級 %d/%d"
 
-#: fortran/check.cc:4856
+#: fortran/check.cc:4857
 #, gcc-internal-format, gfc-internal-format
 msgid "The FROM and TO arguments at %L violate aliasing restrictions (F2003 12.4.1.7)"
 msgstr ""
 
-#: fortran/check.cc:4883
+#: fortran/check.cc:4884
 #, fuzzy, gcc-internal-format
 msgid "Argument %<S%> of NEAREST at %L shall not be zero"
 msgstr "引數『S』的最近的於 %L 不應該是零"
 
-#: fortran/check.cc:4939
+#: fortran/check.cc:4940
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須是指標，ALLOCATABLE 或程序指標"
 
-#: fortran/check.cc:4947
+#: fortran/check.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL intrinsic with allocatable MOLD at %L"
 msgstr "Fortran 2003:空值 intrinsic 與 allocatable 鑄型於 %L"
 
-#: fortran/check.cc:4990
+#: fortran/check.cc:4991
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall appear only if %qs is of type REAL and %qs is of type INTEGER or UNSIGNED"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須有型態的還是真實或整數"
 
-#: fortran/check.cc:5068 fortran/check.cc:7227
+#: fortran/check.cc:5069 fortran/check.cc:7228
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須提供至少做為許多元件做為有些.TRUE。值在中『%s』(%ld/%d)"
 
-#: fortran/check.cc:5129
+#: fortran/check.cc:5130
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個啞元變數"
 
-#: fortran/check.cc:5139
+#: fortran/check.cc:5140
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable"
 msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
 msgstr "「%s」引數(屬於「%s」內建函式，位於 %L)必須是一個 OPTIONAL 啞變數"
 
-#: fortran/check.cc:5158
+#: fortran/check.cc:5159
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須不是子物件的『%s』"
 
-#: fortran/check.cc:5209
+#: fortran/check.cc:5210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The argument of the RANK intrinsic at %L must be a data object"
 msgstr "引數的分級 intrinsic 於 %L 必須是資料物件"
 
-#: fortran/check.cc:5241
+#: fortran/check.cc:5242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The ARRAY argument at %L of REDUCE shall not be polymorphic"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:5251
+#: fortran/check.cc:5252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The DIM argument at %L, if present, must be an integer scalar"
 msgstr "STAT=引數於 %L 必須是純量整數變數"
 
-#: fortran/check.cc:5258
+#: fortran/check.cc:5259
 #, gcc-internal-format, gfc-internal-format
 msgid "The MASK argument at %L, if present, must be a logical array with the same rank as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5270
+#: fortran/check.cc:5271
 #, gcc-internal-format, gfc-internal-format
 msgid "MASK present at %L without IDENTITY"
 msgstr ""
 
-#: fortran/check.cc:5274
+#: fortran/check.cc:5275
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "The ORDERED argument at %L, if present, must be a logical scalar"
 msgstr "%L 引數維數必須是標量"
 
-#: fortran/check.cc:5282
+#: fortran/check.cc:5283
 #, gcc-internal-format, gfc-internal-format
 msgid "The IDENTITY argument at %L, if present, must be a scalar with the same type as ARRAY"
 msgstr ""
 
-#: fortran/check.cc:5373
+#: fortran/check.cc:5374
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
 msgstr "「reshape」內建函式的「shape」引數在 %L 處必須是大小為常數的陣列"
 
-#: fortran/check.cc:5383
+#: fortran/check.cc:5384
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is empty"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 是空的"
 
-#: fortran/check.cc:5390
+#: fortran/check.cc:5391
 #, fuzzy, gcc-internal-format
 #| msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements"
 msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
 msgstr "「reshape」內建函式的「shape」引數在 %L 處有多於 %d 個的元素"
 
-#: fortran/check.cc:5413
+#: fortran/check.cc:5414
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 有負元件 (%d)"
 
-#: fortran/check.cc:5453
+#: fortran/check.cc:5454
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 有錯誤的元件號碼的 (%d/%d)"
 
-#: fortran/check.cc:5471
+#: fortran/check.cc:5472
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 有 out-of-range 尺寸 (%d)"
 
-#: fortran/check.cc:5480
+#: fortran/check.cc:5481
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 有無效的排列的維度 (尺寸『%d』重製)"
 
-#: fortran/check.cc:5515 fortran/simplify.cc:7891
+#: fortran/check.cc:5516 fortran/simplify.cc:7895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
 msgstr "而無需填補，有些不足元件在中 intrinsic 重設形狀來源於 %L 到匹配形狀"
 
-#: fortran/check.cc:5532 fortran/check.cc:5551
+#: fortran/check.cc:5533 fortran/check.cc:5552
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須是 %s"
 
-#: fortran/check.cc:5542 fortran/check.cc:5561
+#: fortran/check.cc:5543 fortran/check.cc:5562
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須是的 extensible 型態"
 
-#: fortran/check.cc:5680
+#: fortran/check.cc:5681
 #, fuzzy, gcc-internal-format
 msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
 msgstr "Fortran 2008:SELECTED_REAL_KIND 與 neither『P』nor『R』引數於 %L"
 
-#: fortran/check.cc:5711
+#: fortran/check.cc:5712
 #, fuzzy, gcc-internal-format
 msgid "%qs intrinsic with RADIX argument at %L"
 msgstr "Fortran 2008:『%s』intrinsic 與基數引數於 %L"
 
-#: fortran/check.cc:5759
+#: fortran/check.cc:5760
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
 msgstr "「shape」內建函式的「source」引數在 %L 處不能是假定大小的陣列"
 
-#: fortran/check.cc:5840 fortran/check.cc:8445
+#: fortran/check.cc:5841 fortran/check.cc:8446
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 可能無法是程序"
 
-#: fortran/check.cc:5856 fortran/check.cc:6002 fortran/check.cc:8437
+#: fortran/check.cc:5857 fortran/check.cc:6003 fortran/check.cc:8438
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:5867 fortran/check.cc:6014
+#: fortran/check.cc:5868 fortran/check.cc:6015
 #, fuzzy, gcc-internal-format
 #| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
 msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
 msgstr "「shape」內建函式的「source」引數在 %L 處不能是假定大小的陣列"
 
-#: fortran/check.cc:5949
+#: fortran/check.cc:5950
 #, gcc-internal-format
 msgid "is_c_interoperable(): gfc_simplify_expr failed"
 msgstr ""
 
-#: fortran/check.cc:5993
+#: fortran/check.cc:5994
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須是可交流的資料個體"
 
-#: fortran/check.cc:6054
+#: fortran/check.cc:6055
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_1 at %L to C_ASSOCIATED shall have the type TYPE(C_PTR) or TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6108
+#: fortran/check.cc:6109
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument C_PTR_2 at %L to C_ASSOCIATED shall have the same type as C_PTR_1, found %s instead of %s"
 msgstr ""
 
-#: fortran/check.cc:6142
+#: fortran/check.cc:6143
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_POINTER shall have the type TYPE(C_PTR)"
 msgstr ""
 
-#: fortran/check.cc:6154
+#: fortran/check.cc:6155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6161
+#: fortran/check.cc:6162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6168
+#: fortran/check.cc:6169
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6175
+#: fortran/check.cc:6176
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected SHAPE argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6181
+#: fortran/check.cc:6182
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected SHAPE argument to C_F_POINTER with array FPTR at %L"
 msgstr ""
 
-#: fortran/check.cc:6200
+#: fortran/check.cc:6201
 #, gcc-internal-format, gfc-internal-format
 msgid "SHAPE argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr ""
 
-#: fortran/check.cc:6209
+#: fortran/check.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6215
+#: fortran/check.cc:6216
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected LOWER argument at %L to C_F_POINTER with scalar FPTR"
 msgstr ""
 
-#: fortran/check.cc:6236
+#: fortran/check.cc:6237
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOWER argument at %L to C_F_POINTER must have the same size as the RANK of FPTR"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6247
+#: fortran/check.cc:6248
 #, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic FPTR at %L to C_F_POINTER"
 msgstr ""
 
-#: fortran/check.cc:6253
+#: fortran/check.cc:6254
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FPTR argument to C_F_POINTER at %L is a function returning a pointer"
 msgstr "回傳與值在中函式不具任何傳回類型"
 
-#: fortran/check.cc:6260
+#: fortran/check.cc:6261
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array FPTR argument to C_F_POINTER at %L: %s"
 msgstr "缺少引數「%s」，在呼叫「%s」時，位於 %L"
 
-#: fortran/check.cc:6276
+#: fortran/check.cc:6277
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)"
 msgstr ""
 
-#: fortran/check.cc:6288
+#: fortran/check.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6295
+#: fortran/check.cc:6296
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6301
+#: fortran/check.cc:6302
 #, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure pointer at %L to C_F_PROCPOINTER"
 msgstr ""
 
-#: fortran/check.cc:6315
+#: fortran/check.cc:6316
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:6327
+#: fortran/check.cc:6328
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
 msgstr "敘述函式『%s』無效在中程序指標指派於 %L"
 
-#: fortran/check.cc:6334
+#: fortran/check.cc:6335
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_FUNLOC shall be a procedure or a procedure pointer"
 msgstr ""
 
-#: fortran/check.cc:6340
+#: fortran/check.cc:6341
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable procedure at %L to C_FUNLOC"
 msgstr "缺少引數「%s」，在呼叫「%s」時，位於 %L"
 
-#: fortran/check.cc:6354
+#: fortran/check.cc:6355
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall not be coindexed"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:6360
+#: fortran/check.cc:6361
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "X argument at %L to C_LOC shall not be polymorphic"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6371
+#: fortran/check.cc:6372
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Component at %C must have the POINTER attribute"
 msgid "Argument X at %L to C_LOC shall have either the POINTER or the TARGET attribute"
 msgstr "%C 處的元件必須有 POINTER 屬性"
 
-#: fortran/check.cc:6379
+#: fortran/check.cc:6380
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
 msgstr "引數『S』的最近的於 %L 不應該是零"
 
-#: fortran/check.cc:6388
+#: fortran/check.cc:6389
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument at %L to C_LOC shall not be polymorphic"
 msgstr "實際引數到『%s』於 %L 必須是 polymorphic"
 
-#: fortran/check.cc:6395
+#: fortran/check.cc:6396
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Noninteroperable array at %L as argument to C_LOC: %s"
 msgstr "缺少引數「%s」，在呼叫「%s」時，位於 %L"
 
-#: fortran/check.cc:6406
+#: fortran/check.cc:6407
 #, gcc-internal-format, gfc-internal-format
 msgid "Array of interoperable type at %L to C_LOC which is nonallocatable and neither assumed size nor explicit size"
 msgstr ""
 
-#: fortran/check.cc:6411
+#: fortran/check.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array section at %L to C_LOC"
 msgstr "陣列區段在中『%s』呼叫於 %L"
 
-#: fortran/check.cc:6439
+#: fortran/check.cc:6440
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non double precision REAL argument to %s intrinsic at %L"
 msgstr "GNU 延伸：非雙倍精度真實引數到 %s intrinsic 於 %L"
 
-#: fortran/check.cc:6455
+#: fortran/check.cc:6456
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
 msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)秩必須小於 %d"
 
-#: fortran/check.cc:6474
+#: fortran/check.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 並非有效尺寸索引"
 
-#: fortran/check.cc:6498
+#: fortran/check.cc:6499
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have length at least 1"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須是預設真實"
 
-#: fortran/check.cc:6773
+#: fortran/check.cc:6774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
 msgstr "%s 引數到 IMAGE_INDEX 必須是分級一個陣列於 %L"
 
-#: fortran/check.cc:6785
+#: fortran/check.cc:6786
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
 msgstr "陣列元素數量的子引數到 IMAGE_INDEX 於 %L 應該是 %d (corank) 無法 %d"
 
-#: fortran/check.cc:6823
+#: fortran/check.cc:6824
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> or %<team_number%> argument to %qs at %L"
 msgstr "給予函式 %s 的參數太多，於 %L"
 
-#: fortran/check.cc:6883
+#: fortran/check.cc:6884
 #, gcc-internal-format
 msgid "First argument of %<this_image%> intrinsic at %L must be a coarray variable or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6912
+#: fortran/check.cc:6913
 #, gcc-internal-format
 msgid "Second argument of %<this_image%> intrinsic at %L must be an %<INTEGER%> typed scalar or an object of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%>"
 msgstr ""
 
-#: fortran/check.cc:6938
+#: fortran/check.cc:6939
 #, fuzzy, gcc-internal-format
 msgid "%<dim%> argument without %<coarray%> argument not allowed for %<this_image%> intrinsic at %L"
 msgstr "DIM 引數而無需陣列引數不允許用於 THIS_IMAGE intrinsic 於 %L"
 
-#: fortran/check.cc:6949
+#: fortran/check.cc:6950
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments to %s at %L"
 msgid "%<team%> argument to %<this_image%> at %L"
 msgstr "給予函式 %s 的參數太多，於 %L"
 
-#: fortran/check.cc:6960
+#: fortran/check.cc:6961
 #, gcc-internal-format
 msgid "At most one argument of type %<team_type%> from the intrinsic module %<ISO_FORTRAN_ENV%> to %<this_image%> at %L allowed"
 msgstr ""
 
-#: fortran/check.cc:7002
+#: fortran/check.cc:7003
 #, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L is an array and shall not have storage size 0 when %<SOURCE%> argument has size greater than 0"
 msgstr ""
 
-#: fortran/check.cc:7054
+#: fortran/check.cc:7055
 #, fuzzy, gcc-internal-format
 msgid "%<SOURCE%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "『鑄型』引數的『轉送』intrinsic 於 %L 必須不是 %s"
 
-#: fortran/check.cc:7073
+#: fortran/check.cc:7074
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be a %s"
 msgstr "『鑄型』引數的『轉送』intrinsic 於 %L 必須不是 %s"
 
-#: fortran/check.cc:7081
+#: fortran/check.cc:7082
 #, fuzzy, gcc-internal-format
 msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
 msgstr "『鑄型』引數的『轉送』intrinsic 於 %L 必須不是 %s"
 
-#: fortran/check.cc:7116
+#: fortran/check.cc:7117
 #, fuzzy
 msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %zd < result size %zd"
 msgstr "Intrinsic 轉送於 %L 有部分未定義的結果：來源大小 %ld<結果大小 %ld"
 
-#: fortran/check.cc:7241
+#: fortran/check.cc:7242
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須有同級做為『%s』或是純量"
 
-#: fortran/check.cc:7254
+#: fortran/check.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
 msgstr "『%s』和『%s』引數的『%s』intrinsic 於 %L 必須有相等的形狀。"
 
-#: fortran/check.cc:7390
+#: fortran/check.cc:7391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUES argument of DATE_AND_TIME at %L has non-default kind"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7402
+#: fortran/check.cc:7403
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument of ATANH at %L must be inside the range -1 to 1"
 msgid "VALUES argument of DATE_AND_TIME at %L must have a decimal exponent range of at least four"
 msgstr "%L 處 ATANH 的參數必須在 -1 和 1 之間"
 
-#: fortran/check.cc:7557 fortran/check.cc:7593
+#: fortran/check.cc:7558 fortran/check.cc:7594
 #, fuzzy, gcc-internal-format
 msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
 msgstr "大小的『%s』引數的『%s』intrinsic 於 %L 太小 (%i/%i)"
 
-#: fortran/check.cc:7604
+#: fortran/check.cc:7605
 #, gcc-internal-format, gfc-internal-format
 msgid "Too many arguments to %s at %L"
 msgstr "給予函式 %s 的參數太多，於 %L"
 
-#: fortran/check.cc:7622
+#: fortran/check.cc:7623
 #, gcc-internal-format
 msgid "fe_runtime_error string must be null terminated"
 msgstr ""
 
-#: fortran/check.cc:7634
+#: fortran/check.cc:7635
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "wrong number of template arguments (%d, should be %d)"
 msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
 msgstr "範本參數數目不正確(不應是 %d 個而應是 %d 個)"
 
-#: fortran/check.cc:7676
+#: fortran/check.cc:7677
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7683
+#: fortran/check.cc:7684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7704
+#: fortran/check.cc:7705
 #, gcc-internal-format, gfc-internal-format
 msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
 msgstr ""
 
-#: fortran/check.cc:7714
+#: fortran/check.cc:7715
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7721
+#: fortran/check.cc:7722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7741
+#: fortran/check.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7751
+#: fortran/check.cc:7752
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L with kind smaller than default integer"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7766 fortran/check.cc:7773
+#: fortran/check.cc:7767 fortran/check.cc:7774
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "integer arguments to SYSTEM_CLOCK at %L with different kind parameters"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 不應該被 coindexed"
 
-#: fortran/check.cc:7987
+#: fortran/check.cc:7988
 #, fuzzy, gcc-internal-format
 msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
 msgstr "『%s』引數的『%s』intrinsic 於 %L 必須是的 kind 無法 wider 比預設 kind (%d)"
 
-#: fortran/check.cc:8169
+#: fortran/check.cc:8170
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L of %qs intrinsic shall be an associated pointer"
 msgstr "原子引數於 %L 的 %s 內建函式應該是 coarray 或 coindexed"
 
-#: fortran/check.cc:8358 fortran/check.cc:8369
+#: fortran/check.cc:8359 fortran/check.cc:8370
 #, fuzzy, gcc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL"
 msgid "%qs argument of %qs intrinsic at %L must be INTEGER, LOGICAL, or a BOZ literal constant"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)必須為 INTEGER 或 LOGICAL"
 
-#: fortran/check.cc:8429
+#: fortran/check.cc:8430
 #, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic function NULL at %L cannot be an actual argument to STORAGE_SIZE, because it returns a disassociated pointer"
 msgstr ""
 
 #. Since the extension field is 8 bit wide, we can only have
 #. up to 255 extension levels.
-#: fortran/class.cc:811 fortran/decl.cc:4348 fortran/decl.cc:11485
+#: fortran/class.cc:811 fortran/decl.cc:4382 fortran/decl.cc:11536
 #, fuzzy, gcc-internal-format
 msgid "Maximum extension level reached with type %qs at %L"
 msgstr "最大值延伸等級達到的與型態『%s』於 %L"
@@ -77972,12 +78137,12 @@ msgstr ""
 msgid "Initialization string at %L was truncated to fit the variable (%wd/%wd)"
 msgstr "初始化字串開始於 %L 被截短至符合變數 (%d/%d)"
 
-#: fortran/data.cc:220 fortran/resolve.cc:5843
+#: fortran/data.cc:220 fortran/resolve.cc:5927
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L is less than one"
 msgstr "%L 處的子字串起始索引小於 1"
 
-#: fortran/data.cc:226 fortran/resolve.cc:5873
+#: fortran/data.cc:226 fortran/resolve.cc:5957
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L exceeds the string length"
 msgstr "子字串結束索引於 %L 超出字串長度"
@@ -78028,2115 +78193,2115 @@ msgstr "變數『%s』於 %C 與初始設定式已經出現在中資料敘述"
 msgid "Simplification error"
 msgstr "gimplification 失敗"
 
-#: fortran/decl.cc:308
+#: fortran/decl.cc:329
 #, gcc-internal-format, gfc-internal-format
 msgid "Inquiry parameter cannot appear in a data-stmt-object-list at %C"
 msgstr ""
 
-#: fortran/decl.cc:322
+#: fortran/decl.cc:343
 #, fuzzy, gcc-internal-format
 msgid "Host associated variable %qs may not be in the DATA statement at %C"
 msgstr "主機關聯的變數『%s』可能無法是在中資料敘述於 %C"
 
-#: fortran/decl.cc:329
+#: fortran/decl.cc:350
 #, fuzzy, gcc-internal-format
 msgid "initialization of common block variable %qs in DATA statement at %C"
 msgstr "擴充：DATA 敘述中對公共塊變數「%s」在 %C 處初始化"
 
-#: fortran/decl.cc:467
+#: fortran/decl.cc:488
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C"
 msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
 msgstr "DATA 敘述中符號「%s」必須是一個 PARAMETER，在 %C 處"
 
-#: fortran/decl.cc:493
+#: fortran/decl.cc:514
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid initializer %s in Data statement at %C"
 msgstr "無效的初始設定式 %s 在中資料敘述於 %C"
 
-#: fortran/decl.cc:598
+#: fortran/decl.cc:619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ at %L cannot appear in an old-style initialization"
 msgstr "%C 處 ENTRY 敘述不能出現在被包含的程序中"
 
-#: fortran/decl.cc:606
+#: fortran/decl.cc:627
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization"
 msgstr ""
 
-#: fortran/decl.cc:616
+#: fortran/decl.cc:637
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C is not allowed in a PURE procedure"
 msgstr "初始化不允許出現在 %C 處的 PURE 程序中"
 
-#: fortran/decl.cc:663
+#: fortran/decl.cc:684
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgid "DATA statement at %C cannot appear within an INTERFACE"
 msgstr "%C 處的 ENTRY 敘述不能出現在 INTERFACE 中"
 
-#: fortran/decl.cc:687
+#: fortran/decl.cc:708
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid substring in data-implied-do at %L in DATA statement"
 msgstr "無效的初始設定式 %s 在中資料敘述於 %C"
 
-#: fortran/decl.cc:710
+#: fortran/decl.cc:731
 #, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component or deferred-shaped array near %C in DATA statement"
 msgstr ""
 
-#: fortran/decl.cc:752
+#: fortran/decl.cc:773
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ literal constant at %L cannot appear in a structure constructor"
 msgstr "%C 處 ENTRY 敘述不能出現在被包含的程序中"
 
-#: fortran/decl.cc:768
+#: fortran/decl.cc:789
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgstr "DATA 敘述不允許出現在 %C 處的 PURE 程序中"
 
-#: fortran/decl.cc:777
+#: fortran/decl.cc:798
 #, gcc-internal-format, gfc-internal-format
 msgid "part-ref with pointer attribute near %L is not rightmost part-ref of data-stmt-object"
 msgstr ""
 
-#: fortran/decl.cc:816
+#: fortran/decl.cc:837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty old style initializer list at %C"
 msgstr "擴充：%C 處舊式的初始化"
 
-#: fortran/decl.cc:825
+#: fortran/decl.cc:846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array in initializer list at %L must have an explicit shape"
 msgstr "陣列成分的結構於 %C 必須有明確的形狀"
 
-#: fortran/decl.cc:848
+#: fortran/decl.cc:869
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "extra elements in scalar initializer"
 msgid "Repeat spec invalid in scalar initializer at %C"
 msgstr "標量初始化設定中有多餘元素"
 
-#: fortran/decl.cc:853
+#: fortran/decl.cc:874
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Repeat spec must be an integer at %C"
 msgstr "Cray 指標於 %C 必須是整數"
 
-#: fortran/decl.cc:864
+#: fortran/decl.cc:885
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Expected data constant after repeat spec at %C"
 msgstr "%C 處需要替代的回傳標籤"
 
-#: fortran/decl.cc:896
+#: fortran/decl.cc:917
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "End of scalar initializer expected at %C"
 msgstr "%C 處需要標量初始化運算式"
 
-#: fortran/decl.cc:924
+#: fortran/decl.cc:945
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Not enough elements in array initializer at %C"
 msgstr "陣列初始值設定項中有多餘的元素"
 
-#: fortran/decl.cc:926
+#: fortran/decl.cc:947
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "excess elements in array initializer"
 msgid "Too many elements in array initializer at %C"
 msgstr "陣列初始值設定項中有多餘的元素"
 
-#: fortran/decl.cc:953
+#: fortran/decl.cc:974
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initializer list at %C"
 msgstr "語法時發生錯誤 OpenMP 變數清單於 %C"
 
-#: fortran/decl.cc:977
+#: fortran/decl.cc:998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed-rank array at %C shall not have a codimension"
 msgstr "資料目標於 %L 不應該有 coindex"
 
-#: fortran/decl.cc:1042
+#: fortran/decl.cc:1063
 #, gcc-internal-format, gfc-internal-format
 msgid "Sum of array rank %d and corank %d at %C exceeds maximum allowed dimensions of %d"
 msgstr ""
 
-#: fortran/decl.cc:1066
+#: fortran/decl.cc:1087
 #, gcc-internal-format, gfc-internal-format
 msgid "Bad INTENT specification at %C"
 msgstr "%C 處錯誤地指定 INTENT"
 
-#: fortran/decl.cc:1088
+#: fortran/decl.cc:1109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "deferred type parameter at %C"
 msgstr "Fortran 2003:已推遲型態參數於 %C"
 
-#: fortran/decl.cc:1181 fortran/resolve.cc:14904
+#: fortran/decl.cc:1202 fortran/resolve.cc:15024
 #, gcc-internal-format, gfc-internal-format
 msgid "Scalar INTEGER expression expected at %L"
 msgstr ""
 
-#: fortran/decl.cc:1207 fortran/decl.cc:1236
+#: fortran/decl.cc:1228 fortran/decl.cc:1257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style character length at %C"
 msgstr "Obsolescent 特徵：舊式字元長度於 %C"
 
-#: fortran/decl.cc:1242
+#: fortran/decl.cc:1263
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in character length specification at %C"
 msgstr "%C 處指定字元長度時語法錯誤"
 
-#: fortran/decl.cc:1394 fortran/decl.cc:1401 fortran/decl.cc:1467
+#: fortran/decl.cc:1415 fortran/decl.cc:1422 fortran/decl.cc:1488
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Procedure %qs at %C is already defined at %L"
 msgstr "程序「%s」在 %C 處已經於 %L 處被宣告"
 
-#: fortran/decl.cc:1409
+#: fortran/decl.cc:1430
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C is already defined at %L"
 msgid "Contained procedure %qs at %C clashes with procedure defined at %L"
 msgstr "程序「%s」在 %C 處已經於 %L 處被宣告"
 
-#: fortran/decl.cc:1421
+#: fortran/decl.cc:1442
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is already defined as a generic interface at %L"
 msgstr "名稱『%s』於 %C 已經定義為通用介面於 %L"
 
-#: fortran/decl.cc:1439
+#: fortran/decl.cc:1460
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
 msgid "Procedure %qs at %C has an explicit interface from a previous declaration"
 msgstr "程序「%s」在 %C 處具有顯式介面，而且必須在 %L 處不具有已宣告的屬性"
 
-#: fortran/decl.cc:1455
+#: fortran/decl.cc:1476
 #, gcc-internal-format
 msgid "Procedure %qs defined in interface body at %L clashes with internal procedure defined at %C"
 msgstr ""
 
-#: fortran/decl.cc:1538
+#: fortran/decl.cc:1559
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
 msgstr "程序『%s』於 %L 必須有繫結©屬性為 C 可交流的"
 
-#: fortran/decl.cc:1603
+#: fortran/decl.cc:1624
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
 msgstr "變數『%s』於 %L 是虛引數到繫結©程序『%s』但是不是 C 可交流的因為衍生類型『%s』不是 C 可交流的"
 
-#: fortran/decl.cc:1610
+#: fortran/decl.cc:1631
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
 msgstr "變數『%s』於 %L 是虛引數到繫結©程序『%s』但是不是 C 可交流的因為它是 polymorphic"
 
-#: fortran/decl.cc:1617
+#: fortran/decl.cc:1638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
 msgstr "變數『%s』於 %L 是參數到繫結©程序『%s』但是可能無法是 C 可交流的"
 
-#: fortran/decl.cc:1626
+#: fortran/decl.cc:1647
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L may not be a pointer with CONTIGUOUS attribute as procedure %qs is BIND(C)"
 msgstr "變數『%s』於 %L 無法有指標屬性因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1636
+#: fortran/decl.cc:1657
 #, fuzzy, gcc-internal-format
 msgid "Default-initialized dummy argument %qs with %s attribute at %L is not permitted in BIND(C) procedure %qs"
 msgstr "Coarray 虛設變數『%s』於 %L 不允許在中繫結©程序『%s』"
 
-#: fortran/decl.cc:1657
+#: fortran/decl.cc:1678
 #, fuzzy, gcc-internal-format
 msgid "Allocatable character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "字元引數『%s』於 %L 必須是長度 1 因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1662
+#: fortran/decl.cc:1683
 #, fuzzy, gcc-internal-format
 msgid "Pointer character dummy argument %qs at %L must have deferred length as procedure %qs is BIND(C)"
 msgstr "字元引數『%s』於 %L 必須是長度 1 因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1669
+#: fortran/decl.cc:1690
 #, fuzzy, gcc-internal-format
 msgid "Deferred-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "字元引數『%s』於 %L 必須是長度 1 因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1681
+#: fortran/decl.cc:1702
 #, fuzzy, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of length 1 as it has the VALUE attribute"
 msgstr "字元引數『%s』於 %L 必須是長度 1 因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1692
+#: fortran/decl.cc:1713
 #, fuzzy, gcc-internal-format
 msgid "Assumed-length character dummy argument %qs at %L of procedure %qs with BIND(C) attribute"
 msgstr "字元引數『%s』於 %L 必須是長度 1 因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1706
+#: fortran/decl.cc:1727
 #, gcc-internal-format
 msgid "Character dummy argument %qs at %L must be of constant length of one or assumed length, unless it has assumed shape or assumed rank, as procedure %qs has the BIND(C) attribute"
 msgstr ""
 
-#: fortran/decl.cc:1724
+#: fortran/decl.cc:1745
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
 msgstr "TS29113:變數『%s』於 %L 與可選的屬性在中程序『%s』該項是繫結©"
 
-#: fortran/decl.cc:1732
+#: fortran/decl.cc:1753
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
 msgstr "TS29113:變數『%s』於 %L 與可選的屬性在中程序『%s』該項是繫結©"
 
-#: fortran/decl.cc:1741
+#: fortran/decl.cc:1762
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
 msgstr "變數『%s』於 %L 無法同時有可選的和值屬性因為程序『%s』是繫結©"
 
-#: fortran/decl.cc:1748
+#: fortran/decl.cc:1769
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
 msgstr "TS29113:變數『%s』於 %L 與可選的屬性在中程序『%s』該項是繫結©"
 
-#: fortran/decl.cc:1759
+#: fortran/decl.cc:1780
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
 msgstr "Assumed-shape 陣列『%s』於 %L 無法引數到程序『%s』於 %L 因為程序是繫結©"
 
-#: fortran/decl.cc:1815
+#: fortran/decl.cc:1836
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8102 %s at %L is already imported by an %s statement and must not be re-declared"
 msgstr ""
 
-#: fortran/decl.cc:1844
+#: fortran/decl.cc:1865
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L already has basic type of %s"
 msgid "Symbol %qs at %C also declared as a type at %L"
 msgstr "符號「%s」在 %L 處已經有了基本類型 %s"
 
-#: fortran/decl.cc:1919
+#: fortran/decl.cc:1940
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
 msgstr "變數『%s』在中共同區塊『%s』於 %C 必須被宣告與 C 可交流的 kind 自從共同區塊『%s』是繫結©"
 
-#: fortran/decl.cc:1959
+#: fortran/decl.cc:1980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length must be a constant at %L"
 msgstr "引數必須是常數"
 
-#: fortran/decl.cc:1974
+#: fortran/decl.cc:1995
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER expression at %L is being truncated (%ld/%ld)"
 msgstr "字元運算式於 %L 正在被截斷 (%d/%d)"
 
-#: fortran/decl.cc:1983 fortran/decl.cc:1989
+#: fortran/decl.cc:2004 fortran/decl.cc:2010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The CHARACTER elements of the array constructor at %L must have the same length (%ld/%ld)"
 msgstr "字元元件的陣列建構子於 %L 必須有相同長度 (%d/%d)"
 
-#: fortran/decl.cc:2128
+#: fortran/decl.cc:2150
 #, fuzzy, gcc-internal-format
 #| msgid "Initializer not allowed for PARAMETER '%s' at %C"
 msgid "Initializer not allowed for PARAMETER %qs at %C"
 msgstr "PARAMETER「%s」在 %C 處不允許有初始值設定"
 
-#: fortran/decl.cc:2141
+#: fortran/decl.cc:2163
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER at %L is missing an initializer"
 msgstr "%L 處 PARAMETER 缺少初始值設定"
 
-#: fortran/decl.cc:2151
+#: fortran/decl.cc:2173
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
 msgstr "變數『%s』於 %C 與初始設定式已經出現在中資料敘述"
 
-#: fortran/decl.cc:2194
+#: fortran/decl.cc:2216
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize parameter array at %L with variable length elements"
 msgstr "無法初始化 implied-shape 陣列於 %L 與純量"
 
-#: fortran/decl.cc:2228
+#: fortran/decl.cc:2260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgid "Rank mismatch of array at %L and its initializer (%d/%d)"
 msgstr "%L 處陣列參照中秩不匹配(%d/%d)"
 
-#: fortran/decl.cc:2241
+#: fortran/decl.cc:2273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cannot initialize implied-shape array at %L with scalar"
 msgstr "無法初始化 implied-shape 陣列於 %L 與純量"
 
-#: fortran/decl.cc:2251
+#: fortran/decl.cc:2283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad shape of initializer at %L"
 msgstr "『%s』於 %L 已經被初始化的於 %L"
 
-#: fortran/decl.cc:2258
+#: fortran/decl.cc:2290
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Cannot determine shape of initializer at %L"
 msgstr "啞元「%s」在 %L 處不能有初始值設定"
 
-#: fortran/decl.cc:2293
+#: fortran/decl.cc:2325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant lower bound in implied-shape declaration at %L"
 msgstr "Non-constant 下限在中 implied-shape 宣告於 %L"
 
-#: fortran/decl.cc:2343
+#: fortran/decl.cc:2375
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is incompatible with a BOZ literal constant"
 msgstr "『我』於 %L 和『J』於 %L 無法兩者是 BOZ 實字常數"
 
-#: fortran/decl.cc:2409 fortran/decl.cc:2416
+#: fortran/decl.cc:2441 fortran/decl.cc:2448
 #, gcc-internal-format, gfc-internal-format
 msgid "Component at %C must have the POINTER attribute"
 msgstr "%C 處的元件必須有 POINTER 屬性"
 
-#: fortran/decl.cc:2425
+#: fortran/decl.cc:2457
 #, fuzzy, gcc-internal-format
 msgid "Component %qs with CLASS at %C must be allocatable or pointer"
 msgstr "成分『%s』與類別於 %L 必須是 allocatable 或指標"
 
-#: fortran/decl.cc:2434
+#: fortran/decl.cc:2466
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have explicit or deferred shape"
 msgstr "陣列成分的結構於 %C 必須有明確的或已推遲形狀"
 
-#: fortran/decl.cc:2458 fortran/symbol.cc:2343
+#: fortran/decl.cc:2490 fortran/symbol.cc:2343
 #, fuzzy, gcc-internal-format
 #| msgid "Component '%s' at %C already declared at %L"
 msgid "Component %qs at %C already declared at %L"
 msgstr "元件「%s」在 %C 處已經於 %L 處被宣告"
 
-#: fortran/decl.cc:2513
+#: fortran/decl.cc:2545
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer array component of structure at %C must have a deferred shape"
 msgstr "指標陣列成分的結構於 %C 必須有已推遲形狀"
 
-#: fortran/decl.cc:2520
+#: fortran/decl.cc:2552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocatable component of structure at %C must have a deferred shape"
 msgstr "Allocatable 成分的結構於 %C 必須有已推遲形狀"
 
-#: fortran/decl.cc:2544
+#: fortran/decl.cc:2576
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array component of structure at %C must have an explicit shape"
 msgstr "陣列成分的結構於 %C 必須有明確的形狀"
 
-#: fortran/decl.cc:2561
+#: fortran/decl.cc:2593
 #, fuzzy, gcc-internal-format
 #| msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration"
 msgid "Type parameter %qs at %C has no corresponding entry in the type parameter name list at %L"
 msgstr "帶有省略號的參數清單無法與空參數名清單宣告匹配"
 
-#: fortran/decl.cc:2618
+#: fortran/decl.cc:2650
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C is ambiguous"
 msgstr "%C 處的 NULL() 初始化有歧義"
 
-#: fortran/decl.cc:2635
+#: fortran/decl.cc:2667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NULL() initialization at %C may not have MOLD"
 msgstr "%C 處的 NULL() 初始化有歧義"
 
-#: fortran/decl.cc:2652
+#: fortran/decl.cc:2684
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
 msgstr "%C 處對指標的初始化不允許出現在 PURE 程序中"
 
-#: fortran/decl.cc:2673
+#: fortran/decl.cc:2705
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in pointer initialization at %C"
 msgstr "在中指標初始化於 %C 時發生錯誤"
 
-#: fortran/decl.cc:2680
+#: fortran/decl.cc:2712
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "non-NULL pointer initialization at %C"
 msgstr "Fortran 2008:non-NULL 指標初始化於 %C"
 
-#: fortran/decl.cc:2703
+#: fortran/decl.cc:2735
 #, gcc-internal-format
 msgid "RESULT variable %qs at %L prohibits FUNCTION name %qs at %C from appearing in a specification statement"
 msgstr ""
 
-#: fortran/decl.cc:2758
+#: fortran/decl.cc:2792
 #, fuzzy, gcc-internal-format
 msgid "%qs not allowed outside STRUCTURE at %C"
 msgstr "值未被允許內部的區塊於 %C"
 
-#: fortran/decl.cc:2760
+#: fortran/decl.cc:2794
 #, gcc-internal-format
 msgid "%qs at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:2768
+#: fortran/decl.cc:2802
 #, fuzzy, gcc-internal-format
 #| msgid "Enumerator cannot have attributes %C"
 msgid "%qs entity cannot have attributes at %C"
 msgstr "列舉量不能有屬性 %C"
 
-#: fortran/decl.cc:2778
+#: fortran/decl.cc:2812
 #, fuzzy, gcc-internal-format
 msgid "Invalid character %qc in variable name at %C"
 msgstr "無效字元在中名稱於 %C"
 
-#: fortran/decl.cc:2820
+#: fortran/decl.cc:2854
 #, fuzzy, gcc-internal-format
 msgid "Non-PARAMETER symbol %qs at %L cannot be implied-shape"
 msgstr "Non-PARAMETER 符號『%s』於 %L 無法 implied-shape"
 
-#: fortran/decl.cc:2830
+#: fortran/decl.cc:2864
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Implied-shape array at %L"
 msgstr "Fortran 2008:Implied-shape 陣列於 %L"
 
-#: fortran/decl.cc:2887
+#: fortran/decl.cc:2921
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit array shape at %C must be constant of INTEGER type and not %s type"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/decl.cc:2895
+#: fortran/decl.cc:2929
 #, gcc-internal-format, gfc-internal-format
 msgid "Explicit shaped array with nonconstant bounds at %C"
 msgstr ""
 
-#: fortran/decl.cc:2996
+#: fortran/decl.cc:3030
 #, gcc-internal-format
 msgid "%qs at %L is a redefinition of the declaration in the corresponding interface for MODULE PROCEDURE %qs"
 msgstr ""
 
-#: fortran/decl.cc:3007
+#: fortran/decl.cc:3041
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "%qs entity cannot have an initializer at %L"
 msgstr "啞元「%s」在 %L 處不能有初始值設定"
 
-#: fortran/decl.cc:3033
+#: fortran/decl.cc:3067
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %L"
 msgstr "重製陣列 spec 用於 Cray 點於 %C"
 
-#: fortran/decl.cc:3041
+#: fortran/decl.cc:3075
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set pointee array spec."
 msgstr "無法轉換為指標類型"
 
-#: fortran/decl.cc:3104
+#: fortran/decl.cc:3138
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Old-style initialization at %C"
 msgstr "擴充：%C 處舊式的初始化"
 
-#: fortran/decl.cc:3112
+#: fortran/decl.cc:3146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid old style initialization for derived type component at %C"
 msgstr "無效的 value-initialization 的參考類型"
 
-#: fortran/decl.cc:3125
+#: fortran/decl.cc:3159
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in old style initialization of %s at %C"
 msgstr "在中指標初始化於 %C 時發生錯誤"
 
-#: fortran/decl.cc:3145 fortran/decl.cc:7874
+#: fortran/decl.cc:3179 fortran/decl.cc:7911
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization at %C isn't for a pointer variable"
 msgstr "%C 的初始化不是為指標變數準備的"
 
-#: fortran/decl.cc:3168
+#: fortran/decl.cc:3202
 #, fuzzy, gcc-internal-format
 #| msgid "Pointer initialization at %C requires '=>', not '='"
 msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
 msgstr "在 %C 處的指標初始化需要「=>」，而不是「=」"
 
-#: fortran/decl.cc:3186 fortran/decl.cc:11659
+#: fortran/decl.cc:3220 fortran/decl.cc:11712
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected an initialization expression at %C"
 msgstr "%C 處需要一個初始化運算式"
 
-#: fortran/decl.cc:3193
+#: fortran/decl.cc:3227
 #, gcc-internal-format, gfc-internal-format
 msgid "Initialization of variable at %C is not allowed in a PURE procedure"
 msgstr "%C 處對變數的初始化不允許出現在 PURE 程序中"
 
-#: fortran/decl.cc:3210
+#: fortran/decl.cc:3244
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initialization of allocatable component at %C is not allowed"
 msgstr "初始化的 allocatable 成分於 %C 未被允許"
 
-#: fortran/decl.cc:3219
+#: fortran/decl.cc:3253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initialization of structure component with a HOLLERITH constant at %L is not allowed"
 msgstr "初始化的 allocatable 成分於 %C 未被允許"
 
-#: fortran/decl.cc:3233
+#: fortran/decl.cc:3267
 #, gcc-internal-format, gfc-internal-format
 msgid "The component with KIND or LEN attribute at %C does not not appear in the type parameter list at %L"
 msgstr ""
 
-#: fortran/decl.cc:3241
+#: fortran/decl.cc:3275
 #, gcc-internal-format, gfc-internal-format
 msgid "The component at %C that appears in the type parameter list at %L has neither the KIND nor LEN attribute"
 msgstr ""
 
-#: fortran/decl.cc:3249
+#: fortran/decl.cc:3283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The component at %C which is a type parameter must be a scalar"
 msgstr "指標成分『%s』的『%s』於 %L 是型態該未被宣告"
 
-#: fortran/decl.cc:3258
+#: fortran/decl.cc:3292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "BOZ literal constant at %L cannot appear as an initializer"
 msgstr "%C 處 ENTRY 敘述不能出現在被包含的程序中"
 
-#: fortran/decl.cc:3275
+#: fortran/decl.cc:3309
 #, gcc-internal-format
 msgid "Incompatible initialization between a derived type entity and an entity with %qs type at %C"
 msgstr ""
 
-#: fortran/decl.cc:3338 fortran/decl.cc:3373
+#: fortran/decl.cc:3373 fortran/decl.cc:3408
 #, gcc-internal-format, gfc-internal-format
 msgid "Old-style type declaration %s*%d not supported at %C"
 msgstr "舊式的型態宣告 %s*%d 在 %C 處不被支援"
 
-#: fortran/decl.cc:3379
+#: fortran/decl.cc:3414
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonstandard type declaration %s*%d at %C"
 msgstr "Nonstandard 類型宣告 %s*%d 於 %C"
 
-#: fortran/decl.cc:3438 fortran/decl.cc:3515
+#: fortran/decl.cc:3473 fortran/decl.cc:3550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis at %C"
 msgstr "缺少右括號於 %C"
 
-#: fortran/decl.cc:3451 fortran/decl.cc:3586
+#: fortran/decl.cc:3486 fortran/decl.cc:3621
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected initialization expression at %C"
 msgstr "%C 處需要初始化運算式"
 
-#: fortran/decl.cc:3459 fortran/decl.cc:3592
+#: fortran/decl.cc:3494 fortran/decl.cc:3627
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar initialization expression at %C"
 msgstr "%C 處需要標量初始化運算式"
 
-#: fortran/decl.cc:3489 fortran/decl.cc:4384
+#: fortran/decl.cc:3524 fortran/decl.cc:4418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d not supported for type %s at %C"
 msgstr "Kind %d 不支援用於型態 %s 於 %C"
 
-#: fortran/decl.cc:3502
+#: fortran/decl.cc:3537
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "C kind type parameter is for type %s but type at %L is %s"
 msgstr "C kind 型態參數是用於型態 %s 但是型態於 %L 是 %s"
 
-#: fortran/decl.cc:3513
+#: fortran/decl.cc:3548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing right parenthesis or comma at %C"
 msgstr "缺少右括號或逗號於 %C"
 
-#: fortran/decl.cc:3618
+#: fortran/decl.cc:3653
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Kind %d is not supported for CHARACTER at %C"
 msgstr "Kind %d 未被支援用於字元於 %C"
 
-#: fortran/decl.cc:3750
+#: fortran/decl.cc:3785
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CHARACTER declaration at %C"
 msgstr "%C 的 CHARACTER 宣告語法錯誤"
 
-#: fortran/decl.cc:3851
+#: fortran/decl.cc:3886
 #, gcc-internal-format
 msgid "RECORD at %C is an extension, enable it with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:3864
+#: fortran/decl.cc:3899
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Structure name expected after RECORD at %C"
 msgstr "Interface-name 預期的之後『(』於 %C"
 
-#: fortran/decl.cc:4038
+#: fortran/decl.cc:4072
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C cannot contain both ASSUMED and DEFERRED parameters"
 msgstr ""
 
-#: fortran/decl.cc:4067
+#: fortran/decl.cc:4101
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C does not contain enough parameter expressions"
 msgstr "Kind 型態參數用於實體於 %L 不同從 kind 型態參數的 typespec"
 
-#: fortran/decl.cc:4091
+#: fortran/decl.cc:4125
 #, fuzzy, gcc-internal-format
 msgid "The derived parameter %qs at %C does not have a default value"
 msgstr "第一個參數的 %<operator new%> 無法有預設引數"
 
-#: fortran/decl.cc:4102
+#: fortran/decl.cc:4136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type parameter expression at %L must be of INTEGER type and not %s"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/decl.cc:4140
+#: fortran/decl.cc:4174
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C must be of INTEGER type and not %s type"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/decl.cc:4147
+#: fortran/decl.cc:4181
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The parameter expression at %C does not simplify to an INTEGER constant"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/decl.cc:4174
+#: fortran/decl.cc:4208
 #, gcc-internal-format
 msgid "The KIND parameter %qs at %C cannot either be ASSUMED or DEFERRED"
 msgstr ""
 
-#: fortran/decl.cc:4181
+#: fortran/decl.cc:4215
 #, fuzzy, gcc-internal-format
 msgid "The value for the KIND parameter %qs at %C does not reduce to a constant expression"
 msgstr "值的 %qD 不是可用在中常數運算式"
 
-#: fortran/decl.cc:4210
+#: fortran/decl.cc:4244
 #, gcc-internal-format, gfc-internal-format
 msgid "The type parameter spec list at %C contains too many parameter expressions"
 msgstr ""
 
-#: fortran/decl.cc:4219
+#: fortran/decl.cc:4253
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "reference to %qD is ambiguous"
 msgid "Parameterized derived type at %C is ambiguous"
 msgstr "對 %qD 的參照有歧義"
 
-#: fortran/decl.cc:4586
+#: fortran/decl.cc:4623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BYTE type at %C"
 msgstr "擴充：%C 處的 BYTE 類型"
 
-#: fortran/decl.cc:4598
+#: fortran/decl.cc:4635
 #, gcc-internal-format, gfc-internal-format
 msgid "BYTE type used at %C is not available on the target machine"
 msgstr "%C 使用到的 BYTE 類型在目標平臺上不可"
 
-#: fortran/decl.cc:4660
+#: fortran/decl.cc:4697
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C is not allowed for components"
 msgstr "By-value 引數於 %L 未被允許在中這個語境"
 
-#: fortran/decl.cc:4663
+#: fortran/decl.cc:4700
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed type at %C"
 msgstr ""
 
-#: fortran/decl.cc:4696 fortran/decl.cc:4730 fortran/decl.cc:4763
-#: fortran/decl.cc:5097
+#: fortran/decl.cc:4733 fortran/decl.cc:4767 fortran/decl.cc:4800
+#: fortran/decl.cc:5134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TYPE with intrinsic-type-spec at %C"
 msgstr "Fortran 2008:型態與 intrinsic-type-spec 於 %C"
 
-#: fortran/decl.cc:4708 fortran/decl.cc:4736 fortran/decl.cc:4769
-#: fortran/decl.cc:4795 fortran/decl.cc:5122 fortran/decl.cc:5140
+#: fortran/decl.cc:4745 fortran/decl.cc:4773 fortran/decl.cc:4806
+#: fortran/decl.cc:4832 fortran/decl.cc:5159 fortran/decl.cc:5177
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed type-spec at %C"
 msgstr "無效的 type-spec 於 %C"
 
-#: fortran/decl.cc:4759
+#: fortran/decl.cc:4796
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DOUBLE COMPLEX at %C"
 msgstr "延伸：雙倍複雜於 %C"
 
-#: fortran/decl.cc:4811 fortran/decl.cc:4978 fortran/decl.cc:4990
-#: fortran/decl.cc:5004 fortran/decl.cc:5617 fortran/decl.cc:5627
+#: fortran/decl.cc:4848 fortran/decl.cc:5015 fortran/decl.cc:5027
+#: fortran/decl.cc:5041 fortran/decl.cc:5654 fortran/decl.cc:5664
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C is ambiguous"
 msgid "Type name %qs at %C is ambiguous"
 msgstr "類型名「%s」(於 %C 處)有歧義"
 
-#: fortran/decl.cc:4912
+#: fortran/decl.cc:4949
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS statement at %C"
 msgstr "Fortran 2003:類別敘述於 %C"
 
-#: fortran/decl.cc:5019
+#: fortran/decl.cc:5056
 #, fuzzy, gcc-internal-format
 msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
 msgstr "型態名稱『%s』於 %C 衝突與在之前宣告的實體於 %L, 該項有同名"
 
-#: fortran/decl.cc:5030
+#: fortran/decl.cc:5067
 #, gcc-internal-format
 msgid "Type %qs is not parameterized and so the type parameter spec list at %C may not appear"
 msgstr ""
 
-#: fortran/decl.cc:5175
+#: fortran/decl.cc:5212
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate IMPLICIT NONE statement at %C"
 msgstr "%C 處 IMPLICIT NONE 敘述重複"
 
-#: fortran/decl.cc:5184
+#: fortran/decl.cc:5221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate IMPLICIT NONE statement at %C"
 msgid "IMPLICIT NONE with spec list at %C"
 msgstr "%C 處 IMPLICIT NONE 敘述重複"
 
-#: fortran/decl.cc:5243
+#: fortran/decl.cc:5280
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing character range in IMPLICIT at %C"
 msgstr "缺少字元範圍在中隱含的於 %C"
 
-#: fortran/decl.cc:5289
+#: fortran/decl.cc:5326
 #, gcc-internal-format, gfc-internal-format
 msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
 msgstr "%C 處 IMPLICIT 敘述中的字母必須按序排列"
 
-#: fortran/decl.cc:5342
+#: fortran/decl.cc:5379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "SAVE statement at %C follows blanket SAVE statement"
 msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
 msgstr "%C 處 SAVE 敘述跟隨空白 SAVE 敘述"
 
-#: fortran/decl.cc:5352
+#: fortran/decl.cc:5389
 #, gcc-internal-format, gfc-internal-format
 msgid "Empty IMPLICIT statement at %C"
 msgstr "%C IMPLICIT 敘述為空"
 
-#: fortran/decl.cc:5509
+#: fortran/decl.cc:5546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C only permitted in an INTERFACE body"
 msgstr "匯入敘述於 %C 只有允許的在中介面內文"
 
-#: fortran/decl.cc:5525
+#: fortran/decl.cc:5562
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
 msgstr "匯入敘述於 %C 只有允許的在中介面內文"
 
-#: fortran/decl.cc:5530
+#: fortran/decl.cc:5567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPORT statement at %C"
 msgstr "%C IMPLICIT 敘述為空"
 
-#: fortran/decl.cc:5609
+#: fortran/decl.cc:5646
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "import-name %qs at %C is in the local scope"
 msgstr "名稱「%s」(位於 %C)是一個程序的名稱"
 
-#: fortran/decl.cc:5636
+#: fortran/decl.cc:5673
 #, fuzzy, gcc-internal-format
 msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
 msgstr "無法匯入『%s』從主機範圍單位於 %C - 不存在。"
 
-#: fortran/decl.cc:5657
+#: fortran/decl.cc:5694
 #, fuzzy, gcc-internal-format
 msgid "%qs is already IMPORTed from host scoping unit at %C"
 msgstr "『%s』已經匯入的從主機範圍單位於 %C。"
 
-#: fortran/decl.cc:5700
+#: fortran/decl.cc:5737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in IMPORT statement at %C"
 msgstr "語法時發生錯誤匯入敘述於 %C"
 
-#: fortran/decl.cc:5704
+#: fortran/decl.cc:5741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "F2018: C897 IMPORT statement at %C cannot appear in a main program, an external subprogram, a module or block data"
 msgstr "匯入敘述於 %C 只有允許的在中介面內文"
 
-#: fortran/decl.cc:5709
+#: fortran/decl.cc:5746
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C898 IMPORT statement at %C is not permitted because a scoping unit has an ONLY specifier, can only have IMPORT with an ONLY specifier"
 msgstr ""
 
-#: fortran/decl.cc:5715
+#: fortran/decl.cc:5752
 #, gcc-internal-format, gfc-internal-format
 msgid "F2018: C899 IMPORT, NONE shall not appear in the scoping unit of a submodule as at %C"
 msgstr ""
 
-#: fortran/decl.cc:5720
+#: fortran/decl.cc:5757
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "F2018: C8100 IMPORT statement at %C is not permitted because %s has already been declared, which must be unique in the scoping unit"
 msgstr "匯入敘述於 %C 只有允許的在中介面內文"
 
-#: fortran/decl.cc:5728
+#: fortran/decl.cc:5765
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting list of named entities at %C"
 msgstr "預期具名的實體清單的於 %C"
 
-#: fortran/decl.cc:6068
+#: fortran/decl.cc:6105
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing codimension specification at %C"
 msgstr "缺少codimension 規格於 %C"
 
-#: fortran/decl.cc:6070
+#: fortran/decl.cc:6107
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing dimension specification at %C"
 msgstr "%C 處沒有指定維數"
 
-#: fortran/decl.cc:6165
+#: fortran/decl.cc:6202
 #, gcc-internal-format, gfc-internal-format
 msgid "Duplicate %s attribute at %L"
 msgstr "重複的 %s 屬性，位於 %L"
 
-#: fortran/decl.cc:6182
+#: fortran/decl.cc:6219
 #, gcc-internal-format
 msgid "%s at %L is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:6201
+#: fortran/decl.cc:6238
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a TYPE definition"
 msgstr "Fortran 2003:ALLOCATABLE 屬性於 %C 在中類型定義"
 
-#: fortran/decl.cc:6203
+#: fortran/decl.cc:6240
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ALLOCATABLE attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003:ALLOCATABLE 屬性於 %C 在中類型定義"
 
-#: fortran/decl.cc:6213
+#: fortran/decl.cc:6250
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a TYPE definition"
 msgstr "Fortran 2003:屬性 %s 於 %L 在中類型定義"
 
-#: fortran/decl.cc:6215
+#: fortran/decl.cc:6252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "KIND attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003:屬性 %s 於 %L 在中類型定義"
 
-#: fortran/decl.cc:6223
+#: fortran/decl.cc:6260
 #, gcc-internal-format, gfc-internal-format
 msgid "Component with KIND attribute at %C must be INTEGER"
 msgstr ""
 
-#: fortran/decl.cc:6232
+#: fortran/decl.cc:6269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a TYPE definition"
 msgstr "Fortran 2003:ALLOCATABLE 屬性於 %C 在中類型定義"
 
-#: fortran/decl.cc:6234
+#: fortran/decl.cc:6271
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LEN attribute at %C in a STRUCTURE definition"
 msgstr "Fortran 2003:ALLOCATABLE 屬性於 %C 在中類型定義"
 
-#: fortran/decl.cc:6242
+#: fortran/decl.cc:6279
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component with LEN attribute at %C must be INTEGER"
 msgstr "成分在中型態於 %C 必須前繼含有"
 
-#: fortran/decl.cc:6250
+#: fortran/decl.cc:6287
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a TYPE definition"
 msgstr "屬性於 %L 未被允許在中類型定義"
 
-#: fortran/decl.cc:6252
+#: fortran/decl.cc:6289
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed in a STRUCTURE definition"
 msgstr "屬性於 %L 未被允許在中類型定義"
 
-#: fortran/decl.cc:6270
+#: fortran/decl.cc:6307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute %s at %L in a TYPE definition"
 msgstr "Fortran 2003:屬性 %s 於 %L 在中類型定義"
 
-#: fortran/decl.cc:6280
+#: fortran/decl.cc:6317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s attribute at %L is not allowed outside of the specification part of a module"
 msgstr "%s 屬性於 %L 未被允許外側的規格部分的模組"
 
-#: fortran/decl.cc:6290
+#: fortran/decl.cc:6327
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Attribute at %L is not allowed outside a TYPE definition"
 msgstr "屬性於 %L 未被允許在中類型定義"
 
-#: fortran/decl.cc:6303
+#: fortran/decl.cc:6340
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS attribute at %C"
 msgstr "Fortran 2003:非同步屬性於 %C"
 
-#: fortran/decl.cc:6314
+#: fortran/decl.cc:6351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS attribute at %C"
 msgstr "Fortran 2008:CONTIGUOUS 屬性於 %C"
 
-#: fortran/decl.cc:6369 fortran/decl.cc:10008
+#: fortran/decl.cc:6406 fortran/decl.cc:10055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED at %C only allowed in specification part of a module"
 msgstr "保護的於 %C 只有允許的在中規格部分的模組"
 
-#: fortran/decl.cc:6375
+#: fortran/decl.cc:6412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute at %C"
 msgstr "Fortran 2003:保護的屬性於 %C"
 
-#: fortran/decl.cc:6409
+#: fortran/decl.cc:6446
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE attribute at %C"
 msgstr "Fortran 2003:值屬性於 %C"
 
-#: fortran/decl.cc:6416
+#: fortran/decl.cc:6453
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE attribute at %C"
 msgstr "Fortran 2003:易變的屬性於 %C"
 
-#: fortran/decl.cc:6423
+#: fortran/decl.cc:6460
 #, gcc-internal-format
 msgid "match_attr_spec(): Bad attribute"
 msgstr ""
 
-#: fortran/decl.cc:6464
+#: fortran/decl.cc:6501
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Multiple identifiers provided with single NAME= specifier at %C"
 msgstr "多重識別碼提供的與單一名稱=說明符於 %C"
 
-#: fortran/decl.cc:6562
+#: fortran/decl.cc:6599
 #, fuzzy, gcc-internal-format
 msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
 msgstr "隱含地宣告的繫結©函式『%s』於 %L 可能無法是 C 可交流的"
 
-#: fortran/decl.cc:6584
+#: fortran/decl.cc:6621
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
 msgstr "變數『%s』在中共同區塊『%s』於 %L 可能無法是 C 可交流的 kind 雖然共同區塊『%s』是繫結©"
 
-#: fortran/decl.cc:6595
+#: fortran/decl.cc:6632
 #, fuzzy, gcc-internal-format
 msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
 msgstr "類型宣告『%s』於 %L 不是 C 可交流的但是它是繫結©"
 
-#: fortran/decl.cc:6601
+#: fortran/decl.cc:6638
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
 msgstr "變數『%s』於 %L 可能無法是 C 可交流的 kind 但是它是繫結©"
 
-#: fortran/decl.cc:6613
+#: fortran/decl.cc:6650
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
 msgstr "變數『%s』在中共同區塊『%s』於 %L 無法宣告的與繫結©自從它並非全域"
 
-#: fortran/decl.cc:6627
+#: fortran/decl.cc:6664
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
 msgstr "變數『%s』於 %L 無法同時有指標和繫結©屬性"
 
-#: fortran/decl.cc:6635
+#: fortran/decl.cc:6672
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
 msgstr "變數『%s』於 %L 無法同時有 ALLOCATABLE 和繫結©屬性"
 
-#: fortran/decl.cc:6647
+#: fortran/decl.cc:6684
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs at %L cannot be an array"
 msgstr "傳回類型的繫結©函式『%s』於 %L 無法陣列"
 
-#: fortran/decl.cc:6653
+#: fortran/decl.cc:6690
 #, fuzzy, gcc-internal-format
 msgid "Return type of BIND(C) function %qs of character type at %L must have length 1"
 msgstr "傳回類型的繫結©函式『%s』於 %L 無法字元串"
 
-#: fortran/decl.cc:6666
+#: fortran/decl.cc:6703
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is marked PRIVATE but is accessible via its default binding name %qs"
 msgstr "符號『%s』於 %L 被標記私人的但是已被給定的繫結標貼『%s』"
 
-#: fortran/decl.cc:6740
+#: fortran/decl.cc:6777
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Need either entity or common block name for attribute specification statement at %C"
 msgstr "需要還是實體或共同區塊名稱用於屬性規格敘述於 %C"
 
-#: fortran/decl.cc:6785
+#: fortran/decl.cc:6822
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing entity or common block name for attribute specification statement at %C"
 msgstr "缺少實體或共同區塊名稱用於屬性規格敘述於 %C"
 
-#: fortran/decl.cc:6792
+#: fortran/decl.cc:6829
 #, fuzzy, gcc-internal-format
 #| msgid "missing number"
 msgid "Missing symbol"
 msgstr "缺少數字"
 
-#: fortran/decl.cc:6821
+#: fortran/decl.cc:6858
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) statement at %C"
 msgstr "Fortran 2008:同步敘述於 %C"
 
-#: fortran/decl.cc:6899
+#: fortran/decl.cc:6936
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CLASS entity at %C cannot have the PARAMETER attribute"
 msgstr "共同區塊『%s』於 %L 無法有外部屬性"
 
-#: fortran/decl.cc:6931
+#: fortran/decl.cc:6968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
 msgstr "衍生類型於 %C 未被在之前定義的和因而無法出現在中衍生類型定義"
 
-#: fortran/decl.cc:6973
+#: fortran/decl.cc:7010
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in data declaration at %C"
 msgid "Syntax error in anonymous structure declaration at %C"
 msgstr "%C 處資料宣告語法錯誤"
 
-#: fortran/decl.cc:6982
+#: fortran/decl.cc:7019
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in data declaration at %C"
 msgstr "%C 處資料宣告語法錯誤"
 
-#: fortran/decl.cc:7128
+#: fortran/decl.cc:7165
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C"
 msgstr "Fortran 2008:IMPURE 程序於 %C"
 
-#: fortran/decl.cc:7133
+#: fortran/decl.cc:7170
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE prefix at %C found outside of a module, submodule, or interface"
 msgstr "模組程序於 %C 必須是在中通用模組介面"
 
-#: fortran/decl.cc:7184
+#: fortran/decl.cc:7221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IMPURE procedure at %C"
 msgstr "Fortran 2008:IMPURE 程序於 %C"
 
-#: fortran/decl.cc:7196
+#: fortran/decl.cc:7233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PURE and IMPURE must not appear both at %C"
 msgstr "PURE 和 IMPURE 必須不出現兩者於 %C"
 
-#: fortran/decl.cc:7242
+#: fortran/decl.cc:7279
 #, gcc-internal-format, gfc-internal-format
 msgid "ELEMENTAL prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7249
+#: fortran/decl.cc:7286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PURE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr "Fortran 2008:雙倍科郎在中模組程序敘述於 %L"
 
-#: fortran/decl.cc:7256
+#: fortran/decl.cc:7293
 #, gcc-internal-format, gfc-internal-format
 msgid "RECURSIVE prefix in MODULE PROCEDURE interface is missing at %L"
 msgstr ""
 
-#: fortran/decl.cc:7317
+#: fortran/decl.cc:7354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A type parameter list is required at %C"
 msgstr "左parenthesis 必要項之後『*』"
 
-#: fortran/decl.cc:7332 fortran/primary.cc:1998
+#: fortran/decl.cc:7369 fortran/primary.cc:1998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected alternate return label at %C"
 msgid "Alternate-return argument at %C"
 msgstr "%C 處需要替代的回傳標籤"
 
-#: fortran/decl.cc:7338 fortran/decl.cc:7347
+#: fortran/decl.cc:7375 fortran/decl.cc:7384
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "A parameter name is required at %C"
 msgstr "參數名稱省略"
 
-#: fortran/decl.cc:7388
+#: fortran/decl.cc:7425
 #, fuzzy, gcc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "Name %qs at %C is the name of the procedure"
 msgstr "名稱「%s」(位於 %C)是一個程序的名稱"
 
-#: fortran/decl.cc:7401
+#: fortran/decl.cc:7438
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected parameter list in type declaration at %C"
 msgstr "%C 處陣列宣告需要另外一維"
 
-#: fortran/decl.cc:7404
+#: fortran/decl.cc:7441
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk in formal argument list at %C"
 msgstr "%C 處參數清單中有非預期的無用字元"
 
-#: fortran/decl.cc:7422
+#: fortran/decl.cc:7459
 #, fuzzy, gcc-internal-format
 msgid "Duplicate name %qs in parameter list at %C"
 msgstr "重製名稱『%s』在中關聯於 %C"
 
-#: fortran/decl.cc:7425
+#: fortran/decl.cc:7462
 #, fuzzy, gcc-internal-format
 #| msgid "Duplicate symbol '%s' in formal argument list at %C"
 msgid "Duplicate symbol %qs in formal argument list at %C"
 msgstr "符號「%s」在 %C 處的參數清單中重複出現"
 
-#: fortran/decl.cc:7467
+#: fortran/decl.cc:7504
 #, fuzzy, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument %qs conflicts with alternate return at %C"
 msgstr "程序屬性衝突與儲存屬性在中『%s』於 %L"
 
-#: fortran/decl.cc:7471
+#: fortran/decl.cc:7508
 #, gcc-internal-format
 msgid "MODULE PROCEDURE formal argument is alternate return and conflicts with %qs in the separate declaration at %C"
 msgstr ""
 
-#: fortran/decl.cc:7476
+#: fortran/decl.cc:7513
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
 msgstr ""
 
-#: fortran/decl.cc:7483
+#: fortran/decl.cc:7520
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
 msgstr "Fortran 2008:雙倍科郎在中模組程序敘述於 %L"
 
-#: fortran/decl.cc:7522
+#: fortran/decl.cc:7559
 #, gcc-internal-format, gfc-internal-format
 msgid "RESULT variable at %C must be different than function name"
 msgstr "%C 處 RESULT 變數不能與函式同名"
 
-#: fortran/decl.cc:7599
+#: fortran/decl.cc:7636
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected junk after function declaration at %C"
 msgstr "%C 處的函式宣告後有非預期的無用字元"
 
-#: fortran/decl.cc:7609 fortran/decl.cc:8752
+#: fortran/decl.cc:7646 fortran/decl.cc:8799
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
 msgstr "Fortran 2008:繫結©屬性於 %L 可能無法被指定的用於內部程序"
 
-#: fortran/decl.cc:7813
+#: fortran/decl.cc:7850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
 msgstr "繫結©屬性於 %C 需求介面與繫結©"
 
-#: fortran/decl.cc:7820
+#: fortran/decl.cc:7857
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
 msgstr "繫結©程序與名稱可能無法有指標屬性於 %C"
 
-#: fortran/decl.cc:7826
+#: fortran/decl.cc:7863
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
 msgstr "虛設程序於 %C 可能無法有繫結©屬性與名稱"
 
-#: fortran/decl.cc:7849
+#: fortran/decl.cc:7886
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L already has basic type of %s"
 msgstr "程序『%s』於 %L 已經有基本型式的 %s"
 
-#: fortran/decl.cc:7895 fortran/decl.cc:8086 fortran/decl.cc:12143
+#: fortran/decl.cc:7934 fortran/decl.cc:8125 fortran/decl.cc:12197
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROCEDURE statement at %C"
 msgstr "語法時發生錯誤程序敘述於 %C"
 
-#: fortran/decl.cc:7944 fortran/decl.cc:12043
+#: fortran/decl.cc:7983 fortran/decl.cc:12097
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> after binding-attributes at %C"
 msgstr "預期『::』之後 binding-attributes 於 %C"
 
-#: fortran/decl.cc:7951
+#: fortran/decl.cc:7990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NOPASS or explicit interface required at %C"
 msgstr "NOPASS 或明確的介面必要項於 %C"
 
-#: fortran/decl.cc:7955
+#: fortran/decl.cc:7994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer component at %C"
 msgstr "Fortran 2003:程序指標成分於 %C"
 
-#: fortran/decl.cc:8030
+#: fortran/decl.cc:8069
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in procedure pointer component at %C"
 msgstr "語法時發生錯誤程序指標成分於 %C"
 
-#: fortran/decl.cc:8048
+#: fortran/decl.cc:8087
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE at %C must be in a generic interface"
 msgstr "程序於 %C 必須是在中通用介面"
 
-#: fortran/decl.cc:8057 fortran/decl.cc:10783
+#: fortran/decl.cc:8096 fortran/decl.cc:10834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "double colon in MODULE PROCEDURE statement at %L"
 msgstr "Fortran 2008:雙倍科郎在中模組程序敘述於 %L"
 
-#: fortran/decl.cc:8127
+#: fortran/decl.cc:8166
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE statement at %C"
 msgstr "Fortran 2003:程序敘述於 %C"
 
-#: fortran/decl.cc:8199
+#: fortran/decl.cc:8242
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected formal argument list in function definition at %C"
 msgstr "預期的形式引數清單在中函式定義於 %C"
 
-#: fortran/decl.cc:8229 fortran/decl.cc:8508 fortran/decl.cc:8719
+#: fortran/decl.cc:8272 fortran/decl.cc:8551 fortran/decl.cc:8766
 #: fortran/symbol.cc:1973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
 msgstr "繫結©屬性於 %L 只能使用用於變數或共同區塊"
 
-#: fortran/decl.cc:8259 fortran/decl.cc:8777
+#: fortran/decl.cc:8302 fortran/decl.cc:8824
 #, gcc-internal-format
 msgid "Mismatch in BIND(C) names (%qs/%qs) at %C"
 msgstr ""
 
-#: fortran/decl.cc:8402
+#: fortran/decl.cc:8445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C"
 msgstr "%C IMPLICIT 敘述為空"
 
-#: fortran/decl.cc:8411
+#: fortran/decl.cc:8454
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a PROGRAM"
 msgstr "%C 處的 ENTRY 敘述不能出現在 PROGRAM 中"
 
-#: fortran/decl.cc:8414
+#: fortran/decl.cc:8457
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgstr "%C 處的 ENTRY 敘述不能出現在 MODULE 中"
 
-#: fortran/decl.cc:8417
+#: fortran/decl.cc:8460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a MODULE"
 msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
 msgstr "%C 處的 ENTRY 敘述不能出現在 MODULE 中"
 
-#: fortran/decl.cc:8420
+#: fortran/decl.cc:8463
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
 msgstr "%C 處的 ENTRY 敘述不能出現在 BLOCK DATA 中"
 
-#: fortran/decl.cc:8424 fortran/decl.cc:8469
+#: fortran/decl.cc:8467 fortran/decl.cc:8512
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an INTERFACE"
 msgstr "%C 處的 ENTRY 敘述不能出現在 INTERFACE 中"
 
-#: fortran/decl.cc:8428
+#: fortran/decl.cc:8471
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgid "ENTRY statement at %C cannot appear within a STRUCTURE block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 SELECT 區塊中"
 
-#: fortran/decl.cc:8432
+#: fortran/decl.cc:8475
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 DERIVED TYPE 區塊中"
 
-#: fortran/decl.cc:8436
+#: fortran/decl.cc:8479
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 IF-THEN 區塊中"
 
-#: fortran/decl.cc:8441
+#: fortran/decl.cc:8484
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a DO block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 DO 中"
 
-#: fortran/decl.cc:8445
+#: fortran/decl.cc:8488
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a SELECT block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 SELECT 區塊中"
 
-#: fortran/decl.cc:8449
+#: fortran/decl.cc:8492
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a FORALL block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 FORALL 區塊中"
 
-#: fortran/decl.cc:8453
+#: fortran/decl.cc:8496
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a WHERE block"
 msgstr "%C 處的 ENTRY 敘述不能出現在 WHERE 區塊中"
 
-#: fortran/decl.cc:8457
+#: fortran/decl.cc:8500
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear within a contained subprogram"
 msgstr "%C 處的 ENTRY 敘述不能出現在巢狀的子程式中"
 
-#: fortran/decl.cc:8461
+#: fortran/decl.cc:8504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected ENTRY statement at %C"
 msgstr "%C 處非預期的 END 敘述"
 
-#: fortran/decl.cc:8482
+#: fortran/decl.cc:8525
 #, gcc-internal-format, gfc-internal-format
 msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgstr "%C 處 ENTRY 敘述不能出現在被包含的程序中"
 
-#: fortran/decl.cc:8533 fortran/decl.cc:8759
+#: fortran/decl.cc:8576 fortran/decl.cc:8806
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing required parentheses before BIND(C) at %C"
 msgstr "缺少必要項 parentheses 之前繫結©於 %C"
 
-#: fortran/decl.cc:8627
+#: fortran/decl.cc:8670
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "ENTRY statement at %C cannot appear in a contained procedure"
 msgid "ENTRY statement at %L with BIND(C) prohibited in an elemental procedure"
 msgstr "%C 處 ENTRY 敘述不能出現在被包含的程序中"
 
-#: fortran/decl.cc:8786
+#: fortran/decl.cc:8833
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate return dummy argument cannot appear in a SUBROUTINE with the BIND(C) attribute at %L"
 msgstr "交替回傳無法出現在中運算子介面於 %L"
 
-#: fortran/decl.cc:8849 fortran/decl.cc:8856
+#: fortran/decl.cc:8896 fortran/decl.cc:8903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid C identifier in NAME= specifier at %C"
 msgstr "無效的 C 名稱在中名稱=說明符於 %C"
 
-#: fortran/decl.cc:8896
+#: fortran/decl.cc:8943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in NAME= specifier for binding label at %C"
 msgstr "語法時發生錯誤名稱=說明符用於繫結標貼於 %C"
 
-#: fortran/decl.cc:8912
+#: fortran/decl.cc:8959
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a constant expression"
 msgstr "非同步=說明符於 %L 必須是初始化運算式"
 
-#: fortran/decl.cc:8920
+#: fortran/decl.cc:8967
 #, gcc-internal-format, gfc-internal-format
 msgid "NAME= specifier at %C should be a scalar of default character kind"
 msgstr ""
 
-#: fortran/decl.cc:8939
+#: fortran/decl.cc:8986
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing closing paren for binding label at %C"
 msgstr "缺少關閉同位用於繫結標貼於 %C"
 
-#: fortran/decl.cc:8945
+#: fortran/decl.cc:8992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "No binding name is allowed in BIND(C) at %C"
 msgstr "沒有繫結名稱被允許在中繫結©於 %C"
 
-#: fortran/decl.cc:8951
+#: fortran/decl.cc:8998
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
 msgstr "用於虛設程序 %s，沒有繫結名稱被允許在中繫結©於 %C"
 
-#: fortran/decl.cc:8980
+#: fortran/decl.cc:9027
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
 msgstr "名稱不允許於繫結©用於摘要介面於 %C"
 
-#: fortran/decl.cc:9263
+#: fortran/decl.cc:9310
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected END statement at %C"
 msgstr "%C 處非預期的 END 敘述"
 
-#: fortran/decl.cc:9272
+#: fortran/decl.cc:9319
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "END statement instead of %s statement at %L"
 msgstr "Fortran 2008:結束敘述以代替 %s 敘述於 %L"
 
 #. We would have required END [something].
-#: fortran/decl.cc:9281
+#: fortran/decl.cc:9328
 #, gcc-internal-format, gfc-internal-format
 msgid "%s statement expected at %L"
 msgstr "需要 %s 敘述在 %L 處"
 
-#: fortran/decl.cc:9292
+#: fortran/decl.cc:9339
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expecting %s statement at %C"
 msgid "Expecting %s statement at %L"
 msgstr "需要 %s 敘述，於 %C"
 
-#: fortran/decl.cc:9317
+#: fortran/decl.cc:9364
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected block name of %qs in %s statement at %L"
 msgstr "需要塊名「%s」在「%s」運算式中，於 %C"
 
-#: fortran/decl.cc:9334
+#: fortran/decl.cc:9381
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected terminating name at %C"
 msgstr "%C 處需要結束名"
 
-#: fortran/decl.cc:9348 fortran/decl.cc:9356
+#: fortran/decl.cc:9395 fortran/decl.cc:9403
 #, fuzzy, gcc-internal-format
 #| msgid "Expected label '%s' for %s statement at %C"
 msgid "Expected label %qs for %s statement at %C"
 msgstr "需要標籤「%s」，為 %s 敘述，於 %C"
 
-#: fortran/decl.cc:9456
+#: fortran/decl.cc:9503
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in DIMENSION statement"
 msgstr "缺少陣列規格於 %L 在中尺寸敘述"
 
-#: fortran/decl.cc:9464
+#: fortran/decl.cc:9511
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Dimensions specified for %s at %L after its initialization"
 msgstr "維度指定的用於 %s 於 %L 之後它的 initialisation"
 
-#: fortran/decl.cc:9472
+#: fortran/decl.cc:9519
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing array specification at %L in CODIMENSION statement"
 msgstr "缺少陣列規格於 %L 在中 CODIMENSION 敘述"
 
-#: fortran/decl.cc:9481
+#: fortran/decl.cc:9528
 #, gcc-internal-format, gfc-internal-format
 msgid "Array specification must be deferred at %L"
 msgstr "%L 處陣列指定必須延遲"
 
-#: fortran/decl.cc:9586
+#: fortran/decl.cc:9633
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected character in variable list at %C"
 msgstr "%C 處變數清單中有非預期的無用字元"
 
-#: fortran/decl.cc:9623
+#: fortran/decl.cc:9670
 #, fuzzy, gcc-internal-format
 #| msgid "Expected '(' at %C"
 msgid "Expected %<(%> at %C"
 msgstr "在 %C 處需要「(」"
 
-#: fortran/decl.cc:9637 fortran/decl.cc:9677
+#: fortran/decl.cc:9684 fortran/decl.cc:9724
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C"
 msgstr "在 %C 處需要變數名"
 
-#: fortran/decl.cc:9653
+#: fortran/decl.cc:9700
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C must be an integer"
 msgstr "Cray 指標於 %C 必須是整數"
 
-#: fortran/decl.cc:9657
+#: fortran/decl.cc:9704
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
 msgstr "Cray 指標於 %C 有 %d 位元組的精確度；記憶體位址需求 %d 位元組"
 
-#: fortran/decl.cc:9663
+#: fortran/decl.cc:9710
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \",\" at %C"
 msgstr "在 %C 處需要「,」"
 
-#: fortran/decl.cc:9702
+#: fortran/decl.cc:9749
 #, fuzzy, gcc-internal-format
 #| msgid "cannot convert to a pointer type"
 msgid "Cannot set Cray pointee array spec."
 msgstr "無法轉換為指標類型"
 
-#: fortran/decl.cc:9706
+#: fortran/decl.cc:9753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate array spec for Cray pointee at %C"
 msgstr "重製陣列 spec 用於 Cray 點於 %C"
 
-#: fortran/decl.cc:9726
+#: fortran/decl.cc:9773
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected \")\" at %C"
 msgstr "在 %C 處需要「)」"
 
-#: fortran/decl.cc:9738
+#: fortran/decl.cc:9785
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" or end of statement at %C"
 msgid "Expected %<,%> or end of statement at %C"
 msgstr "在 %C 處需要「,」或敘述尾"
 
-#: fortran/decl.cc:9764
+#: fortran/decl.cc:9811
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTENT is not allowed inside of BLOCK at %C"
 msgstr "含義未被允許內部的區塊於 %C"
 
-#: fortran/decl.cc:9796
+#: fortran/decl.cc:9843
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "OPTIONAL is not allowed inside of BLOCK at %C"
 msgstr "可選的未被允許內部的區塊於 %C"
 
-#: fortran/decl.cc:9815
+#: fortran/decl.cc:9862
 #, fuzzy, gcc-internal-format
 msgid "Cray pointer declaration at %C requires %<-fcray-pointer%> flag"
 msgstr "Cray 指標宣告於 %C 需求 -fcray-pointer 旗標"
 
-#: fortran/decl.cc:9854
+#: fortran/decl.cc:9901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTIGUOUS statement at %C"
 msgstr "Fortran 2008:CONTIGUOUS 敘述於 %C"
 
-#: fortran/decl.cc:9952
+#: fortran/decl.cc:9999
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the %s operator at %C has already been specified"
 msgstr "存取規格的 %s 運算子於 %C 已指定的"
 
-#: fortran/decl.cc:9968
+#: fortran/decl.cc:10015
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Access specification of the .%s. operator at %C has already been specified"
 msgstr "存取規格的.%s。運算子於 %C 已指定的"
 
-#: fortran/decl.cc:10016
+#: fortran/decl.cc:10063
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED statement at %C"
 msgstr "Fortran 2003:保護的敘述於 %C"
 
-#: fortran/decl.cc:10050
+#: fortran/decl.cc:10097
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in PROTECTED statement at %C"
 msgstr "語法時發生錯誤保護的敘述於 %C"
 
-#: fortran/decl.cc:10077 fortran/decl.cc:10102
+#: fortran/decl.cc:10124 fortran/decl.cc:10149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
 msgstr "私人的敘述於 %C 是只有允許的在中規格部分的模組"
 
-#: fortran/decl.cc:10123 fortran/decl.cc:10143
+#: fortran/decl.cc:10170 fortran/decl.cc:10190
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
 msgstr "公用的敘述於 %C 是只有允許的在中規格部分的模組"
 
-#: fortran/decl.cc:10165
+#: fortran/decl.cc:10215
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected variable name at %C in PARAMETER statement"
 msgstr "預期的變數名稱於 %C 在中參數敘述"
 
-#: fortran/decl.cc:10172
+#: fortran/decl.cc:10222
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected = sign in PARAMETER statement at %C"
 msgstr "%C 在 PARAMETER 敘述中需要 = 符號"
 
-#: fortran/decl.cc:10178
+#: fortran/decl.cc:10228
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected expression at %C in PARAMETER statement"
 msgstr "%C 在 PARAMETER 敘述中需要運算式"
 
-#: fortran/decl.cc:10198
+#: fortran/decl.cc:10248
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Initializing already initialized variable at %C"
 msgstr "初始化已經初始化的變數於 %C"
 
 #. With legacy PARAMETER statements, don't expect a terminating ')'.
-#: fortran/decl.cc:10223
+#: fortran/decl.cc:10274
 #, gcc-internal-format, gfc-internal-format
 msgid "PARAMETER without '()' at %C"
 msgstr ""
 
-#: fortran/decl.cc:10239
+#: fortran/decl.cc:10290
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected characters in PARAMETER statement at %C"
 msgstr "%C 處 PARAMETER 敘述中有非預期的字元"
 
-#: fortran/decl.cc:10258 fortran/decl.cc:10314
+#: fortran/decl.cc:10309 fortran/decl.cc:10365
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-static%>"
 msgstr ""
 
-#: fortran/decl.cc:10293
+#: fortran/decl.cc:10344
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in AUTOMATIC statement at %C"
 msgstr "%C READ 敘述需要變數"
 
-#: fortran/decl.cc:10300
+#: fortran/decl.cc:10351
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in AUTOMATIC statement at %C"
 msgstr "語法時發生錯誤易變的敘述於 %C"
 
-#: fortran/decl.cc:10349
+#: fortran/decl.cc:10400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable in READ statement at %C"
 msgid "Expected entity-list in STATIC statement at %C"
 msgstr "%C READ 敘述需要變數"
 
-#: fortran/decl.cc:10356
+#: fortran/decl.cc:10407
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in SAVE statement at %C"
 msgid "Syntax error in STATIC statement at %C"
 msgstr "%C SAVE 敘述語法錯誤"
 
-#: fortran/decl.cc:10375
+#: fortran/decl.cc:10426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Blanket SAVE statement at %C follows previous SAVE statement"
 msgstr "Blanket 儲存敘述於 %C 追隨前一個儲存敘述"
 
-#: fortran/decl.cc:10386
+#: fortran/decl.cc:10437
 #, gcc-internal-format, gfc-internal-format
 msgid "SAVE statement at %C follows blanket SAVE statement"
 msgstr "%C 處 SAVE 敘述跟隨空白 SAVE 敘述"
 
-#: fortran/decl.cc:10421
+#: fortran/decl.cc:10472
 #, fuzzy, gcc-internal-format
 msgid "SAVE of COMMON block %qs at %C is not allowed in a BLOCK construct"
 msgstr "Fortran 2003:共同區塊『%s』於 %L 該也是函數計算結果"
 
-#: fortran/decl.cc:10443
+#: fortran/decl.cc:10494
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in SAVE statement at %C"
 msgstr "%C SAVE 敘述語法錯誤"
 
-#: fortran/decl.cc:10460
+#: fortran/decl.cc:10511
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE is not allowed inside of BLOCK at %C"
 msgstr "值未被允許內部的區塊於 %C"
 
-#: fortran/decl.cc:10464
+#: fortran/decl.cc:10515
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VALUE statement at %C"
 msgstr "Fortran 2003:值敘述於 %C"
 
-#: fortran/decl.cc:10502
+#: fortran/decl.cc:10553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VALUE statement at %C"
 msgstr "語法時發生錯誤值敘述於 %C"
 
-#: fortran/decl.cc:10514
+#: fortran/decl.cc:10565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "VOLATILE statement at %C"
 msgstr "Fortran 2003:易變的敘述於 %C"
 
-#: fortran/decl.cc:10541
+#: fortran/decl.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
 msgstr "指定易變的用於 coarray 變數『%s』於 %C, 該項是 use-/ host-associated"
 
-#: fortran/decl.cc:10566
+#: fortran/decl.cc:10617
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in VOLATILE statement at %C"
 msgstr "語法時發生錯誤易變的敘述於 %C"
 
-#: fortran/decl.cc:10578
+#: fortran/decl.cc:10629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASYNCHRONOUS statement at %C"
 msgstr "Fortran 2003:非同步敘述於 %C"
 
-#: fortran/decl.cc:10622
+#: fortran/decl.cc:10673
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ASYNCHRONOUS statement at %C"
 msgstr "語法時發生錯誤非同步敘述於 %C"
 
-#: fortran/decl.cc:10647
+#: fortran/decl.cc:10698
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE declaration at %C"
 msgstr "Fortran 2008:程序清單於 %C"
 
-#: fortran/decl.cc:10758
+#: fortran/decl.cc:10809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MODULE PROCEDURE at %C must be in a generic module interface"
 msgstr "模組程序於 %C 必須是在中通用模組介面"
 
-#: fortran/decl.cc:10816
+#: fortran/decl.cc:10867
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
 msgstr "Intrinsic 程序於 %L 無法模組程序"
 
-#: fortran/decl.cc:10865
+#: fortran/decl.cc:10916
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Ambiguous symbol in TYPE definition at %C"
 msgstr "模稜兩可的符號在中類型定義於 %C"
 
-#: fortran/decl.cc:10874
+#: fortran/decl.cc:10925
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has not been previously defined"
 msgstr "符號『%s』於 %C 已主機關聯的"
 
-#: fortran/decl.cc:10880
+#: fortran/decl.cc:10931
 #, fuzzy, gcc-internal-format
 msgid "%qs in EXTENDS expression at %C is not a derived type"
 msgstr "『%s』在中延伸運算式於 %C 並非衍生類型"
 
-#: fortran/decl.cc:10887
+#: fortran/decl.cc:10938
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is BIND(C)"
 msgstr "『%s』無法進階於 %C 因為它是繫結©"
 
-#: fortran/decl.cc:10894
+#: fortran/decl.cc:10945
 #, fuzzy, gcc-internal-format
 msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
 msgstr "『%s』無法進階於 %C 因為它是序列型態"
 
-#: fortran/decl.cc:10917
+#: fortran/decl.cc:10968
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
 msgstr "衍生類型於 %C 只能是私人的在中規格部分的模組"
 
-#: fortran/decl.cc:10929
+#: fortran/decl.cc:10980
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
 msgstr "衍生類型於 %C 只能是公用的在中規格部分的模組"
 
-#: fortran/decl.cc:10950
+#: fortran/decl.cc:11001
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ABSTRACT type at %C"
 msgstr "摘要型態『%s』使用的於 %L"
 
-#: fortran/decl.cc:10996
+#: fortran/decl.cc:11047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate construct label '%s' at %C"
 msgid "Failed to create structure type '%s' at %C"
 msgstr "重複的建構標籤「%s」出現在 %C 處"
 
-#: fortran/decl.cc:11002
+#: fortran/decl.cc:11053
 #, fuzzy, gcc-internal-format
 msgid "Type definition of %qs at %C was already defined at %L"
 msgstr "衍生類型定義的『%s』於 %C 已定義"
 
-#: fortran/decl.cc:11049
+#: fortran/decl.cc:11100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after MAP statement at %C"
 msgstr "垃圾之後關聯敘述於 %C"
 
-#: fortran/decl.cc:11082
+#: fortran/decl.cc:11133
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after UNION statement at %C"
 msgstr "垃圾之後關聯敘述於 %C"
 
-#: fortran/decl.cc:11117
+#: fortran/decl.cc:11168
 #, gcc-internal-format
 msgid "%s at %C is a DEC extension, enable with %<-fdec-structure%>"
 msgstr ""
 
-#: fortran/decl.cc:11131
+#: fortran/decl.cc:11182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected junk after function declaration at %C"
 msgid "Structure name expected in non-nested structure declaration at %C"
 msgstr "%C 處的函式宣告後有非預期的無用字元"
 
-#: fortran/decl.cc:11149
+#: fortran/decl.cc:11200
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after non-nested STRUCTURE statement at %C"
 msgstr "垃圾之後關聯敘述於 %C"
 
-#: fortran/decl.cc:11156
+#: fortran/decl.cc:11207
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Structure name %qs at %C cannot be the same as an intrinsic type"
 msgstr "類型「%s」(位於 %C)不能與內建類型同名"
 
-#: fortran/decl.cc:11319
+#: fortran/decl.cc:11370
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected :: in TYPE definition at %C"
 msgstr "%C 在 TYPE 定義中需要 ::"
 
-#: fortran/decl.cc:11332
+#: fortran/decl.cc:11383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mangled derived type definition at %C"
 msgstr "Fortran 2003: 含有區塊在中衍生類型定義於 %C"
 
-#: fortran/decl.cc:11361
+#: fortran/decl.cc:11412
 #, fuzzy, gcc-internal-format
 #| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
 msgid "Type name %qs at %C cannot be the same as an intrinsic type"
 msgstr "類型「%s」(位於 %C)不能與內建類型同名"
 
-#: fortran/decl.cc:11372
+#: fortran/decl.cc:11423
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type of %s"
 msgstr "衍生類型名稱『%s』於 %C 已經有基本型式的 %s"
 
-#: fortran/decl.cc:11375
+#: fortran/decl.cc:11426
 #, fuzzy, gcc-internal-format
 msgid "Derived type name %qs at %C already has a basic type"
 msgstr "衍生類型名稱『%s』於 %C 已經有基本型式的 %s"
 
-#: fortran/decl.cc:11390
+#: fortran/decl.cc:11441
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be a derived type at %C"
 msgstr "啞元「%s」(位於 %L)不能是 OPTIONAL"
 
-#: fortran/decl.cc:11399
+#: fortran/decl.cc:11450
 #, fuzzy, gcc-internal-format
 msgid "Derived type definition of %qs at %C has already been defined"
 msgstr "衍生類型定義的『%s』於 %C 已定義"
 
-#: fortran/decl.cc:11462
+#: fortran/decl.cc:11513
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in CHARACTER declaration at %C"
 msgid "Garbage after PARAMETERIZED TYPE declaration at %C"
 msgstr "%C 的 CHARACTER 宣告語法錯誤"
 
-#: fortran/decl.cc:11545
+#: fortran/decl.cc:11596
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Cray Pointee at %C cannot be assumed shape array"
 msgstr "Cray 點於 %C 無法假設的形狀陣列"
 
-#: fortran/decl.cc:11565
+#: fortran/decl.cc:11616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUM and ENUMERATOR at %C"
 msgstr "Fortran 2003:ENUM 和列舉值於 %C"
 
-#: fortran/decl.cc:11597
+#: fortran/decl.cc:11648
 #, gcc-internal-format, gfc-internal-format
 msgid "Enumerator exceeds the C integer type at %C"
 msgstr "%C 處：列舉量超過 C 整數類型"
 
-#: fortran/decl.cc:11676
+#: fortran/decl.cc:11729
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUMERATOR %L not initialized with integer expression"
 msgstr "列舉值 %L 無法初始化的與整數運算式"
 
-#: fortran/decl.cc:11724
+#: fortran/decl.cc:11778
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENUM definition statement expected before %C"
 msgstr "ENUM 定義敘述預期的之前 %C"
 
-#: fortran/decl.cc:11760
+#: fortran/decl.cc:11814
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in ENUMERATOR definition at %C"
 msgstr "%C 處 ENUMERATOR 定義中語法錯誤"
 
-#: fortran/decl.cc:11807 fortran/decl.cc:11822
+#: fortran/decl.cc:11861 fortran/decl.cc:11876
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate access-specifier at %C"
 msgstr "重製 access-specifier 於 %C"
 
-#: fortran/decl.cc:11842
+#: fortran/decl.cc:11896
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal NOPASS at %C"
 msgstr "繫結屬性已經指定傳遞，不合法的 NOPASS 於 %C"
 
-#: fortran/decl.cc:11862
+#: fortran/decl.cc:11916
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Binding attributes already specify passing, illegal PASS at %C"
 msgstr "繫結屬性已經指定傳遞，不合法的回合於 %C"
 
-#: fortran/decl.cc:11889
+#: fortran/decl.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate POINTER attribute at %C"
 msgstr "重製指標屬性於 %C"
 
-#: fortran/decl.cc:11907
+#: fortran/decl.cc:11961
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate NON_OVERRIDABLE at %C"
 msgstr "重製 NON_OVERRIDABLE 於 %C"
 
-#: fortran/decl.cc:11923
+#: fortran/decl.cc:11977
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Duplicate DEFERRED at %C"
 msgstr "重製已推遲於 %C"
 
-#: fortran/decl.cc:11936
+#: fortran/decl.cc:11990
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected access-specifier at %C"
 msgstr "預期 access-specifier 於 %C"
 
-#: fortran/decl.cc:11938
+#: fortran/decl.cc:11992
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected binding attribute at %C"
 msgstr "預期的繫結屬性於 %C"
 
-#: fortran/decl.cc:11946
+#: fortran/decl.cc:12000
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "NON_OVERRIDABLE and DEFERRED cannot both appear at %C"
 msgstr "NON_OVERRIDABLE 和已推遲無法兩者出現於 %C"
 
-#: fortran/decl.cc:11959
+#: fortran/decl.cc:12013
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER attribute is required for procedure pointer component at %C"
 msgstr "指標屬性被必要項用於程序指標成分於 %C"
 
-#: fortran/decl.cc:12001
+#: fortran/decl.cc:12055
 #, fuzzy, gcc-internal-format
 msgid "Interface-name expected after %<(%> at %C"
 msgstr "Interface-name 預期的之後『(』於 %C"
 
-#: fortran/decl.cc:12007
+#: fortran/decl.cc:12061
 #, fuzzy, gcc-internal-format
 msgid "%<)%> expected at %C"
 msgstr "『)』預期的於 %C"
 
-#: fortran/decl.cc:12027
+#: fortran/decl.cc:12081
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Interface must be specified for DEFERRED binding at %C"
 msgstr "介面必須被指定的用於已推遲繫結於 %C"
 
-#: fortran/decl.cc:12032
+#: fortran/decl.cc:12086
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
 msgstr "程序 (介面) 於 %C 應該被宣告已推遲"
 
-#: fortran/decl.cc:12055
+#: fortran/decl.cc:12109
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected binding name at %C"
 msgstr "預期的繫結名稱於 %C"
 
-#: fortran/decl.cc:12059
+#: fortran/decl.cc:12113
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE list at %C"
 msgstr "Fortran 2008:程序清單於 %C"
 
-#: fortran/decl.cc:12071
+#: fortran/decl.cc:12125
 #, fuzzy, gcc-internal-format
 msgid "%<=> target%> is invalid for DEFERRED binding at %C"
 msgstr "『=>目標』無效用於已推遲繫結於 %C"
 
-#: fortran/decl.cc:12077
+#: fortran/decl.cc:12131
 #, fuzzy, gcc-internal-format
 msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
 msgstr "『::』所需的在中程序繫結與明確的目標於 %C"
 
-#: fortran/decl.cc:12087
+#: fortran/decl.cc:12141
 #, fuzzy, gcc-internal-format
 msgid "Expected binding target after %<=>%> at %C"
 msgstr "預期的繫結目標之後『=>』於 %C"
 
-#: fortran/decl.cc:12104
+#: fortran/decl.cc:12158
 #, fuzzy, gcc-internal-format
 msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
 msgstr "型態『%s』包含已推遲繫結於 %C 不是摘要"
 
-#: fortran/decl.cc:12115
+#: fortran/decl.cc:12169
 #, fuzzy, gcc-internal-format
 msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
 msgstr "已經有程序與繫結名稱『%s』用於衍生類型『%s』於 %C"
 
-#: fortran/decl.cc:12202 fortran/decl.cc:12484
+#: fortran/decl.cc:12256 fortran/decl.cc:12538
 #, fuzzy, gcc-internal-format
 msgid "Expected %<::%> at %C"
 msgstr "預期『::』於 %C"
 
-#: fortran/decl.cc:12213 fortran/decl.cc:12496
+#: fortran/decl.cc:12267 fortran/decl.cc:12550
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected generic name or operator descriptor at %C"
 msgstr "預期的通用名稱或運算子描述元於 %C"
 
-#: fortran/decl.cc:12234 fortran/decl.cc:12517
+#: fortran/decl.cc:12288 fortran/decl.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Malformed GENERIC statement at %C"
 msgstr "%C IMPLICIT 敘述為空"
 
-#: fortran/decl.cc:12245 fortran/decl.cc:12528
+#: fortran/decl.cc:12299 fortran/decl.cc:12582
 #, fuzzy, gcc-internal-format
 msgid "Expected %<=>%> at %C"
 msgstr "預期『=>』於 %C"
 
-#: fortran/decl.cc:12252
+#: fortran/decl.cc:12306
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The access specification at %L not in a module"
 msgstr "範圍規格於 %L 可以永不被匹配"
 
-#: fortran/decl.cc:12273
+#: fortran/decl.cc:12327
 #, gcc-internal-format
 msgid "The generic-spec name %qs at %C clashes with the name of an entity declared at %L that is not a procedure"
 msgstr ""
 
-#: fortran/decl.cc:12282
+#: fortran/decl.cc:12336
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with name %qs at %C"
 msgstr "那裡『s 已經 non-generic 程序與繫結名稱 』%s『 用於衍生類型 』%s' 於 %C"
 
-#: fortran/decl.cc:12291
+#: fortran/decl.cc:12345
 #, fuzzy, gcc-internal-format
 msgid "The access specification at %L conflicts with that already given to %qs"
 msgstr "存取規格的 %s 運算子於 %C 已指定的"
 
-#: fortran/decl.cc:12298
+#: fortran/decl.cc:12352
 #, fuzzy, gcc-internal-format
 msgid "The access specification at %L repeats that already given to %qs"
 msgstr "存取規格的 %s 運算子於 %C 已指定的"
 
-#: fortran/decl.cc:12307
+#: fortran/decl.cc:12361
 #, gcc-internal-format, gfc-internal-format
 msgid "The generic-spec in the generic statement at %C has a type from the declaration at %L"
 msgstr ""
 
-#: fortran/decl.cc:12348
+#: fortran/decl.cc:12402
 #, fuzzy, gcc-internal-format
 msgid "The user operator at %L must have the same access specification as already defined user operator %qs"
 msgstr "繫結於 %C 必須有相同存取做為已經定義的繫結『%s』"
 
-#: fortran/decl.cc:12355
+#: fortran/decl.cc:12409
 #, gcc-internal-format
 msgid "The user operator at %L repeats the access specification of already defined user operator %qs"
 msgstr ""
 
-#: fortran/decl.cc:12391
+#: fortran/decl.cc:12445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected specific procedure name at %C"
 msgstr "預期的模組程序名稱於 %C"
 
-#: fortran/decl.cc:12398
+#: fortran/decl.cc:12452
 #, gcc-internal-format
 msgid "The name %qs of the specific procedure at %C conflicts with that of the generic-spec"
 msgstr ""
 
-#: fortran/decl.cc:12408
+#: fortran/decl.cc:12462
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as a specific procedure for the generic %qs at %C"
 msgstr "『%s』已經定義為特定的繫結用於通用『%s』於 %C"
 
-#: fortran/decl.cc:12434
+#: fortran/decl.cc:12488
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC statement at %C"
 msgstr "垃圾之後關聯敘述於 %C"
 
-#: fortran/decl.cc:12464
+#: fortran/decl.cc:12518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GENERIC at %C must be inside a derived-type CONTAINS"
 msgstr "通用於 %C 必須是內部衍生類型含有"
 
-#: fortran/decl.cc:12564
+#: fortran/decl.cc:12618
 #, fuzzy, gcc-internal-format
 msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
 msgstr "那裡『s 已經 non-generic 程序與繫結名稱 』%s『 用於衍生類型 』%s' 於 %C"
 
-#: fortran/decl.cc:12572
+#: fortran/decl.cc:12626
 #, fuzzy, gcc-internal-format
 msgid "Binding at %C must have the same access as already defined binding %qs"
 msgstr "繫結於 %C 必須有相同存取做為已經定義的繫結『%s』"
 
-#: fortran/decl.cc:12620
+#: fortran/decl.cc:12674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected specific binding name at %C"
 msgstr "預期的特定的繫結名稱於 %C"
 
-#: fortran/decl.cc:12630
+#: fortran/decl.cc:12684
 #, fuzzy, gcc-internal-format
 msgid "%qs already defined as specific binding for the generic %qs at %C"
 msgstr "『%s』已經定義為特定的繫結用於通用『%s』於 %C"
 
-#: fortran/decl.cc:12648
+#: fortran/decl.cc:12702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Junk after GENERIC binding at %C"
 msgstr "垃圾之後通用繫結於 %C"
 
-#: fortran/decl.cc:12694
+#: fortran/decl.cc:12748
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
 msgstr "最後的宣告於 %C 必須是內部衍生類型含有區段"
 
-#: fortran/decl.cc:12706
+#: fortran/decl.cc:12760
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
 msgstr "衍生類型宣告與最後的於 %C 必須是在中規格部分的模組"
 
-#: fortran/decl.cc:12728
+#: fortran/decl.cc:12782
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Empty FINAL at %C"
 msgstr "清空最後的於 %C"
 
-#: fortran/decl.cc:12735
+#: fortran/decl.cc:12789
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected module procedure name at %C"
 msgstr "預期的模組程序名稱於 %C"
 
-#: fortran/decl.cc:12745
+#: fortran/decl.cc:12799
 #, fuzzy, gcc-internal-format
 #| msgid "Expected \",\" at %C"
 msgid "Expected %<,%> at %C"
 msgstr "在 %C 處需要「,」"
 
-#: fortran/decl.cc:12751
+#: fortran/decl.cc:12805
 #, fuzzy, gcc-internal-format
 msgid "Unknown procedure name %qs at %C"
 msgstr "不明程序名稱「%s」於 %C"
 
-#: fortran/decl.cc:12764
+#: fortran/decl.cc:12818
 #, fuzzy, gcc-internal-format
 msgid "%qs at %C is already defined as FINAL procedure"
 msgstr "『%s』於 %C 已經定義為最後的程序！"
 
-#: fortran/decl.cc:12838
+#: fortran/decl.cc:12892
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
 msgstr "不明屬性在中！GCC $ 屬性敘述於 %C"
 
-#: fortran/decl.cc:12884
+#: fortran/decl.cc:12938
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
 msgstr "語法時發生錯誤！GCC $ 屬性敘述於 %C"
 
-#: fortran/decl.cc:12905
+#: fortran/decl.cc:12959
 #, gcc-internal-format
 msgid "%<GCC unroll%> directive requires a non-negative integral constant less than or equal to %u at %C"
 msgstr ""
 
-#: fortran/decl.cc:12919
+#: fortran/decl.cc:12973
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ UNROLL directive at %C"
 msgstr "%C 處 FORALL 迭代語法錯誤"
 
-#: fortran/decl.cc:12991
+#: fortran/decl.cc:13045
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ IVDEP directive at %C"
 msgstr "%C 處 FORALL 迭代語法錯誤"
 
-#: fortran/decl.cc:13008
+#: fortran/decl.cc:13062
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ VECTOR directive at %C"
 msgstr "%C 處 FORALL 迭代語法錯誤"
 
-#: fortran/decl.cc:13025
+#: fortran/decl.cc:13079
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Syntax error in FORALL iterator at %C"
 msgid "Syntax error in !GCC$ NOVECTOR directive at %C"
@@ -80286,419 +80451,419 @@ msgstr "Fortran 2008:IMPURE 程序於 %C"
 msgid "IM part_ref at %C"
 msgstr "Fortran 2008:IMPURE 程序於 %C"
 
-#: fortran/expr.cc:2777
+#: fortran/expr.cc:2780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "elemental function arguments at %C are not compliant"
 msgstr "elemental 函式引數於 %C 不是相容"
 
-#: fortran/expr.cc:2821
+#: fortran/expr.cc:2824
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Numeric or CHARACTER operands are required in expression at %L"
 msgstr "數值或字元運算元被必要項在中運算式於 %L"
 
-#: fortran/expr.cc:2846
+#: fortran/expr.cc:2849
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
 msgstr "串連運算子在中運算式於 %L 必須有兩字元運算元"
 
-#: fortran/expr.cc:2853
+#: fortran/expr.cc:2856
 #, gcc-internal-format, gfc-internal-format
 msgid "Concat operator at %L must concatenate strings of the same kind"
 msgstr "%L 處的粘貼運算子必須粘貼同一種別的字串"
 
-#: fortran/expr.cc:2863
+#: fortran/expr.cc:2866
 #, gcc-internal-format, gfc-internal-format
 msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
 msgstr "%L 處的運算式中的 .NOT. 運算子必須帶 LOGICAL 運算元"
 
-#: fortran/expr.cc:2879
+#: fortran/expr.cc:2882
 #, gcc-internal-format, gfc-internal-format
 msgid "LOGICAL operands are required in expression at %L"
 msgstr "%L 處的運算式需要 LOGICAL 運算元"
 
-#: fortran/expr.cc:2890
+#: fortran/expr.cc:2893
 #, gcc-internal-format, gfc-internal-format
 msgid "Only intrinsic operators can be used in expression at %L"
 msgstr "%L 處只有內建運算子才能用於運算式中"
 
-#: fortran/expr.cc:2898
+#: fortran/expr.cc:2901
 #, gcc-internal-format, gfc-internal-format
 msgid "Numeric operands are required in expression at %L"
 msgstr "%L 處的運算式需要數字運算元"
 
-#: fortran/expr.cc:2921
+#: fortran/expr.cc:2924
 #, fuzzy, gcc-internal-format
 msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
 msgstr "無效的初始化運算式用於 ALLOCATABLE 成分『%s』在中結構建構子於 %L"
 
-#: fortran/expr.cc:3058
+#: fortran/expr.cc:3061
 #, fuzzy, gcc-internal-format
 msgid "Assumed or deferred character length variable %qs in constant expression at %L"
 msgstr "假設的或已推遲字元長度變數『%s』 在中常數運算式於 %L"
 
-#: fortran/expr.cc:3142
+#: fortran/expr.cc:3145
 #, fuzzy, gcc-internal-format
 msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
 msgstr "transformational intrinsic『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3173
+#: fortran/expr.cc:3176
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of nonstandard initialization expression at %L"
 msgstr "延伸：求值的 nonstandard 初始化運算式於 %L"
 
-#: fortran/expr.cc:3264 fortran/resolve.cc:2915
+#: fortran/expr.cc:3267 fortran/resolve.cc:2945
 #, fuzzy, gcc-internal-format
 msgid "Function %qs in initialization expression at %L must be an intrinsic function"
 msgstr "函式『%s』在中初始化運算式於 %L 必須是內建函式"
 
-#: fortran/expr.cc:3276
+#: fortran/expr.cc:3279
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
 msgstr "內建函式『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3315
+#: fortran/expr.cc:3318
 #, fuzzy, gcc-internal-format
 msgid "PARAMETER %qs is used at %L before its definition is complete"
 msgstr "參數『%s』被使用於 %L 之前它的定義是完成"
 
-#: fortran/expr.cc:3335
+#: fortran/expr.cc:3338
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
 msgstr "假設的大小陣列『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3341
+#: fortran/expr.cc:3344
 #, fuzzy, gcc-internal-format
 msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
 msgstr "假設的形狀陣列『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3350
+#: fortran/expr.cc:3353
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape array %qs at %L is not permitted in an initialization expression"
 msgstr "假設的形狀陣列『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3354
+#: fortran/expr.cc:3357
 #, fuzzy, gcc-internal-format
 msgid "Deferred array %qs at %L is not permitted in an initialization expression"
 msgstr "已推遲陣列『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3360
+#: fortran/expr.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
 msgstr "陣列『%s』於 %L 是變數，該項不縮小到常數運算式"
 
-#: fortran/expr.cc:3366
+#: fortran/expr.cc:3369
 #, fuzzy, gcc-internal-format
 msgid "Assumed-rank array %qs at %L is not permitted in an initialization expression"
 msgstr "假設的形狀陣列『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/expr.cc:3376
+#: fortran/expr.cc:3379
 #, fuzzy, gcc-internal-format
 msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
 msgstr "參數『%s』於 %L 未被宣告的或是變數，該項不縮小到常數運算式"
 
-#: fortran/expr.cc:3430
+#: fortran/expr.cc:3433
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_init_expr(): Unknown expression type"
 msgstr "需要運算式類型"
 
-#: fortran/expr.cc:3570
+#: fortran/expr.cc:3573
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be a statement function"
 msgid "Specification function %qs at %L cannot be a statement function"
 msgstr "指定函式「%s」(位於 %L)不能是一個敘述函式"
 
-#: fortran/expr.cc:3577
+#: fortran/expr.cc:3580
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be an internal function"
 msgid "Specification function %qs at %L cannot be an internal function"
 msgstr "指定函式「%s」(位於 %L)不能是一個內部函式"
 
-#: fortran/expr.cc:3584
+#: fortran/expr.cc:3587
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L must be PURE"
 msgid "Specification function %qs at %L must be PURE"
 msgstr "指定函式「%s」(位於 %L)必須為 PURE"
 
-#: fortran/expr.cc:3592
+#: fortran/expr.cc:3595
 #, fuzzy, gcc-internal-format
 #| msgid "Specification function '%s' at %L cannot be RECURSIVE"
 msgid "Specification function %qs at %L cannot be RECURSIVE"
 msgstr "指定函式「%s」(位於 %L)不能是 RECURSIVE"
 
-#: fortran/expr.cc:3753
+#: fortran/expr.cc:3756
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs not allowed in expression at %L"
 msgstr "虛引數『%s』不允許在中運算式於 %L"
 
-#: fortran/expr.cc:3761
+#: fortran/expr.cc:3764
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
 msgid "Dummy argument %qs at %L cannot be OPTIONAL"
 msgstr "啞元「%s」(位於 %L)不能是 OPTIONAL"
 
-#: fortran/expr.cc:3768
+#: fortran/expr.cc:3771
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
 msgstr "「%s」啞元引數在 %L 處不能是 INTENT(OUT)"
 
-#: fortran/expr.cc:3790
+#: fortran/expr.cc:3793
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' cannot appear in the expression at %L"
 msgid "Variable %qs cannot appear in the expression at %L"
 msgstr "變數「%s」不能出現在 %L 處的運算式中"
 
-#: fortran/expr.cc:3821
+#: fortran/expr.cc:3824
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "check_restricted(): Unknown expression type"
 msgstr "需要運算式類型"
 
-#: fortran/expr.cc:3841
+#: fortran/expr.cc:3844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be of INTEGER type, found %s"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/expr.cc:3853
+#: fortran/expr.cc:3856
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L must be PURE"
 msgstr "函式『%s』於 %L 必須是 PURE"
 
-#: fortran/expr.cc:3862
+#: fortran/expr.cc:3865
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression at %L must be scalar"
 msgstr "%L 處的運算式必須具有標量類型"
 
 #. Reject truncation.
-#: fortran/expr.cc:3894
+#: fortran/expr.cc:3897
 #, gcc-internal-format, gfc-internal-format
 msgid "optype_msgid overflow: %d"
 msgstr ""
 
-#: fortran/expr.cc:3898
+#: fortran/expr.cc:3901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks in %s (%d and %d) at %L"
 msgstr "不相容的分級在中 %s (%d 和 %d) 於 %L"
 
-#: fortran/expr.cc:3912
+#: fortran/expr.cc:3915
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different shape for %s at %L on dimension %d (%d and %d)"
 msgstr "不同的形狀用於 %s 於 %L 於尺寸 %d (%d 和 %d)"
 
-#: fortran/expr.cc:3980
+#: fortran/expr.cc:3983
 #, fuzzy, gcc-internal-format
 #| msgid "using template type parameter %qT after %qs"
 msgid "Mismatched type parameters %qs(%d/%d) %s at %L/%L"
 msgstr "使用範本類型參數 %qT，在 %qs 後"
 
-#: fortran/expr.cc:4021
+#: fortran/expr.cc:4024
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a LEN or KIND part_ref at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4077
+#: fortran/expr.cc:4080
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a VALUE"
 msgstr "『%s』於 %L 並非值"
 
-#: fortran/expr.cc:4088
+#: fortran/expr.cc:4091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Illegal stride of zero at %L"
 msgid "Illegal assignment to external procedure at %L"
 msgstr "%L 零間隔無效"
 
-#: fortran/expr.cc:4096
+#: fortran/expr.cc:4099
 #, gcc-internal-format, gfc-internal-format
 msgid "Incompatible ranks %d and %d in assignment at %L"
 msgstr "賦值中有不相容的秩 %d 和 %d，位於 %L"
 
-#: fortran/expr.cc:4103
+#: fortran/expr.cc:4106
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable type is UNKNOWN in assignment at %L"
 msgstr "%L 處賦值中的變數類型是 UNKNOWN"
 
-#: fortran/expr.cc:4121
+#: fortran/expr.cc:4124
 #, gcc-internal-format, gfc-internal-format
 msgid "NULL appears on right-hand side in assignment at %L"
 msgstr "%L 處賦值右手邊出現 NULL"
 
-#: fortran/expr.cc:4131
+#: fortran/expr.cc:4134
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "POINTER-valued function appears on right-hand side of assignment at %L"
 msgstr "%L 處賦值右手邊出現值為 POINTER 的函式"
 
-#: fortran/expr.cc:4174
+#: fortran/expr.cc:4177
 #, gcc-internal-format
 msgid "BOZ literal constant near %L cannot be assigned to a %qs variable"
 msgstr ""
 
-#: fortran/expr.cc:4181
+#: fortran/expr.cc:4184
 #, gcc-internal-format, gfc-internal-format
 msgid "The assignment to a KIND or LEN component of a parameterized type at %L is not allowed"
 msgstr ""
 
-#: fortran/expr.cc:4218
+#: fortran/expr.cc:4221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
 msgstr "不相容的類型在中資料敘述於 %L; 試圖的轉換的 %s 到 %s"
 
-#: fortran/expr.cc:4262
+#: fortran/expr.cc:4265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is not a POINTER at %L"
 msgstr "指標指派目標並非指標於 %L"
 
-#: fortran/expr.cc:4270
+#: fortran/expr.cc:4273
 #, fuzzy, gcc-internal-format
 msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
 msgstr "『%s』在中指標指派於 %L 無法 l-value 自從它是程序"
 
-#: fortran/expr.cc:4294
+#: fortran/expr.cc:4297
 #, fuzzy, gcc-internal-format
 msgid "Expected bounds specification for %qs at %L"
 msgstr "預期的邊界規格用於『%s』於 %L"
 
-#: fortran/expr.cc:4299
+#: fortran/expr.cc:4302
 #, fuzzy, gcc-internal-format
 msgid "Bounds specification for %qs in pointer assignment at %L"
 msgstr "Fortran 2003:邊界規格用於『%s』在中指標指派於 %L"
 
-#: fortran/expr.cc:4328
+#: fortran/expr.cc:4331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stride must not be present at %L"
 msgstr "Stride 必須不都到位於 %L"
 
-#: fortran/expr.cc:4334 fortran/expr.cc:4354
+#: fortran/expr.cc:4337 fortran/expr.cc:4357
 #, gcc-internal-format
 msgid "Rank remapping requires a list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4342 fortran/expr.cc:4361
+#: fortran/expr.cc:4345 fortran/expr.cc:4364
 #, gcc-internal-format
 msgid "Expected list of %<lower-bound :%> or list of %<lower-bound : upper-bound%> specifications at %L"
 msgstr ""
 
-#: fortran/expr.cc:4388
+#: fortran/expr.cc:4391
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer object at %L shall not have a coindex"
 msgstr "指標物件於 %L 不應該有 coindex"
 
-#: fortran/expr.cc:4409
+#: fortran/expr.cc:4412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid procedure pointer assignment at %L"
 msgstr "無效的程序指標指派於 %L"
 
-#: fortran/expr.cc:4434
+#: fortran/expr.cc:4437
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
 msgstr "敘述函式『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:4443
+#: fortran/expr.cc:4446
 #, fuzzy, gcc-internal-format
 msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
 msgstr "摘要介面『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:4453
+#: fortran/expr.cc:4456
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
 msgstr "敘述函式『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:4459
+#: fortran/expr.cc:4462
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "內部程序『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:4466
+#: fortran/expr.cc:4469
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
 msgstr "內部程序『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:4474
+#: fortran/expr.cc:4477
 #, fuzzy, gcc-internal-format
 msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
 msgstr "Nonintrinsic elemental 程序『%s』無效在中程序指標 assigment 於 %L"
 
-#: fortran/expr.cc:4497
+#: fortran/expr.cc:4500
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
 msgstr "不匹配在中程序指標指派於 %L:不匹配在中呼叫慣例"
 
-#: fortran/expr.cc:4550
+#: fortran/expr.cc:4553
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %qs is not a subroutine"
 msgstr "介面不匹配在中程序指標指派於 %L:%s"
 
-#: fortran/expr.cc:4560 fortran/expr.cc:4575
+#: fortran/expr.cc:4563 fortran/expr.cc:4578
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for component %qs at %L: %s"
 msgstr "關鍵字引數需求明確的介面用於程序指標成分『%s』於 %L"
 
-#: fortran/expr.cc:4566 fortran/expr.cc:4581 fortran/resolve.cc:2789
+#: fortran/expr.cc:4569 fortran/expr.cc:4584 fortran/resolve.cc:2819
 #, fuzzy, gcc-internal-format
 msgid "Explicit interface required for %qs at %L: %s"
 msgstr "NOPASS 或明確的介面必要項於 %C"
 
-#: fortran/expr.cc:4593
+#: fortran/expr.cc:4596
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Interface mismatch in procedure pointer assignment at %L: %s"
 msgstr "介面不匹配在中程序指標指派於 %L:%s"
 
-#: fortran/expr.cc:4602
+#: fortran/expr.cc:4605
 #, gcc-internal-format
 msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or use associated, referenced or have the EXTERNAL attribute"
 msgstr ""
 
-#: fortran/expr.cc:4615
+#: fortran/expr.cc:4618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target cannot be a constant at %L"
 msgstr "指標指派目標並非指標於 %L"
 
-#: fortran/expr.cc:4629
+#: fortran/expr.cc:4632
 #, gcc-internal-format, gfc-internal-format
 msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
 msgstr ""
 
-#: fortran/expr.cc:4634
+#: fortran/expr.cc:4637
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
 msgstr "不同的類型在中指標指派於 %L; 試圖的指派的 %s 到 %s"
 
-#: fortran/expr.cc:4642
+#: fortran/expr.cc:4645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Different kind type parameters in pointer assignment at %L"
 msgstr "不同的 kind 型態參數在中指標指派於 %L"
 
-#: fortran/expr.cc:4650
+#: fortran/expr.cc:4653
 #, gcc-internal-format, gfc-internal-format
 msgid "Different ranks in pointer assignment at %L"
 msgstr "%L 處指標賦值時秩不同"
 
-#: fortran/expr.cc:4671
+#: fortran/expr.cc:4674
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
 msgstr "分級重新映射目標是小於大小的指標 (%ld<%ld) 於 %L"
 
-#: fortran/expr.cc:4687
+#: fortran/expr.cc:4690
 #, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank target at %L is an experimental F202y feature. Use option -std=f202y to enable"
 msgstr ""
 
-#: fortran/expr.cc:4699
+#: fortran/expr.cc:4702
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
 msgstr "分級重新映射目標必須是分級 1 或僅需 contiguous 於 %L"
 
-#: fortran/expr.cc:4703
+#: fortran/expr.cc:4706
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rank remapping target is not rank 1 at %L"
 msgstr "Fortran 2008:分級重新映射目標不是分級 1 於 %L"
 
-#: fortran/expr.cc:4710
+#: fortran/expr.cc:4713
 #, gcc-internal-format, gfc-internal-format
 msgid "The data-target at %L is an assumed rank object and so the data-pointer-object %s must have a bounds remapping list (list of lbound:ubound for each dimension)"
 msgstr ""
 
-#: fortran/expr.cc:4719
+#: fortran/expr.cc:4722
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The assumed rank data-target at %L must be contiguous"
 msgstr "資料目標於 %L 不應該有 coindex"
@@ -80706,197 +80871,197 @@ msgstr "資料目標於 %L 不應該有 coindex"
 #. The test above might need to be extend when F08, Note 5.4 has to be
 #. interpreted in the way that target and pointer with the same coindex
 #. are allowed.
-#: fortran/expr.cc:4743 fortran/expr.cc:4869
+#: fortran/expr.cc:4746 fortran/expr.cc:4872
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data target at %L shall not have a coindex"
 msgstr "資料目標於 %L 不應該有 coindex"
 
-#: fortran/expr.cc:4746
+#: fortran/expr.cc:4749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Target expression in pointer assignment at %L must deliver a pointer result"
 msgstr "目標運算式在中指標指派於 %L 必須投遞指標結果"
 
-#: fortran/expr.cc:4760
+#: fortran/expr.cc:4763
 #, gcc-internal-format, gfc-internal-format
 msgid "Zero-sized array detected at %L where an entity with the TARGET attribute is expected"
 msgstr ""
 
-#: fortran/expr.cc:4766 fortran/expr.cc:4781
+#: fortran/expr.cc:4769 fortran/expr.cc:4784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target in initialization expression does not have the TARGET attribute at %L"
 msgstr "指標初始化目標於 %C 必須有目標屬性"
 
-#: fortran/expr.cc:4797
+#: fortran/expr.cc:4800
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Every subscript of target specification at %L must be a constant expression"
 msgstr "非同步=說明符於 %L 必須是初始化運算式"
 
-#: fortran/expr.cc:4808
+#: fortran/expr.cc:4811
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring starting and ending points of target specification at %L must be constant expressions"
 msgstr ""
 
-#: fortran/expr.cc:4824
+#: fortran/expr.cc:4827
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
 msgstr "指標指派目標是 neither 目標 nor 指標於 %L"
 
-#: fortran/expr.cc:4839
+#: fortran/expr.cc:4842
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad target in pointer assignment in PURE procedure at %L"
 msgstr "不當的目標在中指標指派在中 PURE 程序於 %L"
 
-#: fortran/expr.cc:4848
+#: fortran/expr.cc:4851
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment with vector subscript on rhs at %L"
 msgstr "指標指派與向量註標於 rhs 於 %L"
 
-#: fortran/expr.cc:4856
+#: fortran/expr.cc:4859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target has PROTECTED attribute at %L"
 msgstr "指標指派目標有保護的屬性於 %L"
 
-#: fortran/expr.cc:4884 fortran/expr.cc:4889
+#: fortran/expr.cc:4887 fortran/expr.cc:4892
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to contiguous pointer from non-contiguous target at %L"
 msgstr ""
 
-#: fortran/expr.cc:4929
+#: fortran/expr.cc:4932
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer at %L in pointer assignment might outlive the pointer target"
 msgstr "目標運算式在中指標指派於 %L 必須投遞指標結果"
 
-#: fortran/expr.cc:4987
+#: fortran/expr.cc:4990
 #, gcc-internal-format
 msgid "The component %qs at %L of derived type %qs has paramterized type or array length parameters, which is not compatible with a default initializer"
 msgstr ""
 
-#: fortran/expr.cc:5055 fortran/resolve.cc:1574
+#: fortran/expr.cc:5058 fortran/resolve.cc:1599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must not be ALLOCATABLE"
 msgstr "指標初始化目標於 %L 必須不是 ALLOCATABLE "
 
-#: fortran/expr.cc:5061
+#: fortran/expr.cc:5064
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the TARGET attribute"
 msgstr "指標初始化目標於 %C 必須有目標屬性"
 
-#: fortran/expr.cc:5076 fortran/resolve.cc:1580
+#: fortran/expr.cc:5079 fortran/resolve.cc:1605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer initialization target at %L must have the SAVE attribute"
 msgstr "指標初始化目標於 %L 必須有儲存屬性"
 
-#: fortran/expr.cc:5088
+#: fortran/expr.cc:5091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
 msgstr "程序指標初始化目標於 %L 可能無法是程序指標"
 
-#: fortran/expr.cc:5094
+#: fortran/expr.cc:5097
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "內部程序『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:5101
+#: fortran/expr.cc:5104
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs is invalid in procedure pointer initialization at %L"
 msgstr "內部程序『%s』無效在中程序指標指派於 %L"
 
-#: fortran/expr.cc:5585
+#: fortran/expr.cc:5588
 #, gcc-internal-format
 msgid "generate_isocbinding_initializer(): bad iso_c_binding type, expected %<c_ptr%> or %<c_funptr%>"
 msgstr ""
 
-#: fortran/expr.cc:6738
+#: fortran/expr.cc:6741
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
 msgstr "Fortran 2008:指標函式在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6746
+#: fortran/expr.cc:6749
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-variable expression in variable definition context (%s) at %L"
 msgstr "Non-variable 運算式在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6754
+#: fortran/expr.cc:6757
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs in variable definition context (%s) at %L"
 msgstr "具名的常數『%s』在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6765
+#: fortran/expr.cc:6768
 #, fuzzy, gcc-internal-format
 msgid "%qs in variable definition context (%s) at %L is not a variable"
 msgstr "『%s』在中變數定義語境 (%s) 於 %L 並非變數"
 
-#: fortran/expr.cc:6776
+#: fortran/expr.cc:6779
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-POINTER in pointer association context (%s) at %L"
 msgstr "Non-POINTER 在中指標關聯語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6785
+#: fortran/expr.cc:6788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type inaccessible in variable definition context (%s) at %L"
 msgstr "具名的常數『%s』在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6798
+#: fortran/expr.cc:6801
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_TYPE in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE 在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6811
+#: fortran/expr.cc:6814
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "LOCK_EVENT in variable definition context (%s) at %L"
 msgstr "LOCK_TYPE 在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6845
+#: fortran/expr.cc:6848
 #, fuzzy, gcc-internal-format
 msgid "%qs parameter inquiry for %qs in variable definition context (%s) at %L"
 msgstr "具名的常數『%s』在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6891
+#: fortran/expr.cc:6894
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
 msgstr "虛引數『%s』與含義 (在中) 在中指標關聯語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6899
+#: fortran/expr.cc:6902
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
 msgstr "虛引數『%s』與含義 (在中) 在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6916
+#: fortran/expr.cc:6919
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a pointer association context (%s) at %L"
 msgstr "變數『%s』是保護的和無法出現在中指標關聯語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6924
+#: fortran/expr.cc:6927
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is PROTECTED and cannot appear in a variable definition context (%s) at %L"
 msgstr "變數『%s』是保護的和無法出現在中變數定義語境 (%s) 於 %L"
 
-#: fortran/expr.cc:6939
+#: fortran/expr.cc:6942
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs cannot appear in a variable definition context (%s) at %L in PURE procedure"
 msgstr "變數『%s』無法出現在中變數定義語境 (%s) 於 %L 在中 PURE 程序"
 
-#: fortran/expr.cc:7000 fortran/expr.cc:7021
+#: fortran/expr.cc:7003 fortran/expr.cc:7024
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to vector-indexed target cannot be used in a variable definition context (%s)"
 msgstr "『%s』於 %L 關聯的到 vector-indexed 目標無法已用於變數定義語境 (%s)"
 
-#: fortran/expr.cc:7005
+#: fortran/expr.cc:7008
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to expression cannot be used in a variable definition context (%s)"
 msgstr "『%s』於 %L 關聯的到運算式無法已用於變數定義語境 (%s)"
 
-#: fortran/expr.cc:7014
+#: fortran/expr.cc:7017
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L associated to pointer function target being used in a variable definition context (%s)"
 msgstr "『%s』於 %L 關聯的到運算式無法已用於變數定義語境 (%s)"
 
-#: fortran/expr.cc:7035
+#: fortran/expr.cc:7038
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs cannot appear in a variable definition context (%s) at %L because its target at %L cannot, either"
 msgstr "Associate-name『%s』無法出現在中變數定義語境 (%s) 於 %L 因為它的目標於 %L 無法，還是"
 
-#: fortran/expr.cc:7077
+#: fortran/expr.cc:7080
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
 msgstr "『%s』於 %L 關聯的到運算式無法已用於變數定義語境 (%s)"
@@ -80917,7 +81082,7 @@ msgid "Illegal id in copy_walk_reduction_arg"
 msgstr ""
 
 #: fortran/frontend-passes.cc:874 fortran/trans-array.cc:1545
-#: fortran/trans-array.cc:7709 fortran/trans-array.cc:9537
+#: fortran/trans-array.cc:7745 fortran/trans-array.cc:9573
 #: fortran/trans-intrinsic.cc:8803
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Creating array temporary at %L"
@@ -80979,42 +81144,42 @@ msgstr "變數『%s』於 %C 無法重新定義的內部迴圈起始部分於 %L
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
 msgstr "變數『%s』於 %C 無法重新定義的內部迴圈起始部分於 %L"
 
-#: fortran/frontend-passes.cc:2893 fortran/frontend-passes.cc:2919
+#: fortran/frontend-passes.cc:2958 fortran/frontend-passes.cc:2984
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L"
 msgstr "陣列參照於 %L 是超出邊界 (%ld<%ld) 在中 codimension %d"
 
-#: fortran/frontend-passes.cc:2903 fortran/frontend-passes.cc:2929
+#: fortran/frontend-passes.cc:2968 fortran/frontend-passes.cc:2994
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L"
 msgstr "陣列參照於 %L 是超出邊界 (%ld>%ld) 在中 codimension %d"
 
-#: fortran/frontend-passes.cc:3021
+#: fortran/frontend-passes.cc:3086
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
 msgstr "變數『%s』於 %C 無法重新定義的內部迴圈起始部分於 %L"
 
-#: fortran/frontend-passes.cc:3027
+#: fortran/frontend-passes.cc:3092
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
 msgstr "變數『%s』於 %C 無法重新定義的內部迴圈起始部分於 %L"
 
-#: fortran/frontend-passes.cc:3443 fortran/trans-expr.cc:2102
+#: fortran/frontend-passes.cc:3508 fortran/trans-expr.cc:2102
 #, gcc-internal-format, gfc-internal-format
 msgid "Code for reallocating the allocatable array at %L will be added"
 msgstr ""
 
-#: fortran/frontend-passes.cc:3968
+#: fortran/frontend-passes.cc:4033
 #, gcc-internal-format
 msgid "Scalarization using DIMEN_RANGE unimplemented"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5185
+#: fortran/frontend-passes.cc:5250
 #, gcc-internal-format, gfc-internal-format
 msgid "Interchanging loops at %L"
 msgstr ""
 
-#: fortran/frontend-passes.cc:5843
+#: fortran/frontend-passes.cc:5908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s between %L and %L"
 msgstr "比較介於 %qT 和 %qT"
@@ -81143,12 +81308,12 @@ msgstr "第一個引數的定義的指派於 %L 必須是含義 (出) 或含義
 msgid "Second argument of defined assignment at %L must be INTENT(IN)"
 msgstr "%L 處定義賦值的第二個參數必須是 INTENT(IN)"
 
-#: fortran/interface.cc:1064 fortran/resolve.cc:20098
+#: fortran/interface.cc:1064 fortran/resolve.cc:20232
 #, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L must be INTENT(IN)"
 msgstr "%L 處運算子介面的第一個參數必須是 INTENT(IN)"
 
-#: fortran/interface.cc:1071 fortran/resolve.cc:20116
+#: fortran/interface.cc:1071 fortran/resolve.cc:20250
 #, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L must be INTENT(IN)"
 msgstr "%L 處運算子介面的第二個參數必須是 INTENT(IN)"
@@ -81578,315 +81743,320 @@ msgstr "實際引數用於『%s』必須是 ALLOCATABLE 於 %L"
 msgid "Actual argument for %qs at %L is a function result and the dummy argument is ALLOCATABLE"
 msgstr ""
 
-#: fortran/interface.cc:4063
+#: fortran/interface.cc:4072
 #, fuzzy, gcc-internal-format
 msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
 msgstr "Array-section 實際引數與向量註標於 %L 是不相容的與含義 (出)，含義 (INOUT)，易變的或非同步屬性的虛引數『%s』"
 
-#: fortran/interface.cc:4083
+#: fortran/interface.cc:4092
 #, fuzzy, gcc-internal-format
 msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Assumed-shape 實際引數於 %L 是不相容的與 non-assumed-shape 虛引數『%s』由於易變的屬性"
 
-#: fortran/interface.cc:4101
+#: fortran/interface.cc:4110
 #, fuzzy, gcc-internal-format
 msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
 msgstr "Array-section 實際引數於 %L 是不相容的與 non-assumed-shape 虛引數『%s』由於易變的屬性"
 
-#: fortran/interface.cc:4122
+#: fortran/interface.cc:4131
 #, fuzzy, gcc-internal-format
 msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
 msgstr "Pointer-array 實際引數於 %L 需求 assumed-shape 或 pointer-array 虛引數『%s』由於易變的屬性"
 
-#: fortran/interface.cc:4150
+#: fortran/interface.cc:4153
+#, fuzzy, gcc-internal-format
+msgid "ISO_C_BINDING function actual argument at %L requires dummy argument %qs to have a matching type from ISO_C_BINDING"
+msgstr "假定外形的陣列在 %L 處必須是啞引數"
+
+#: fortran/interface.cc:4181
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Missing alternate return spec in subroutine call at %L"
 msgstr "缺少交替回傳 spec 在中副常式呼叫於 %L"
 
-#: fortran/interface.cc:4163
+#: fortran/interface.cc:4194
 #, fuzzy, gcc-internal-format
 #| msgid "Missing actual argument for argument '%s' at %L"
 msgid "Missing actual argument for argument %qs at %L"
 msgstr "參數「%s」在 %L 處缺少引數"
 
-#: fortran/interface.cc:4291
+#: fortran/interface.cc:4322
 #, gcc-internal-format
 msgid "compare_actual_expr(): Bad component code"
 msgstr ""
 
-#: fortran/interface.cc:4320
+#: fortran/interface.cc:4351
 #, gcc-internal-format
 msgid "check_some_aliasing(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4346
+#: fortran/interface.cc:4377
 #, gcc-internal-format
 msgid "check_some_aliasing(): corrupted data"
 msgstr ""
 
-#: fortran/interface.cc:4356
+#: fortran/interface.cc:4387
 #, fuzzy, gcc-internal-format
 msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
 msgstr "相同實際引數關聯的與含義 (%s) 引數『%s』和含義 (%s) 引數『%s』於 %L"
 
-#: fortran/interface.cc:4386
+#: fortran/interface.cc:4417
 #, gcc-internal-format
 msgid "check_intents(): List mismatch"
 msgstr ""
 
-#: fortran/interface.cc:4406
+#: fortran/interface.cc:4437
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
 msgstr "程序引數於 %L 是本地到 PURE 程序和有指標屬性"
 
-#: fortran/interface.cc:4418
+#: fortran/interface.cc:4449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
 msgstr "Coindexed 實際引數於 %L 在中 PURE 程序被傳遞到含義 (%s) 引數"
 
-#: fortran/interface.cc:4428
+#: fortran/interface.cc:4459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
 msgstr "Coindexed 實際引數於 %L 在中 PURE 程序被傳遞到指標虛引數"
 
-#: fortran/interface.cc:4439
+#: fortran/interface.cc:4470
 #, fuzzy, gcc-internal-format
 msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
 msgstr "Coindexed polymorphic 實際引數於 %L 被傳遞 polymorphic 虛引數『%s』"
 
-#: fortran/interface.cc:4481
+#: fortran/interface.cc:4512
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared; did you mean %qs?"
 msgstr "程序『%s』called 於 %L 不是明確的宣告"
 
-#: fortran/interface.cc:4485 fortran/interface.cc:4495
+#: fortran/interface.cc:4516 fortran/interface.cc:4526
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs called at %L is not explicitly declared"
 msgstr "程序『%s』called 於 %L 不是明確的宣告"
 
-#: fortran/interface.cc:4491
+#: fortran/interface.cc:4522
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' called with an implicit interface at %L"
 msgid "Procedure %qs called with an implicit interface at %L"
 msgstr "呼叫程序「%s」帶隱含介面，位於 %L"
 
-#: fortran/interface.cc:4504
+#: fortran/interface.cc:4535
 #, fuzzy, gcc-internal-format
 msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "指標物件『%s』於 %L 必須有明確的函式介面或被宣告做為陣列"
 
-#: fortran/interface.cc:4512
+#: fortran/interface.cc:4543
 #, fuzzy, gcc-internal-format
 msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
 msgstr "allocatable 物件『%s』於 %L 必須有明確的函式介面或被宣告做為陣列"
 
-#: fortran/interface.cc:4520
+#: fortran/interface.cc:4551
 #, fuzzy, gcc-internal-format
 msgid "Allocatable function %qs at %L must have an explicit function interface"
 msgstr "Allocatable 函式『%s』於 %L 必須有明確的函式介面"
 
-#: fortran/interface.cc:4537
+#: fortran/interface.cc:4568
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Explicit interface required for polymorphic argument at %L"
 msgstr "關鍵字引數需求明確的介面用於程序指標成分『%s』於 %L"
 
-#: fortran/interface.cc:4546
+#: fortran/interface.cc:4577
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure %qs at %L"
 msgstr "關鍵字引數需求明確的介面用於程序『%s』於 %L"
 
-#: fortran/interface.cc:4555
+#: fortran/interface.cc:4586
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type argument %s at %L requires an explicit interface"
 msgstr "符號「%s」在 %L 處已經有了明確介面"
 
-#: fortran/interface.cc:4570
+#: fortran/interface.cc:4601
 #, fuzzy, gcc-internal-format
 msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "實際引數的 LOCK_TYPE 或與 LOCK_TYPE 成分於 %L 需求明確的介面用於程序『%s』"
 
-#: fortran/interface.cc:4585
+#: fortran/interface.cc:4616
 #, fuzzy, gcc-internal-format
 msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
 msgstr "實際引數的 LOCK_TYPE 或與 LOCK_TYPE 成分於 %L 需求明確的介面用於程序『%s』"
 
-#: fortran/interface.cc:4595
+#: fortran/interface.cc:4626
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MOLD argument to NULL required at %L"
 msgstr "鑄型引數到空值必要項於 %L"
 
-#: fortran/interface.cc:4603
+#: fortran/interface.cc:4634
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passing intrinsic NULL as actual argument at %L requires an explicit interface"
 msgstr "符號「%s」在 %L 處已經有了明確介面"
 
-#: fortran/interface.cc:4613
+#: fortran/interface.cc:4644
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank argument requires an explicit interface at %L"
 msgstr "關鍵字引數需求明確的介面用於程序『%s』於 %L"
 
-#: fortran/interface.cc:4655
+#: fortran/interface.cc:4686
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs called with an implicit interface at %L"
 msgstr "程序指標成分『%s』called 與隱含的介面於 %L"
 
-#: fortran/interface.cc:4666
+#: fortran/interface.cc:4697
 #, fuzzy, gcc-internal-format
 msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
 msgstr "關鍵字引數需求明確的介面用於程序指標成分『%s』於 %L"
 
-#: fortran/interface.cc:4751
+#: fortran/interface.cc:4782
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
 msgstr "鑄型=必要項在中空值() 引數於 %L:模稜兩可介於特定的函式 %s 和 %s"
 
-#: fortran/interface.cc:4821
+#: fortran/interface.cc:4852
 #, fuzzy, gcc-internal-format
 msgid "Unable to find symbol %qs"
 msgstr "%q+D 別名到未定義的符號 %qE"
 
-#: fortran/interface.cc:5216
+#: fortran/interface.cc:5247
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L is already present in the interface"
 msgstr "實體『%s』於 %C 已經呈現在中介面"
 
-#: fortran/interface.cc:5333
+#: fortran/interface.cc:5364
 #, gcc-internal-format
 msgid "gfc_add_interface(): Bad interface type"
 msgstr ""
 
-#: fortran/interface.cc:5427
+#: fortran/interface.cc:5458
 #, fuzzy, gcc-internal-format
 msgid "Cannot overwrite GENERIC %qs at %L"
 msgstr "無法覆寫通用『%s』於 %L"
 
-#: fortran/interface.cc:5439
+#: fortran/interface.cc:5470
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
 msgstr "『%s』於 %L 強制變更程序繫結宣告 NON_OVERRIDABLE"
 
-#: fortran/interface.cc:5447
+#: fortran/interface.cc:5478
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
 msgstr "『%s』於 %L 必須不是已推遲做為它強制變更 non-DEFERRED 繫結"
 
-#: fortran/interface.cc:5455
+#: fortran/interface.cc:5486
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a PURE procedure and must also be PURE"
 msgstr "『%s』於 %L 強制變更 PURE 程序且須也是 PURE"
 
-#: fortran/interface.cc:5464
+#: fortran/interface.cc:5495
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
 msgstr "『%s』於 %L 強制變更 ELEMENTAL 程序且須也是 ELEMENTAL"
 
-#: fortran/interface.cc:5470
+#: fortran/interface.cc:5501
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
 msgstr "『%s』於 %L 強制變更 non-ELEMENTAL 程序且須無法是 ELEMENTAL，還是"
 
-#: fortran/interface.cc:5479
+#: fortran/interface.cc:5510
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
 msgstr "『%s』於 %L 強制變更副常式且須也是副常式"
 
-#: fortran/interface.cc:5490
+#: fortran/interface.cc:5521
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
 msgstr "『%s』於 %L 強制變更函式且須也是函式"
 
-#: fortran/interface.cc:5498
+#: fortran/interface.cc:5529
 #, fuzzy, gcc-internal-format
 msgid "Result mismatch for the overriding procedure %qs at %L: %s"
 msgstr "引數不匹配用於強迫程序『%s』於 %L:%s"
 
-#: fortran/interface.cc:5509
+#: fortran/interface.cc:5540
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
 msgstr "『%s』於 %L 強制變更公用的程序且須無法是私人的"
 
-#: fortran/interface.cc:5539
+#: fortran/interface.cc:5570
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
 msgstr "虛引數『%s』的『%s』於 %L 應該被具名的『%s』做為到匹配相應引數的 overridden 程序"
 
-#: fortran/interface.cc:5550
+#: fortran/interface.cc:5581
 #, fuzzy, gcc-internal-format
 msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
 msgstr "引數不匹配用於強迫程序『%s』於 %L:%s"
 
-#: fortran/interface.cc:5559
+#: fortran/interface.cc:5590
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
 msgstr "『%s』於 %L 必須有相同形式引數數量做為 overridden 程序"
 
-#: fortran/interface.cc:5568
+#: fortran/interface.cc:5599
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
 msgstr "『%s』於 %L 強制變更 NOPASS 繫結且須也是 NOPASS"
 
-#: fortran/interface.cc:5579
+#: fortran/interface.cc:5610
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L overrides a binding with PASS and must also be PASS"
 msgstr "『%s』於 %L 強制變更繫結與回合且須也是回合"
 
-#: fortran/interface.cc:5586
+#: fortran/interface.cc:5617
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
 msgstr "Passed-object 虛引數的『%s』於 %L 必須是於相同位置做為 passed-object 虛引數的 overridden 程序"
 
-#: fortran/interface.cc:5607
+#: fortran/interface.cc:5638
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "%s tag at %L must be of type %s"
 msgid "DTIO dummy argument at %L must be of type %s"
 msgstr "%s 標記在 %L 處必須具有類型 %s"
 
-#: fortran/interface.cc:5614
+#: fortran/interface.cc:5645
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be of INTEGER type"
 msgid "DTIO dummy argument at %L must be of KIND = %d"
 msgstr "%L 處引數維數必須具有 INTEGER 類型"
 
-#: fortran/interface.cc:5621
+#: fortran/interface.cc:5652
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "DTIO dummy argument at %L must be a scalar"
 msgstr "%L 引數維數必須是標量"
 
-#: fortran/interface.cc:5625
+#: fortran/interface.cc:5656
 #, gcc-internal-format, gfc-internal-format
 msgid "DTIO dummy argument at %L must be an ASSUMED SHAPE ARRAY"
 msgstr ""
 
-#: fortran/interface.cc:5629
+#: fortran/interface.cc:5660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO character argument at %L must have assumed length"
 msgstr "Character-valued %s『%s』於 %L 必須不被假設長度"
 
-#: fortran/interface.cc:5633
+#: fortran/interface.cc:5664
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
 msgid "DTIO dummy argument at %L must have INTENT %s"
 msgstr "「%s」啞元引數在 %L 處不能是 INTENT(OUT)"
 
-#: fortran/interface.cc:5691 fortran/interface.cc:5737
+#: fortran/interface.cc:5722 fortran/interface.cc:5768
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "DATA statement at %C is not allowed in a PURE procedure"
 msgid "Alternate return at %L is not permitted in a DTIO procedure"
 msgstr "DATA 敘述不允許出現在 %C 處的 PURE 程序中"
 
-#: fortran/interface.cc:5703
+#: fortran/interface.cc:5734
 #, fuzzy, gcc-internal-format
 msgid "DTIO procedure %qs at %L must be a subroutine"
 msgstr "ELEMENTAL 程序『%s』於 %L 必須有明確的介面"
 
-#: fortran/interface.cc:5715
+#: fortran/interface.cc:5746
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too few dummy arguments in DTIO procedure %qs at %L"
 msgstr "對「%s」的呼叫給出的參數太多，於 %L 處"
 
-#: fortran/interface.cc:5722
+#: fortran/interface.cc:5753
 #, fuzzy, gcc-internal-format
 #| msgid "Too many arguments in call to '%s' at %L"
 msgid "Too many dummy arguments in DTIO procedure %qs at %L"
@@ -82084,7 +82254,7 @@ msgstr "從 %s 轉換到 %s，位於 %L"
 #. Use of -fdec-char-conversions allows assignment of character data
 #. to non-character variables.  This not permitted for nonconstant
 #. strings.
-#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13050
+#: fortran/intrinsic.cc:5654 fortran/resolve.cc:13128
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot convert %s to %s at %L"
@@ -82640,7 +82810,7 @@ msgstr "名稱表列『%s』在中讀取敘述於 %L 含有符號『%s』該項
 msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
 msgstr "名稱表列物件『%s』在中名稱表列『%s』於 %L 是 polymorphic 和需要定義的輸入/輸出程序"
 
-#: fortran/io.cc:3423 fortran/resolve.cc:17850
+#: fortran/io.cc:3423 fortran/resolve.cc:17981
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
 msgstr "Fortran 2003:名稱表列物件『%s』在中名稱表列『%s』於 %L 與 ALLOCATABLE 或指標成分"
@@ -82819,12 +82989,12 @@ msgstr "整數溢出"
 msgid "check_charlen_present(): length not set"
 msgstr ""
 
-#: fortran/iresolve.cc:3235
+#: fortran/iresolve.cc:3258
 #, gcc-internal-format, gfc-internal-format
 msgid "GET_TEAM at %L needs USE of the intrinsic module ISO_FORTRAN_ENV to define its result type TEAM_TYPE"
 msgstr ""
 
-#: fortran/iresolve.cc:3366
+#: fortran/iresolve.cc:3389
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: unlimited polymorphic MOLD in TRANSFER intrinsic at %L"
 msgstr ""
@@ -83341,7 +83511,7 @@ msgstr "停止編碼於 %L 必須是預設字元 KIND=%d"
 msgid "STOP code at %L must be default integer KIND=%d"
 msgstr "停止編碼於 %L 必須是預設整數 KIND=%d"
 
-#: fortran/match.cc:3821 fortran/resolve.cc:14180
+#: fortran/match.cc:3821 fortran/resolve.cc:14300
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "QUIET specifier at %L must be a scalar LOGICAL"
 msgstr "非同步=說明符於 %L 必須是初始化運算式"
@@ -83861,95 +84031,95 @@ msgstr "預期的區塊名稱『%s』的選取建構於 %C"
 msgid "SELECT TYPE at %C cannot appear in this scope"
 msgstr "%C 處的 ENTRY 敘述不能出現在巢狀的子程式中"
 
-#: fortran/match.cc:7524
+#: fortran/match.cc:7529
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT TYPE statement at %C"
 msgstr "語法時發生錯誤保護的敘述於 %C"
 
-#: fortran/match.cc:7549
+#: fortran/match.cc:7554
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
 msgstr "選擇器在中選取型態於 %C 並非具名的變數；使用 associate-name=>"
 
-#: fortran/match.cc:7737
+#: fortran/match.cc:7742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SELECT RANK statement at %C"
 msgstr "Fortran 2008:鎖定敘述於 %C"
 
-#: fortran/match.cc:7778 fortran/match.cc:7832
+#: fortran/match.cc:7783 fortran/match.cc:7837
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "The SELECT RANK selector at %C must be an assumed rank variable"
 msgstr "%C 處的 STAT 運算式必須是一個變數"
 
-#: fortran/match.cc:7842
+#: fortran/match.cc:7847
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "parse error in SELECT RANK statement at %C"
 msgstr "語法時發生錯誤保護的敘述於 %C"
 
-#: fortran/match.cc:7878
+#: fortran/match.cc:7883
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected CASE statement at %C"
 msgstr "%C 處非預期的 CASE 敘述"
 
-#: fortran/match.cc:7930
+#: fortran/match.cc:7935
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CASE specification at %C"
 msgstr "語法時發生錯誤大小寫規格於 %C"
 
-#: fortran/match.cc:7948
+#: fortran/match.cc:7953
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unexpected TYPE IS statement at %C"
 msgstr "未預期的型態是敘述於 %C"
 
-#: fortran/match.cc:7980
+#: fortran/match.cc:7985
 #, gcc-internal-format, gfc-internal-format
 msgid "The type-spec shall not specify a sequence derived type or a type with the BIND attribute in SELECT TYPE at %C [F2003:C815]"
 msgstr ""
 
-#: fortran/match.cc:7989
+#: fortran/match.cc:7994
 #, gcc-internal-format, gfc-internal-format
 msgid "All the LEN type parameters in the TYPE IS statement at %C must be ASSUMED"
 msgstr ""
 
-#: fortran/match.cc:8002
+#: fortran/match.cc:8007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in TYPE IS specification at %C"
 msgstr "語法時發生錯誤型態是規格於 %C"
 
-#: fortran/match.cc:8078
+#: fortran/match.cc:8083
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in CLASS IS specification at %C"
 msgstr "語法時發生錯誤類別是規格於 %C"
 
-#: fortran/match.cc:8098
+#: fortran/match.cc:8103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Unexpected END statement at %C"
 msgid "Unexpected RANK statement at %C"
 msgstr "%C 處非預期的 END 敘述"
 
-#: fortran/match.cc:8144
+#: fortran/match.cc:8149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "STAT expression at %C must be a variable"
 msgid "The SELECT RANK CASE expression at %C must be a scalar, integer constant"
 msgstr "%C 處的 STAT 運算式必須是一個變數"
 
-#: fortran/match.cc:8153
+#: fortran/match.cc:8158
 #, gcc-internal-format, gfc-internal-format
 msgid "The value of the SELECT RANK CASE expression at %C must not be less than zero or greater than %d"
 msgstr ""
 
-#: fortran/match.cc:8180
+#: fortran/match.cc:8185
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in RANK specification at %C"
 msgstr "語法時發生錯誤大小寫規格於 %C"
 
-#: fortran/match.cc:8302
+#: fortran/match.cc:8307
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
 msgstr "其他情況下敘述於 %C 無法夾於位置區塊"
 
-#: fortran/match.cc:8340
+#: fortran/match.cc:8345
 #, fuzzy, gcc-internal-format
 msgid "Label %qs at %C doesn't match WHERE label %qs"
 msgstr "標貼『%s』於 %C 不匹配位置標貼『%s』"
@@ -84969,7 +85139,7 @@ msgstr ""
 msgid "DEPEND clause at %L of OMP DEPOBJ construct shall have only a single locator"
 msgstr ""
 
-#: fortran/openmp.cc:5672 fortran/openmp.cc:10702
+#: fortran/openmp.cc:5672 fortran/openmp.cc:10737
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "MESSAGE clause at %L requires a scalar default-kind CHARACTER expression"
 msgstr "NUM_THREADS 子句於 %L 需要純量整數運算式"
@@ -85005,12 +85175,12 @@ msgstr ""
 msgid "Unexpected junk after $OMP FLUSH statement at %C"
 msgstr "未預期的垃圾之後 $OMP 清理敘述於 %C"
 
-#: fortran/openmp.cc:6149 fortran/openmp.cc:13621
+#: fortran/openmp.cc:6149 fortran/openmp.cc:13656
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined %s !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:6153 fortran/openmp.cc:13625
+#: fortran/openmp.cc:6153 fortran/openmp.cc:13660
 #, gcc-internal-format, gfc-internal-format
 msgid "Redefinition of predefined !$OMP DECLARE REDUCTION at %L"
 msgstr ""
@@ -85497,7 +85667,7 @@ msgstr "未預期的垃圾之後 NOWAIT 子句於 %C"
 msgid "%s clause at %L requires a scalar INTEGER expression"
 msgstr "NUM_THREADS 子句於 %L 需要純量整數運算式"
 
-#: fortran/openmp.cc:8482 fortran/openmp.cc:10737
+#: fortran/openmp.cc:8482 fortran/openmp.cc:10772
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "INTEGER expression of %s clause at %L must be positive"
 msgstr "大小於 %L 必須是正值"
@@ -85517,7 +85687,7 @@ msgstr "Cray 指標『%s』在中 %s 子句於 %L"
 msgid "Cray pointee object %qs of derived type in %s clause at %L"
 msgstr "Cray 點『%s』在中 %s 子句於 %L"
 
-#: fortran/openmp.cc:8514 fortran/openmp.cc:10560
+#: fortran/openmp.cc:8514 fortran/openmp.cc:10595
 #, fuzzy, gcc-internal-format
 msgid "POINTER object %qs of polymorphic type in %s clause at %L"
 msgstr "指標物件『%s』在中 %s 子句於 %L"
@@ -85547,17 +85717,17 @@ msgstr "假設的大小陣列『%s』在中 %s 子句於 %L"
 msgid "POINTER object %qs in %s clause at %L"
 msgstr "指標物件『%s』在中 %s 子句於 %L"
 
-#: fortran/openmp.cc:8558 fortran/openmp.cc:10564
+#: fortran/openmp.cc:8558 fortran/openmp.cc:10599
 #, fuzzy, gcc-internal-format
 msgid "Cray pointer object %qs in %s clause at %L"
 msgstr "Cray 指標『%s』在中 %s 子句於 %L"
 
-#: fortran/openmp.cc:8563 fortran/openmp.cc:10567
+#: fortran/openmp.cc:8563 fortran/openmp.cc:10602
 #, fuzzy, gcc-internal-format
 msgid "Cray pointee object %qs in %s clause at %L"
 msgstr "Cray 點『%s』在中 %s 子句於 %L"
 
-#: fortran/openmp.cc:8568 fortran/openmp.cc:10555
+#: fortran/openmp.cc:8568 fortran/openmp.cc:10590
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE object %qs in %s clause at %L"
 msgstr "指標物件『%s』在中 %s 子句於 %L"
@@ -85679,8 +85849,8 @@ msgstr ""
 msgid "ORDER clause must not be used together with ORDERED at %L"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12828
-#: fortran/resolve.cc:14446
+#: fortran/openmp.cc:8918 fortran/openmp.cc:8929 fortran/resolve.cc:12906
+#: fortran/resolve.cc:14566
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "IF clause at %L requires a scalar LOGICAL expression"
 msgstr "如果子句於 %L 需要純量邏輯的運算式"
@@ -85761,7 +85931,7 @@ msgstr "物件『%s』並非變數於 %L"
 msgid "Clause for object %qs at %L is ignored as it is a parameter"
 msgstr ""
 
-#: fortran/openmp.cc:9205 fortran/openmp.cc:13163
+#: fortran/openmp.cc:9205 fortran/openmp.cc:13198
 #, fuzzy, gcc-internal-format
 msgid "Object %qs is not a variable at %L"
 msgstr "物件『%s』並非變數於 %L"
@@ -85784,7 +85954,7 @@ msgstr "%qE 有無效的型態用於 %<reduction%>"
 #: fortran/openmp.cc:9255 fortran/openmp.cc:9267 fortran/openmp.cc:9288
 #: fortran/openmp.cc:9300 fortran/openmp.cc:9362 fortran/openmp.cc:9370
 #: fortran/openmp.cc:9391 fortran/openmp.cc:9402 fortran/openmp.cc:9414
-#: fortran/openmp.cc:9655 fortran/openmp.cc:13197
+#: fortran/openmp.cc:9655 fortran/openmp.cc:13232
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs present on multiple clauses at %L"
 msgstr "符號『%s』呈現於多重子句於 %L"
@@ -85824,7 +85994,7 @@ msgstr "符號『%s』呈現於多重子句於 %L"
 msgid "%qs appears more than once in %<allocate%> at %L"
 msgstr "%qE 出現一次以上在中資料子句"
 
-#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8531
+#: fortran/openmp.cc:9513 fortran/trans-openmp.cc:8561
 #, gcc-internal-format
 msgid "%qs specified in %<allocate%> clause at %L but not in an explicit privatization clause"
 msgstr ""
@@ -86142,604 +86312,614 @@ msgstr ""
 msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10491
+#: fortran/openmp.cc:10507
+#, gcc-internal-format
+msgid "Sorry, ALLOCATABLE object %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10512
+#, gcc-internal-format
+msgid "Sorry, array %qs in LINEAR clause on worksharing-loop construct at %L is not yet supported"
+msgstr ""
+
+#: fortran/openmp.cc:10526
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10497
+#: fortran/openmp.cc:10532
 #, gcc-internal-format, gfc-internal-format
 msgid "LINEAR clause modifier other than VAL used on DO or SIMD construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10505
+#: fortran/openmp.cc:10540
 #, fuzzy, gcc-internal-format
 msgid "LINEAR variable %qs must be INTEGER at %L"
 msgstr "%s 消除變數『%s』必須是整數於 %L"
 
-#: fortran/openmp.cc:10510
+#: fortran/openmp.cc:10545
 #, gcc-internal-format
 msgid "LINEAR dummy argument %qs with VALUE attribute with %s modifier at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10521
+#: fortran/openmp.cc:10556
 #, fuzzy, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
 msgstr "最後的子句於 %L 需要純量邏輯的運算式"
 
-#: fortran/openmp.cc:10538
+#: fortran/openmp.cc:10573
 #, gcc-internal-format
 msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression or dummy argument specified in UNIFORM clause"
 msgstr ""
 
-#: fortran/openmp.cc:10572
+#: fortran/openmp.cc:10607
 #, gcc-internal-format
 msgid "%s clause variable %qs at %L is neither a POINTER nor an array"
 msgstr ""
 
-#: fortran/openmp.cc:10632
+#: fortran/openmp.cc:10667
 #, gcc-internal-format, gfc-internal-format
 msgid "NUM_TEAMS lower bound at %L larger than upper bound at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10645
+#: fortran/openmp.cc:10680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Value of HINT clause at %L shall be a valid constant hint expression"
 msgstr "值的 %qD 不是可用在中常數運算式"
 
-#: fortran/openmp.cc:10655
+#: fortran/openmp.cc:10690
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
 msgstr "排程子句 chunksize 於 %L 需要純量整數運算式(_S)"
 
-#: fortran/openmp.cc:10665
+#: fortran/openmp.cc:10700
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<GRAINSIZE%> clause at %L must not be used together with %<NUM_TASKS%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: fortran/openmp.cc:10668
+#: fortran/openmp.cc:10703
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<REDUCTION%> clause at %L must not be used together with %<NOGROUP%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: fortran/openmp.cc:10672
+#: fortran/openmp.cc:10707
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<FULL%> clause at %C must not be used together with %<PARTIAL%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: fortran/openmp.cc:10695
+#: fortran/openmp.cc:10730
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible use of TILE and COLLAPSE at %L"
 msgstr "不相容的分級在中 %s (%d 和 %d) 於 %L"
 
-#: fortran/openmp.cc:10719
+#: fortran/openmp.cc:10754
 #, gcc-internal-format, gfc-internal-format
 msgid "TARGET DATA must contain at least one MAP, USE_DEVICE_PTR, or USE_DEVICE_ADDR clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10722
+#: fortran/openmp.cc:10757
 #, gcc-internal-format, gfc-internal-format
 msgid "%s must contain at least one MAP clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:10732
+#: fortran/openmp.cc:10767
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "SIZES requires constant expression at %L"
 msgstr "%qE 並非常數運算式"
 
-#: fortran/openmp.cc:10748
+#: fortran/openmp.cc:10783
 #, gcc-internal-format
 msgid "%qs at %L should be a scalar of type integer(kind=omp_event_handle_kind)"
 msgstr ""
 
-#: fortran/openmp.cc:10753
+#: fortran/openmp.cc:10788
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be an array element"
 msgstr "指標物件於 %C 不應該被 coindexed"
 
-#: fortran/openmp.cc:10757
+#: fortran/openmp.cc:10792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event handle at %L must not be part of a derived type or class"
 msgstr "指標物件於 %C 不應該被 coindexed"
 
-#: fortran/openmp.cc:10761
+#: fortran/openmp.cc:10796
 #, fuzzy, gcc-internal-format
 #| msgid "-frepo must be used with -c"
 msgid "%<DETACH%> clause at %L must not be used together with %<MERGEABLE%> clause"
 msgstr "-frepo 必須與 -c 一起使用"
 
-#: fortran/openmp.cc:10768
+#: fortran/openmp.cc:10803
 #, gcc-internal-format
 msgid "%<host_data%> construct at %L requires %<use_device%> clause"
 msgstr ""
 
-#: fortran/openmp.cc:10922
+#: fortran/openmp.cc:10957
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected IF at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:10930
+#: fortran/openmp.cc:10965
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected ELSE at %L in atomic compare capture"
 msgstr ""
 
-#: fortran/openmp.cc:11042
+#: fortran/openmp.cc:11077
 #, gcc-internal-format
 msgid "Expected %<==%>, %<.EQ.%> or %<.EQV.%> atomic comparison expression at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11048
+#: fortran/openmp.cc:11083
 #, gcc-internal-format, gfc-internal-format
 msgid "Expected scalar intrinsic variable at %L in atomic comparison"
 msgstr ""
 
-#: fortran/openmp.cc:11056
+#: fortran/openmp.cc:11091
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected scalar initialization expression at %C"
 msgid "Expected scalar intrinsic expression at %L in atomic comparison"
 msgstr "%C 處需要標量初始化運算式"
 
-#: fortran/openmp.cc:11064
+#: fortran/openmp.cc:11099
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP 基元的敘述必須設定純量變數的 intrinsic 型態於 %L"
 
-#: fortran/openmp.cc:11073
+#: fortran/openmp.cc:11108
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC statement must assign an expression of intrinsic type at %L"
 msgstr "!$OMP 基元的敘述必須設定純量變數的 intrinsic 型態於 %L"
 
-#: fortran/openmp.cc:11080
+#: fortran/openmp.cc:11115
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11097
+#: fortran/openmp.cc:11132
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
 msgstr "!$OMP 基元的讀取敘述必須讀取從純量變數的 intrinsic 型態於 %L"
 
-#: fortran/openmp.cc:11102
+#: fortran/openmp.cc:11137
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr 在中 !$OMP 基元的寫入指派 var=expr 必須是純量和無法參考 var 於 %L"
 
-#: fortran/openmp.cc:11114
+#: fortran/openmp.cc:11149
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement must set a scalar variable of intrinsic type at %L"
 msgstr "!$OMP 基元的敘述必須設定純量變數的 intrinsic 型態於 %L"
 
-#: fortran/openmp.cc:11122
+#: fortran/openmp.cc:11157
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC capture-statement requires a scalar variable of intrinsic type at %L"
 msgstr "!$OMP 基元的擷取擷取敘述必須設定純量變數的 intrinsic 型態於 %L"
 
-#: fortran/openmp.cc:11132
+#: fortran/openmp.cc:11167
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
 msgstr "!$OMP 基元的擷取擷取敘述讀取從不同的變數比更新敘述寫入進入於 %L"
 
-#: fortran/openmp.cc:11148
+#: fortran/openmp.cc:11183
 #, fuzzy, gcc-internal-format
 msgid "For !$OMP ATOMIC COMPARE, the first operand in comparison at %L must be the variable %qs that the update statement writes into at %L"
 msgstr "!$OMP 基元的擷取擷取敘述讀取從不同的變數比更新敘述寫入進入於 %L"
 
-#: fortran/openmp.cc:11156
+#: fortran/openmp.cc:11191
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC COMPARE assignment var = expr must be scalar and cannot reference var at %L"
 msgstr "expr 在中 !$OMP 基元的寫入指派 var=expr 必須是純量和無法參考 var 於 %L"
 
-#: fortran/openmp.cc:11174
+#: fortran/openmp.cc:11209
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC UPDATE at %L with FAIL clause requires either the COMPARE clause or using the intrinsic MIN/MAX procedure"
 msgstr ""
 
-#: fortran/openmp.cc:11201
+#: fortran/openmp.cc:11236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
 msgstr "!$OMP 基元的指派運算子必須是+, *, -,/,.AND.,.OR.,.EQV。或.NEQV。於 %L"
 
-#: fortran/openmp.cc:11249
+#: fortran/openmp.cc:11284
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
 msgstr "!$OMP 基元的指派必須是 var=var op expr 或 var=expr op var 於 %L"
 
-#: fortran/openmp.cc:11263
+#: fortran/openmp.cc:11298
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
 msgstr "!$OMP 基元的 var=var op expr 無法數學的 equivalent 到 var=var op (expr) 於 %L"
 
-#: fortran/openmp.cc:11296
+#: fortran/openmp.cc:11331
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
 msgstr "expr 在中 !$OMP 基元的指派 var=var op expr 必須是純量和無法參考 var 於 %L"
 
-#: fortran/openmp.cc:11320
+#: fortran/openmp.cc:11355
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
 msgstr "!$OMP 基元的指派 intrinsic IAND，IOR 或 IEOR 必須有兩引數於 %L"
 
-#: fortran/openmp.cc:11327
+#: fortran/openmp.cc:11362
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
 msgstr "!$OMP 基元的指派 intrinsic 必須是最小、最大、IAND，IOR 或 IEOR 於 %L"
 
-#: fortran/openmp.cc:11350
+#: fortran/openmp.cc:11385
 #, fuzzy, gcc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
 msgstr "!$OMP 基元的 intrinsic 引數除了一個必須不參考『%s』於 %L"
 
-#: fortran/openmp.cc:11357
+#: fortran/openmp.cc:11392
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
 msgstr "!$OMP 基元的 intrinsic 引數必須是純量於 %L"
 
-#: fortran/openmp.cc:11365
+#: fortran/openmp.cc:11400
 #, fuzzy, gcc-internal-format
 msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
 msgstr "第一個或最後一筆 !$OMP 基元的 intrinsic 引數必須是『%s』於 %L"
 
-#: fortran/openmp.cc:11383
+#: fortran/openmp.cc:11418
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
 msgstr "!$OMP 基元的指派必須有運算子或 intrinsic 右側手側邊於 %L"
 
-#: fortran/openmp.cc:11388
+#: fortran/openmp.cc:11423
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "unexpected !$OMP ATOMIC expression at %L"
 msgstr "未預期的垃圾之後 $OMP 基元的敘述於 %C"
 
-#: fortran/openmp.cc:11496
+#: fortran/openmp.cc:11531
 #, gcc-internal-format, gfc-internal-format
 msgid "With INSCAN at %L, expected loop body with !$OMP SCAN between two structured block sequences"
 msgstr ""
 
-#: fortran/openmp.cc:11503
+#: fortran/openmp.cc:11538
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in preceding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11510
+#: fortran/openmp.cc:11545
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP SCAN at %L with zero executable statements in succeeding structured block sequence"
 msgstr ""
 
-#: fortran/openmp.cc:11726
+#: fortran/openmp.cc:11761
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain loop in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11747 fortran/openmp.cc:11780
+#: fortran/openmp.cc:11782 fortran/openmp.cc:11815
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP API call in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:11757
+#: fortran/openmp.cc:11792
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot contain OpenMP directive in intervening code at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12303
+#: fortran/openmp.cc:12338
 #, gcc-internal-format, gfc-internal-format
 msgid "SIZES clause is required on !$OMP TILE construct at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12330
+#: fortran/openmp.cc:12365
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP 做無法做當或做而無需迴圈控制於 %L"
 
-#: fortran/openmp.cc:12336
+#: fortran/openmp.cc:12371
 #, gcc-internal-format, gfc-internal-format
 msgid "%s cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12346
+#: fortran/openmp.cc:12381
 #, gcc-internal-format, gfc-internal-format
 msgid "Generated loop of UNROLL construct at %L without PARTIAL clause does not have canonical form"
 msgstr ""
 
-#: fortran/openmp.cc:12353
+#: fortran/openmp.cc:12388
 #, gcc-internal-format, gfc-internal-format
 msgid "UNROLL construct at %L with PARTIAL clause generates just one loop with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12368
+#: fortran/openmp.cc:12403
 #, gcc-internal-format, gfc-internal-format
 msgid "TILE construct at %L generates %d loops with canonical form but %d loops are needed"
 msgstr ""
 
-#: fortran/openmp.cc:12379
+#: fortran/openmp.cc:12414
 #, gcc-internal-format
 msgid "Imperfectly nested loop using generated loops"
 msgstr ""
 
-#: fortran/openmp.cc:12391
+#: fortran/openmp.cc:12426
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must be of type integer at %L"
 msgstr "!$OMP 做迭代變數必須是的型態整數於 %L"
 
-#: fortran/openmp.cc:12398
+#: fortran/openmp.cc:12433
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable must not be THREADPRIVATE at %L"
 msgstr "!$OMP 做迭代變數必須不是 THREADPRIVATE 於 %L"
 
-#: fortran/openmp.cc:12413
+#: fortran/openmp.cc:12448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE or ALLOCATE at %L"
 msgstr "!$OMP 做迭代變數呈現於子句不同於私人的或 LASTPRIVATE 於 %L"
 
-#: fortran/openmp.cc:12417
+#: fortran/openmp.cc:12452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable present on clause other than PRIVATE, LASTPRIVATE, ALLOCATE or LINEAR at %L"
 msgstr "!$OMP 做迭代變數呈現於子句不同於私人的或 LASTPRIVATE 於 %L"
 
-#: fortran/openmp.cc:12424
+#: fortran/openmp.cc:12459
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable used in more than one loop at %L"
 msgstr "!$OMP 做迭代變數必須是的型態整數於 %L"
 
-#: fortran/openmp.cc:12430
+#: fortran/openmp.cc:12465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s iteration variable at %L is bound in intervening code"
 msgstr "迭代變數 %qE 不應為消除"
 
-#: fortran/openmp.cc:12439
+#: fortran/openmp.cc:12474
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12446
+#: fortran/openmp.cc:12481
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop start expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12455
+#: fortran/openmp.cc:12490
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression not in canonical form at %L"
 msgstr "不當的 kind 運算式用於函式『%s』於 %L"
 
-#: fortran/openmp.cc:12462
+#: fortran/openmp.cc:12497
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop end expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12469
+#: fortran/openmp.cc:12504
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s loop bounds reference different iteration variables at %L"
 msgstr "無效的型態用於迭代變數 %qE"
 
-#: fortran/openmp.cc:12475
+#: fortran/openmp.cc:12510
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment not in canonical form at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12482
+#: fortran/openmp.cc:12517
 #, gcc-internal-format, gfc-internal-format
 msgid "%s loop increment expression at %L uses variable bound in intervening code"
 msgstr ""
 
-#: fortran/openmp.cc:12493
+#: fortran/openmp.cc:12528
 #, gcc-internal-format
 msgid "Non-rectangular loops from generated loops unsupported"
 msgstr ""
 
 #. Parse error, can't recover from this.
-#: fortran/openmp.cc:12509
+#: fortran/openmp.cc:12544
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for collapsed %s (level %d) at %L"
 msgstr "不足做迴圈用於崩潰 !$OMP 做於 %L"
 
-#: fortran/openmp.cc:12522
+#: fortran/openmp.cc:12557
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with ORDERED clause at %L"
 msgstr "崩潰 !$OMP 做迴圈無法 perfectly 巢狀的於 %L"
 
-#: fortran/openmp.cc:12529
+#: fortran/openmp.cc:12564
 #, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested with REDUCTION INSCAN clause at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12536
+#: fortran/openmp.cc:12571
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s inner loops must be perfectly nested at %L"
 msgstr "崩潰 !$OMP 做迴圈無法 perfectly 巢狀的於 %L"
 
-#: fortran/openmp.cc:12584
+#: fortran/openmp.cc:12619
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be constant integer expression at %L"
 msgstr "崩潰引數需要正面的常數整數運算式"
 
-#: fortran/openmp.cc:12592
+#: fortran/openmp.cc:12627
 #, fuzzy, gcc-internal-format
 msgid "%<score%> argument must be non-negative at %L"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: fortran/openmp.cc:12621
+#: fortran/openmp.cc:12656
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a logical expression at %L"
 msgstr "預期的整數運算式"
 
-#: fortran/openmp.cc:12625
+#: fortran/openmp.cc:12660
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be an integer expression at %L"
 msgstr "預期的整數運算式"
 
-#: fortran/openmp.cc:12632
+#: fortran/openmp.cc:12667
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant logical expression at %L"
 msgstr "預期的整數運算式"
 
-#: fortran/openmp.cc:12636
+#: fortran/openmp.cc:12671
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "property must be a constant integer expression at %L"
 msgstr "預期的整數運算式"
 
-#: fortran/openmp.cc:12661
+#: fortran/openmp.cc:12696
 #, gcc-internal-format, gfc-internal-format
 msgid "property must be a conforming device number at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12940 fortran/openmp.cc:12953
+#: fortran/openmp.cc:12975 fortran/openmp.cc:12988
 #, gcc-internal-format, gfc-internal-format
 msgid "The %s directive cannot be specified within a %s region at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12972
+#: fortran/openmp.cc:13007
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
 msgstr "!$OMP 做無法做當或做而無需迴圈控制於 %L"
 
-#: fortran/openmp.cc:12978
+#: fortran/openmp.cc:13013
 #, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP cannot be a DO CONCURRENT loop at %L"
 msgstr ""
 
-#: fortran/openmp.cc:12984
+#: fortran/openmp.cc:13019
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP iteration variable must be of type integer at %L"
 msgstr "!$OMP 做迭代變數必須是的型態整數於 %L"
 
-#: fortran/openmp.cc:13000
+#: fortran/openmp.cc:13035
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
 msgstr "!$OMP 做崩潰的迴圈不表單矩形迭代空格於 %L"
 
-#: fortran/openmp.cc:13012
+#: fortran/openmp.cc:13047
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s !$ACC LOOP loops not perfectly nested at %L"
 msgstr "崩潰 !$OMP 做迴圈無法 perfectly 巢狀的於 %L"
 
-#: fortran/openmp.cc:13022 fortran/openmp.cc:13031
+#: fortran/openmp.cc:13057 fortran/openmp.cc:13066
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "not enough DO loops for %s !$ACC LOOP at %L"
 msgstr "不足做迴圈用於崩潰 !$OMP 做於 %L"
 
-#: fortran/openmp.cc:13047
+#: fortran/openmp.cc:13082
 #, gcc-internal-format, gfc-internal-format
 msgid "Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13068
+#: fortran/openmp.cc:13103
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TILE requires constant expression at %L"
 msgstr "%qE 並非常數運算式"
 
-#: fortran/openmp.cc:13173
+#: fortran/openmp.cc:13208
 #, fuzzy, gcc-internal-format
 msgid "Object %qs at %L is ignored as parameters need not be copied"
 msgstr "物件『%s』並非變數於 %L"
 
-#: fortran/openmp.cc:13180
+#: fortran/openmp.cc:13215
 #, fuzzy, gcc-internal-format
 msgid "Array sections: %qs not allowed in !$ACC DECLARE at %L"
 msgstr "陣列區段無法允許的在中『%s』呼叫於 %L"
 
-#: fortran/openmp.cc:13227
+#: fortran/openmp.cc:13262
 #, gcc-internal-format
 msgid "NAME %qs does not refer to a subroutine or function in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13233
+#: fortran/openmp.cc:13268
 #, gcc-internal-format
 msgid "NAME %qs invalid in !$ACC ROUTINE ( NAME ) at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13320
+#: fortran/openmp.cc:13355
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS at %L may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13324
+#: fortran/openmp.cc:13359
 #, gcc-internal-format, gfc-internal-format
 msgid "!$OMP TARGET region at %L with a nested TEAMS may not contain any other statement, declaration or directive outside of the single TEAMS construct"
 msgstr ""
 
-#: fortran/openmp.cc:13342
+#: fortran/openmp.cc:13377
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L must be followed by a procedure call with optional assignment"
 msgstr ""
 
-#: fortran/openmp.cc:13349
+#: fortran/openmp.cc:13384
 #, gcc-internal-format
 msgid "%<OMP DISPATCH%> directive at %L cannot be followed by a procedure pointer"
 msgstr ""
 
-#: fortran/openmp.cc:13444
+#: fortran/openmp.cc:13479
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP TARGET UPDATE at %L requires at least one TO or FROM clause"
 msgstr ""
 
-#: fortran/openmp.cc:13458
+#: fortran/openmp.cc:13493
 #, gcc-internal-format, gfc-internal-format
 msgid "OMP CRITICAL at %L with HINT clause requires a NAME, except when omp_sync_hint_none is used"
 msgstr ""
 
-#: fortran/openmp.cc:13464
+#: fortran/openmp.cc:13499
 #, gcc-internal-format
 msgid "Unexpected !$OMP SCAN at %L outside loop construct with %<inscan%> REDUCTION clause"
 msgstr ""
 
-#: fortran/openmp.cc:13493
+#: fortran/openmp.cc:13528
 #, gcc-internal-format
 msgid "!$OMP DECLARE SIMD should refer to containing procedure %qs at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13532
+#: fortran/openmp.cc:13567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected constant non-negative scalar integer offset expression at %L"
 msgstr "預期的整數運算式"
 
-#: fortran/openmp.cc:13535
+#: fortran/openmp.cc:13570
 #, gcc-internal-format
 msgid "For range-based %<adjust_args%>, a constant positive scalar integer expression is required at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13549
+#: fortran/openmp.cc:13584
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected another dimension in array declaration at %C"
 msgid "Expected dummy parameter name or a positive integer at %L"
 msgstr "%C 處陣列宣告需要另外一維"
 
-#: fortran/openmp.cc:13575
+#: fortran/openmp.cc:13610
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_PRIV or OMP_ORIG used in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13583
+#: fortran/openmp.cc:13618
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable other than OMP_OUT or OMP_IN used in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13612
+#: fortran/openmp.cc:13647
 #, gcc-internal-format, gfc-internal-format
 msgid "Invalid operator for !$OMP DECLARE REDUCTION %s at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13634
+#: fortran/openmp.cc:13669
 #, gcc-internal-format, gfc-internal-format
 msgid "CHARACTER length in !$OMP DECLARE REDUCTION %s not constant at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13650
+#: fortran/openmp.cc:13685
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in combiner of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13665
+#: fortran/openmp.cc:13700
 #, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call with alternate returns in INITIALIZER clause of !$OMP DECLARE REDUCTION at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13675
+#: fortran/openmp.cc:13710
 #, gcc-internal-format, gfc-internal-format
 msgid "One of actual subroutine arguments in INITIALIZER clause of !$OMP DECLARE REDUCTION must be OMP_PRIV at %L"
 msgstr ""
 
-#: fortran/openmp.cc:13683
+#: fortran/openmp.cc:13718
 #, gcc-internal-format, gfc-internal-format
 msgid "Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L"
 msgstr ""
@@ -87415,62 +87595,62 @@ msgstr ""
 msgid "%<GCC novector%> directive not at the start of a loop at %C"
 msgstr ""
 
-#: fortran/parse.cc:6967
+#: fortran/parse.cc:6994
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %C is already ambiguous"
 msgstr "包含的程序『%s』於 %C 已經模稜兩可的"
 
-#: fortran/parse.cc:7024
+#: fortran/parse.cc:7051
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in CONTAINS section at %C"
 msgstr "非預期的 %s 敘述出現在 %C 處的 CONTAINS 段中"
 
-#: fortran/parse.cc:7049
+#: fortran/parse.cc:7076
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %L"
 msgstr "Fortran 2008:含有敘述而無需函式或副常式敘述於 %C"
 
-#: fortran/parse.cc:7144
+#: fortran/parse.cc:7171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s statement at %C cannot appear after executable statements"
 msgstr "%L 處 FORMAT 敘述沒有敘述標籤"
 
-#: fortran/parse.cc:7172
+#: fortran/parse.cc:7199
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CONTAINS statement at %C is already in a contained program unit"
 msgstr "含有敘述於 %C 已經在中包含的程式單元"
 
-#: fortran/parse.cc:7224
+#: fortran/parse.cc:7251
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used as a %s at %L"
 msgstr "總體名稱『%s』於 %L 已經被做為 %s 於 %L"
 
-#: fortran/parse.cc:7228
+#: fortran/parse.cc:7255
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used as a %s at %L"
 msgstr "總體名稱『%s』於 %L 已經被做為 %s 於 %L"
 
-#: fortran/parse.cc:7234
+#: fortran/parse.cc:7261
 #, fuzzy, gcc-internal-format
 msgid "Global binding name %qs at %L is already being used at %L"
 msgstr "總體名稱『%s』於 %L 已經被做為 %s 於 %L"
 
-#: fortran/parse.cc:7237
+#: fortran/parse.cc:7264
 #, fuzzy, gcc-internal-format
 msgid "Global name %qs at %L is already being used at %L"
 msgstr "總體名稱『%s』於 %L 已經被做為 %s 於 %L"
 
-#: fortran/parse.cc:7259
+#: fortran/parse.cc:7286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
 msgstr "空白區塊資料於 %C 衝突與事前區塊資料於 %L"
 
-#: fortran/parse.cc:7285
+#: fortran/parse.cc:7312
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in BLOCK DATA at %C"
 msgstr "非預期的 %s 敘述出現在 %C 處的 DATA 區塊中"
 
-#: fortran/parse.cc:7388
+#: fortran/parse.cc:7415
 #, gcc-internal-format, gfc-internal-format
 msgid "Unexpected %s statement in MODULE at %C"
 msgstr "非預期的 %s 敘述出現在 %C 處的 MODULE 中"
@@ -87478,7 +87658,7 @@ msgstr "非預期的 %s 敘述出現在 %C 處的 MODULE 中"
 #. If we see a duplicate main program, shut down.  If the second
 #. instance is an implied main program, i.e. data decls or executable
 #. statements, we're in for lots of errors.
-#: fortran/parse.cc:7915
+#: fortran/parse.cc:7942
 #, gcc-internal-format, gfc-internal-format
 msgid "Two main PROGRAMs at %L and %C"
 msgstr "%L 和 %C 處有兩個主 PROGRAM"
@@ -87949,1108 +88129,1108 @@ msgstr "變數『%s』於 %C 與初始設定式已經出現在中資料敘述"
 msgid "%qs at %C is not a variable"
 msgstr "『%s』於 %C 並非變數"
 
-#: fortran/resolve.cc:121
+#: fortran/resolve.cc:142
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is of the ABSTRACT type %qs"
 msgstr "『%s』於 %L 是的摘要型態『%s』"
 
-#: fortran/resolve.cc:124
+#: fortran/resolve.cc:145
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT type %qs used at %L"
 msgstr "摘要型態『%s』使用的於 %L"
 
-#: fortran/resolve.cc:141
+#: fortran/resolve.cc:162
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
 msgstr "介面『%s』，使用的由程序『%s』於 %L, 被宣告在中稍後程序敘述"
 
-#: fortran/resolve.cc:154
+#: fortran/resolve.cc:175
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be generic"
 msgstr "介面『%s』於 %C 可能無法是通用"
 
-#: fortran/resolve.cc:161
+#: fortran/resolve.cc:182
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L may not be a statement function"
 msgstr "介面『%s』於 %C 可能無法是敘述函式"
 
-#: fortran/resolve.cc:170
+#: fortran/resolve.cc:191
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
 msgstr "Intrinsic 程序『%s』不允許在中程序敘述於 %C"
 
-#: fortran/resolve.cc:176
+#: fortran/resolve.cc:197
 #, fuzzy, gcc-internal-format
 msgid "Interface %qs at %L must be explicit"
 msgstr "介面『%s』的程序『%s』於 %L 必須是明確的"
 
-#: fortran/resolve.cc:198
+#: fortran/resolve.cc:219
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE %qs at %L may not be used as its own interface"
 msgstr "程序『%s』於 %L 可能無法被做為它的本身介面"
 
-#: fortran/resolve.cc:299
+#: fortran/resolve.cc:321
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
 msgstr "交替回傳說明符在中 elemental 副常式『%s』於 %L 未被允許"
 
-#: fortran/resolve.cc:303
+#: fortran/resolve.cc:325
 #, fuzzy, gcc-internal-format
 msgid "Alternate return specifier in function %qs at %L is not allowed"
 msgstr "交替回傳說明符在中函式『%s』於 %L 未被允許"
 
-#: fortran/resolve.cc:315
+#: fortran/resolve.cc:337
 #, fuzzy, gcc-internal-format
 msgid "Self-referential argument %qs at %L is not allowed"
 msgstr "By-value 引數於 %L 未被允許在中這個語境"
 
-#: fortran/resolve.cc:387
+#: fortran/resolve.cc:412
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
 msgstr "虛設程序『%s』的 PURE 程序於 %L 必須也是 PURE"
 
-#: fortran/resolve.cc:397
+#: fortran/resolve.cc:422
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
 msgstr "Fortran 2008:引數『%s』的 pure 函式『%s』於 %L 與值屬性但是而無需含義 (在中)"
 
-#: fortran/resolve.cc:402
+#: fortran/resolve.cc:427
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
 msgstr "引數『%s』的 pure 函式『%s』於 %L 必須是含義 (在中) 或值"
 
-#: fortran/resolve.cc:410
+#: fortran/resolve.cc:435
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
 msgstr "Fortran 2008:引數『%s』的 pure 副常式『%s』於 %L 與值屬性但是而無需含義"
 
-#: fortran/resolve.cc:415
+#: fortran/resolve.cc:440
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "引數『%s』的 pure 副常式『%s』於 %L 必須有它的含義指定的或有值屬性"
 
-#: fortran/resolve.cc:425
+#: fortran/resolve.cc:450
 #, fuzzy, gcc-internal-format
 msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
 msgstr "參數『%s』到『%s』於 %L 必須不是 polymorphic"
 
-#: fortran/resolve.cc:458
+#: fortran/resolve.cc:483
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy argument %qs at %L to elemental procedure"
 msgstr "Coarray 虛引數『%s』於 %L 到 elemental 程序"
 
-#: fortran/resolve.cc:466
+#: fortran/resolve.cc:491
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of elemental procedure at %L must be scalar"
 msgid "Argument %qs of elemental procedure at %L must be scalar"
 msgstr "元素程序的引數「%s」在 %L 處必須是標量"
 
-#: fortran/resolve.cc:475
+#: fortran/resolve.cc:500
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
 msgstr "引數『%s』的 elemental 程序於 %L 無法有 ALLOCATABLE 屬性"
 
-#: fortran/resolve.cc:485
+#: fortran/resolve.cc:510
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
 msgstr "引數『%s』的 elemental 程序於 %L 無法有指標屬性"
 
-#: fortran/resolve.cc:493
+#: fortran/resolve.cc:518
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
 msgstr "虛設程序『%s』不允許在中 elemental 程序『%s』於 %L"
 
-#: fortran/resolve.cc:502
+#: fortran/resolve.cc:527
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
 msgstr "引數『%s』的 pure 副常式『%s』於 %L 必須有它的含義指定的或有值屬性"
 
 #. F03:C1263 (R1238) The function-name and each dummy-arg-name
 #. shall be specified, explicitly or implicitly, to be scalar.
-#: fortran/resolve.cc:517
+#: fortran/resolve.cc:542
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs of statement function %qs at %L must be scalar"
 msgstr "敘述函式的引數「%s」在 %L 處必須是標量"
 
-#: fortran/resolve.cc:528
+#: fortran/resolve.cc:553
 #, fuzzy, gcc-internal-format
 msgid "Character-valued argument %qs of statement function at %L must have constant length"
 msgstr "Character-valued 引數『%s』的敘述函式於 %L 必須有常數長度"
 
-#: fortran/resolve.cc:579
+#: fortran/resolve.cc:604
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L has the same name as its encompassing procedure"
 msgstr "介面程序『%s』於 %L 有同名做為封閉程序"
 
-#: fortran/resolve.cc:599
+#: fortran/resolve.cc:624
 #, fuzzy, gcc-internal-format
 msgid "Contained function %qs at %L has no IMPLICIT type"
 msgstr "包含的函式『%s』於 %L 沒有任何隱含的型態"
 
-#: fortran/resolve.cc:602
+#: fortran/resolve.cc:627
 #, fuzzy, gcc-internal-format
 msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
 msgstr "結果『%s』的包含的函式『%s』於 %L 沒有任何隱含的型態"
 
-#: fortran/resolve.cc:628
+#: fortran/resolve.cc:653
 #, fuzzy, gcc-internal-format
 msgid "Character-valued module procedure %qs at %L must not be assumed length"
 msgstr "Character-valued %s『%s』於 %L 必須不被假設長度"
 
-#: fortran/resolve.cc:630
+#: fortran/resolve.cc:655
 #, fuzzy, gcc-internal-format
 msgid "Character-valued internal function %qs at %L must not be assumed length"
 msgstr "Character-valued %s『%s』於 %L 必須不被假設長度"
 
-#: fortran/resolve.cc:803
+#: fortran/resolve.cc:828
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entries with mismatched array specifications"
 msgstr "函式 %s 於 %L 有條目與不匹配的陣列規格"
 
-#: fortran/resolve.cc:814
+#: fortran/resolve.cc:839
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L has entry %s with mismatched characteristics"
 msgstr "函式 %s 於 %L 有條目與不匹配的陣列規格"
 
-#: fortran/resolve.cc:829
+#: fortran/resolve.cc:854
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Function %s at %L with entries returning variables of different string lengths"
 msgstr "延伸：函式 %s 於 %L 與條目回傳變數的不同的字串長度"
 
-#: fortran/resolve.cc:861
+#: fortran/resolve.cc:886
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be an array in FUNCTION %s at %L"
 msgstr "函數計算結果 %s 無法陣列在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:865
+#: fortran/resolve.cc:890
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be an array in FUNCTION %s at %L"
 msgstr "條目結果 %s 無法陣列在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:872
+#: fortran/resolve.cc:897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "函數計算結果 %s 無法指標在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:876
+#: fortran/resolve.cc:901
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be a POINTER in FUNCTION %s at %L"
 msgstr "條目結果 %s 無法指標在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:883
+#: fortran/resolve.cc:908
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "函數計算結果 %s 無法指標在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:887
+#: fortran/resolve.cc:912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be ALLOCATABLE in FUNCTION %s at %L"
 msgstr "條目結果 %s 無法指標在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:925
+#: fortran/resolve.cc:950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FUNCTION result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "函數計算結果 %s 無法的型態 %s 在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:930
+#: fortran/resolve.cc:955
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ENTRY result %s cannot be of type %s in FUNCTION %s at %L"
 msgstr "條目結果 %s 無法的型態 %s 在中函式 %s 於 %L"
 
-#: fortran/resolve.cc:981
+#: fortran/resolve.cc:1006
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block at %L"
 msgstr "符號『%s』於 %C 已經在中共同區塊"
 
-#: fortran/resolve.cc:985
+#: fortran/resolve.cc:1010
 #, fuzzy, gcc-internal-format
 msgid "Global entity %qs at %L cannot appear in a COMMON block"
 msgstr "符號『%s』於 %C 已經在中共同區塊"
 
-#: fortran/resolve.cc:995
+#: fortran/resolve.cc:1020
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "COMMON block at %L"
 msgstr "共同區塊/%s/找不到於 %C"
 
-#: fortran/resolve.cc:1002
+#: fortran/resolve.cc:1027
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
 msgstr "變數『%s』於 %L 是在中共同但是只有在中區塊資料初始化被允許"
 
-#: fortran/resolve.cc:1006
+#: fortran/resolve.cc:1031
 #, fuzzy, gcc-internal-format
 msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
 msgstr "初始化的變數『%s』於 %L 是在中空白共同但是初始化是只有允許的在中具名的共同區塊"
 
-#: fortran/resolve.cc:1013
+#: fortran/resolve.cc:1038
 #, gcc-internal-format
 msgid "%qs at %L cannot appear in COMMON [F2008:C5100]"
 msgstr ""
 
-#: fortran/resolve.cc:1018
+#: fortran/resolve.cc:1043
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot appear in COMMON at %L"
 msgstr "Allocate-object 於 %L 也出現於 %L"
 
-#: fortran/resolve.cc:1030
+#: fortran/resolve.cc:1055
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
 msgstr "衍生類型變數『%s』在中共同於 %L 有 neither 序列 nor 繫結©屬性"
 
-#: fortran/resolve.cc:1034
+#: fortran/resolve.cc:1059
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
 msgstr "衍生類型變數『%s』在中共同於 %L 有 ultimate 成分該是 allocatable"
 
-#: fortran/resolve.cc:1038
+#: fortran/resolve.cc:1063
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
 msgstr "衍生類型變數『%s』在中共同於 %L 可能無法有預設初始設定式"
 
-#: fortran/resolve.cc:1082
+#: fortran/resolve.cc:1107
 #, gcc-internal-format
 msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
 msgstr ""
 
-#: fortran/resolve.cc:1096
+#: fortran/resolve.cc:1121
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
 msgstr "共同區塊『%s』於 %L 被做為參數於 %L"
 
-#: fortran/resolve.cc:1104
+#: fortran/resolve.cc:1129
 #, gcc-internal-format
 msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1126
+#: fortran/resolve.cc:1151
 #, gcc-internal-format
 msgid "COMMON block at %L with binding label %qs uses the same global identifier as entity at %L"
 msgstr ""
 
-#: fortran/resolve.cc:1147
+#: fortran/resolve.cc:1172
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is used as PARAMETER at %L"
 msgstr "共同區塊『%s』於 %L 被做為參數於 %L"
 
-#: fortran/resolve.cc:1151
+#: fortran/resolve.cc:1176
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L cannot have the EXTERNAL attribute"
 msgstr "共同區塊『%s』於 %L 無法有外部屬性"
 
-#: fortran/resolve.cc:1155
+#: fortran/resolve.cc:1180
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L is also an intrinsic procedure"
 msgstr "共同區塊『%s』於 %L 也是 intrinsic 程序"
 
-#: fortran/resolve.cc:1159
+#: fortran/resolve.cc:1184
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a function result"
 msgstr "Fortran 2003:共同區塊『%s』於 %L 該也是函數計算結果"
 
-#: fortran/resolve.cc:1164
+#: fortran/resolve.cc:1189
 #, fuzzy, gcc-internal-format
 msgid "COMMON block %qs at %L that is also a global procedure"
 msgstr "Fortran 2003:共同區塊『%s』於 %L 該也是全域程序"
 
-#: fortran/resolve.cc:1231
+#: fortran/resolve.cc:1256
 #, gcc-internal-format
 msgid "The KIND parameter %qs in the PDT constructor at %C has no value"
 msgstr ""
 
-#: fortran/resolve.cc:1374
+#: fortran/resolve.cc:1399
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
 msgstr "分級的元件在中結構建構子於 %L 不匹配該的成分 (%d/%d)"
 
-#: fortran/resolve.cc:1395
+#: fortran/resolve.cc:1420
 #, fuzzy, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
 msgstr "元件在中結構建構子於 %L, 用於指標成分『%s』，是 %s 但是應該是 %s"
 
-#: fortran/resolve.cc:1430
+#: fortran/resolve.cc:1455
 #, fuzzy, gcc-internal-format
 msgid "Unequal character lengths (%wd/%wd) for pointer component %qs in constructor at %L"
 msgstr "Unequal 字元長度 (%ld/%ld) 在中 %s 於 %L"
 
-#: fortran/resolve.cc:1476
+#: fortran/resolve.cc:1501
 #, fuzzy, gcc-internal-format
 msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
 msgstr "空值在中結構建構子於 %L 正在被套用到成分『%s』，該項是 neither 指標 nor ALLOCATABLE"
 
-#: fortran/resolve.cc:1510
+#: fortran/resolve.cc:1535
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
 msgstr "介面不匹配用於 procedure-pointer 成分『%s』在中結構建構子於 %L:%s"
 
-#: fortran/resolve.cc:1529
+#: fortran/resolve.cc:1554
 #, fuzzy, gcc-internal-format
 msgid "Bad array spec of component %qs referenced in structure constructor at %L"
 msgstr "太多成分在中結構建構子於 %L！"
 
-#: fortran/resolve.cc:1542
+#: fortran/resolve.cc:1567
 #, fuzzy, gcc-internal-format
 msgid "The shape of component %qs in the structure constructor at %L differs from the shape of the declared component for dimension %d (%ld/%ld)"
 msgstr "分級的元件在中結構建構子於 %L 不匹配該的成分 (%d/%d)"
 
-#: fortran/resolve.cc:1563
+#: fortran/resolve.cc:1588
 #, fuzzy, gcc-internal-format
 msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
 msgstr "元件在中結構建構子於 %L, 用於指標成分『%s』應該是指標或目標"
 
-#: fortran/resolve.cc:1590
+#: fortran/resolve.cc:1615
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer assignment target at %L has a vector subscript"
 msgstr "指標指派與向量註標於 rhs 於 %L"
 
-#: fortran/resolve.cc:1602
+#: fortran/resolve.cc:1627
 #, fuzzy, gcc-internal-format
 msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
 msgstr "無效的運算式在中結構建構子用於指標成分『%s』於 %L 在中 PURE 程序"
 
-#: fortran/resolve.cc:1728
+#: fortran/resolve.cc:1753
 #, fuzzy, gcc-internal-format
 msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
 msgstr "上限在中最後一筆尺寸必須出現在中參考到假設的大小陣列『%s』於 %L"
 
-#: fortran/resolve.cc:1790
+#: fortran/resolve.cc:1815
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is ambiguous"
 msgstr "『%s』於 %L 是模稜兩可的"
 
-#: fortran/resolve.cc:1794
+#: fortran/resolve.cc:1819
 #, fuzzy, gcc-internal-format
 msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "通用程序『%s』未被允許做為實際引數於 %L"
 
-#: fortran/resolve.cc:1915
+#: fortran/resolve.cc:1940
 #, fuzzy, gcc-internal-format
 msgid "Type specified for intrinsic function %qs at %L is ignored"
 msgstr "型態指定的用於內建函式『%s』於 %L 被忽略"
 
-#: fortran/resolve.cc:1928
+#: fortran/resolve.cc:1953
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
 msgstr "Intrinsic 副常式『%s』於 %L 不應該有型態說明符"
 
-#: fortran/resolve.cc:1939
+#: fortran/resolve.cc:1964
 #, fuzzy, gcc-internal-format
 msgid "%qs declared INTRINSIC at %L does not exist"
 msgstr "『%s』宣告的 INTRINSIC 於 %L 不存在"
 
-#: fortran/resolve.cc:1952
+#: fortran/resolve.cc:1977
 #, fuzzy, gcc-internal-format
 msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
 msgstr "intrinsic『%s』宣告的 INTRINSIC 於 %L 不是可用在中目前的標準設定值但是 %s。 使用適當 -std=* 選項或啟用 -fall-intrinsics 以便使用它。"
 
-#: fortran/resolve.cc:1990
+#: fortran/resolve.cc:2015
 #, fuzzy, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs from module %qs is possibly calling itself recursively in procedure %qs.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "非遞迴程序『%s』於 %L 是可能會呼叫它自己遞迴。 宣告它遞迴或使用 -frecursive"
 
-#: fortran/resolve.cc:1995 fortran/resolve.cc:7476
+#: fortran/resolve.cc:2020 fortran/resolve.cc:7554
 #, fuzzy, gcc-internal-format
 msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
 msgstr "非遞迴程序『%s』於 %L 是可能會呼叫它自己遞迴。 宣告它遞迴或使用 -frecursive"
 
-#: fortran/resolve.cc:2054 fortran/resolve.cc:12104 fortran/resolve.cc:14373
+#: fortran/resolve.cc:2079 fortran/resolve.cc:12182 fortran/resolve.cc:14493
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d referenced at %L is never defined"
 msgstr "標籤 %d(參照自 %L)從未被定義"
 
-#: fortran/resolve.cc:2086
+#: fortran/resolve.cc:2111
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs is used as an actual argument at %L"
 msgstr "Fortran 2008:內部程序『%s』被做為實際引數於 %L"
 
-#: fortran/resolve.cc:2104
+#: fortran/resolve.cc:2129
 #, fuzzy, gcc-internal-format
 #| msgid "Statement function '%s' at %L is not allowed as an actual argument"
 msgid "Statement function %qs at %L is not allowed as an actual argument"
 msgstr "敘述函式「%s」在 %L 處不允許做為實際引數"
 
-#: fortran/resolve.cc:2112
+#: fortran/resolve.cc:2137
 #, fuzzy, gcc-internal-format
 msgid "Intrinsic %qs at %L is not allowed as an actual argument"
 msgstr "Intrinsic『%s』於 %L 未被允許做為實際引數"
 
-#: fortran/resolve.cc:2119
+#: fortran/resolve.cc:2144
 #, fuzzy, gcc-internal-format
 msgid "Internal procedure %qs is used as actual argument at %L"
 msgstr "Fortran 2008:內部程序『%s』被做為實際引數於 %L"
 
-#: fortran/resolve.cc:2127
+#: fortran/resolve.cc:2152
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL non-INTRINSIC 程序「%s」在 %L 處不允許做為實際引數"
 
-#: fortran/resolve.cc:2154
+#: fortran/resolve.cc:2179
 #, fuzzy, gcc-internal-format
 msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
 msgstr "無法找到特定的 INTRINSIC 程序用於參考『%s』於 %L"
 
-#: fortran/resolve.cc:2176
+#: fortran/resolve.cc:2201
 #, fuzzy, gcc-internal-format
 #| msgid "Symbol '%s' at %L is ambiguous"
 msgid "Symbol %qs at %L is ambiguous"
 msgstr "符號「%s」(位於 %L)有歧義"
 
-#: fortran/resolve.cc:2240
+#: fortran/resolve.cc:2265
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not of numeric type"
 msgstr "By-value 引數於 %L 不是的數字類型"
 
-#: fortran/resolve.cc:2247
+#: fortran/resolve.cc:2272
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L cannot be an array or an array section"
 msgstr "By-value 引數於 %L 無法陣列或陣列區段"
 
-#: fortran/resolve.cc:2261
+#: fortran/resolve.cc:2286
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "By-value argument at %L is not allowed in this context"
 msgstr "By-value 引數於 %L 未被允許在中這個語境"
 
-#: fortran/resolve.cc:2273
+#: fortran/resolve.cc:2298
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passing internal procedure at %L by location not allowed"
 msgstr "傳遞內部程序於 %L 依位置不允許"
 
-#: fortran/resolve.cc:2284
+#: fortran/resolve.cc:2309
 #, fuzzy, gcc-internal-format
 #| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
 msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
 msgstr "ELEMENTAL non-INTRINSIC 程序「%s」在 %L 處不允許做為實際引數"
 
-#: fortran/resolve.cc:2293
+#: fortran/resolve.cc:2318
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed actual argument at %L with ultimate pointer component"
 msgstr "Coindexed 實際引數於 %L 與 ultimate 指標成分"
 
-#: fortran/resolve.cc:2310 fortran/resolve.cc:2315
+#: fortran/resolve.cc:2335 fortran/resolve.cc:2340
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L used as actual argument but does neither have an explicit interface nor the EXTERNAL attribute"
 msgstr "程序『%s』於 %L 與 assumed-shape 虛引數『%s』必須有明確的介面"
 
-#: fortran/resolve.cc:2467
+#: fortran/resolve.cc:2492
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is an array and OPTIONAL; If it is not present, then it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (Fortran 2018, 15.5.2.12)"
 msgstr "『%s』於 %L 是陣列和可選的；如果它缺少，它無法實際引數的 ELEMENTAL 程序除非有 non-optional 引數與同級 (12.4.1.5)"
 
-#: fortran/resolve.cc:2506
+#: fortran/resolve.cc:2531
 #, fuzzy, gcc-internal-format
 msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
 msgstr "實際引數於 %L 用於含義 (%s) 虛設『%s』的 ELEMENTAL 副常式『%s』是純量，但是另外的實際引數是陣列"
 
-#: fortran/resolve.cc:2780
+#: fortran/resolve.cc:2810
 #, fuzzy, gcc-internal-format
 msgid "Return type mismatch of function %qs at %L (%s/%s)"
 msgstr "傳回類型不匹配的函式『%s』於 %L (%s/%s)"
 
-#: fortran/resolve.cc:2807
+#: fortran/resolve.cc:2837
 #, fuzzy, gcc-internal-format
 msgid "Interface mismatch in global procedure %qs at %L: %s"
 msgstr "介面不匹配在中虛設程序『%s』於 %L:%s"
 
-#: fortran/resolve.cc:2919
+#: fortran/resolve.cc:2949
 #, fuzzy, gcc-internal-format
 msgid "There is no specific function for the generic %qs at %L"
 msgstr "沒有任何特定的函式用於通用『%s』於 %L"
 
-#: fortran/resolve.cc:2939
+#: fortran/resolve.cc:2969
 #, fuzzy, gcc-internal-format
 msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
 msgstr "通用函式『%s』於 %L 不是一致的與特定的 intrinsic 介面"
 
-#: fortran/resolve.cc:2977
+#: fortran/resolve.cc:3007
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "函式『%s』於 %L 是 INTRINSIC 但是不是相容與 intrinsic"
 
-#: fortran/resolve.cc:3038
+#: fortran/resolve.cc:3068
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific function %qs at %L"
 msgstr "無法解析特定的函式『%s』於 %L"
 
-#: fortran/resolve.cc:3115
+#: fortran/resolve.cc:3145
 #, gcc-internal-format
 msgid "Missing explicit declaration with EXTERNAL attribute for symbol %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:3150
+#: fortran/resolve.cc:3180
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type; did you mean %qs?"
 msgstr "函式「%s」在 %L 處沒有 IMPLICIT 類型"
 
-#: fortran/resolve.cc:3154 fortran/resolve.cc:20028
+#: fortran/resolve.cc:3184 fortran/resolve.cc:20162
 #, fuzzy, gcc-internal-format
 #| msgid "Function '%s' at %L has no IMPLICIT type"
 msgid "Function %qs at %L has no IMPLICIT type"
 msgstr "函式「%s」在 %L 處沒有 IMPLICIT 類型"
 
-#: fortran/resolve.cc:3308
+#: fortran/resolve.cc:3338
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Reference to impure function at %L inside a DO CONCURRENT"
 msgstr "參考到 non-PURE 函式『%s』於 %L 內部做共時 %s"
 
-#: fortran/resolve.cc:3319
+#: fortran/resolve.cc:3349
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a FORALL %s"
 msgstr "參考到 non-PURE 函式『%s』於 %L 內部 FORALL %s"
 
-#: fortran/resolve.cc:3326
+#: fortran/resolve.cc:3356
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
 msgstr "參考到 non-PURE 函式『%s』於 %L 內部做共時 %s"
 
-#: fortran/resolve.cc:3333
+#: fortran/resolve.cc:3363
 #, fuzzy, gcc-internal-format
 msgid "Reference to impure function %qs at %L within a PURE procedure"
 msgstr "參考到 non-PURE 函式『%s』於 %L 內部 FORALL %s"
 
-#: fortran/resolve.cc:3400
+#: fortran/resolve.cc:3430
 #, fuzzy, gcc-internal-format
 msgid "Unexpected junk after %qs at %L"
 msgstr "未預期的垃圾之後 NOWAIT 子句於 %C"
 
-#: fortran/resolve.cc:3411
+#: fortran/resolve.cc:3441
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L is not a function"
 msgstr "『%s』於 %L 並非函式"
 
-#: fortran/resolve.cc:3419 fortran/resolve.cc:4148
+#: fortran/resolve.cc:3449 fortran/resolve.cc:4227
 #, fuzzy, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
 msgstr "摘要介面『%s』必須不被引用於 %L"
 
-#: fortran/resolve.cc:3431
+#: fortran/resolve.cc:3461
 #, gcc-internal-format
 msgid "ABSTRACT INTERFACE %qs at %L must not have an assumed character length result (F2008: C418)"
 msgstr ""
 
 #. Internal procedures are taken care of in resolve_contained_fntype.
-#: fortran/resolve.cc:3474
+#: fortran/resolve.cc:3504
 #, fuzzy, gcc-internal-format
 msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
 msgstr "函式『%s』被宣告字元 (*) 和無法使用的於 %L 自從它並非虛引數"
 
-#: fortran/resolve.cc:3495
+#: fortran/resolve.cc:3525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Missing argument list in function '%s' at %C"
 msgid "Different argument lists in external dummy function %s at %L and %L"
 msgstr "函式「%s」在 %C 處缺少參數清單"
 
-#: fortran/resolve.cc:3534
+#: fortran/resolve.cc:3564
 #, fuzzy, gcc-internal-format
 msgid "resolve_function(): bad function type"
 msgstr "<unresolved overloaded function type>"
 
-#: fortran/resolve.cc:3548
+#: fortran/resolve.cc:3578
 #, gcc-internal-format, gfc-internal-format
 msgid "A BOZ literal constant at %L cannot appear as an actual argument in a function reference"
 msgstr ""
 
-#: fortran/resolve.cc:3564
+#: fortran/resolve.cc:3594
 #, fuzzy, gcc-internal-format
 msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
 msgstr "使用者自訂 non-ELEMENTAL 函式『%s』於 %L 不允許在中 WORKSHARE 建構"
 
-#: fortran/resolve.cc:3626
+#: fortran/resolve.cc:3656
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
 msgstr "條目『%s』於 %L 無法 called 遞迴，因為函式『%s』不是遞迴"
 
-#: fortran/resolve.cc:3630
+#: fortran/resolve.cc:3660
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "函式『%s』於 %L 無法 called 遞迴，因為它不是遞迴"
 
-#: fortran/resolve.cc:3688
+#: fortran/resolve.cc:3718
 #, fuzzy, gcc-internal-format
 msgid "Using function %qs at %L is deprecated"
 msgstr "%qE 被不宜用"
 
-#: fortran/resolve.cc:3699 fortran/resolve.cc:4189
+#: fortran/resolve.cc:3729 fortran/resolve.cc:4268
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L requires an EXTERNAL attribute"
 msgstr "共同區塊『%s』於 %L 無法有外部屬性"
 
-#: fortran/resolve.cc:3740
+#: fortran/resolve.cc:3770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Subroutine call at %L in a DO CONCURRENT block is not PURE"
 msgstr "副常式呼叫到『%s』在中做共時區塊於 %L 不是 PURE"
 
-#: fortran/resolve.cc:3749
+#: fortran/resolve.cc:3779
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
 msgstr "副常式呼叫到『%s』在中 FORALL 區塊於 %L 不是 PURE"
 
-#: fortran/resolve.cc:3755
+#: fortran/resolve.cc:3785
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
 msgstr "副常式呼叫到『%s』在中做共時區塊於 %L 不是 PURE"
 
-#: fortran/resolve.cc:3761
+#: fortran/resolve.cc:3791
 #, fuzzy, gcc-internal-format
 msgid "Subroutine call to %qs at %L is not PURE"
 msgstr "副常式呼叫到『%s』於 %L 不是 PURE"
 
-#: fortran/resolve.cc:3829
+#: fortran/resolve.cc:3859
 #, fuzzy, gcc-internal-format
 msgid "There is no specific subroutine for the generic %qs at %L"
 msgstr "沒有任何特定的副常式用於通用『%s』於 %L"
 
-#: fortran/resolve.cc:3838
+#: fortran/resolve.cc:3868
 #, fuzzy, gcc-internal-format
 msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
 msgstr "通用副常式『%s』於 %L 不是一致的與 intrinsic 副常式介面"
 
-#: fortran/resolve.cc:3873
+#: fortran/resolve.cc:3903
 #, fuzzy, gcc-internal-format
 msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
 msgstr "副常式『%s』於 %L 是 INTRINSIC 但是不是相容與 intrinsic"
 
-#: fortran/resolve.cc:3918
+#: fortran/resolve.cc:3948
 #, fuzzy, gcc-internal-format
 msgid "Unable to resolve the specific subroutine %qs at %L"
 msgstr "無法解析特定的副常式『%s』於 %L"
 
-#: fortran/resolve.cc:3983
+#: fortran/resolve.cc:4013
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated but does not appear in an IMPORT or IMPORT, ONLY list"
 msgstr ""
 
-#: fortran/resolve.cc:3990
+#: fortran/resolve.cc:4020
 #, gcc-internal-format
 msgid "F2018: C8102 %qs at %L is host associated in a scope that has IMPORT, NONE"
 msgstr ""
 
-#: fortran/resolve.cc:4119
+#: fortran/resolve.cc:4198
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
 msgstr "『%s』於 %L 有型態，該項不是一致的與呼叫於 %L"
 
-#: fortran/resolve.cc:4158
+#: fortran/resolve.cc:4237
 #, fuzzy, gcc-internal-format
 msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
 msgstr "條目『%s』於 %L 無法 called 遞迴，因為副常式『%s』不是遞迴"
 
-#: fortran/resolve.cc:4162
+#: fortran/resolve.cc:4241
 #, fuzzy, gcc-internal-format
 msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
 msgstr "副常式『%s』於 %L 無法 called 遞迴，因為它不是遞迴"
 
-#: fortran/resolve.cc:4223
+#: fortran/resolve.cc:4302
 #, gcc-internal-format, gfc-internal-format
 msgid "Different argument lists in external dummy subroutine %s at %L and %L"
 msgstr ""
 
-#: fortran/resolve.cc:4254
+#: fortran/resolve.cc:4333
 #, fuzzy, gcc-internal-format
 msgid "resolve_subroutine(): bad function type"
 msgstr "<unresolved overloaded function type>"
 
-#: fortran/resolve.cc:4271
+#: fortran/resolve.cc:4355
 #, fuzzy, gcc-internal-format
 msgid "Using subroutine %qs at %L is deprecated"
 msgstr "%qE 被不宜用"
 
-#: fortran/resolve.cc:4303
+#: fortran/resolve.cc:4387
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes for operands at %L and %L are not conformable"
 msgstr "%L 和 %L 處的運算元外形不相容"
 
-#: fortran/resolve.cc:4355
+#: fortran/resolve.cc:4439
 #, gcc-internal-format
 msgid "logical_to_bitwise(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:4458
+#: fortran/resolve.cc:4542
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "Impure function %qs at %L might not be evaluated"
 msgstr "CHARACTER(*) 函式「%s」(位於 %L)不能以指標賦值"
 
-#: fortran/resolve.cc:4462
+#: fortran/resolve.cc:4546
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Impure function at %L might not be evaluated"
 msgstr "alwaysinline 函式也許無法是 inlinable(_I)"
 
-#: fortran/resolve.cc:4557
+#: fortran/resolve.cc:4641
 #, fuzzy, gcc-internal-format
 msgid "BOZ literal constant at %L cannot be an operand of unary operator %qs"
 msgstr "By-value 引數於 %L 無法陣列或陣列區段"
 
-#: fortran/resolve.cc:4565
+#: fortran/resolve.cc:4649
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "comparison of unsigned expression >= 0 is always true"
 msgid "Negation of unsigned expression at %L not permitted "
 msgstr "無號運算式永遠大於或等於 0"
 
-#: fortran/resolve.cc:4586
+#: fortran/resolve.cc:4670
 #, gcc-internal-format
 msgid "Operands at %L and %L cannot appear as operands of binary operator %qs"
 msgstr ""
 
-#: fortran/resolve.cc:4596
+#: fortran/resolve.cc:4680
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL() pointer at %L"
 msgstr "無效的語境用於空值() 指標於 %%L"
 
-#: fortran/resolve.cc:4614
+#: fortran/resolve.cc:4698
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of unary numeric operator '%s' at %%L is %s"
 msgid "Operand of unary numeric operator %qs at %L is %s"
 msgstr "單位元數值運算子「%s」(位於 %%L)的運算元為 %s"
 
-#: fortran/resolve.cc:4629 fortran/resolve.cc:4663
+#: fortran/resolve.cc:4713 fortran/resolve.cc:4747
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
 msgid "Operands of binary numeric operator %qs at %L are %s/%s"
 msgstr "二元數值運算子「%s」(位於 %%L)的運算元為 %s/%s"
 
-#: fortran/resolve.cc:4643 fortran/resolve.cc:4832 fortran/resolve.cc:5001
+#: fortran/resolve.cc:4727 fortran/resolve.cc:4916 fortran/resolve.cc:5085
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent ranks for operator at %L and %L"
 msgstr "不一致分級用於運算子於 %%L 和 %%L"
 
-#: fortran/resolve.cc:4655
+#: fortran/resolve.cc:4739
 #, gcc-internal-format
 msgid "Unexpected derived-type entities in binary intrinsic numeric operator %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:4679
+#: fortran/resolve.cc:4763
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Operands of string concatenation operator at %%L are %s/%s"
 msgid "Operands of string concatenation operator at %L are %s/%s"
 msgstr "字串粘貼運算子(位於 %%L)的運算元為 %s/%s"
 
-#: fortran/resolve.cc:4722
+#: fortran/resolve.cc:4806
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of logical operator '%s' at %%L are %s/%s"
 msgid "Operands of logical operator %qs at %L are %s/%s"
 msgstr "邏輯運算子「%s」(位於 %%L)的運算元為 %s/%s"
 
-#: fortran/resolve.cc:4745
+#: fortran/resolve.cc:4829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Operand of .not. operator at %L is %s"
 msgstr "運算元的.not。運算子於 %%L 是 %s"
 
-#: fortran/resolve.cc:4760
+#: fortran/resolve.cc:4844
 #, gcc-internal-format, gfc-internal-format
 msgid "COMPLEX quantities cannot be compared at %L"
 msgstr "%L 處複數不能比較大小"
 
-#: fortran/resolve.cc:4790 fortran/resolve.cc:4805
+#: fortran/resolve.cc:4874 fortran/resolve.cc:4889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "BOZ literal constant near %L cannot appear as an operand of a relational operator"
 msgstr "By-value 引數於 %L 無法陣列或陣列區段"
 
-#: fortran/resolve.cc:4840
+#: fortran/resolve.cc:4924
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Inconsistent types for operator at %L and %L: %s and %s"
 msgstr "不一致分級用於運算子於 %%L 和 %%L"
 
-#: fortran/resolve.cc:4864
+#: fortran/resolve.cc:4948
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Equality comparison for %s at %L"
 msgstr "%s 種別無效，於 %L 處"
 
-#: fortran/resolve.cc:4866
+#: fortran/resolve.cc:4950
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Inequality comparison for %s at %L"
 msgstr "%s 種別無效，於 %L 處"
 
-#: fortran/resolve.cc:4879
+#: fortran/resolve.cc:4963
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Logicals at %%L must be compared with %s instead of %s"
 msgid "Logicals at %L must be compared with %s instead of %s"
 msgstr "%%L 處邏輯值必須與 %s 比較，而不是 %s"
 
-#: fortran/resolve.cc:4887
+#: fortran/resolve.cc:4971
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
 msgid "Operands of comparison operator %qs at %L are %s/%s"
 msgstr "比較運算子「%s」(位於 %%L)的運算元為 %s/%s"
 
-#: fortran/resolve.cc:4902
+#: fortran/resolve.cc:4986
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L; did you mean %qs?"
 msgstr "不明運算子『%s』於 %%L"
 
-#: fortran/resolve.cc:4905
+#: fortran/resolve.cc:4989
 #, fuzzy, gcc-internal-format
 msgid "Unknown operator %qs at %L"
 msgstr "不明運算子『%s』於 %%L"
 
-#: fortran/resolve.cc:4910
+#: fortran/resolve.cc:4994
 #, fuzzy, gcc-internal-format
 #| msgid "Operand of user operator '%s' at %%L is %s"
 msgid "Operand of user operator %qs at %L is %s"
 msgstr "使用者運算子「%s」(位於 %%L)的運算元為 %s"
 
-#: fortran/resolve.cc:4917
+#: fortran/resolve.cc:5001
 #, fuzzy, gcc-internal-format
 #| msgid "Operands of user operator '%s' at %%L are %s/%s"
 msgid "Operands of user operator %qs at %L are %s/%s"
 msgstr "使用者運算子「%s」(位於 %%L)的運算元為 %s/%s"
 
-#: fortran/resolve.cc:4931
+#: fortran/resolve.cc:5015
 #, gcc-internal-format
 msgid "resolve_operator(): Bad intrinsic"
 msgstr ""
 
-#: fortran/resolve.cc:5056
+#: fortran/resolve.cc:5140
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Condition in conditional expression must be a scalar logical at %L"
 msgstr "Coindex 的 codimension %d 必須是純量於 %L"
 
-#: fortran/resolve.cc:5063
+#: fortran/resolve.cc:5147
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same declared type"
 msgstr "實際引數到『%s』於 %L 必須有相同宣告的型態"
 
-#: fortran/resolve.cc:5071
+#: fortran/resolve.cc:5155
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same kind parameter"
 msgstr "allocate-object 於 %L 和 source-expr 於 %L 應該有相同 kind 型態參數"
 
-#: fortran/resolve.cc:5079
+#: fortran/resolve.cc:5163
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "expr at %L and expr at %L in conditional expression must have the same rank"
 msgstr "Source-expr 於 %L 和 allocate-object 於 %L 必須有相同形狀"
 
-#: fortran/resolve.cc:5091
+#: fortran/resolve.cc:5175
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, only integer, logical, real, complex and character types are currently supported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5100
+#: fortran/resolve.cc:5184
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, array is currently unsupported for conditional expressions at %L"
 msgstr ""
 
-#: fortran/resolve.cc:5270
+#: fortran/resolve.cc:5354
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "陣列參照於 %L 是超出邊界 (%ld<%ld) 在中尺寸 %d"
 
-#: fortran/resolve.cc:5275
+#: fortran/resolve.cc:5359
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
 msgstr "陣列參照於 %L 是超出邊界 (%ld<%ld) 在中 codimension %d"
 
-#: fortran/resolve.cc:5285
+#: fortran/resolve.cc:5369
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "陣列參照於 %L 是超出邊界 (%ld>%ld) 在中尺寸 %d"
 
-#: fortran/resolve.cc:5290
+#: fortran/resolve.cc:5374
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
 msgstr "陣列參照於 %L 是超出邊界 (%ld>%ld) 在中 codimension %d"
 
-#: fortran/resolve.cc:5311
+#: fortran/resolve.cc:5395
 #, gcc-internal-format, gfc-internal-format
 msgid "Illegal stride of zero at %L"
 msgstr "%L 零間隔無效"
 
-#: fortran/resolve.cc:5328
+#: fortran/resolve.cc:5412
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "降低陣列參照於 %L 是超出邊界 (%ld<%ld) 在中尺寸 %d"
 
-#: fortran/resolve.cc:5336
+#: fortran/resolve.cc:5420
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "降低陣列參照於 %L 是超出邊界 (%ld>%ld) 在中尺寸 %d"
 
-#: fortran/resolve.cc:5352
+#: fortran/resolve.cc:5436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
 msgstr "大寫陣列參照於 %L 是超出邊界 (%ld<%ld) 在中尺寸 %d"
 
-#: fortran/resolve.cc:5361
+#: fortran/resolve.cc:5445
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
 msgstr "大寫陣列參照於 %L 是超出邊界 (%ld>%ld) 在中尺寸 %d"
 
-#: fortran/resolve.cc:5377
+#: fortran/resolve.cc:5461
 #, fuzzy, gcc-internal-format
 #| msgid "subscript missing in array reference"
 msgid "check_dimension(): Bad array reference"
 msgstr "陣列參照缺少下標"
 
-#: fortran/resolve.cc:5400
+#: fortran/resolve.cc:5484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Rightmost upper bound of assumed size array section not specified at %L"
 msgstr "Rightmost 上限的假設的大小陣列區段尚未指定於 %L"
 
-#: fortran/resolve.cc:5410
+#: fortran/resolve.cc:5494
 #, gcc-internal-format, gfc-internal-format
 msgid "Rank mismatch in array reference at %L (%d/%d)"
 msgstr "%L 處陣列參照中秩不匹配(%d/%d)"
 
-#: fortran/resolve.cc:5418
+#: fortran/resolve.cc:5502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
 msgstr "Coindex 分級不匹配在中陣列參照於 %L (%d/%d)"
 
-#: fortran/resolve.cc:5434
+#: fortran/resolve.cc:5518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindex of codimension %d must be a scalar at %L"
 msgstr "Coindex 的 codimension %d 必須是純量於 %L"
 
-#: fortran/resolve.cc:5462
+#: fortran/resolve.cc:5546
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be scalar"
 msgstr "%L 處陣列索引必須是標量"
 
-#: fortran/resolve.cc:5468
+#: fortran/resolve.cc:5552
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L must be of INTEGER type, found %s"
 msgstr "陣列索引於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/resolve.cc:5474
+#: fortran/resolve.cc:5558
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "REAL array index at %L"
 msgstr "擴充：%L 處的 REAL 陣列索引"
 
-#: fortran/resolve.cc:5514
+#: fortran/resolve.cc:5598
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be scalar"
 msgstr "%L 引數維數必須是標量"
 
-#: fortran/resolve.cc:5521
+#: fortran/resolve.cc:5605
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument dim at %L must be of INTEGER type"
 msgstr "%L 處引數維數必須具有 INTEGER 類型"
 
-#: fortran/resolve.cc:5582
+#: fortran/resolve.cc:5666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid form of array reference at %C"
 msgid "Invalid array reference of a non-array entity at %L"
 msgstr "%C 處陣列參照形式無效"
 
-#: fortran/resolve.cc:5597
+#: fortran/resolve.cc:5681
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(1)"
 msgstr ""
 
-#: fortran/resolve.cc:5609
+#: fortran/resolve.cc:5693
 #, gcc-internal-format
 msgid "find_array_spec(): unused as(2)"
 msgstr ""
 
-#: fortran/resolve.cc:5654
+#: fortran/resolve.cc:5738
 #, gcc-internal-format, gfc-internal-format
 msgid "Array index at %L is an array of rank %d"
 msgstr "%L 處陣列索引是一個秩為 %d 的陣列"
 
-#: fortran/resolve.cc:5745
+#: fortran/resolve.cc:5829
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM_NUMBER argument at %L must be scalar"
 msgstr "%L 引數維數必須是標量"
 
-#: fortran/resolve.cc:5752
+#: fortran/resolve.cc:5836
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TEAM_NUMBER argument at %L must be of INTEGER type, found %s"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/resolve.cc:5766
+#: fortran/resolve.cc:5850
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "TEAM argument at %L must be scalar"
 msgstr "%L 引數維數必須是標量"
 
-#: fortran/resolve.cc:5775
+#: fortran/resolve.cc:5859
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be of TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV, found %s"
 msgstr ""
 
-#: fortran/resolve.cc:5789
+#: fortran/resolve.cc:5873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Argument dim at %L must be scalar"
 msgid "STAT argument at %L must be scalar"
 msgstr "%L 引數維數必須是標量"
 
-#: fortran/resolve.cc:5796
+#: fortran/resolve.cc:5880
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT argument at %L must be of INTEGER type, found %s"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/resolve.cc:5805
+#: fortran/resolve.cc:5889
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expression at %L must be scalar"
 msgid "STAT's expression at %L must be a variable"
 msgstr "%L 處的運算式必須具有標量類型"
 
-#: fortran/resolve.cc:5827
+#: fortran/resolve.cc:5911
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be of type INTEGER"
 msgstr "%L 處的子字串起始索引類型必須為 INTEGER"
 
-#: fortran/resolve.cc:5834
+#: fortran/resolve.cc:5918
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring start index at %L must be scalar"
 msgstr "%L 處的子字串起始索引必須是標量"
 
-#: fortran/resolve.cc:5856
+#: fortran/resolve.cc:5940
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be of type INTEGER"
 msgstr "%L 處的子字串終止索引類型必須為 INTEGER"
 
-#: fortran/resolve.cc:5863
+#: fortran/resolve.cc:5947
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L must be scalar"
 msgstr "%L 處的子字串終止索引必須是標量"
 
-#: fortran/resolve.cc:5883
+#: fortran/resolve.cc:5967
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Substring end index at %L is too large"
 msgstr "子字串結束索引於 %L 太大"
 
-#: fortran/resolve.cc:6112
+#: fortran/resolve.cc:6196
 #, fuzzy, gcc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "resolve_ref(): Bad array reference"
 msgstr "%L 處陣列參照錯誤"
 
-#: fortran/resolve.cc:6126
+#: fortran/resolve.cc:6210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
 msgstr "成分到權限的部分參考與非零值分級必須不有指標屬性於 %L"
 
-#: fortran/resolve.cc:6136
+#: fortran/resolve.cc:6220
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
 msgstr "成分到權限的部分參考與非零值分級必須不有 ALLOCATABLE 屬性於 %L"
 
-#: fortran/resolve.cc:6204
+#: fortran/resolve.cc:6288
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Two or more part references with nonzero rank must not be specified at %L"
 msgstr "兩個以上部分參考與非零值分級必須不被指定的於 %L"
 
-#: fortran/resolve.cc:6316
+#: fortran/resolve.cc:6400
 #, gcc-internal-format
 msgid "gfc_expression_rank(): Two array specs"
 msgstr ""
 
-#: fortran/resolve.cc:6345
+#: fortran/resolve.cc:6429
 #, fuzzy, gcc-internal-format
 msgid "Illegal coarray index"
 msgstr "不合法的運算元偵測到"
 
-#: fortran/resolve.cc:6393
+#: fortran/resolve.cc:6477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
 msgstr "假定外形的陣列在 %L 處必須是啞引數"
 
-#: fortran/resolve.cc:6403
+#: fortran/resolve.cc:6487
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may only be used as actual argument"
 msgstr "假定外形的陣列在 %L 處必須是啞引數"
@@ -89059,12 +89239,12 @@ msgstr "假定外形的陣列在 %L 處必須是啞引數"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6413
+#: fortran/resolve.cc:6497
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6434
+#: fortran/resolve.cc:6518
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L may only be used as actual argument"
 msgstr "假定外形的陣列在 %L 處必須是啞引數"
@@ -89073,420 +89253,420 @@ msgstr "假定外形的陣列在 %L 處必須是啞引數"
 #. for all inquiry functions in resolve_function; the reason is
 #. that the function-name resolution happens too late in that
 #. function.
-#: fortran/resolve.cc:6444
+#: fortran/resolve.cc:6528
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L as actual argument to an inquiry function shall be the first argument"
 msgstr ""
 
-#: fortran/resolve.cc:6455
+#: fortran/resolve.cc:6539
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
 msgstr "Coarray 變數『%s』於 %L 不應該有 codimensions 與已推遲形狀"
 
-#: fortran/resolve.cc:6464
+#: fortran/resolve.cc:6548
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not have a subobject reference"
 msgstr "Coarray 變數『%s』於 %L 不應該有 codimensions 與已推遲形狀"
 
-#: fortran/resolve.cc:6481
+#: fortran/resolve.cc:6565
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
 msgstr "Coarray 變數『%s』於 %L 不應該有 codimensions 與已推遲形狀"
 
-#: fortran/resolve.cc:6542
+#: fortran/resolve.cc:6626
 #, fuzzy, gcc-internal-format
 msgid "Scalar variable %qs has an array reference at %L"
 msgstr "建立陣列的參考"
 
-#: fortran/resolve.cc:6698
+#: fortran/resolve.cc:6773
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
 msgstr "變數『%s』，已用於規格運算式，被引用於 %L 之前條目敘述在中該項它是參數"
 
-#: fortran/resolve.cc:6703
+#: fortran/resolve.cc:6778
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
 msgstr "變數『%s』被使用於 %L 之前條目敘述在中該項它是參數"
 
-#: fortran/resolve.cc:6777
+#: fortran/resolve.cc:6855
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic subobject of coindexed object at %L"
 msgstr "Polymorphic 子物件的 coindexed 物件於 %L"
 
-#: fortran/resolve.cc:6790
+#: fortran/resolve.cc:6868
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
 msgstr "Coindexed 物件與 polymorphic allocatable subcomponent 於 %L"
 
-#: fortran/resolve.cc:6803
+#: fortran/resolve.cc:6881
 #, fuzzy, gcc-internal-format
 msgid "Using variable %qs at %L is deprecated"
 msgstr "%qE 被不宜用"
 
-#: fortran/resolve.cc:6859 fortran/resolve.cc:6947 fortran/resolve.cc:6971
+#: fortran/resolve.cc:6937 fortran/resolve.cc:7025 fortran/resolve.cc:7049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Bad array reference at %L"
 msgid "Invalid array reference at %L"
 msgstr "%L 處陣列參照錯誤"
 
-#: fortran/resolve.cc:7056
+#: fortran/resolve.cc:7134
 #, gcc-internal-format
 msgid "%qs at %L is host associated at %L into a contained procedure with an internal procedure of the same name"
 msgstr ""
 
-#: fortran/resolve.cc:7235 fortran/resolve.cc:7387
+#: fortran/resolve.cc:7313 fortran/resolve.cc:7465
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Error in typebound call at %L"
 msgstr "在中 type-spec 於 %L 時發生錯誤"
 
-#: fortran/resolve.cc:7351
+#: fortran/resolve.cc:7429
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Passed-object at %L must be scalar"
 msgstr "Passed-object 於 %L 必須是純量"
 
-#: fortran/resolve.cc:7358
+#: fortran/resolve.cc:7436
 #, fuzzy, gcc-internal-format
 msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
 msgstr "基底物件用於 procedure-pointer 成分呼叫於 %L 是的摘要型態『%s』"
 
-#: fortran/resolve.cc:7397
+#: fortran/resolve.cc:7475
 #, fuzzy, gcc-internal-format
 msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
 msgstr "基底物件用於 type-bound 程序呼叫於 %L 是的摘要型態『%s』"
 
-#: fortran/resolve.cc:7406
+#: fortran/resolve.cc:7484
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
 msgstr "基底物件用於 NOPASS type-bound 程序呼叫於 %L 必須是純量"
 
 #. Nothing matching found!
-#: fortran/resolve.cc:7601
+#: fortran/resolve.cc:7679
 #, fuzzy, gcc-internal-format
 msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
 msgstr "找到沒有匹配特定的繫結用於呼叫到通用『%s』於 %L"
 
-#: fortran/resolve.cc:7635
+#: fortran/resolve.cc:7713
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L should be a SUBROUTINE"
 msgstr "『%s』於 %L 應該是副常式"
 
-#: fortran/resolve.cc:7688
+#: fortran/resolve.cc:7766
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L should be a FUNCTION"
 msgstr "『%s』於 %L 應該是函式"
 
-#: fortran/resolve.cc:8253
+#: fortran/resolve.cc:8331
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "gfc_resolve_expr(): Bad expression type"
 msgstr "需要運算式類型"
 
-#: fortran/resolve.cc:8289
+#: fortran/resolve.cc:8367
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be a scalar"
 msgstr "%s (%L 處)必須是一個標量"
 
-#: fortran/resolve.cc:8299
+#: fortran/resolve.cc:8377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be integer"
 msgstr "『%s』於 %L 必須是 nonnegative"
 
-#: fortran/resolve.cc:8303 fortran/resolve.cc:8310
+#: fortran/resolve.cc:8381 fortran/resolve.cc:8388
 #, gcc-internal-format, gfc-internal-format
 msgid "%s at %L must be INTEGER"
 msgstr "%s (%L 處)必須是 INTEGER"
 
-#: fortran/resolve.cc:8365
+#: fortran/resolve.cc:8443
 #, gcc-internal-format, gfc-internal-format
 msgid "Step expression in DO loop at %L cannot be zero"
 msgstr "步進敘述於 %L 處的 DO 迴圈中不可為零"
 
-#: fortran/resolve.cc:8388
+#: fortran/resolve.cc:8466
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L will be executed zero times"
 msgstr "做迴圈於 %L 將被執行零次"
 
-#: fortran/resolve.cc:8405
+#: fortran/resolve.cc:8483
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it overflows"
 msgstr ""
 
-#: fortran/resolve.cc:8411
+#: fortran/resolve.cc:8489
 #, gcc-internal-format, gfc-internal-format
 msgid "DO loop at %L is undefined as it underflows"
 msgstr ""
 
-#: fortran/resolve.cc:8471
+#: fortran/resolve.cc:8549
 #, gcc-internal-format
 msgid "Variable %qs referenced in concurrent-header at %L must not appear in LOCAL locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8520
+#: fortran/resolve.cc:8598
 #, gcc-internal-format
 msgid "Variable %qs at %L not specified in a locality spec of DO CONCURRENT at %L but required due to DEFAULT (NONE)"
 msgstr ""
 
-#: fortran/resolve.cc:8572
+#: fortran/resolve.cc:8650
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected variable name in %s locality spec at %L"
 msgstr "在 %C 處需要變數名"
 
-#: fortran/resolve.cc:8581
+#: fortran/resolve.cc:8659
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' at %L has not been assigned a format label"
 msgid "Variable %qs at %L has already been specified in a locality-spec"
 msgstr "變數「%s」在 %L 尚未指派到格式標籤"
 
-#: fortran/resolve.cc:8591
+#: fortran/resolve.cc:8669
 #, fuzzy, gcc-internal-format
 #| msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
 msgid "Index variable %qs at %L cannot be specified in a locality-spec"
 msgstr "%L 處 PURE 程序不能指定 SAVE 屬性"
 
-#: fortran/resolve.cc:8604
+#: fortran/resolve.cc:8682
 #, gcc-internal-format
 msgid "OPTIONAL attribute not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8611
+#: fortran/resolve.cc:8689
 #, fuzzy, gcc-internal-format
 msgid "Assumed-size array not permitted for %qs in %s locality-spec at %L"
 msgstr "假設的大小陣列『%s』在中 %s 子句於 %L"
 
-#: fortran/resolve.cc:8624
+#: fortran/resolve.cc:8702
 #, fuzzy, gcc-internal-format
 msgid "ALLOCATABLE attribute not permitted for %qs in %s locality-spec at %L"
 msgstr "指標物件『%s』在中 %s 子句於 %L"
 
-#: fortran/resolve.cc:8629
+#: fortran/resolve.cc:8707
 #, fuzzy, gcc-internal-format
 msgid "Nonpointer polymorphic dummy argument not permitted for %qs in %s locality-spec at %L"
 msgstr "Coindexed 引數無法允許的在中『%s』呼叫於 %L"
 
-#: fortran/resolve.cc:8634
+#: fortran/resolve.cc:8712
 #, fuzzy, gcc-internal-format
 msgid "Coarray not permitted for %qs in %s locality-spec at %L"
 msgstr "Cray 點『%s』在中 %s 子句於 %L"
 
-#: fortran/resolve.cc:8640
+#: fortran/resolve.cc:8718
 #, fuzzy, gcc-internal-format
 msgid "Finalizable type not permitted for %qs in %s locality-spec at %L"
 msgstr "Coindexed 引數無法允許的在中『%s』呼叫於 %L"
 
-#: fortran/resolve.cc:8645
+#: fortran/resolve.cc:8723
 #, gcc-internal-format
 msgid "Type with ultimate allocatable component not permitted for %qs in %s locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8653
+#: fortran/resolve.cc:8731
 #, gcc-internal-format
 msgid "ASYNCHRONOUS attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8657
+#: fortran/resolve.cc:8735
 #, gcc-internal-format
 msgid "VOLATILE attribute not permitted for %qs in REDUCE locality-spec at %L"
 msgstr ""
 
-#: fortran/resolve.cc:8711
+#: fortran/resolve.cc:8789
 #, fuzzy, gcc-internal-format
 msgid "Expected numeric type for %qs in REDUCE at %L, got %s"
 msgstr "未預期的空值() intrinsic 於 %L 到虛設『%s』"
 
-#: fortran/resolve.cc:8720
+#: fortran/resolve.cc:8798
 #, fuzzy, gcc-internal-format
 #| msgid "Expected block name of '%s' in %s statement at %C"
 msgid "Expected logical type for %qs in REDUCE at %L, got %qs"
 msgstr "需要塊名「%s」在「%s」運算式中，於 %C"
 
-#: fortran/resolve.cc:8738
+#: fortran/resolve.cc:8816
 #, gcc-internal-format
 msgid "Expected INTEGER, REAL or CHARACTER type for %qs in REDUCE with MIN/MAX at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8747
+#: fortran/resolve.cc:8825
 #, gcc-internal-format
 msgid "Expected integer type for %qs in REDUCE with IAND/IOR/IEOR at %L, got %s"
 msgstr ""
 
-#: fortran/resolve.cc:8785
+#: fortran/resolve.cc:8863
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs in locality-spec at %L is not used"
 msgstr "變數 %qD 設定並不是使用"
 
-#: fortran/resolve.cc:8818
+#: fortran/resolve.cc:8896
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgstr "%L 處 FORALL 索引名稱必須是 INTEGER 標量"
 
-#: fortran/resolve.cc:8823
+#: fortran/resolve.cc:8901
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL start expression at %L must be a scalar INTEGER"
 msgstr "%L 處的 FORALL 啟始敘述必須是 INTEGER 標量"
 
-#: fortran/resolve.cc:8830
+#: fortran/resolve.cc:8908
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL end expression at %L must be a scalar INTEGER"
 msgstr "%L 處的 FORALL 結束敘述必須是 INTEGER 標量"
 
-#: fortran/resolve.cc:8838
+#: fortran/resolve.cc:8916
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L must be a scalar %s"
 msgstr "%L 處的 FORALL 步幅敘述必須是 %s 標量"
 
-#: fortran/resolve.cc:8843
+#: fortran/resolve.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "FORALL stride expression at %L cannot be zero"
 msgstr "%L 處的 FORALL 步幅敘述不能為零"
 
-#: fortran/resolve.cc:8856
+#: fortran/resolve.cc:8934
 #, fuzzy, gcc-internal-format
 msgid "FORALL index %qs may not appear in triplet specification at %L"
 msgstr "FORALL 索引『%s』可能無法出現在中 triplet 規格於 %L"
 
-#: fortran/resolve.cc:8961 fortran/resolve.cc:9284
+#: fortran/resolve.cc:9039 fortran/resolve.cc:9362
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
 msgstr "Allocate-object 於 %L 必須是 ALLOCATABLE 或指標"
 
-#: fortran/resolve.cc:8969 fortran/resolve.cc:9247
+#: fortran/resolve.cc:9047 fortran/resolve.cc:9325
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed allocatable object at %L"
 msgstr "Coindexed allocatable 物件於 %L"
 
-#: fortran/resolve.cc:9093
+#: fortran/resolve.cc:9171
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L has rank %d but MOLD= expression at %L has rank %d"
 msgstr "Allocate-object 於 %L 也出現於 %L"
 
-#: fortran/resolve.cc:9104
+#: fortran/resolve.cc:9182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
 msgstr "Source-expr 於 %L 必須是純量或有同級做為 allocate-object 於 %L"
 
-#: fortran/resolve.cc:9135
+#: fortran/resolve.cc:9213
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Source-expr at %L and allocate-object at %L must have the same shape"
 msgstr "Source-expr 於 %L 和 allocate-object 於 %L 必須有相同形狀"
 
-#: fortran/resolve.cc:9299
+#: fortran/resolve.cc:9377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Only intrinsic operators can be used in expression at %L"
 msgid "The intrinsic NULL cannot be used as source-expr at %L"
 msgstr "%L 處只有內建運算子才能用於運算式中"
 
-#: fortran/resolve.cc:9307
+#: fortran/resolve.cc:9385
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type of entity at %L is type incompatible with source-expr at %L"
 msgstr "型態的實體於 %L 是型態不相容的與 source-expr 於 %L"
 
-#: fortran/resolve.cc:9319
+#: fortran/resolve.cc:9397
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
 msgstr "allocate-object 於 %L 和 source-expr 於 %L 應該有相同 kind 型態參數"
 
-#: fortran/resolve.cc:9333
+#: fortran/resolve.cc:9411
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
 msgstr "source-expr 於 %L 應該 neither 是的型態 LOCK_TYPE nor 有 LOCK_TYPE 成分如果 allocate-object 於 %L 是 coarray"
 
-#: fortran/resolve.cc:9358
+#: fortran/resolve.cc:9436
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
 msgstr "source-expr 於 %L 應該 neither 是的型態 LOCK_TYPE nor 有 LOCK_TYPE 成分如果 allocate-object 於 %L 是 coarray"
 
-#: fortran/resolve.cc:9371
+#: fortran/resolve.cc:9449
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
 msgstr "配置 %s 的摘要基底類型於 %L 需要 type-spec 或 source-expr"
 
-#: fortran/resolve.cc:9385
+#: fortran/resolve.cc:9463
 #, gcc-internal-format
 msgid "The type parameter in ALLOCATE statement with type-spec shall be an asterisk as allocate object %qs at %L is a dummy argument with assumed type parameter"
 msgstr ""
 
-#: fortran/resolve.cc:9405
+#: fortran/resolve.cc:9483
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
 msgstr "配置 %s 於 %L 與 type-spec 需求相同 character-length 參數做為在中宣告"
 
-#: fortran/resolve.cc:9489 fortran/resolve.cc:9504
+#: fortran/resolve.cc:9567 fortran/resolve.cc:9582
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array specification required in ALLOCATE statement at %L"
 msgstr "陣列規格必要項在中配置敘述於 %L"
 
-#: fortran/resolve.cc:9496
+#: fortran/resolve.cc:9574
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
 msgstr "陣列規格必要項在中配置敘述於 %L"
 
-#: fortran/resolve.cc:9521
+#: fortran/resolve.cc:9599
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coarray specification required in ALLOCATE statement at %L"
 msgstr "Coarray 規格必要項在中配置敘述於 %L"
 
-#: fortran/resolve.cc:9531 fortran/resolve.cc:9633
+#: fortran/resolve.cc:9609 fortran/resolve.cc:9711
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad coarray specification in ALLOCATE statement at %L"
 msgstr "不當的 coarray 規格在中配置敘述於 %L"
 
-#: fortran/resolve.cc:9537
+#: fortran/resolve.cc:9615
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9549
+#: fortran/resolve.cc:9627
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper cobound is less than lower cobound of 1 at %L"
 msgstr ""
 
-#: fortran/resolve.cc:9560 fortran/resolve.cc:9588
+#: fortran/resolve.cc:9638 fortran/resolve.cc:9666
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad array specification in ALLOCATE statement at %L"
 msgstr "不當的陣列規格在中配置敘述於 %L"
 
-#: fortran/resolve.cc:9607
+#: fortran/resolve.cc:9685
 #, fuzzy, gcc-internal-format
 msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
 msgstr "『%s』必須不出現在中陣列規格於 %L 在中相同配置敘述位置它是它自己配置"
 
-#: fortran/resolve.cc:9622
+#: fortran/resolve.cc:9700
 #, fuzzy, gcc-internal-format
 msgid "Expected %<*%> in coindex specification in ALLOCATE statement at %L"
 msgstr "預期『*』在中 coindex 規格在中配置敘述於 %L"
 
-#: fortran/resolve.cc:9664
+#: fortran/resolve.cc:9742
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L must be a scalar INTEGER variable"
 msgstr "Stat-variable 於 %L 必須是純量整數變數"
 
-#: fortran/resolve.cc:9693
+#: fortran/resolve.cc:9771
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Stat-variable at %L shall not be %sd within the same %s statement"
 msgstr "Stat-variable 於 %L 不應該是 %sd 在之內相同 %s 敘述"
 
-#: fortran/resolve.cc:9706
+#: fortran/resolve.cc:9784
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG at %L is useless without a STAT tag"
 msgstr "ERRMSG 於 %L 是無用的而無需 STAT 標籤"
 
-#: fortran/resolve.cc:9720
+#: fortran/resolve.cc:9798
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG variable at %L shall be a scalar default CHARACTER variable"
 msgstr "ERRMSG=引數於 %L 必須是純量字元變數"
 
-#: fortran/resolve.cc:9749
+#: fortran/resolve.cc:9827
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
 msgstr "Errmsg-variable 於 %L 不應該是 %sd 在之內相同 %s 敘述"
 
-#: fortran/resolve.cc:9781
+#: fortran/resolve.cc:9859
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L also appears at %L"
 msgstr "Allocate-object 於 %L 也出現於 %L"
 
-#: fortran/resolve.cc:9787 fortran/resolve.cc:9793
+#: fortran/resolve.cc:9865 fortran/resolve.cc:9871
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Allocate-object at %L is subobject of object at %L"
 msgstr "Allocate-object 於 %L 是子物件的物件於 %L"
@@ -89495,315 +89675,315 @@ msgstr "Allocate-object 於 %L 是子物件的物件於 %L"
 #. element in the list.  Either way, we must
 #. issue an error and get the next case from P.
 #. FIXME: Sort P and Q by line number.
-#: fortran/resolve.cc:10022
+#: fortran/resolve.cc:10100
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "CASE label at %L overlaps with CASE label at %L"
 msgstr "大小寫標貼於 %L 重疊與大小寫標貼於 %L"
 
-#: fortran/resolve.cc:10073
+#: fortran/resolve.cc:10151
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of type %s"
 msgstr "%L 處 CASE 敘述中的運算式必須具有 %s 類型"
 
-#: fortran/resolve.cc:10084
+#: fortran/resolve.cc:10162
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be of kind %d"
 msgstr "運算式在中條件敘述於 %L 必須是的 kind %d"
 
-#: fortran/resolve.cc:10097
+#: fortran/resolve.cc:10175
 #, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L must be scalar"
 msgstr "%L 處 CASE 敘述中的運算式必須為標量"
 
-#: fortran/resolve.cc:10143
+#: fortran/resolve.cc:10221
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
 msgstr "選擇運算式在中計算的前往敘述於 %L 必須是純量整數運算式"
 
-#: fortran/resolve.cc:10164
+#: fortran/resolve.cc:10242
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L cannot be %s"
 msgstr "%L 處 SELECT 敘述的引數不能是 %s"
 
-#: fortran/resolve.cc:10174
+#: fortran/resolve.cc:10252
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of SELECT statement at %L must be a scalar expression"
 msgstr "%L 處 SELECT 敘述的引數不能是 %s"
 
-#: fortran/resolve.cc:10192 fortran/resolve.cc:10200
+#: fortran/resolve.cc:10270 fortran/resolve.cc:10278
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expression in CASE statement at %L is not in the range of %s"
 msgstr "運算式在中條件敘述於 %L 不是在中範圍的 %s"
 
-#: fortran/resolve.cc:10262 fortran/resolve.cc:11118
+#: fortran/resolve.cc:10340 fortran/resolve.cc:11196
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
 msgstr "預設大小寫於 %L 無法在之後秒預設大小寫於 %L"
 
-#: fortran/resolve.cc:10288
+#: fortran/resolve.cc:10366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Logical range in CASE statement at %L is not allowed"
 msgstr "邏輯的範圍在中條件敘述於 %L 未被允許"
 
-#: fortran/resolve.cc:10301
+#: fortran/resolve.cc:10379
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Constant logical value in CASE statement is repeated at %L"
 msgstr "常數邏輯的值在中條件敘述被重複於 %L"
 
-#: fortran/resolve.cc:10316
+#: fortran/resolve.cc:10394
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Range specification at %L can never be matched"
 msgstr "範圍規格於 %L 可以永不被匹配"
 
-#: fortran/resolve.cc:10419
+#: fortran/resolve.cc:10497
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Logical SELECT CASE block at %L has more that two cases"
 msgstr "邏輯的選取大小寫區塊於 %L 有更多該兩大小寫"
 
-#: fortran/resolve.cc:10460
+#: fortran/resolve.cc:10538
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s could not be resolved to a specific function at %L"
 msgstr "無法解析特定的函式『%s』於 %L"
 
-#: fortran/resolve.cc:10498
+#: fortran/resolve.cc:10576
 #, gcc-internal-format, gfc-internal-format
 msgid "(F202y)Missing or invalid bound in ASSOCIATE rank remapping of associate name %s at %L"
 msgstr ""
 
-#: fortran/resolve.cc:10514
+#: fortran/resolve.cc:10592
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure pointer"
 msgstr "內部程序『%s』無效在中程序指標指派於 %L"
 
-#: fortran/resolve.cc:10523
+#: fortran/resolve.cc:10601
 #, fuzzy, gcc-internal-format
 #| msgid "The name '%s' cannot be used as a defined operator at %C"
 msgid "Derived type %qs cannot be used as a variable at %L"
 msgstr "名稱「%s」在 %C 處不能做為已定義的運算子"
 
-#: fortran/resolve.cc:10540
+#: fortran/resolve.cc:10618
 #, fuzzy, gcc-internal-format
 msgid "Associating entity %qs at %L is a procedure name"
 msgstr "Associate-name『%s』於 %L 被做為陣列"
 
-#: fortran/resolve.cc:10556
+#: fortran/resolve.cc:10634
 #, gcc-internal-format, gfc-internal-format
 msgid "Associating selector-expression at %L yields a procedure"
 msgstr ""
 
-#: fortran/resolve.cc:10610
+#: fortran/resolve.cc:10688
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L cannot be NULL()"
 msgstr "關聯目標於 %C 必須不被 coindexed"
 
-#: fortran/resolve.cc:10615
+#: fortran/resolve.cc:10693
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L has no type"
 msgstr "關聯目標於 %C 必須不被 coindexed"
 
-#: fortran/resolve.cc:10674
+#: fortran/resolve.cc:10752
 #, fuzzy, gcc-internal-format
 msgid "Associate-name %qs at %L is used as array"
 msgstr "Associate-name『%s』於 %L 被做為陣列"
 
-#: fortran/resolve.cc:10685
+#: fortran/resolve.cc:10763
 #, gcc-internal-format, gfc-internal-format
 msgid "CLASS selector at %L needs a temporary which is not yet implemented"
 msgstr ""
 
-#: fortran/resolve.cc:10977
+#: fortran/resolve.cc:11055
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
 msgstr "選擇器應該是 polymorphic 在中選取型態敘述於 %L"
 
-#: fortran/resolve.cc:11026 fortran/resolve.cc:11038
+#: fortran/resolve.cc:11104 fortran/resolve.cc:11116
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Selector at %L must not be coindexed"
 msgstr "關聯目標於 %C 必須不被 coindexed"
 
-#: fortran/resolve.cc:11067
+#: fortran/resolve.cc:11145
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "TYPE IS at %L overlaps with TYPE IS at %L"
 msgstr "大小寫標貼於 %L 重疊與大小寫標貼於 %L"
 
-#: fortran/resolve.cc:11080
+#: fortran/resolve.cc:11158
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be extensible"
 msgstr "衍生類型『%s』於 %L 必須是 extensible"
 
-#: fortran/resolve.cc:11093
+#: fortran/resolve.cc:11171
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L must be an extension of %qs"
 msgstr "衍生類型『%s』於 %L 必須是延伸的『%s』"
 
-#: fortran/resolve.cc:11096
+#: fortran/resolve.cc:11174
 #, fuzzy, gcc-internal-format
 msgid "Unexpected intrinsic type %qs at %L"
 msgstr "未預期的空值() intrinsic 於 %L 到虛設『%s』"
 
-#: fortran/resolve.cc:11106
+#: fortran/resolve.cc:11184
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The type-spec at %L shall specify that each length type parameter is assumed"
 msgstr "Type-spec 於 %L 無法包含已推遲型態參數"
 
-#: fortran/resolve.cc:11374
+#: fortran/resolve.cc:11452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Double CLASS IS block in SELECT TYPE statement at %L"
 msgstr "雙倍類別是區塊在中選取型態敘述於 %L"
 
-#: fortran/resolve.cc:11507
+#: fortran/resolve.cc:11585
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK DEFAULT at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11516
+#: fortran/resolve.cc:11594
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11519
+#: fortran/resolve.cc:11597
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (%i) at %L is repeated at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11529
+#: fortran/resolve.cc:11607
 #, gcc-internal-format, gfc-internal-format
 msgid "RANK (*) at %L cannot be used with the pointer or allocatable selector at %L"
 msgstr ""
 
-#: fortran/resolve.cc:11638
+#: fortran/resolve.cc:11716
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid context for NULL () intrinsic at %L"
 msgstr "無效的語境用於空值() 指標於 %%L"
 
-#: fortran/resolve.cc:11692
+#: fortran/resolve.cc:11770
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DTIO %s procedure at %L must be recursive"
 msgstr "停止編碼於 %L 必須是純量"
 
-#: fortran/resolve.cc:11702
+#: fortran/resolve.cc:11780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
 msgstr "資料轉移元件於 %L 無法 polymorphic 除非它被處理由定義的輸入/輸出程序"
 
-#: fortran/resolve.cc:11715
+#: fortran/resolve.cc:11793
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
 msgstr "資料轉移元件於 %L 無法有指標成分除非它被處理由定義的輸入/輸出程序"
 
-#: fortran/resolve.cc:11724
+#: fortran/resolve.cc:11802
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have procedure pointer components"
 msgstr "資料轉移元件於 %L 無法有程序指標成分"
 
-#: fortran/resolve.cc:11731
+#: fortran/resolve.cc:11809
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
 msgstr "資料轉移元件於 %L 無法有 ALLOCATABLE 成分除非它被處理由定義的輸入/輸出程序"
 
-#: fortran/resolve.cc:11742
+#: fortran/resolve.cc:11820
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components"
 msgstr "資料轉移元件於 %L 無法有私人的成分"
 
-#: fortran/resolve.cc:11748
+#: fortran/resolve.cc:11826
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot have PRIVATE components unless it is processed by a defined input/output procedure"
 msgstr "資料轉移元件於 %L 無法有指標成分除非它被處理由定義的輸入/輸出程序"
 
-#: fortran/resolve.cc:11766
+#: fortran/resolve.cc:11844
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
 msgstr "資料轉移元件於 %L 無法全部參考到 assumed-size 陣列"
 
-#: fortran/resolve.cc:11817
+#: fortran/resolve.cc:11895
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
 msgstr "鎖定變數於 %L 必須是純量的型態 LOCK_TYPE"
 
-#: fortran/resolve.cc:11827
+#: fortran/resolve.cc:11905
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
 msgstr "鎖定變數於 %L 必須是純量的型態 LOCK_TYPE"
 
-#: fortran/resolve.cc:11831
+#: fortran/resolve.cc:11909
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray or coindexed"
 msgstr "實際引數到『%s』於 %L 必須是 coarray"
 
-#: fortran/resolve.cc:11834
+#: fortran/resolve.cc:11912
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Event variable argument at %L must be a coarray but not coindexed"
 msgstr "實際引數到『%s』於 %L 必須是 coarray"
 
-#: fortran/resolve.cc:11841 fortran/resolve.cc:12068
+#: fortran/resolve.cc:11919 fortran/resolve.cc:12146
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "STAT= argument at %L must be a scalar INTEGER variable"
 msgstr "STAT=引數於 %L 必須是純量整數變數"
 
-#: fortran/resolve.cc:11853 fortran/resolve.cc:12080
+#: fortran/resolve.cc:11931 fortran/resolve.cc:12158
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
 msgstr "ERRMSG=引數於 %L 必須是純量字元變數"
 
-#: fortran/resolve.cc:11865
+#: fortran/resolve.cc:11943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
 msgstr "ACQUIRED_LOCK=引數於 %L 必須是純量邏輯的變數"
 
-#: fortran/resolve.cc:11878
+#: fortran/resolve.cc:11956
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
 msgstr "Imageset 引數於 %L 必須是純量或 rank-1 整數運算式"
 
-#: fortran/resolve.cc:11891
+#: fortran/resolve.cc:11969
 #, gcc-internal-format, gfc-internal-format
 msgid "TEAM argument at %L must be a scalar expression of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV"
 msgstr ""
 
-#: fortran/resolve.cc:11905
+#: fortran/resolve.cc:11983
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s variable of at least kind %d"
 msgstr "STAT=引數於 %L 必須是純量整數變數"
 
-#: fortran/resolve.cc:11926
+#: fortran/resolve.cc:12004
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s argument at %L must be a scalar %s of at least kind %d"
 msgstr "%s 標籤於 %L 必須是字元串的預設 kind"
 
-#: fortran/resolve.cc:12044
+#: fortran/resolve.cc:12122
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
 msgstr "Imageset 引數於 %L 必須是純量或 rank-1 整數運算式"
 
-#: fortran/resolve.cc:12048 fortran/resolve.cc:12058
+#: fortran/resolve.cc:12126 fortran/resolve.cc:12136
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Imageset argument at %L must between 1 and num_images()"
 msgstr "Imageset 引數於 %L 必須介於 1 和 numimages()(_I)"
 
-#: fortran/resolve.cc:12111
+#: fortran/resolve.cc:12189
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
 msgstr "敘述於 %L 並非有效分支目標敘述用於分支敘述於 %L"
 
-#: fortran/resolve.cc:12120
+#: fortran/resolve.cc:12198
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Branch at %L may result in an infinite loop"
 msgstr "分支於 %L 也許會導致無窮迴圈"
 
 #. Note: A label at END CRITICAL does not leave the CRITICAL
 #. construct as END CRITICAL is still part of it.
-#: fortran/resolve.cc:12138 fortran/resolve.cc:12165
+#: fortran/resolve.cc:12216 fortran/resolve.cc:12243
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
 msgstr "前往敘述於 %L 樹葉重要建構用於標貼於 %L"
 
-#: fortran/resolve.cc:12142 fortran/resolve.cc:12171
+#: fortran/resolve.cc:12220 fortran/resolve.cc:12249
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
 msgstr "前往敘述於 %L 樹葉做共時建構用於標貼於 %L"
 
-#: fortran/resolve.cc:12146
+#: fortran/resolve.cc:12224
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "GOTO statement at %L leaves CHANGE TEAM construct for label at %L"
 msgstr "前往敘述於 %L 樹葉重要建構用於標貼於 %L"
@@ -89811,220 +89991,220 @@ msgstr "前往敘述於 %L 樹葉重要建構用於標貼於 %L"
 #. The label is not in an enclosing block, so illegal.  This was
 #. allowed in Fortran 66, so we allow it as extension.  No
 #. further checks are necessary in this case.
-#: fortran/resolve.cc:12186
+#: fortran/resolve.cc:12264
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Label at %L is not in the same block as the GOTO statement at %L"
 msgstr "標貼於 %L 不是在中相同區塊做為前往敘述於 %L"
 
-#: fortran/resolve.cc:12258
+#: fortran/resolve.cc:12336
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "WHERE mask at %L has inconsistent shape"
 msgstr "位置遮罩於 %L 有不一致形狀"
 
-#: fortran/resolve.cc:12274
+#: fortran/resolve.cc:12352
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "WHERE assignment target at %L has inconsistent shape"
 msgstr "位置指派目標於 %L 有不一致形狀"
 
-#: fortran/resolve.cc:12287 fortran/resolve.cc:12382
+#: fortran/resolve.cc:12365 fortran/resolve.cc:12460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
 msgstr "Non-ELEMENTAL 使用者定義的指派在中位置於 %L"
 
-#: fortran/resolve.cc:12297 fortran/resolve.cc:12392
+#: fortran/resolve.cc:12375 fortran/resolve.cc:12470
 #, gcc-internal-format, gfc-internal-format
 msgid "Unsupported statement inside WHERE at %L"
 msgstr "%L 處在 WHERE 內不支援的敘述"
 
-#: fortran/resolve.cc:12327
+#: fortran/resolve.cc:12405
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to a FORALL index variable at %L"
 msgstr "%L 處向 FORALL 索引變數賦值"
 
-#: fortran/resolve.cc:12340
+#: fortran/resolve.cc:12418
 #, fuzzy, gcc-internal-format
 msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
 msgstr "FORALL 與索引『%s』未被使用左側的側邊的指派於 %L 和因而也許造成多重指派到這個物件"
 
-#: fortran/resolve.cc:12676
+#: fortran/resolve.cc:12754
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL construct at %L"
 msgstr "Fortran 2008:區塊建構於 %C"
 
-#: fortran/resolve.cc:12702
+#: fortran/resolve.cc:12780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "FORALL index-name at %L must be a scalar INTEGER"
 msgid "FORALL index-name at %L must be a scalar variable of type integer"
 msgstr "%L 處 FORALL 索引名稱必須是 INTEGER 標量"
 
-#: fortran/resolve.cc:12714
+#: fortran/resolve.cc:12792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "An outer FORALL construct already has an index with this name %L"
 msgstr "外 FORALL 建構已經有索引與這個名稱 %L"
 
-#: fortran/resolve.cc:12749
+#: fortran/resolve.cc:12827
 #, fuzzy, gcc-internal-format
 #| msgid "Expected variable name at %C"
 msgid "Expected shadow variable name to start with _"
 msgstr "在 %C 處需要變數名"
 
-#: fortran/resolve.cc:12836
+#: fortran/resolve.cc:12914
 #, gcc-internal-format, gfc-internal-format
 msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
 msgstr "%L 處的 WHERE/ELSEWHERE 子句需要一個 LOGICAL 陣列"
 
-#: fortran/resolve.cc:12957
+#: fortran/resolve.cc:13035
 #, gcc-internal-format
 msgid "gfc_resolve_blocks(): Bad block type"
 msgstr ""
 
-#: fortran/resolve.cc:13037
+#: fortran/resolve.cc:13115
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable in the ordinary assignment at %L is a procedure pointer component"
 msgstr "資料轉移元件於 %L 無法有程序指標成分"
 
-#: fortran/resolve.cc:13057
+#: fortran/resolve.cc:13135
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot assign %s to %s at %L"
 msgstr "不能將 %s 轉換為 %s，於 %L"
 
-#: fortran/resolve.cc:13105
+#: fortran/resolve.cc:13183
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER expression will be truncated in assignment (%wd/%wd) at %L"
 msgstr "字元運算式將被截斷在中指派 (%d/%d) 於 %L"
 
-#: fortran/resolve.cc:13137
+#: fortran/resolve.cc:13215
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
 msgstr "Coindexed 運算式於 %L 被指派到衍生類型變數與指標成分在中 PURE 程序"
 
 #. F2008, C1283 (4).
-#: fortran/resolve.cc:13143
+#: fortran/resolve.cc:13221
 #, gcc-internal-format, gfc-internal-format
 msgid "In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection."
 msgstr ""
 
-#: fortran/resolve.cc:13155
+#: fortran/resolve.cc:13233
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assignment to coindexed variable at %L in a PURE procedure"
 msgstr "指派到 coindexed 變數於 %L 在中 PURE 程序"
 
-#: fortran/resolve.cc:13187
+#: fortran/resolve.cc:13265
 #, gcc-internal-format, gfc-internal-format
 msgid "Assignment to polymorphic coarray at %L is not permitted"
 msgstr ""
 
-#: fortran/resolve.cc:13191
+#: fortran/resolve.cc:13269
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Assignment to a FORALL index variable at %L"
 msgid "Assignment to an allocatable polymorphic variable at %L"
 msgstr "%L 處向 FORALL 索引變數賦值"
 
-#: fortran/resolve.cc:13196
+#: fortran/resolve.cc:13274
 #, gcc-internal-format
 msgid "Assignment to an allocatable polymorphic variable at %L requires %<-frealloc-lhs%>"
 msgstr ""
 
-#: fortran/resolve.cc:13203
+#: fortran/resolve.cc:13281
 #, fuzzy, gcc-internal-format
 msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for %<=%> operator"
 msgstr "變數必須不是 polymorphic 在中 intrinsic 指派於 %L - 檢查該有匹配特定的副常式用於『=』運算子"
 
-#: fortran/resolve.cc:13214
+#: fortran/resolve.cc:13292
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
 msgstr "Coindexed 變數必須不是有 allocatable ultimate 成分在中指派於 %L"
 
-#: fortran/resolve.cc:13603
+#: fortran/resolve.cc:13723
 #, gcc-internal-format, gfc-internal-format
 msgid "TODO: type-bound defined assignment(s) at %L not done because multiple part array references would occur in intermediate expressions."
 msgstr ""
 
 #. Even if standard does not support this feature, continue to build
 #. the two statements to avoid upsetting frontend_passes.c.
-#: fortran/resolve.cc:13917
+#: fortran/resolve.cc:14037
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Pointer procedure assignment at %L"
 msgstr "無效的程序指標指派於 %L"
 
-#: fortran/resolve.cc:13929
+#: fortran/resolve.cc:14049
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
 msgstr "目標運算式在中指標指派於 %L 必須投遞指標結果"
 
-#: fortran/resolve.cc:14246
+#: fortran/resolve.cc:14366
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASSIGNED GOTO statement at %L requires a scalar INTEGER variable"
 msgstr "指派的前往敘述於 %L 需求整數變數"
 
-#: fortran/resolve.cc:14250
+#: fortran/resolve.cc:14370
 #, fuzzy, gcc-internal-format
 #| msgid "Variable '%s' has not been assigned a target label at %L"
 msgid "Variable %qs has not been assigned a target label at %L"
 msgstr "變數「%s」在 %L 尚未指派到目標標籤"
 
-#: fortran/resolve.cc:14261
+#: fortran/resolve.cc:14381
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
 msgstr "交替回傳敘述於 %L 需要 SCALAR-INTEGER 回傳說明符"
 
-#: fortran/resolve.cc:14340
+#: fortran/resolve.cc:14460
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Expected initialization expression in CASE at %C"
 msgid "Expected intrinsic assignment in OMP WORKSHARE at %L"
 msgstr "%C 處 CASE 中需要初始化運算式"
 
-#: fortran/resolve.cc:14382
+#: fortran/resolve.cc:14502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
 msgstr "指派敘述於 %L 需要純量預設整數變數"
 
-#: fortran/resolve.cc:14429
+#: fortran/resolve.cc:14549
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid kind for %s at %L"
 msgid "Invalid NULL at %L"
 msgstr "%s 種別無效，於 %L 處"
 
-#: fortran/resolve.cc:14433
+#: fortran/resolve.cc:14553
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
 msgstr "算術如果敘述於 %L 需要數值運算式"
 
-#: fortran/resolve.cc:14494
+#: fortran/resolve.cc:14614
 #, gcc-internal-format
 msgid "gfc_resolve_code(): No expression on DO WHILE"
 msgstr ""
 
-#: fortran/resolve.cc:14499
+#: fortran/resolve.cc:14619
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
 msgstr "離開條件的做當迴圈於 %L 必須是純量邏輯的運算式"
 
-#: fortran/resolve.cc:14583
+#: fortran/resolve.cc:14703
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
 msgstr "FORALL 遮罩子句於 %L 需要純量邏輯的運算式"
 
-#: fortran/resolve.cc:14695
+#: fortran/resolve.cc:14815
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_resolve_code(): Bad statement code"
 msgstr "gfc_trans_code()：錯誤的敘述程式碼"
 
-#: fortran/resolve.cc:14716
+#: fortran/resolve.cc:14836
 #, fuzzy, gcc-internal-format
 msgid "Using parameter %qs declared at %L is deprecated"
 msgstr "未使用的參數『%s』宣告的於 %L"
 
-#: fortran/resolve.cc:14812
+#: fortran/resolve.cc:14932
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "繫結標貼『%s』於 %L collides 與全域實體『%s』於 %L"
 
 #. This can only happen if the variable is defined in a module - if it
 #. isn't the same module, reject it.
-#: fortran/resolve.cc:14826
+#: fortran/resolve.cc:14946
 #, gcc-internal-format
 msgid "Variable %qs from module %qs with binding label %qs at %L uses the same global identifier as entity at %L from module %qs"
 msgstr ""
@@ -90032,1076 +90212,1076 @@ msgstr ""
 #. Print an error if the procedure is defined multiple times; we have to
 #. exclude references to the same procedure via module association or
 #. multiple checks for the same procedure.
-#: fortran/resolve.cc:14845
+#: fortran/resolve.cc:14965
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with binding label %qs at %L uses the same global identifier as entity at %L"
 msgstr "繫結標貼『%s』於 %L collides 與全域實體『%s』於 %L"
 
-#: fortran/resolve.cc:14931
+#: fortran/resolve.cc:15051
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "String length at %L is too large"
 msgstr "字串長度於 %L 太大"
 
-#: fortran/resolve.cc:15175
+#: fortran/resolve.cc:15295
 #, fuzzy, gcc-internal-format
 msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
 msgstr "可指派的陣列「%s」在 %L 處必須有延遲的外形"
 
-#: fortran/resolve.cc:15179
+#: fortran/resolve.cc:15299
 #, fuzzy, gcc-internal-format
 msgid "Scalar object %qs at %L may not be ALLOCATABLE"
 msgstr "純量物件『%s』於 %L 可能無法是 ALLOCATABLE"
 
-#: fortran/resolve.cc:15187
+#: fortran/resolve.cc:15307
 #, fuzzy, gcc-internal-format
 msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
 msgstr "陣列指標「%s」在 %L 處必須有延遲的外形"
 
-#: fortran/resolve.cc:15198
+#: fortran/resolve.cc:15318
 #, fuzzy, gcc-internal-format
 #| msgid "Array '%s' at %L cannot have a deferred shape"
 msgid "Array %qs at %L cannot have a deferred shape"
 msgstr "陣列「%s」在 %L 處不能有延遲的外形"
 
-#: fortran/resolve.cc:15216
+#: fortran/resolve.cc:15336
 #, fuzzy, gcc-internal-format
 msgid "Type %qs of CLASS variable %qs at %L is not extensible"
 msgstr "型態『%s』的類別變數『%s』於 %L 不是 extensible"
 
-#: fortran/resolve.cc:15230
+#: fortran/resolve.cc:15350
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
 msgstr "類別變數『%s』於 %L 必須是虛設，allocatable 或指標"
 
-#: fortran/resolve.cc:15263
+#: fortran/resolve.cc:15383
 #, fuzzy, gcc-internal-format
 msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
 msgstr "型態『%s』無法主機關聯的於 %L 因為它被阻斷由不相容的物件的同名宣告的於 %L"
 
-#: fortran/resolve.cc:15285
+#: fortran/resolve.cc:15405
 #, fuzzy, gcc-internal-format
 msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
 msgstr "Fortran 2008:意味著的儲存用於模組變數『%s』於 %L, 所需的由於預設初始化"
 
-#: fortran/resolve.cc:15318
+#: fortran/resolve.cc:15438
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L has a deferred type parameter and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "實體『%s』於 %L 有已推遲型態參數和需求還是指標或 allocatable 屬性"
 
-#: fortran/resolve.cc:15332
+#: fortran/resolve.cc:15452
 #, fuzzy, gcc-internal-format
 msgid "Automatic object %qs at %L cannot have the SAVE attribute"
 msgstr "共同區塊『%s』於 %L 無法有外部屬性"
 
 #. F08:C541. The shape of an array defined in a main program or module
 #. * needs to be constant.
-#: fortran/resolve.cc:15354
+#: fortran/resolve.cc:15476
 #, fuzzy, gcc-internal-format
 #| msgid "The module or main program array '%s' at %L must have constant shape"
 msgid "The module or main program array %qs at %L must have constant shape"
 msgstr "模組或主程式陣列「%s」在 %L 處必須有常態的外形"
 
-#: fortran/resolve.cc:15379
+#: fortran/resolve.cc:15502
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
 msgstr "實體與假設的字元長度於 %L 必須是虛引數或參數"
 
-#: fortran/resolve.cc:15400
+#: fortran/resolve.cc:15525
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L must have constant character length in this context"
 msgstr "『%s』於 %L 必須有常數字元長度在中這個語境"
 
-#: fortran/resolve.cc:15407
+#: fortran/resolve.cc:15533
 #, fuzzy, gcc-internal-format
 msgid "COMMON variable %qs at %L must have constant character length"
 msgstr "共同變數『%s』於 %L 必須有常數字元長度"
 
-#: fortran/resolve.cc:15455
+#: fortran/resolve.cc:15583
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "Allocatable %qs at %L cannot have an initializer"
 msgstr "可指派的「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15458
+#: fortran/resolve.cc:15586
 #, fuzzy, gcc-internal-format
 #| msgid "External '%s' at %L cannot have an initializer"
 msgid "External %qs at %L cannot have an initializer"
 msgstr "外部「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15461
+#: fortran/resolve.cc:15589
 #, fuzzy, gcc-internal-format
 #| msgid "Dummy '%s' at %L cannot have an initializer"
 msgid "Dummy %qs at %L cannot have an initializer"
 msgstr "啞元「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15464
+#: fortran/resolve.cc:15592
 #, fuzzy, gcc-internal-format
 #| msgid "Intrinsic '%s' at %L cannot have an initializer"
 msgid "Intrinsic %qs at %L cannot have an initializer"
 msgstr "內建函式「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15467
+#: fortran/resolve.cc:15595
 #, fuzzy, gcc-internal-format
 #| msgid "Function result '%s' at %L cannot have an initializer"
 msgid "Function result %qs at %L cannot have an initializer"
 msgstr "函式結果「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15470
+#: fortran/resolve.cc:15598
 #, fuzzy, gcc-internal-format
 #| msgid "Automatic array '%s' at %L cannot have an initializer"
 msgid "Automatic array %qs at %L cannot have an initializer"
 msgstr "自動陣列「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15512
+#: fortran/resolve.cc:15643
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "in %s, at %s:%d"
 msgid "%s at %L"
 msgstr "在 %s 中，於 %s:%d"
 
-#: fortran/resolve.cc:15544
+#: fortran/resolve.cc:15675
 #, fuzzy, gcc-internal-format
 msgid "Character-valued statement function %qs at %L must have constant length"
 msgstr "Character-valued 敘述函式『%s』於 %L 必須有常數長度"
 
-#: fortran/resolve.cc:15567
+#: fortran/resolve.cc:15698
 #, fuzzy, gcc-internal-format
 msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003:『%s』是的私人的型態和無法虛引數的『%s』，該項是公用的於 %L"
 
-#: fortran/resolve.cc:15589
+#: fortran/resolve.cc:15720
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
 msgstr "Fortran 2003:程序『%s』在中公用的介面『%s』於 %L 需虛引數的『%s』該項是私人的"
 
-#: fortran/resolve.cc:15607
+#: fortran/resolve.cc:15738
 #, fuzzy, gcc-internal-format
 msgid "Function %qs at %L cannot have an initializer"
 msgstr "函式『%s』於 %L 無法有初始設定式"
 
-#: fortran/resolve.cc:15619
+#: fortran/resolve.cc:15750
 #, fuzzy, gcc-internal-format
 #| msgid "External object '%s' at %L may not have an initializer"
 msgid "External object %qs at %L may not have an initializer"
 msgstr "外部物件「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:15629
+#: fortran/resolve.cc:15760
 #, fuzzy, gcc-internal-format
 msgid "ELEMENTAL function %qs at %L must have a scalar result"
 msgstr "ELEMENTAL 函式『%s』於 %L 必須有純量結果"
 
-#: fortran/resolve.cc:15639
+#: fortran/resolve.cc:15770
 #, fuzzy, gcc-internal-format
 msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
 msgstr "敘述函式『%s』於 %L 可能無法有指標或 allocatable 屬性"
 
-#: fortran/resolve.cc:15658
+#: fortran/resolve.cc:15789
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
 msgstr "CHARACTER(*) 函式「%s」(位於 %L)不能以陣列賦值"
 
-#: fortran/resolve.cc:15662
+#: fortran/resolve.cc:15793
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
 msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
 msgstr "CHARACTER(*) 函式「%s」(位於 %L)不能以指標賦值"
 
-#: fortran/resolve.cc:15666
+#: fortran/resolve.cc:15797
 #, fuzzy, gcc-internal-format
 #| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
 msgid "CHARACTER(*) function %qs at %L cannot be pure"
 msgstr "CHARACTER(*) 函式「%s」(位於 %L)不能是純量"
 
-#: fortran/resolve.cc:15670
+#: fortran/resolve.cc:15801
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L cannot be recursive"
 msgstr "字元 (*) 函式『%s』於 %L 無法遞迴"
 
-#: fortran/resolve.cc:15683
+#: fortran/resolve.cc:15814
 #, fuzzy, gcc-internal-format
 msgid "CHARACTER(*) function %qs at %L"
 msgstr "CHARACTER(*) 函式「%s」(位於 %L)不能是純量"
 
-#: fortran/resolve.cc:15694
+#: fortran/resolve.cc:15825
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer %qs at %L shall not be elemental"
 msgstr "程序『%s』在中 %s 於 %L 沒有任何明確的介面"
 
-#: fortran/resolve.cc:15700
+#: fortran/resolve.cc:15831
 #, fuzzy, gcc-internal-format
 msgid "Dummy procedure %qs at %L shall not be elemental"
 msgstr "虛設程序『%s』於 %C 無法有通用介面"
 
-#: fortran/resolve.cc:15720
+#: fortran/resolve.cc:15851
 #, fuzzy, gcc-internal-format
 msgid "Function result variable %qs at %L of elemental function %qs shall not have an ALLOCATABLE or POINTER attribute"
 msgstr "變數『%s』於 %L 無法同時有 ALLOCATABLE 和繫結©屬性"
 
-#: fortran/resolve.cc:15737
+#: fortran/resolve.cc:15868
 #, gcc-internal-format
 msgid "Result variable %qs of pure function at %L is polymorphic allocatable"
 msgstr ""
 
-#: fortran/resolve.cc:15751
+#: fortran/resolve.cc:15882
 #, fuzzy, gcc-internal-format
 msgid "Result variable %qs of pure function at %L has polymorphic allocatable component %qs"
 msgstr "Coindexed 物件與 polymorphic allocatable subcomponent 於 %L"
 
-#: fortran/resolve.cc:15810
+#: fortran/resolve.cc:15941
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
 msgstr "程序屬性衝突與儲存屬性在中『%s』於 %L"
 
-#: fortran/resolve.cc:15816
+#: fortran/resolve.cc:15947
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
 msgstr "程序屬性衝突與含義屬性在中『%s』於 %L"
 
-#: fortran/resolve.cc:15822
+#: fortran/resolve.cc:15953
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
 msgstr "程序屬性衝突與結果屬性在中『%s』於 %L"
 
-#: fortran/resolve.cc:15830
+#: fortran/resolve.cc:15961
 #, fuzzy, gcc-internal-format
 msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
 msgstr "外部屬性衝突與函式屬性在中『%s』於 %L"
 
-#: fortran/resolve.cc:15836
+#: fortran/resolve.cc:15967
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
 msgstr "程序指標結果『%s』於 %L 缺少指標屬性"
 
-#: fortran/resolve.cc:15879
+#: fortran/resolve.cc:16010
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in ELEMENTAL attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15887
+#: fortran/resolve.cc:16018
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in PURE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15895
+#: fortran/resolve.cc:16026
 #, gcc-internal-format, gfc-internal-format
 msgid "Mismatch in RECURSIVE attribute between MODULE PROCEDURE at %L and its interface in %s"
 msgstr ""
 
-#: fortran/resolve.cc:15904
+#: fortran/resolve.cc:16035
 #, gcc-internal-format
 msgid "%s between the MODULE PROCEDURE declaration in MODULE %qs and the declaration at %L in (SUB)MODULE %qs"
 msgstr ""
 
-#: fortran/resolve.cc:15928
+#: fortran/resolve.cc:16059
 #, fuzzy, gcc-internal-format
 msgid "Interface of %qs at %L must be explicit"
 msgstr "介面『%s』的程序『%s』於 %L 必須是明確的"
 
-#: fortran/resolve.cc:16033
+#: fortran/resolve.cc:16164
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
 msgstr "最後的程序『%s』於 %L 並非副常式"
 
-#: fortran/resolve.cc:16042
+#: fortran/resolve.cc:16173
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L must have exactly one argument"
 msgstr "最後的程序於 %L 必須有精確的一個引數"
 
-#: fortran/resolve.cc:16050 fortran/resolve.cc:16068
+#: fortran/resolve.cc:16181 fortran/resolve.cc:16199
 #, fuzzy, gcc-internal-format
 msgid "Argument of FINAL procedure at %L must be of type %qs"
 msgstr "引數的最後的程序於 %L 必須是的型態『%s』"
 
-#: fortran/resolve.cc:16058
+#: fortran/resolve.cc:16189
 #, gcc-internal-format, gfc-internal-format
 msgid "FINAL procedure at %L with assumed rank argument must be the only finalizer with the same kind/type (F2018: C790)"
 msgstr ""
 
-#: fortran/resolve.cc:16076
+#: fortran/resolve.cc:16207
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be a POINTER"
 msgstr "引數的最後的程序於 %L 必須不是指標"
 
-#: fortran/resolve.cc:16082
+#: fortran/resolve.cc:16213
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
 msgstr "引數的最後的程序於 %L 必須不是 ALLOCATABLE"
 
-#: fortran/resolve.cc:16088
+#: fortran/resolve.cc:16219
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
 msgstr "引數的最後的程序於 %L 必須不是可選的"
 
-#: fortran/resolve.cc:16096
+#: fortran/resolve.cc:16227
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
 msgstr "引數的最後的程序於 %L 必須不是含義 (出)"
 
-#: fortran/resolve.cc:16105
+#: fortran/resolve.cc:16236
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
 msgstr "Non-scalar 最後的程序於 %L 應該已假設形狀引數"
 
-#: fortran/resolve.cc:16127
+#: fortran/resolve.cc:16258
 #, fuzzy, gcc-internal-format
 msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
 msgstr "最後的程序『%s』宣告的於 %L 有同級 (%d) 做為『%s』"
 
-#: fortran/resolve.cc:16164
+#: fortran/resolve.cc:16295
 #, fuzzy, gcc-internal-format
 msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one unless an assumed rank finalizer has been declared"
 msgstr "只有陣列最後的程序宣告的用於衍生類型『%s』定義的於 %L, 建議也純量一個"
 
-#: fortran/resolve.cc:16234
+#: fortran/resolve.cc:16365
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
 msgstr "『%s』和『%s』無法混合的函式/副常式用於通用『%s』於 %L"
 
-#: fortran/resolve.cc:16281
+#: fortran/resolve.cc:16412
 #, fuzzy, gcc-internal-format
 msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
 msgstr "『%s』和『%s』用於通用『%s』於 %L 是模稜兩可的"
 
-#: fortran/resolve.cc:16340
+#: fortran/resolve.cc:16471
 #, fuzzy, gcc-internal-format
 msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
 msgstr "未定義的特定的繫結『%s』做為目標的通用『%s』於 %L"
 
-#: fortran/resolve.cc:16352
+#: fortran/resolve.cc:16483
 #, fuzzy, gcc-internal-format
 msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
 msgstr "通用『%s』於 %L 必須目標特定的繫結，『%s』是通用，太"
 
-#: fortran/resolve.cc:16380
+#: fortran/resolve.cc:16511
 #, fuzzy, gcc-internal-format
 msgid "GENERIC %qs at %L cannot overwrite specific binding with the same name"
 msgstr "通用『%s』於 %L 無法覆寫特定的繫結與同名"
 
-#: fortran/resolve.cc:16436
+#: fortran/resolve.cc:16567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Type-bound operator at %L cannot be NOPASS"
 msgstr "Type-bound 運算子於 %L 無法 NOPASS"
 
-#: fortran/resolve.cc:16652
+#: fortran/resolve.cc:16783
 #, fuzzy, gcc-internal-format
 msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
 msgstr "『%s』必須是模組程序或外部程序與明確的介面於 %L"
 
-#: fortran/resolve.cc:16695
+#: fortran/resolve.cc:16826
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
 msgstr "程序『%s』與回合 (%s) 於 %L 沒有任何引數『%s』"
 
-#: fortran/resolve.cc:16709
+#: fortran/resolve.cc:16840
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs with PASS at %L must have at least one argument"
 msgstr "程序『%s』與回合於 %L 必須至少有一個引數"
 
-#: fortran/resolve.cc:16723 fortran/resolve.cc:17289
+#: fortran/resolve.cc:16854 fortran/resolve.cc:17420
 #, fuzzy, gcc-internal-format
 msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
 msgstr "Non-polymorphic passed-object 虛引數的『%s』於 %L"
 
-#: fortran/resolve.cc:16734
+#: fortran/resolve.cc:16865
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
 msgstr "引數『%s』的『%s』與回合 (%s) 於 %L 必須是的衍生類型『%s』"
 
-#: fortran/resolve.cc:16744
+#: fortran/resolve.cc:16875
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the parametric derived-type %qs"
 msgstr "引數『%s』的『%s』與回合 (%s) 於 %L 必須是的衍生類型『%s』"
 
-#: fortran/resolve.cc:16787
+#: fortran/resolve.cc:16918
 #, gcc-internal-format
 msgid "All LEN type parameters of the passed dummy argument %qs of %qs at %L must be ASSUMED."
 msgstr ""
 
-#: fortran/resolve.cc:16797
+#: fortran/resolve.cc:16928
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must be scalar"
 msgstr "Passed-object 虛引數的『%s』於 %L 必須是純量"
 
-#: fortran/resolve.cc:16803
+#: fortran/resolve.cc:16934
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
 msgstr "Passed-object 虛引數的『%s』於 %L 必須不是 ALLOCATABLE"
 
-#: fortran/resolve.cc:16809
+#: fortran/resolve.cc:16940
 #, fuzzy, gcc-internal-format
 msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
 msgstr "Passed-object 虛引數的『%s』於 %L 必須不是指標"
 
-#: fortran/resolve.cc:16838
+#: fortran/resolve.cc:16969
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as a component of %qs"
 msgstr "程序『%s』於 %L 有同名做為成分的『%s』"
 
-#: fortran/resolve.cc:16848
+#: fortran/resolve.cc:16979
 #, fuzzy, gcc-internal-format
 msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
 msgstr "程序『%s』於 %L 有同名做為繼承的成分的『%s』"
 
-#: fortran/resolve.cc:16945
+#: fortran/resolve.cc:17076
 #, fuzzy, gcc-internal-format
 msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
 msgstr "衍生類型『%s』宣告的於 %L 必須是摘要因為『%s』是已推遲和無法 overridden"
 
-#: fortran/resolve.cc:17050
+#: fortran/resolve.cc:17181
 #, fuzzy, gcc-internal-format
 msgid "Coarray component %qs at %L must be allocatable with deferred shape"
 msgstr "Coarray 成分『%s』於 %L 必須是 allocatable 與已推遲形狀"
 
-#: fortran/resolve.cc:17059
+#: fortran/resolve.cc:17190
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "成分『%s』於 %L 的型態 (C_PTR) 或型態 (C_FUNPTR) 不應該是 coarray"
 
-#: fortran/resolve.cc:17069
+#: fortran/resolve.cc:17200
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
 msgstr "成分『%s』於 %L 與 coarray 成分應該是 nonpointer，nonallocatable 純量"
 
-#: fortran/resolve.cc:17094
+#: fortran/resolve.cc:17225
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
 msgstr "成分『%s』於 %L 有 CONTIGUOUS 屬性但是不是陣列指標"
 
-#: fortran/resolve.cc:17105
+#: fortran/resolve.cc:17236
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of ICHAR at %L must be of length one"
 msgid "Component %qs of BIND(C) type at %L must have length one"
 msgstr "%L 處 ICHAR 的參數長度必須為 1"
 
-#: fortran/resolve.cc:17222
+#: fortran/resolve.cc:17353
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
 msgstr "程序指標成分『%s』與回合 (%s) 於 %L 沒有任何引數『%s』"
 
-#: fortran/resolve.cc:17236
+#: fortran/resolve.cc:17367
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
 msgstr "程序指標成分『%s』與回合於 %L 必須至少有一個引數"
 
-#: fortran/resolve.cc:17252
+#: fortran/resolve.cc:17383
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
 msgstr "引數『%s』的『%s』與回合 (%s) 於 %L 必須是的衍生類型『%s』"
 
-#: fortran/resolve.cc:17262
+#: fortran/resolve.cc:17393
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
 msgstr "引數『%s』的『%s』與回合 (%s) 於 %L 必須是純量"
 
-#: fortran/resolve.cc:17271
+#: fortran/resolve.cc:17402
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
 msgstr "引數『%s』的『%s』與回合 (%s) 於 %L 可能無法有指標屬性"
 
-#: fortran/resolve.cc:17280
+#: fortran/resolve.cc:17411
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
 msgstr "引數『%s』的『%s』與回合 (%s) 於 %L 可能無法是 ALLOCATABLE"
 
-#: fortran/resolve.cc:17322
+#: fortran/resolve.cc:17453
 #, fuzzy, gcc-internal-format
 msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
 msgstr "成分『%s』的『%s』於 %L 有同名做為繼承 type-bound 程序"
 
-#: fortran/resolve.cc:17338
+#: fortran/resolve.cc:17469
 #, fuzzy, gcc-internal-format
 msgid "Character length of component %qs needs to be a constant specification expression at %L"
 msgstr "字元長度的成分『%s』需要是常數規格運算式於 %L"
 
-#: fortran/resolve.cc:17349
+#: fortran/resolve.cc:17480
 #, fuzzy, gcc-internal-format
 msgid "Character length expression of component %qs at %L must be of INTEGER type, found %s"
 msgstr "運算式於 %L 必須是的整數類型，找到 %s"
 
-#: fortran/resolve.cc:17362
+#: fortran/resolve.cc:17493
 #, fuzzy, gcc-internal-format
 msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
 msgstr "字元成分『%s』的『%s』於 %L 與已推遲長度必須是指標或 ALLOCATABLE"
 
-#: fortran/resolve.cc:17395
+#: fortran/resolve.cc:17526
 #, fuzzy, gcc-internal-format
 msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
 msgstr "Fortran 2003:成分『%s』是私人的型態和無法成分的『%s』，該項是公用的於 %L"
 
-#: fortran/resolve.cc:17403
+#: fortran/resolve.cc:17534
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
 msgstr "Polymorphic 成分 %s 於 %L 在中序列或繫結©型態 %s"
 
-#: fortran/resolve.cc:17412
+#: fortran/resolve.cc:17543
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
 msgstr "成分 %s 的序列型態宣告的於 %L 沒有序列屬性"
 
-#: fortran/resolve.cc:17498
+#: fortran/resolve.cc:17629
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Conflicting initializers in union at %L and %L"
 msgstr "衝突在中屬性的函式引數於 %C"
 
-#: fortran/resolve.cc:17590
+#: fortran/resolve.cc:17721
 #, fuzzy, gcc-internal-format
 msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
 msgstr "做為延伸型態『%s』於 %L 有 coarray 成分，親代型態『%s』應該也有一個"
 
-#: fortran/resolve.cc:17603
+#: fortran/resolve.cc:17734
 #, fuzzy, gcc-internal-format
 msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
 msgstr "Non-extensible 衍生類型『%s』於 %L 必須不是摘要"
 
-#: fortran/resolve.cc:17673
+#: fortran/resolve.cc:17804
 #, gcc-internal-format
 msgid "Parameterized type %qs does not have a component corresponding to parameter %qs at %L"
 msgstr ""
 
-#: fortran/resolve.cc:17705
+#: fortran/resolve.cc:17836
 #, fuzzy, gcc-internal-format
 msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
 msgstr "Fortran 2003:通用名稱『%s』的函式『%s』於 %L 相同名稱做為衍生類型於 %L"
 
-#: fortran/resolve.cc:17719
+#: fortran/resolve.cc:17850
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L has not been declared"
 msgstr "衍生類型『%s』於 %L 必須是 extensible"
 
-#: fortran/resolve.cc:17742
+#: fortran/resolve.cc:17873
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Duplicate construct label '%s' at %C"
 msgid "Failed to build PDT class component at %L"
 msgstr "重複的建構標籤「%s」出現在 %C 處"
 
-#: fortran/resolve.cc:17803
+#: fortran/resolve.cc:17934
 #, fuzzy, gcc-internal-format
 msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
 msgstr "假設的大小陣列『%s』在中名稱表列『%s』於 %L 未被允許"
 
-#: fortran/resolve.cc:17809
+#: fortran/resolve.cc:17940
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
 msgstr "Fortran 2003:名稱表列陣列物件『%s』與假設的形狀在中名稱表列『%s』於 %L"
 
-#: fortran/resolve.cc:17815
+#: fortran/resolve.cc:17946
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
 msgstr "Fortran 2003:名稱表列陣列物件『%s』與 nonconstant 形狀在中名稱表列『%s』於 %L"
 
-#: fortran/resolve.cc:17823
+#: fortran/resolve.cc:17954
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
 msgstr "Fortran 2003:名稱表列物件『%s』與 nonconstant 字元長度在中名稱表列『%s』於 %L"
 
-#: fortran/resolve.cc:17840
+#: fortran/resolve.cc:17971
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
 msgstr "名稱表列物件『%s』被宣告私人的和無法成員的公用的名稱表列『%s』於 %L"
 
-#: fortran/resolve.cc:17862
+#: fortran/resolve.cc:17993
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
 msgstr "名稱表列物件『%s』已 use-associated 私人的成分和無法成員的名稱表列『%s』於 %L"
 
-#: fortran/resolve.cc:17873
+#: fortran/resolve.cc:18004
 #, fuzzy, gcc-internal-format
 msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
 msgstr "名稱表列物件『%s』有私人的成分和無法成員的公用的名稱表列『%s』於 %L"
 
-#: fortran/resolve.cc:17900
+#: fortran/resolve.cc:18031
 #, fuzzy, gcc-internal-format
 msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
 msgstr "程序屬性衝突與名稱表列屬性在中『%s』於 %L"
 
-#: fortran/resolve.cc:17919
+#: fortran/resolve.cc:18050
 #, fuzzy, gcc-internal-format
 msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
 msgstr "參數陣列『%s』於 %L 無法自動或的已推遲形狀"
 
-#: fortran/resolve.cc:17935
+#: fortran/resolve.cc:18066
 #, fuzzy, gcc-internal-format
 msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
 msgstr "隱含地型態的參數『%s』於 %L 不匹配稍後隱含的型態"
 
-#: fortran/resolve.cc:17946
+#: fortran/resolve.cc:18077
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Incompatible derived type in PARAMETER at %L"
 msgstr "不相容的衍生類型在中參數於 %L"
 
-#: fortran/resolve.cc:17954
+#: fortran/resolve.cc:18085
 #, fuzzy, gcc-internal-format
 msgid "CLASS variable %qs at %L cannot have the PARAMETER attribute"
 msgstr "共同區塊『%s』於 %L 無法有外部屬性"
 
-#: fortran/resolve.cc:17976
+#: fortran/resolve.cc:18107
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting constant expression near %L"
 msgstr "%qE 並非常數運算式"
 
-#: fortran/resolve.cc:18027
+#: fortran/resolve.cc:18158
 #, fuzzy, gcc-internal-format
 msgid "Entity %qs at %L has a deferred LEN parameter %qs and requires either the POINTER or ALLOCATABLE attribute"
 msgstr "實體『%s』於 %L 有已推遲型態參數和需求還是指標或 allocatable 屬性"
 
-#: fortran/resolve.cc:18039
+#: fortran/resolve.cc:18170
 #, gcc-internal-format
 msgid "The AUTOMATIC object %qs at %L must not have the SAVE attribute or be a variable declared in the main program, a module or a submodule(F08/C513)"
 msgstr ""
 
-#: fortran/resolve.cc:18046
+#: fortran/resolve.cc:18177
 #, gcc-internal-format
 msgid "The object %qs at %L with ASSUMED type parameters must be a dummy or a SELECT TYPE selector(F08/4.2)"
 msgstr ""
 
-#: fortran/resolve.cc:18105
+#: fortran/resolve.cc:18239
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, allocatable/pointer components in polymorphic (CLASS) type coarrays at %L are unsupported"
 msgstr ""
 
-#: fortran/resolve.cc:18118
+#: fortran/resolve.cc:18252
 #, gcc-internal-format
 msgid "%<omp_all_memory%>, declared at %L, may only be used in the OpenMP DEPEND clause"
 msgstr ""
 
-#: fortran/resolve.cc:18183
+#: fortran/resolve.cc:18317
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
 msgstr "保護的屬性衝突與外部屬性於 %L"
 
-#: fortran/resolve.cc:18186
+#: fortran/resolve.cc:18320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
 msgstr "程序屬性衝突與保護的屬性於 %L"
 
-#: fortran/resolve.cc:18293
+#: fortran/resolve.cc:18427
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
 msgstr "『%s』於 %L 有 CONTIGUOUS 屬性但是不是陣列指標或 assumed-shape 陣列"
 
-#: fortran/resolve.cc:18314
+#: fortran/resolve.cc:18448
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Bad specification for assumed size array at %L"
 msgstr "不當的規格用於假設的大小陣列於 %C"
 
-#: fortran/resolve.cc:18328
+#: fortran/resolve.cc:18462
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed size array at %L must be a dummy argument"
 msgstr "假定大小的陣列在 %L 處必須是啞引數"
 
-#: fortran/resolve.cc:18331
+#: fortran/resolve.cc:18465
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed shape array at %L must be a dummy argument"
 msgstr "假定外形的陣列在 %L 處必須是啞引數"
 
-#: fortran/resolve.cc:18343
+#: fortran/resolve.cc:18477
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L must be a dummy argument"
 msgstr "假定外形的陣列在 %L 處必須是啞引數"
 
-#: fortran/resolve.cc:18350
+#: fortran/resolve.cc:18484
 #, gcc-internal-format, gfc-internal-format
 msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute"
 msgstr ""
 
-#: fortran/resolve.cc:18363
+#: fortran/resolve.cc:18497
 #, gcc-internal-format, gfc-internal-format
 msgid "Symbol at %L is not a DUMMY variable"
 msgstr "%L 處的符號不是一個 DUMMY 變數"
 
-#: fortran/resolve.cc:18369
+#: fortran/resolve.cc:18503
 #, fuzzy, gcc-internal-format
 msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
 msgstr "『%s』於 %L 無法有值屬性因為它並非虛引數"
 
-#: fortran/resolve.cc:18379
+#: fortran/resolve.cc:18513
 #, fuzzy, gcc-internal-format
 msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
 msgstr "字元虛設變數『%s』於 %L 與值屬性必須有常數長度"
 
-#: fortran/resolve.cc:18388
+#: fortran/resolve.cc:18522
 #, fuzzy, gcc-internal-format
 msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
 msgstr "C 可交流的字元虛設變數『%s』於 %L 與值屬性必須有長度一個"
 
-#: fortran/resolve.cc:18401 fortran/resolve.cc:18578
+#: fortran/resolve.cc:18535 fortran/resolve.cc:18712
 #, fuzzy, gcc-internal-format
 msgid "The derived type %qs at %L is of type %qs, which has not been defined"
 msgstr "衍生類型『%s』於 %L 是的型態『%s』，該項未被定義"
 
-#: fortran/resolve.cc:18415
+#: fortran/resolve.cc:18549
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be a dummy argument"
 msgstr ""
 
-#: fortran/resolve.cc:18424
+#: fortran/resolve.cc:18558
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or of an numeric intrinsic type"
 msgstr ""
 
-#: fortran/resolve.cc:18433
+#: fortran/resolve.cc:18567
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "變數『%s』於 %L 無法同時有 ALLOCATABLE 和繫結©屬性"
 
-#: fortran/resolve.cc:18441
+#: fortran/resolve.cc:18575
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
 msgstr "變數『%s』於 %L 無法同時有指標和繫結©屬性"
 
-#: fortran/resolve.cc:18448
+#: fortran/resolve.cc:18582
 #, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
 msgstr ""
 
-#: fortran/resolve.cc:18468
+#: fortran/resolve.cc:18602
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
 msgstr "假設的形狀陣列『%s』於 %L 未被允許在中初始化運算式"
 
-#: fortran/resolve.cc:18475
+#: fortran/resolve.cc:18609
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
 msgstr "變數『%s』於 %L 無法同時有 ALLOCATABLE 和繫結©屬性"
 
-#: fortran/resolve.cc:18482
+#: fortran/resolve.cc:18616
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
 msgstr "變數『%s』於 %L 無法同時有指標和繫結©屬性"
 
-#: fortran/resolve.cc:18489
+#: fortran/resolve.cc:18623
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
 msgstr "迴圈變數於 %C 無法 coarray"
 
-#: fortran/resolve.cc:18515
+#: fortran/resolve.cc:18649
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
 msgstr "變數『%s』於 %L 無法繫結©因為它是 neither 共同區塊 nor 宣告的於模組等級範圍"
 
-#: fortran/resolve.cc:18525
+#: fortran/resolve.cc:18659
 #, fuzzy, gcc-internal-format
 #| msgid "Argument of %s at %L must be of length one"
 msgid "BIND(C) Variable %qs at %L must have length one"
 msgstr "%s 的參數(位於 %L)長度必須為 1"
 
-#: fortran/resolve.cc:18604
+#: fortran/resolve.cc:18738
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
 msgstr "Fortran 2003:公用的 %s『%s』於 %L 的私人的衍生類型『%s』"
 
-#: fortran/resolve.cc:18619
+#: fortran/resolve.cc:18753
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
 msgstr "變數 %s 於 %L 的型態 LOCK_TYPE 或與 subcomponent 的型態 LOCK_TYPE 必須是 coarray"
 
-#: fortran/resolve.cc:18632
+#: fortran/resolve.cc:18766
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must be a coarray"
 msgstr "變數 %s 於 %L 的型態 LOCK_TYPE 或與 subcomponent 的型態 LOCK_TYPE 必須是 coarray"
 
-#: fortran/resolve.cc:18650
+#: fortran/resolve.cc:18784
 #, fuzzy, gcc-internal-format
 msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
 msgstr "含義 (出) 虛引數『%s』於 %L 是假設的大小和因而無法有預設初始設定式"
 
-#: fortran/resolve.cc:18662
+#: fortran/resolve.cc:18796
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
 msgstr "虛引數『%s』於 %L 的 LOCK_TYPE 不應該是含義 (出)"
 
-#: fortran/resolve.cc:18671
+#: fortran/resolve.cc:18805
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
 msgstr "虛引數『%s』於 %L 的 LOCK_TYPE 不應該是含義 (出)"
 
-#: fortran/resolve.cc:18684
+#: fortran/resolve.cc:18818
 #, fuzzy, gcc-internal-format
 msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
 msgstr "函數計算結果『%s』於 %L 不應該是 coarray 或有 coarray 成分"
 
-#: fortran/resolve.cc:18693
+#: fortran/resolve.cc:18827
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
 msgstr "變數『%s』於 %L 的型態 (C_PTR) 或型態 (C_FUNPTR) 不應該是 coarray"
 
-#: fortran/resolve.cc:18706
+#: fortran/resolve.cc:18840
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
 msgstr "變數『%s』於 %L 與 coarray 成分應該是 nonpointer，nonallocatable 純量"
 
-#: fortran/resolve.cc:18722
+#: fortran/resolve.cc:18856
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
 msgstr "變數『%s』於 %L 是 coarray 和不是 ALLOCATABLE，儲存 nor 虛引數"
 
-#: fortran/resolve.cc:18730
+#: fortran/resolve.cc:18864
 #, fuzzy, gcc-internal-format
 msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape without allocatable"
 msgstr "Coarray 變數『%s』於 %L 不應該有 codimensions 與已推遲形狀"
 
-#: fortran/resolve.cc:18738
+#: fortran/resolve.cc:18872
 #, fuzzy, gcc-internal-format
 msgid "Allocatable coarray variable %qs at %L must have deferred shape"
 msgstr "Allocatable coarray 變數『%s』於 %L 必須已已推遲形狀"
 
-#: fortran/resolve.cc:18751
+#: fortran/resolve.cc:18885
 #, fuzzy, gcc-internal-format
 msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
 msgstr "變數『%s』於 %L 是含義 (出) 和可以因而無法是 allocatable coarray 或有 coarray 成分"
 
-#: fortran/resolve.cc:18760
+#: fortran/resolve.cc:18894
 #, fuzzy, gcc-internal-format
 msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
 msgstr "Coarray 虛設變數『%s』於 %L 不允許在中繫結©程序『%s』"
 
-#: fortran/resolve.cc:18776
+#: fortran/resolve.cc:18910
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "Coarray 虛設變數『%s』於 %L 不允許在中繫結©程序『%s』"
 
-#: fortran/resolve.cc:18782
+#: fortran/resolve.cc:18916
 #, fuzzy, gcc-internal-format
 msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
 msgstr "Coarray 虛設變數『%s』於 %L 不允許在中繫結©程序『%s』"
 
-#: fortran/resolve.cc:18807
+#: fortran/resolve.cc:18941
 #, fuzzy, gcc-internal-format
 msgid "Namelist %qs cannot be an argument to subroutine or function at %L"
 msgstr "名稱表列 %s 無法重新命名的由使用關聯到 %s"
 
-#: fortran/resolve.cc:18869
+#: fortran/resolve.cc:19003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Threadprivate at %L isn't SAVEd"
 msgstr "Threadprivate 於 %L 不是儲存"
 
-#: fortran/resolve.cc:18871
+#: fortran/resolve.cc:19005
 #, fuzzy, gcc-internal-format
 msgid "OpenMP groupprivate variable %qs at %L must have the SAVE attribute"
 msgstr "指標初始化目標於 %L 必須有儲存屬性"
 
-#: fortran/resolve.cc:18876
+#: fortran/resolve.cc:19010
 #, fuzzy, gcc-internal-format
 #| msgid "Allocatable '%s' at %L cannot have an initializer"
 msgid "!$OMP GROUPPRIVATE variable %qs at %L must not have an initializer"
 msgstr "可指派的「%s」在 %L 處不能有初始值設定"
 
-#: fortran/resolve.cc:18892
+#: fortran/resolve.cc:19026
 #, gcc-internal-format
 msgid "!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd"
 msgstr ""
 
-#: fortran/resolve.cc:19010
+#: fortran/resolve.cc:19144
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expecting definable entity near %L"
 msgstr "預期具名的實體清單的於 %C"
 
-#: fortran/resolve.cc:19018
+#: fortran/resolve.cc:19152
 #, fuzzy, gcc-internal-format
 msgid "BLOCK DATA element %qs at %L must be in COMMON"
 msgstr "區塊資料元素『%s』於 %L 必須是在中共同"
 
-#: fortran/resolve.cc:19025
+#: fortran/resolve.cc:19159
 #, fuzzy, gcc-internal-format
 msgid "DATA array %qs at %L must be specified in a previous declaration"
 msgstr "資料陣列『%s』於 %L 必須被指定的在中前一個宣告"
 
-#: fortran/resolve.cc:19032
+#: fortran/resolve.cc:19166
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have a coindex"
 msgstr "資料元素『%s』於 %L 無法有 coindex"
 
-#: fortran/resolve.cc:19048
+#: fortran/resolve.cc:19182
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L is a pointer and so must be a full array"
 msgstr "資料元素『%s』於 %L 是指標和因而必須是全部陣列"
 
-#: fortran/resolve.cc:19055
+#: fortran/resolve.cc:19189
 #, gcc-internal-format, gfc-internal-format
 msgid "DATA object near %L has the pointer attribute and the corresponding DATA value is not a valid initial-data-target"
 msgstr ""
 
-#: fortran/resolve.cc:19064
+#: fortran/resolve.cc:19198
 #, fuzzy, gcc-internal-format
 msgid "DATA element %qs at %L cannot have the ALLOCATABLE attribute"
 msgstr "引數『%s』的 elemental 程序於 %L 無法有 ALLOCATABLE 屬性"
 
-#: fortran/resolve.cc:19126
+#: fortran/resolve.cc:19260
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonconstant array section at %L in DATA statement"
 msgstr "Nonconstant 陣列區段於 %L 在中資料敘述"
 
-#: fortran/resolve.cc:19139
+#: fortran/resolve.cc:19273
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more variables than values"
 msgstr "資料敘述於 %L 有更多變數比值"
 
-#: fortran/resolve.cc:19215
+#: fortran/resolve.cc:19349
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Non-constant character length at %L in DATA statement"
 msgstr "Nonconstant 陣列區段於 %L 在中資料敘述"
 
-#: fortran/resolve.cc:19243
+#: fortran/resolve.cc:19377
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "start of implied-do loop at %L could not be simplified to a constant value"
 msgstr "開始的 implied-do 迴圈於 %L 無法被簡化到常數"
 
-#: fortran/resolve.cc:19251
+#: fortran/resolve.cc:19385
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "end of implied-do loop at %L could not be simplified to a constant value"
 msgstr "結束的 implied-do 迴圈於 %L 無法被簡化到常數"
 
-#: fortran/resolve.cc:19259
+#: fortran/resolve.cc:19393
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L could not be simplified to a constant value"
 msgstr "步驟的 implied-do 迴圈於 %L 無法被簡化到常數"
 
-#: fortran/resolve.cc:19266
+#: fortran/resolve.cc:19400
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "step of implied-do loop at %L shall not be zero"
 msgstr "步驟的 implied-do 迴圈於 %L 無法被簡化到常數"
 
-#: fortran/resolve.cc:19391
+#: fortran/resolve.cc:19525
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "DATA statement at %L has more values than variables"
 msgstr "資料敘述於 %L 有更多值比變數"
 
-#: fortran/resolve.cc:19568
+#: fortran/resolve.cc:19702
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but not used"
 msgstr "標籤 %d 於 %L 經定義但未被使用"
 
-#: fortran/resolve.cc:19574
+#: fortran/resolve.cc:19708
 #, gcc-internal-format, gfc-internal-format
 msgid "Label %d at %L defined but cannot be used"
 msgstr "標籤 %d 於 %L 經定義但無法被使用"
 
-#: fortran/resolve.cc:19658
+#: fortran/resolve.cc:19792
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
 msgstr "衍生類型變數『%s』於 %L 必須有序列屬性為等價物件"
 
-#: fortran/resolve.cc:19667
+#: fortran/resolve.cc:19801
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
 msgstr "衍生類型變數『%s』於 %L 無法有 ALLOCATABLE 成分為等價物件"
 
-#: fortran/resolve.cc:19675
+#: fortran/resolve.cc:19809
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
 msgstr "衍生類型變數『%s』於 %L 與預設初始化無法在中等價與變數在中共同"
 
-#: fortran/resolve.cc:19691
+#: fortran/resolve.cc:19825
 #, fuzzy, gcc-internal-format
 msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
 msgstr "衍生類型變數『%s』於 %L 與指標成分無法等價物件"
 
-#: fortran/resolve.cc:19794
+#: fortran/resolve.cc:19928
 #, gcc-internal-format, gfc-internal-format
 msgid "Syntax error in EQUIVALENCE statement at %L"
 msgstr "%L 處 EQUIVALENCE 敘述語法錯誤"
 
-#: fortran/resolve.cc:19809
+#: fortran/resolve.cc:19943
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
 msgstr "還是所有或沒有任何物件在中等價設定於 %L 應該有保護的屬性"
 
-#: fortran/resolve.cc:19834
+#: fortran/resolve.cc:19968
 #, fuzzy, gcc-internal-format
 msgid "COMMON block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
 msgstr "共同區塊成員『%s』於 %L 無法等價物件在中 pure 程序『%s』"
 
-#: fortran/resolve.cc:19843
+#: fortran/resolve.cc:19977
 #, fuzzy, gcc-internal-format
 msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
 msgstr "具名的常數『%s』於 %L 無法等價物件"
 
 #. Since the pair of objects is not of the same type, mixed or
 #. non-default sequences can be rejected.
-#: fortran/resolve.cc:19873
+#: fortran/resolve.cc:20007
 #, gcc-internal-format, gfc-internal-format
 msgid "Sequence %s with mixed components in EQUIVALENCE statement at %L with different type objects"
 msgstr ""
 
-#: fortran/resolve.cc:19883
+#: fortran/resolve.cc:20017
 #, gcc-internal-format, gfc-internal-format
 msgid "Non-default type object or sequence %s in EQUIVALENCE statement at %L with objects of different type"
 msgstr ""
 
-#: fortran/resolve.cc:19893
+#: fortran/resolve.cc:20027
 #, gcc-internal-format
 msgid "Non-CHARACTER object %qs in default CHARACTER EQUIVALENCE statement at %L"
 msgstr ""
 
-#: fortran/resolve.cc:19900
+#: fortran/resolve.cc:20034
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in EQUIVALENCE statement at %L"
 msgid "Non-NUMERIC object %qs in default NUMERIC EQUIVALENCE statement at %L"
 msgstr "%L 處 EQUIVALENCE 敘述語法錯誤"
 
-#: fortran/resolve.cc:19918
+#: fortran/resolve.cc:20052
 #, fuzzy, gcc-internal-format
 msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
 msgstr "陣列『%s』於 %L 與 non-constant 邊界無法等價物件"
 
-#: fortran/resolve.cc:19929
+#: fortran/resolve.cc:20063
 #, fuzzy, gcc-internal-format
 msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
 msgstr "結構成分『%s』於 %L 無法等價物件"
 
-#: fortran/resolve.cc:19940
+#: fortran/resolve.cc:20074
 #, gcc-internal-format, gfc-internal-format
 msgid "Substring at %L has length zero"
 msgstr "%L 的子字串長度為零"
 
-#: fortran/resolve.cc:19971
+#: fortran/resolve.cc:20105
 #, fuzzy, gcc-internal-format
 #| msgid "Syntax error in character length specification at %C"
 msgid "Self reference in character length expression for %qs at %L"
 msgstr "%C 處指定字元長度時語法錯誤"
 
-#: fortran/resolve.cc:20038
+#: fortran/resolve.cc:20172
 #, fuzzy, gcc-internal-format
 msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
 msgstr "Fortran 2003:公用的函式『%s』於 %L 的私人的型態『%s』"
 
-#: fortran/resolve.cc:20051
+#: fortran/resolve.cc:20185
 #, fuzzy, gcc-internal-format
 #| msgid "ENTRY '%s' at %L has no IMPLICIT type"
 msgid "ENTRY %qs at %L has no IMPLICIT type"
 msgstr "ENTRY「%s」在 %L 處沒有 IMPLICIT 類型"
 
-#: fortran/resolve.cc:20073
+#: fortran/resolve.cc:20207
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must be a FUNCTION"
 msgstr "使用者運算子程序『%s』於 %L 必須是函式"
 
-#: fortran/resolve.cc:20083
+#: fortran/resolve.cc:20217
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L cannot be assumed character length"
 msgstr "使用者運算子程序『%s』於 %L 無法假設的字元長度"
 
-#: fortran/resolve.cc:20091
+#: fortran/resolve.cc:20225
 #, fuzzy, gcc-internal-format
 msgid "User operator procedure %qs at %L must have at least one argument"
 msgstr "使用者運算子程序『%s』於 %L 必須至少有一個引數"
 
-#: fortran/resolve.cc:20105
+#: fortran/resolve.cc:20239
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "First argument of operator interface at %L cannot be optional"
 msgstr "第一個引數的運算子介面於 %L 無法可選的"
 
-#: fortran/resolve.cc:20123
+#: fortran/resolve.cc:20257
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of operator interface at %L cannot be optional"
 msgstr "秒引數的運算子介面於 %L 無法可選的"
 
-#: fortran/resolve.cc:20130
+#: fortran/resolve.cc:20264
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Operator interface at %L must have, at most, two arguments"
 msgstr "運算子介面於 %L 必須有，最多，兩引數"
 
-#: fortran/resolve.cc:20212
+#: fortran/resolve.cc:20346
 #, fuzzy, gcc-internal-format
 msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
 msgstr "包含的程序『%s』於 %L 的 PURE 程序必須也是 PURE"
@@ -91121,103 +91301,103 @@ msgstr "忽略不存在的目錄「%s」\n"
 msgid "%qs is not a directory"
 msgstr "%qD 並非型態"
 
-#: fortran/scanner.cc:790
+#: fortran/scanner.cc:792
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP 於 %C 開始評論的列做為它 neither 被在之後空格 nor 是延續列"
 
-#: fortran/scanner.cc:830
+#: fortran/scanner.cc:834
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
 msgstr "!$OMP 於 %C 開始評論的列做為它 neither 被在之後空格 nor 是延續列"
 
-#: fortran/scanner.cc:1009
+#: fortran/scanner.cc:1013
 #, gcc-internal-format
 msgid "Ignoring %<!$omx%> vendor-extension sentinel at %C"
 msgstr ""
 
-#: fortran/scanner.cc:1321 fortran/scanner.cc:1524
+#: fortran/scanner.cc:1325 fortran/scanner.cc:1528
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Line truncated at %L"
 msgstr "列截斷的於 %L"
 
-#: fortran/scanner.cc:1385 fortran/scanner.cc:1614
+#: fortran/scanner.cc:1389 fortran/scanner.cc:1618
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Limit of %d continuations exceeded in statement at %C"
 msgstr "限制的 %d 延續超出的在中敘述於 %C"
 
-#: fortran/scanner.cc:1464 fortran/scanner.cc:1573
+#: fortran/scanner.cc:1468 fortran/scanner.cc:1577
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenACC continuation at %C: expected !$ACC, got !$OMP"
 msgstr ""
 
-#: fortran/scanner.cc:1466 fortran/scanner.cc:1575
+#: fortran/scanner.cc:1470 fortran/scanner.cc:1579
 #, gcc-internal-format, gfc-internal-format
 msgid "Wrong OpenMP continuation at %C: expected !$OMP, got !$ACC"
 msgstr ""
 
-#: fortran/scanner.cc:1479
+#: fortran/scanner.cc:1483
 #, fuzzy, gcc-internal-format
 msgid "Missing %<&%> in continued character constant at %C"
 msgstr "缺少『&』在中繼續的字元常數於 %C"
 
-#: fortran/scanner.cc:1765
+#: fortran/scanner.cc:1769
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character at %C"
 msgstr "Nonconforming 定位字元於 %C"
 
-#: fortran/scanner.cc:1776
+#: fortran/scanner.cc:1780
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Invalid character 0x%s at %C"
 msgstr "無效字元在中名稱於 %C"
 
-#: fortran/scanner.cc:1865 fortran/scanner.cc:1868
+#: fortran/scanner.cc:1869 fortran/scanner.cc:1872
 #, fuzzy, gcc-internal-format
 msgid "%<&%> not allowed by itself in line %d"
 msgstr "『&』不允許由它自己於第 %d 列"
 
-#: fortran/scanner.cc:1958
+#: fortran/scanner.cc:1962
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Nonconforming tab character in column %d of line %d"
 msgstr "Nonconforming 定位字元在中欄 %d 的列 %d"
 
-#: fortran/scanner.cc:2187
+#: fortran/scanner.cc:2191
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: file %s left but not entered"
 msgid "file %qs left but not entered"
 msgstr "%s:%d: 檔案 %s 被留下但未進入"
 
-#: fortran/scanner.cc:2229
+#: fortran/scanner.cc:2233
 #, fuzzy, gcc-internal-format
 #| msgid "%s:%d: Illegal preprocessor directive"
 msgid "Illegal preprocessor directive"
 msgstr "%s:%d：無效的預包含指示"
 
-#: fortran/scanner.cc:2552
+#: fortran/scanner.cc:2556
 #, fuzzy, gcc-internal-format
 #| msgid "File '%s' is being included recursively"
 msgid "File %qs is being included recursively"
 msgstr "檔案「%s」被遞迴地包含"
 
-#: fortran/scanner.cc:2564
+#: fortran/scanner.cc:2568
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open file '%s'"
 msgid "Cannot open file %qs"
 msgstr "無法開啟檔案「%s」"
 
-#: fortran/scanner.cc:2574
+#: fortran/scanner.cc:2578
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open included file %qs"
 msgstr "無法開啟包含檔案「%s」"
 
-#: fortran/scanner.cc:2576
+#: fortran/scanner.cc:2580
 #, fuzzy, gcc-internal-format
 #| msgid "Can't open included file '%s'"
 msgid "Cannot open pre-included file %qs"
 msgstr "無法開啟包含檔案「%s」"
 
-#: fortran/scanner.cc:2584 fortran/scanner.cc:2586
+#: fortran/scanner.cc:2588 fortran/scanner.cc:2590
 #, fuzzy, gcc-internal-format
 #| msgid "%qs is not a valid output file"
 msgid "Included file %qs is not a regular file"
@@ -91392,223 +91572,223 @@ msgstr "如果 ATAN2 %L 的第一個參數為 0，第二個參數必須不為 0"
 msgid "gfc_simplify_dim(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3336
+#: fortran/simplify.cc:3340
 #, gcc-internal-format
 msgid "in gfc_simplify_exp(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:3556
+#: fortran/simplify.cc:3560
 #, gcc-internal-format
 msgid "gfc_simplify_floor(): Bad kind"
 msgstr ""
 
-#: fortran/simplify.cc:3673
+#: fortran/simplify.cc:3677
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR at %L must be of length one"
 msgstr "%L 處 IACHAR 的參數長度必須為 1"
 
-#: fortran/simplify.cc:3681
+#: fortran/simplify.cc:3685
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of IACHAR function at %L outside of range 0..127"
 msgstr "引數的 IACHAR 函式於 %L 外側的範圍 0..127"
 
-#: fortran/simplify.cc:3842
+#: fortran/simplify.cc:3846
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
 msgstr "和的秒和第三引數的 IBITS 超出位元大小於 %L"
 
-#: fortran/simplify.cc:3868
+#: fortran/simplify.cc:3872
 #, gcc-internal-format
 msgid "IBITS: Bad bit"
 msgstr ""
 
-#: fortran/simplify.cc:3935
+#: fortran/simplify.cc:3939
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of ICHAR at %L must be of length one"
 msgstr "%L 處 ICHAR 的參數長度必須為 1"
 
 #. Left shift, as in SHIFTL.
-#: fortran/simplify.cc:4296 fortran/simplify.cc:4304
+#: fortran/simplify.cc:4300 fortran/simplify.cc:4308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Second argument of %s is negative at %L"
 msgstr "秒引數的 %s 是負於 %L"
 
-#: fortran/simplify.cc:4316
+#: fortran/simplify.cc:4320
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of %s exceeds bit size at %L"
 msgstr "振幅的秒引數的 %s 超出位元大小於 %L"
 
-#: fortran/simplify.cc:4448
+#: fortran/simplify.cc:4452
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %C"
 msgstr "振幅的秒引數的 ISHFTC 超出 BIT_SIZE 的先引數於 %L"
 
-#: fortran/simplify.cc:4451
+#: fortran/simplify.cc:4455
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Absolute value of SHIFT shall be less than or equal to SIZE at %C"
 msgstr "絕對值的 Shift 於 %L 必須是少於或等於大小於 %L"
 
-#: fortran/simplify.cc:4798 fortran/simplify.cc:4931
+#: fortran/simplify.cc:4802 fortran/simplify.cc:4935
 #, gcc-internal-format, gfc-internal-format
 msgid "DIM argument at %L is out of bounds"
 msgstr "%L 處的 DIM 參數越界"
 
-#: fortran/simplify.cc:5279
+#: fortran/simplify.cc:5283
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG at %L cannot be less than or equal to zero"
 msgstr "引數的記錄檔於 %L 無法少於或等於零"
 
-#: fortran/simplify.cc:5292
+#: fortran/simplify.cc:5296
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Complex argument of LOG at %L cannot be zero"
 msgstr "複雜引數的記錄檔於 %L 無法零"
 
-#: fortran/simplify.cc:5303
+#: fortran/simplify.cc:5307
 #, gcc-internal-format
 msgid "gfc_simplify_log: bad type"
 msgstr ""
 
-#: fortran/simplify.cc:5320
+#: fortran/simplify.cc:5324
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
 msgstr "引數的 LOG10 於 %L 無法少於或等於零"
 
-#: fortran/simplify.cc:5752
+#: fortran/simplify.cc:5756
 #, gcc-internal-format
 msgid "simplify_min_max(): Bad type in arglist"
 msgstr ""
 
-#: fortran/simplify.cc:6675 fortran/simplify.cc:6683
+#: fortran/simplify.cc:6679 fortran/simplify.cc:6687
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MOD at %L shall not be zero"
 msgstr "引數『S』的最近的於 %L 不應該是零"
 
-#: fortran/simplify.cc:6689
+#: fortran/simplify.cc:6693
 #, fuzzy, gcc-internal-format
 #| msgid "gfc_trans_code(): Bad statement code"
 msgid "gfc_simplify_mod(): Bad arguments"
 msgstr "gfc_trans_code()：錯誤的敘述程式碼"
 
-#: fortran/simplify.cc:6728 fortran/simplify.cc:6736
+#: fortran/simplify.cc:6732 fortran/simplify.cc:6740
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs of MODULO at %L shall not be zero"
 msgstr "引數『S』的最近的於 %L 不應該是零"
 
-#: fortran/simplify.cc:6742
+#: fortran/simplify.cc:6746
 #, gcc-internal-format
 msgid "gfc_simplify_modulo(): Bad arguments"
 msgstr ""
 
-#: fortran/simplify.cc:6814
+#: fortran/simplify.cc:6818
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Result of NEAREST is NaN at %L"
 msgstr "結果的最近的是 NaN 於 %L"
 
-#: fortran/simplify.cc:7601
+#: fortran/simplify.cc:7605
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
 msgstr "引數 NCOPIES 的重複 intrinsic 是負於 %L"
 
-#: fortran/simplify.cc:7657
+#: fortran/simplify.cc:7661
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
 msgstr "引數 NCOPIES 的重複 intrinsic 太大於 %L"
 
-#: fortran/simplify.cc:7694
+#: fortran/simplify.cc:7698
 #, gcc-internal-format, gfc-internal-format
 msgid "Evaluation of string longer than 2**28 at %L deferred to runtime, expect bugs"
 msgstr ""
 
-#: fortran/simplify.cc:7752
+#: fortran/simplify.cc:7756
 #, gcc-internal-format, gfc-internal-format
 msgid "The SHAPE array for the RESHAPE intrinsic at %L has a negative value %d for dimension %d"
 msgstr ""
 
-#: fortran/simplify.cc:7777
+#: fortran/simplify.cc:7781
 #, gcc-internal-format, gfc-internal-format
 msgid "Shapes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7791
+#: fortran/simplify.cc:7795
 #, gcc-internal-format, gfc-internal-format
 msgid "Sizes of ORDER at %L and SHAPE at %L are different"
 msgstr ""
 
-#: fortran/simplify.cc:7806
+#: fortran/simplify.cc:7810
 #, gcc-internal-format, gfc-internal-format
 msgid "Element with a value of %d in ORDER at %L must be in the range [1, ..., %d] for the RESHAPE intrinsic near %L"
 msgstr ""
 
-#: fortran/simplify.cc:7817
+#: fortran/simplify.cc:7821
 #, gcc-internal-format, gfc-internal-format
 msgid "ORDER at %L is not a permutation of the size of SHAPE at %L"
 msgstr ""
 
-#: fortran/simplify.cc:7879
+#: fortran/simplify.cc:7883
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Integer too large at %C"
 msgid "Reshaped array too large at %C"
 msgstr "%C 處整數太大"
 
-#: fortran/simplify.cc:8000
+#: fortran/simplify.cc:8004
 #, gcc-internal-format, gfc-internal-format
 msgid "Result of SCALE overflows its kind at %L"
 msgstr "%L 處 SCALE 的結果向上溢位其種別"
 
-#: fortran/simplify.cc:8520
+#: fortran/simplify.cc:8524
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
 msgid "DIM argument (%d) to intrinsic SIZE at %L out of range (1:%d)"
 msgstr "引數「%s」(屬於內建函式「%s」，位於 %L)的秩必須為 %d"
 
-#: fortran/simplify.cc:8649
+#: fortran/simplify.cc:8653
 #, fuzzy, gcc-internal-format
 #| msgid "Bad type in constant expression"
 msgid "Bad type in gfc_simplify_sign"
 msgstr "常數運算式中類型錯誤"
 
-#: fortran/simplify.cc:8678
+#: fortran/simplify.cc:8682
 #, gcc-internal-format
 msgid "in gfc_simplify_sin(): Bad type"
 msgstr ""
 
-#: fortran/simplify.cc:8816 fortran/simplify.cc:9099
+#: fortran/simplify.cc:8820 fortran/simplify.cc:9103
 #, gcc-internal-format
 msgid "Failure getting length of a constant array."
 msgstr ""
 
-#: fortran/simplify.cc:8826
+#: fortran/simplify.cc:8830
 #, fuzzy, gcc-internal-format
 msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
 msgstr "元件號碼的在中陣列建構子於 %L 需求增加的允許 %d 上限。  參看 -fmax-array-constructor 選項"
 
-#: fortran/simplify.cc:8893
+#: fortran/simplify.cc:8897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Simplification of SPREAD at %C not yet implemented"
 msgstr "Finalization 於 %L 不是未實作"
 
-#: fortran/simplify.cc:8917
+#: fortran/simplify.cc:8921
 #, gcc-internal-format, gfc-internal-format
 msgid "Argument of SQRT at %L has a negative value"
 msgstr "%L 處 SQRT 的參數為負"
 
-#: fortran/simplify.cc:8933
+#: fortran/simplify.cc:8937
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Invalid second argument of IBSET at %L"
 msgid "invalid argument of SQRT at %L"
 msgstr "%L 處 IBSET 的第二個參數無效"
 
-#: fortran/simplify.cc:9281
+#: fortran/simplify.cc:9285
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
 msgstr "發信匣的邊界在中 IMAGE_INDEX 於 %L 用於尺寸 %d，子有 %ld 和 COARRAY 下限是 %ld)"
 
-#: fortran/simplify.cc:9304
+#: fortran/simplify.cc:9308
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
 msgstr "發信匣的邊界在中 IMAGE_INDEX 於 %L 用於尺寸 %d，子有 %ld 和 COARRAY 上限是 %ld)"
 
-#: fortran/simplify.cc:9846
+#: fortran/simplify.cc:9850
 #, fuzzy, gcc-internal-format
 msgid "Character %qs in string at %L cannot be converted into character kind %d"
 msgstr "字元『%s』在中字串於 %L 無法轉換的進入字元 kind %d"
@@ -91961,74 +92141,74 @@ msgstr "%C 處需要結束名"
 msgid "Labeled DO statement at %L"
 msgstr "Fortran 2008:鎖定敘述於 %C"
 
-#: fortran/symbol.cc:3436
+#: fortran/symbol.cc:3444
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
 msgstr "名稱『%s』於 %C 是模稜兩可的參考到『%s』從模組『%s』"
 
-#: fortran/symbol.cc:3439
+#: fortran/symbol.cc:3447
 #, fuzzy, gcc-internal-format
 msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
 msgstr "名稱『%s』於 %C 是模稜兩可的參考到『%s』從目前的程式單元"
 
 #. Symbol is from another namespace.
-#: fortran/symbol.cc:3684
+#: fortran/symbol.cc:3692
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %C has already been host associated"
 msgstr "符號『%s』於 %C 已主機關聯的"
 
-#: fortran/symbol.cc:4739
+#: fortran/symbol.cc:4747
 #, gcc-internal-format
 msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
 msgstr ""
 
-#: fortran/symbol.cc:4752
+#: fortran/symbol.cc:4760
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
 msgstr "衍生類型『%s』宣告的於 %L 必須有繫結屬性為 C 可交流的"
 
-#: fortran/symbol.cc:4780
+#: fortran/symbol.cc:4788
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L has no components"
 msgstr "衍生類型『%s』於 %L 有私人的成分"
 
 #. Generally emit warning, but not twice if -pedantic is given.
-#: fortran/symbol.cc:4786
+#: fortran/symbol.cc:4794
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
 msgstr "衍生類型『%s』與繫結©屬性於 %L 是空的，而也許會是不可存取由 C companion 處理器"
 
-#: fortran/symbol.cc:4808
+#: fortran/symbol.cc:4816
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "成分『%s』於 %L 無法有指標屬性因為它是成員的繫結©衍生類型『%s』於 %L"
 
-#: fortran/symbol.cc:4818
+#: fortran/symbol.cc:4826
 #, fuzzy, gcc-internal-format
 msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
 msgstr "程序指標成分『%s』於 %L 無法成員的繫結©衍生類型『%s』於 %L"
 
-#: fortran/symbol.cc:4829
+#: fortran/symbol.cc:4837
 #, fuzzy, gcc-internal-format
 msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
 msgstr "成分『%s』於 %L 無法有 ALLOCATABLE 屬性因為它是成員的繫結©衍生類型『%s』於 %L"
 
-#: fortran/symbol.cc:4868
+#: fortran/symbol.cc:4876
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
 msgstr "成分『%s』在中衍生類型『%s』於 %L 可能無法是 C 可交流的，甚至雖然衍生類型『%s』是繫結©"
 
-#: fortran/symbol.cc:4878
+#: fortran/symbol.cc:4886
 #, fuzzy, gcc-internal-format
 msgid "Component %qs in derived type %qs at %L may not be C interoperable"
 msgstr "成分『%s』在中衍生類型『%s』於 %L 可能無法是 C 可交流的"
 
-#: fortran/symbol.cc:4890
+#: fortran/symbol.cc:4898
 #, fuzzy, gcc-internal-format
 msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
 msgstr "衍生類型『%s』於 %L 無法有序列屬性因為它是繫結©"
 
-#: fortran/symbol.cc:5403 fortran/symbol.cc:5408
+#: fortran/symbol.cc:5411 fortran/symbol.cc:5416
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs is used before it is typed at %L"
 msgstr "符號『%s』被使用之前它被型態於 %L"
@@ -92058,29 +92238,34 @@ msgstr "重疊 unequal 初始設定式在中等價於 %L"
 msgid "Overlapping unequal initializers in EQUIVALENCE at %C"
 msgstr "重疊 unequal 初始設定式在中等價於 %L"
 
-#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10648
+#: fortran/trans-array.cc:2452 fortran/trans-expr.cc:10704
 #, gcc-internal-format, gfc-internal-format
 msgid "The structure constructor at %L has been finalized. This feature was removed by f08/0011. Use -std=f2018 or -std=gnu to eliminate the finalization."
 msgstr ""
 
-#: fortran/trans-array.cc:4023
+#: fortran/trans-array.cc:4046
 #, gcc-internal-format
 msgid "Bounds checking of the elemental index at %L will cause two calls to %qs, which is not declared to be PURE or is not implicitly pure."
 msgstr ""
 
+#: fortran/trans-array.cc:7109
+#, fuzzy, gcc-internal-format, gfc-internal-format
+msgid "Array initializer at %L does not reduce to a constant expression"
+msgstr "陣列『%s』於 %L 是變數，該項不縮小到常數運算式"
+
 #. Problems occur when we get something like
 #. integer :: a(lots) = (/(i, i=1, lots)/)
-#: fortran/trans-array.cc:7113
+#: fortran/trans-array.cc:7149
 #, fuzzy, gcc-internal-format
 msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
 msgstr "元件號碼的在中陣列建構子於 %L 需求增加的允許 %d 上限。  參看 -fmax-array-constructor 選項"
 
-#: fortran/trans-array.cc:9533
+#: fortran/trans-array.cc:9569
 #, fuzzy, gcc-internal-format
 msgid "Creating array temporary at %L for argument %qs"
 msgstr "建立陣列暫時的於 %L 用於引數『%s』"
 
-#: fortran/trans-array.cc:13291
+#: fortran/trans-array.cc:13383
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "bad expression type during walk (%d)"
 msgstr "不當的運算式型態在的期間遍歷 (%d)"
@@ -92183,114 +92368,114 @@ msgstr "指派值不同於 0 或 1 到邏輯的已未定義結果於 %L"
 msgid "non-constant initialization expression at %L"
 msgstr "non-constant 初始化運算式於 %L"
 
-#: fortran/trans-decl.cc:785
+#: fortran/trans-decl.cc:798
 #, gcc-internal-format
 msgid "Array %qs at %L is larger than limit set by %<-fmax-stack-var-size=%>, moved from stack to static storage. This makes the procedure unsafe when called recursively, or concurrently from multiple threads. Consider increasing the %<-fmax-stack-var-size=%> limit (or use %<-frecursive%>, which implies unlimited %<-fmax-stack-var-size%>) - or change the code to use an ALLOCATABLE array. If the variable is never accessed concurrently, this warning can be ignored, and the variable could also be declared with the SAVE attribute."
 msgstr ""
 
-#: fortran/trans-decl.cc:1591
+#: fortran/trans-decl.cc:1604
 #, gcc-internal-format
 msgid "Sorry, OMP GROUPPRIVATE not implemented, used by %qs declared at %L"
 msgstr ""
 
 #. Use 'else if' as groupprivate implies 'local'.
-#: fortran/trans-decl.cc:1595
+#: fortran/trans-decl.cc:1608
 #, gcc-internal-format
 msgid "Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, used by %qs declared at %L"
 msgstr ""
 
-#: fortran/trans-decl.cc:1939
+#: fortran/trans-decl.cc:1952
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "%s at %L has no default type"
 msgstr "關聯目標於 %C 必須不被 coindexed"
 
-#: fortran/trans-decl.cc:1943
+#: fortran/trans-decl.cc:1956
 #, gcc-internal-format
 msgid "intrinsic variable which isn't a procedure"
 msgstr "內建函式變數不是一個程序"
 
-#: fortran/trans-decl.cc:4824 fortran/trans-decl.cc:7998
+#: fortran/trans-decl.cc:4899 fortran/trans-decl.cc:8078
 #, fuzzy, gcc-internal-format
 msgid "Return value of function %qs at %L not set"
 msgstr "傳回值的函式『%s』於 %L 無法設定"
 
-#: fortran/trans-decl.cc:5381
+#: fortran/trans-decl.cc:5461
 #, fuzzy, gcc-internal-format
 msgid "Deferred type parameter not yet supported"
 msgstr "已推遲型態參數尚未支援"
 
-#: fortran/trans-decl.cc:5693
+#: fortran/trans-decl.cc:5773
 #, fuzzy, gcc-internal-format
 #| msgid "backend decl for module variable %s already exists"
 msgid "backend decl for module variable %qs already exists"
 msgstr "模組變數 %s 的後端程式宣告已存在"
 
-#: fortran/trans-decl.cc:5706
+#: fortran/trans-decl.cc:5786
 #, fuzzy, gcc-internal-format
 msgid "Unused PRIVATE module variable %qs declared at %L"
 msgstr "未使用的變數『%s』宣告的於 %L"
 
-#: fortran/trans-decl.cc:6392
+#: fortran/trans-decl.cc:6472
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a dummy argument"
 msgstr "『%s』於 %L 無法有值屬性因為它並非虛引數"
 
-#: fortran/trans-decl.cc:6395
+#: fortran/trans-decl.cc:6475
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L has the WEAK attribute but is a local variable"
 msgstr "成分『%s』於 %L 有 CONTIGUOUS 屬性但是不是陣列指標"
 
-#: fortran/trans-decl.cc:6410
+#: fortran/trans-decl.cc:6490
 #, fuzzy, gcc-internal-format
 msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
 msgstr "虛引數『%s』於 %L 被宣告含義 (出) 但是不是設定"
 
-#: fortran/trans-decl.cc:6416
+#: fortran/trans-decl.cc:6496
 #, fuzzy, gcc-internal-format
 msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
 msgstr "衍生類型虛引數『%s』於 %L 被宣告含義 (出) 但是不是設定和沒有預設初始設定式"
 
-#: fortran/trans-decl.cc:6427 fortran/trans-decl.cc:6578
+#: fortran/trans-decl.cc:6507 fortran/trans-decl.cc:6658
 #, fuzzy, gcc-internal-format
 msgid "Unused dummy argument %qs at %L"
 msgstr "未使用的虛引數『%s』於 %L"
 
-#: fortran/trans-decl.cc:6443
+#: fortran/trans-decl.cc:6523
 #, fuzzy, gcc-internal-format
 msgid "Unused module variable %qs which has been explicitly imported at %L"
 msgstr "未使用的模組變數『%s』該項已被明確的匯入的於 %L"
 
-#: fortran/trans-decl.cc:6462
+#: fortran/trans-decl.cc:6542
 #, fuzzy, gcc-internal-format
 msgid "Unused variable %qs declared at %L"
 msgstr "未使用的變數『%s』宣告的於 %L"
 
-#: fortran/trans-decl.cc:6511
+#: fortran/trans-decl.cc:6591
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs declared at %L"
 msgstr "未使用的參數『%s』宣告的於 %L"
 
-#: fortran/trans-decl.cc:6515
+#: fortran/trans-decl.cc:6595
 #, fuzzy, gcc-internal-format
 msgid "Unused parameter %qs which has been explicitly imported at %L"
 msgstr "未使用的參數『%s』該項已被明確的匯入的於 %L"
 
-#: fortran/trans-decl.cc:6545
+#: fortran/trans-decl.cc:6625
 #, fuzzy, gcc-internal-format
 msgid "Return value %qs of function %qs declared at %L not set"
 msgstr "傳回值『%s』的函式『%s』宣告的於 %L 無法設定"
 
-#: fortran/trans-decl.cc:7144
+#: fortran/trans-decl.cc:7224
 #, gcc-internal-format, gfc-internal-format
 msgid "Sorry, !$ACC DECLARE at %L is not allowed in BLOCK construct"
 msgstr ""
 
-#: fortran/trans-decl.cc:7343 fortran/trans-expr.cc:6252
+#: fortran/trans-decl.cc:7423 fortran/trans-expr.cc:6272
 #, fuzzy, gcc-internal-format
 msgid "Unsigned not yet implemented"
 msgstr "Finalization 於 %L 不是未實作"
 
-#: fortran/trans-decl.cc:8482
+#: fortran/trans-decl.cc:8562
 #, fuzzy, gcc-internal-format
 msgid "Symbol %qs at %L is declared in a BLOCK DATA program unit but is not in a COMMON block"
 msgstr "符號『%s』於 %C 已經在中共同區塊"
@@ -92320,12 +92505,12 @@ msgstr "無限制的多型於 %C 尚未支援"
 msgid "Unknown intrinsic op"
 msgstr "不明的內建作業"
 
-#: fortran/trans-expr.cc:6003
+#: fortran/trans-expr.cc:6023
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Unknown argument list function at %L"
 msgstr "不明引數清單函式於 %L"
 
-#: fortran/trans-expr.cc:11255
+#: fortran/trans-expr.cc:11311
 #, gcc-internal-format, gfc-internal-format
 msgid "If bounds remapping is specified at %L, the pointer target shall not be NULL"
 msgstr ""
@@ -92342,12 +92527,12 @@ msgstr "內部函式 %s(%d) 無法識別"
 msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
 msgstr "『dim』引數的 %s intrinsic 於 %L 並非有效尺寸索引"
 
-#: fortran/trans-intrinsic.cc:12993 fortran/trans-stmt.cc:1234
+#: fortran/trans-intrinsic.cc:12996 fortran/trans-stmt.cc:1234
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Sorry, the event component of derived type at %L is not yet supported"
 msgstr "Deferred-length 字元成分『%s』於 %L 不是未支援"
 
-#: fortran/trans-intrinsic.cc:13000
+#: fortran/trans-intrinsic.cc:13003
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The event variable at %L shall not be coindexed"
 msgstr "指標物件於 %C 不應該被 coindexed"
@@ -92372,192 +92557,192 @@ msgstr ""
 msgid "implicit mapping of assumed size array %qD"
 msgstr "不當的規格用於假設的大小陣列於 %C"
 
-#: fortran/trans-openmp.cc:2187
+#: fortran/trans-openmp.cc:2217
 #, gcc-internal-format
 msgid "Mapping of unlimited polymorphic list item %qD is unspecified behavior and unsupported"
 msgstr ""
 
-#: fortran/trans-openmp.cc:2192
+#: fortran/trans-openmp.cc:2222
 #, gcc-internal-format
 msgid "Mapping of polymorphic list item %qD is unspecified behavior"
 msgstr ""
 
-#: fortran/trans-openmp.cc:4423
+#: fortran/trans-openmp.cc:4453
 #, fuzzy, gcc-internal-format
 msgid "optional class parameter"
 msgstr "無效的 PHI 引數"
 
-#: fortran/trans-openmp.cc:4914
+#: fortran/trans-openmp.cc:4944
 #, fuzzy, gcc-internal-format
 #| msgid "Expected expression type"
 msgid "unhandled expression type"
 msgstr "需要運算式類型"
 
-#: fortran/trans-openmp.cc:5109
+#: fortran/trans-openmp.cc:5139
 #, fuzzy, gcc-internal-format
 #| msgid "expected expression"
 msgid "unhandled expression"
 msgstr "需要運算式"
 
-#: fortran/trans-openmp.cc:5234
+#: fortran/trans-openmp.cc:5264
 #, gcc-internal-format
 msgid "%<uses_allocators%> clause with traits and memory spaces"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6270
+#: fortran/trans-openmp.cc:6300
 #, gcc-internal-format
 msgid "%<!$OMP %s%> at %L requires %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6273
+#: fortran/trans-openmp.cc:6303
 #, gcc-internal-format
 msgid "All files that might deallocate such a variable must be compiled with %<-fopenmp-allocators%>"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6276
+#: fortran/trans-openmp.cc:6306
 #, gcc-internal-format
 msgid "This includes explicit DEALLOCATE, reallocation on intrinsic assignment, INTENT(OUT) for allocatable dummy arguments, and reallocation of allocatable components allocated with an OpenMP allocator"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6853 fortran/trans-openmp.cc:6873
+#: fortran/trans-openmp.cc:6883 fortran/trans-openmp.cc:6903
 #, gcc-internal-format
 msgid "non-rectangular loop nest with non-constant step for %qs"
 msgstr ""
 
-#: fortran/trans-openmp.cc:6875
+#: fortran/trans-openmp.cc:6905
 #, fuzzy, gcc-internal-format
 msgid "Used here"
 msgstr "聯合定義的在此"
 
-#: fortran/trans-openmp.cc:9443
+#: fortran/trans-openmp.cc:9473
 #, fuzzy, gcc-internal-format
 msgid "gfc_trans_omp_workshare(): Bad statement code"
 msgstr "gfc_trans_omp_workshare()：不當的敘述編碼"
 
-#: fortran/trans-openmp.cc:9853
+#: fortran/trans-openmp.cc:9883
 #, fuzzy, gcc-internal-format
 msgid "The base name for %<declare variant%> must be specified at %L"
 msgstr "還是所有或沒有任何上限必須被指定的於 %L"
 
-#: fortran/trans-openmp.cc:9864
+#: fortran/trans-openmp.cc:9894
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "Name '%s' at %C is the name of the procedure"
 msgid "The base name at %L does not match the name of the current procedure"
 msgstr "名稱「%s」(位於 %C)是一個程序的名稱"
 
-#: fortran/trans-openmp.cc:9867
+#: fortran/trans-openmp.cc:9897
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be an entry name"
 msgstr "STAT=引數於 %L 必須是純量整數變數"
 
-#: fortran/trans-openmp.cc:9870
+#: fortran/trans-openmp.cc:9900
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a generic name"
 msgstr "介面『%s』於 %C 可能無法是通用"
 
-#: fortran/trans-openmp.cc:9873
+#: fortran/trans-openmp.cc:9903
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base name at %L must not be a procedure pointer"
 msgstr "程序指標初始化目標於 %L 可能無法是程序指標"
 
-#: fortran/trans-openmp.cc:9876
+#: fortran/trans-openmp.cc:9906
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "The base procedure at %L must have an explicit interface"
 msgstr "程序『%s』在中 %s 於 %L 沒有任何明確的介面"
 
-#: fortran/trans-openmp.cc:9912
+#: fortran/trans-openmp.cc:9942
 #, fuzzy, gcc-internal-format
 #| msgid "Can't convert %s to %s at %L"
 msgid "Cannot find symbol %qs at %L"
 msgstr "不能將 %s 轉換為 %s，於 %L"
 
-#: fortran/trans-openmp.cc:9925
+#: fortran/trans-openmp.cc:9955
 #, fuzzy, gcc-internal-format
 #| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
 msgid "variant %qs at %L is not a function or subroutine"
 msgstr "程序「%s」(在 %s 中，位於 %L) 既不是函式也不是子處理序"
 
-#: fortran/trans-openmp.cc:9931
+#: fortran/trans-openmp.cc:9961
 #, fuzzy, gcc-internal-format
 msgid "variant %qs at %L is the same as base function"
 msgstr "『%s』於 %L 並非函式"
 
-#: fortran/trans-openmp.cc:9973
+#: fortran/trans-openmp.cc:10003
 #, fuzzy, gcc-internal-format
 #| msgid "-f%s and -msdata=%s are incompatible"
 msgid "variant %qs and base %qs at %L have incompatible types: %s"
 msgstr "-f%s 和 -msdata=%s 互不相容"
 
-#: fortran/trans-openmp.cc:9979
+#: fortran/trans-openmp.cc:10009
 #, gcc-internal-format
 msgid "%<append_args%> clause implies that %qs has %d dummy arguments of integer type with %<omp_interop_kind%> kind"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10005
+#: fortran/trans-openmp.cc:10035
 #, gcc-internal-format
 msgid "%qs at %L must be a nonpointer, nonallocatable scalar integer dummy argument of %<omp_interop_kind%> kind as it utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10015
+#: fortran/trans-openmp.cc:10045
 #, gcc-internal-format
 msgid "%qs at %L with OPTIONAL attribute not support when utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10025
+#: fortran/trans-openmp.cc:10055
 #, gcc-internal-format
 msgid "%qs at %L has %d but requires %d %<omp_interop_kind%> kind dummy arguments as it is utilized with the %<append_args%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10040
+#: fortran/trans-openmp.cc:10070
 #, gcc-internal-format
 msgid "the %qs clause can only be specified if the %<dispatch%> selector of the construct selector set appears in the %<match%> clause at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10141 fortran/trans-openmp.cc:10180
+#: fortran/trans-openmp.cc:10171 fortran/trans-openmp.cc:10210
 #, fuzzy, gcc-internal-format, gfc-internal-format
 msgid "Expected positive argument index at %L"
 msgstr "預期的引數清單於 %C"
 
-#: fortran/trans-openmp.cc:10152
+#: fortran/trans-openmp.cc:10182
 #, fuzzy, gcc-internal-format, gfc-internal-format
 #| msgid "default arguments are only permitted for function parameters"
 msgid "Argument index at %L exceeds number of arguments %d"
 msgstr "預設參數只允許出現在函式參數中"
 
-#: fortran/trans-openmp.cc:10190
+#: fortran/trans-openmp.cc:10220
 #, gcc-internal-format, gfc-internal-format
 msgid "Upper argument index smaller than lower one at %L"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10216
+#: fortran/trans-openmp.cc:10246
 #, fuzzy, gcc-internal-format
 #| msgid "An alternate return at %L without a * dummy argument"
 msgid "List item %qs at %L, declared at %L, is not a dummy argument"
 msgstr "%L 不帶 * 啞引數的替代回傳"
 
-#: fortran/trans-openmp.cc:10230
+#: fortran/trans-openmp.cc:10260
 #, fuzzy, gcc-internal-format
 #| msgid "Argument '%s' of statement function at %L must be scalar"
 msgid "Argument %qs at %L to list item in %<need_device_ptr%> at %L must be a scalar of TYPE(C_PTR)"
 msgstr "敘述函式的引數「%s」在 %L 處必須是標量"
 
-#: fortran/trans-openmp.cc:10237
+#: fortran/trans-openmp.cc:10267
 #, gcc-internal-format
 msgid "Consider using %<need_device_addr%> instead"
 msgstr ""
 
-#: fortran/trans-openmp.cc:10244
+#: fortran/trans-openmp.cc:10274
 #, fuzzy, gcc-internal-format
 msgid "Argument %qs at %L to list item in %<need_device_addr%> at %L must not have the VALUE attribute"
 msgstr "引數『%s』的 elemental 程序於 %L 無法有 ALLOCATABLE 屬性"
 
-#: fortran/trans-openmp.cc:10253
+#: fortran/trans-openmp.cc:10283
 #, fuzzy, gcc-internal-format
 #| msgid "Array specification at %C has more than %d dimensions"
 msgid "%qs at %L is specified more than once"
 msgstr "%C 處陣列指定了多於 %d 的維數"
 
-#: fortran/trans-openmp.cc:10270
+#: fortran/trans-openmp.cc:10300
 #, fuzzy, gcc-internal-format
 #| msgid "-pipe not supported"
 msgid "%<need_device_addr%> not yet supported"
@@ -92906,7 +93091,7 @@ msgstr "關閉：%s"
 msgid "two or more sections for %s"
 msgstr "兩個以上區段用於 %s"
 
-#: lto/lto-partition.cc:1233
+#: lto/lto-partition.cc:1264
 #, gcc-internal-format
 msgid "min partition size cannot be greater than max partition size"
 msgstr ""
@@ -93245,33 +93430,33 @@ msgstr "陣列使用的做為初始設定式"
 msgid "array element value must be the same type as its declaration"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2534
+#: m2/gm2-gcc/m2type.cc:2547
 #, gcc-internal-format
 msgid "low bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2536
+#: m2/gm2-gcc/m2type.cc:2549
 #, gcc-internal-format
 msgid "high bound for the subrange has overflowed"
 msgstr ""
 
-#: m2/gm2-gcc/m2type.cc:2833
+#: m2/gm2-gcc/m2type.cc:2846
 #, fuzzy, gcc-internal-format
 msgid "requested alignment is not a constant"
 msgstr "要求的對齊不是整數常數"
 
-#: m2/gm2-gcc/m2type.cc:2835
+#: m2/gm2-gcc/m2type.cc:2848
 #, fuzzy, gcc-internal-format
 #| msgid "requested alignment is not a power of 2"
 msgid "requested alignment is not a power of 2"
 msgstr "要求的對齊邊界不是 2 的某次方"
 
-#: m2/gm2-gcc/m2type.cc:2837
+#: m2/gm2-gcc/m2type.cc:2850
 #, gcc-internal-format
 msgid "requested alignment is too large"
 msgstr "要求的對齊邊界太大"
 
-#: m2/gm2-gcc/m2type.cc:2863
+#: m2/gm2-gcc/m2type.cc:2876
 #, fuzzy, gcc-internal-format
 #| msgid "alignment may not be specified for %q+D"
 msgid "alignment may not be specified for %qD"
@@ -96911,11 +97096,6 @@ msgstr ""
 #~ msgid "looser throw specifier for %q+#F"
 #~ msgstr "放鬆 %q+#F 的 throw 限定"
 
-#, fuzzy
-#~| msgid "cannot disable built-in function %qs"
-#~ msgid "cannot call function %qD"
-#~ msgstr "無法停用內建函式 %qs"
-
 #, fuzzy
 #~ msgid "left rotate count >= width of type"
 #~ msgstr "左旋轉計數>=寬度的型態"
@@ -98088,10 +98268,6 @@ msgstr ""
 #~ msgid "junk at end of '#pragma options'"
 #~ msgstr "「#pragma options」末尾有無用字元"
 
-#, fuzzy
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "引數 %d(屬於 %qE)類型不相容"
-
 #, fuzzy
 #~ msgid "function profiling"
 #~ msgstr "啟用函式取樣"
@@ -99399,9 +99575,6 @@ msgstr ""
 #~ msgid "non-static method %q+D overrides static method"
 #~ msgstr "非靜態方法 %q+D 覆寫了靜態方法"
 
-#~ msgid "%q+D used prior to declaration"
-#~ msgstr "%q+D 在宣告前使用"
-
 #~ msgid "In %+D: overlapped variable and exception ranges at %d"
 #~ msgstr "在 %+D 中：重疊的變數和異常範圍，在 %d"
 
--- a/src/gcc/range-op-float.cc
+++ b/src/gcc/range-op-float.cc
@@ -759,6 +759,9 @@ operator_not_equal::fold_range (irange &r, tree type,
       // Avoid frelop_early_resolve() below as it could fold to FALSE
       // without regards to NANs.  This would be incorrect if trying
       // to fold x_5 != x_5 without prior knowledge of NANs.
+      // Still, if either operand is undefined, return VARYING.
+      if (empty_range_varying (r, type, op1, op2))
+	return true;
     }
   else if (frelop_early_resolve (r, type, op1, op2, trio, VREL_NE))
     return true;
--- a/src/gcc/testsuite/ChangeLog
+++ b/src/gcc/testsuite/ChangeLog
@@ -1,3 +1,884 @@
+2026-06-11  Georg-Johann Lay  <avr@gjlay.de>
+
+	Backported from master:
+	2026-06-11  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/125752
+	* gcc.target/avr/torture/fx-to-double.c: New test.
+
+2026-06-11  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	* lib/target-supports.exp (arm_mixed_fp): Simplify
+	implementation.
+
+2026-06-10  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-21  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125284
+	PR c++/125333
+	* g++.dg/cpp1z/using-variadic4.C: New test.
+	* g++.dg/cpp1z/using-variadic5.C: New test.
+
+2026-06-10  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-06-10  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125498
+	* g++.dg/reflect/mangle7.C: New test.
+	* g++.dg/reflect/parameters_of9.C: New test.
+
+2026-06-09  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/bigint1.adb: New  test.
+
+2026-06-09  Paul Thomas  <pault@gcc.gnu.org>
+
+	Backported from master:
+	2026-06-09  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/125669
+	* gfortran.dg/pdt_92.f03: New test.
+
+2026-06-09  Xin Liu  <liulxx@hygon.cn>
+
+	Backported from master:
+	2026-04-29  Xin Liu  <liulxx@hygon.cn>
+		    Zhaoling Bao  <baozhaoling@hygon.cn>
+
+	* gcc.target/i386/builtin_target.c: Add handling for HYGON CPUs by
+	validating the vendor and invoking HYGON-specific CPU detection.
+	* gcc.target/i386/funcspec-56.inc: Test function target attribute on
+	{arch,tune}=c86-4g-m{4,6,7}.
+	* g++.target/i386/mv33.C: New test.
+
+2026-06-08  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-06-06  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/125606
+	* gfortran.dg/loc_3.f90: New test.
+
+2026-06-08  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	Backported from master:
+	2026-06-08  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	* g++.dg/modules/test-p1689.py: Make arrays have predictable
+	order.
+
+2026-06-06  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-06-06  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125611
+	* gcc.target/i386/ssse3-pr125611.c: New test.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-06-03  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125378
+	* g++.dg/lookup/operator-8b.C: New test.
+	* g++.dg/lookup/operator-8c.C: New test.
+	* g++.dg/lookup/operator-9a.C: New test.
+	* g++.dg/lookup/operator-9b.C: New test.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-06-03  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125490
+	* g++.dg/cpp2a/concepts-pr125490.C: New test.
+	* g++.dg/cpp2a/concepts-pr125490a.C: New test.
+
+2026-06-03  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* gcc.dg/pr125375.c: New test.
+
+2026-06-03  Kyrylo Tkachov  <ktkachov@nvidia.com>
+
+	Backported from master:
+	2026-06-01  Kyrylo Tkachov  <ktkachov@nvidia.com>
+
+	PR target/122827
+	* gcc.target/aarch64/sve/pr122827.c: New test.
+
+2026-06-03  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/atomic9.adb (NVIC_STIR): Add alignment clause.
+
+2026-06-02  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-06-02  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125250
+	* gcc.dg/torture/pr125250.c: Declare g0 as _Bool.
+
+2026-06-02  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-11  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125250
+	* gcc.dg/torture/pr125250.c: New testcase.
+
+2026-06-02  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-04  Richard Biener  <rguenther@suse.de>
+
+	PR middle-end/125156
+	* gcc.dg/torture/pr125156.c: New testcase.
+
+2026-06-01  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-05-29  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/125393
+	* gfortran.dg/argument_checking_28.f90: New test.
+
+2026-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125123
+	* g++.dg/cpp26/expansion-stmt42.C: New test.
+
+2026-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125412
+	* g++.dg/reflect/pr125412.C: New test.
+
+2026-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-21  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125376
+	* g++.dg/coroutines/pr125376.C: New test.
+
+2026-06-01  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	Backported from master:
+	2026-06-01  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	* gcc.dg/lto/toplevel-simple-asm-1_0.c: Adjust inline assembler
+	for arm-none-eabi.
+
+2026-06-01  Christophe Lyon  <christophe.lyon@arm.com>
+
+	Backported from master:
+	2026-05-19  Christophe Lyon  <christophe.lyon@arm.com>
+
+	PR target/124870
+	* gcc.target/arm/mve/intrinsics/pr124870.c: New test.
+
+2026-06-01  Hongyu Wang  <hongyu.wang@intel.com>
+
+	Backported from master:
+	2026-06-01  Hongyu Wang  <hongyu.wang@intel.com>
+
+	* gcc.target/i386/apx-zu-4.c: New test.
+
+2026-05-31  Zhongyao Chen  <chen.zhongyao@zte.com.cn>
+
+	Backported from master:
+	2026-05-13  Zhongyao Chen  <chen.zhongyao@zte.com.cn>
+
+	PR target/125215
+	* gcc.target/riscv/rvv/autovec/pr125215.c: New test.
+	* gcc.target/riscv/rvv/autovec/slp-interleave-1.c: Remove.
+	* gcc.target/riscv/rvv/autovec/slp-interleave-2.c: Remove.
+	* gcc.target/riscv/rvv/autovec/slp-interleave-3.c: Remove.
+	* gcc.target/riscv/rvv/autovec/slp-interleave-4.c: Remove.
+	* gcc.target/riscv/rvv/autovec/slp-interleave-5.c: Remove.
+
+2026-05-30  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-30  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+	PR fortran/105582
+	* gfortran.dg/block_proc_ptr_1.f90: New test.
+
+2026-05-28  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-28  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125454
+	* g++.dg/other/array8.C: New test.
+
+2026-05-28  Martin Jambor  <mjambor@suse.cz>
+
+	Backported from master:
+	2026-05-12  Martin Jambor  <mjambor@suse.cz>
+
+	PR tree-optimization/124151
+	* gcc.dg/tree-ssa/pr124151.c: New test.
+
+2026-05-26  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-26  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125423
+	* g++.dg/reflect/bases_of6.C: New test.
+
+2026-05-26  Soumya AR  <soumyaa@nvidia.com>
+
+	Backported from master:
+	2026-05-08  Soumya AR  <soumyaa@nvidia.com>
+
+	PR target/124895
+	* gcc.target/aarch64/narrow-gp-writes-8.c: New test.
+
+2026-05-25  Georg-Johann Lay  <avr@gjlay.de>
+
+	Backported from master:
+	2026-05-25  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/125409
+	* gcc.target/avr/torture/pr125409.h: New file.
+	* gcc.target/avr/torture/pr125409-fx24-ssk.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-ssr.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-suk.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-sur.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-usk.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-usr.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-uuk.c: New test.
+	* gcc.target/avr/torture/pr125409-fx24-uur.c: New test.
+
+2026-05-23  Paul Thomas  <pault@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-23  Paul Thomas  <pault@gcc.gnu.org>
+
+	PR fortran/125391
+	* gfortran.dg/pr125391.f90: New test.
+
+2026-05-23  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-23  Jason Merrill  <jason@redhat.com>
+
+	PR c++/125135
+	* g++.dg/cpp0x/implicit18.C: New test.
+
+2026-05-23  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-21  Jason Merrill  <jason@redhat.com>
+
+	PR c++/125384
+	PR c++/113563
+	* g++.dg/cpp0x/lambda/lambda-this23.C: New test.
+
+2026-05-21  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-20  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/106546
+	* gfortran.dg/inline_matmul_27.f90: New test.
+
+2026-05-21  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-21  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/125320
+	* gcc.target/riscv/pr125320.c: New test.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125373
+	* gcc.c-torture/compile/pr125373.c: New test.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-19  Jakub Jelinek  <jakub@redhat.com>
+
+	PR other/125348
+	* gcc.target/i386/pr117416-2.c (prefetch_test): Adjust expected
+	diagnostic spelling.
+	* gdc.test/compilable/dtoh_TemplateDeclaration.d: Fix comment
+	spelling, paramter -> parameter.
+
+2026-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125007
+	* g++.dg/reflect/pr125007.C: New test.
+
+2026-05-20  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-19  Thomas Koenig  <tkoenig@gcc.gnu.org>
+
+	PR fortran/115260
+	* gfortran.dg/pr115260.f90: New test.
+
+2026-05-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/125355
+	* gcc.target/i386/pr125355-2.c: New test.
+
+2026-05-19  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-18  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/125355
+	* gcc.target/i386/pr125355.c: New test.
+
+2026-05-19  Andre Vehreschild  <vehre@gcc.gnu.org>
+
+	Backported from master:
+	2026-04-29  Andre Vehreschild  <vehre@gcc.gnu.org>
+
+	PR fortran/125021
+	* gfortran.dg/coarray/pr125021.f90: New test.
+
+2026-05-19  Andi Kleen  <ak@gcc.gnu.org>
+
+	PR target/125351
+	* gcc.target/i386/pr125351.c: New test.
+
+2026-05-15  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-13  H.J. Lu  <hjl.tools@gmail.com>
+		    Uros Bizjak  <ubizjak@gmail.com>
+
+	PR target/120870
+	* gcc.target/i386/pr120870-1.c: New test.
+	* gcc.target/i386/pr120870-2.c: Likewise.
+
+2026-05-15  Andi Kleen  <ak@gcc.gnu.org>
+
+	PR c/124532
+	* c-c++-common/pr124532.c: New test.
+
+2026-05-15  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-15  Xi Ruoyao  <xry111@xry111.site>
+
+	PR tree-optimization/125291
+	* gcc.c-torture/execute/pr125291.c: New test.
+
+2026-05-15  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	* lib/lto.exp: Make file listing case sensitive by doing case
+	sensitive filter after directory listing.
+
+2026-05-15  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-15  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125308
+	* gcc.target/i386/pr125308.c: New test.
+
+2026-05-15  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-15  Jason Merrill  <jason@redhat.com>
+
+	PR c++/125315
+	* g++.dg/cpp2a/no_unique_address16.C: New test.
+
+2026-05-15  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-14  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124628
+	* g++.dg/reflect/can_substitute2.C: New test.
+	* g++.dg/reflect/members_of14.C: New test.
+	* g++.dg/reflect/substitute3.C: Adjust test so that f<int>'s
+	return type fails to get deduced.
+	* g++.dg/reflect/type_of3.C: Also test type_of of a templated
+	member function with deduced return type.
+
+2026-05-14  Andi Kleen  <ak@gcc.gnu.org>
+
+	PR target/124316
+	* gcc.target/i386/pr124316.c: New test.
+
+2026-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125184
+	* g++.dg/reflect/using3.C: New test.
+
+2026-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/125111
+	* g++.dg/reflect/extract12.C: New test.
+
+2026-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jakub Jelinek  <jakub@redhat.com>
+
+	PR c++/124991
+	* g++.dg/reflect/anon5.C: New test.
+
+2026-05-13  Mikael Morin  <mikael@gcc.gnu.org>
+
+	Backported from master:
+	2026-05-07  Mikael Morin  <mikael@gcc.gnu.org>
+
+	PR fortran/125192
+	PR fortran/125198
+	* gfortran.dg/bounds_check_29.f90: New test.
+
+2026-05-13  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-05-08  Harald Anlauf  <anlauf@gmx.de>
+
+	PR fortran/111952
+	PR fortran/125059
+	* gfortran.dg/dtio_37.f90: New test.
+
+2026-05-13  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-05-06  Harald Anlauf  <anlauf@gmx.de>
+
+	PR libfortran/125095
+	* gfortran.dg/namelist_102.f90: New test.
+
+2026-05-13  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-13  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125280
+	* g++.dg/reflect/init19.C: New test.
+	* g++.dg/reflect/type12.C: New test.
+	* g++.dg/reflect/type13.C: New test.
+
+2026-05-13  Xi Ruoyao  <xry111@xry111.site>
+
+	Backported from master:
+	2026-05-08  Xi Ruoyao  <xry111@xry111.site>
+
+	PR target/125049
+	* gcc.target/loongarch/pr125049.c: New test.
+
+2026-05-12  Jason Merrill  <jason@redhat.com>
+
+	Backported from master:
+	2026-05-12  Jason Merrill  <jason@redhat.com>
+
+	PR c++/100903
+	* g++.dg/cpp2a/spaceship-warn1.C: New test.
+
+2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-08  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/115181
+	PR c++/125043
+	PR c++/124979
+	* g++.dg/cpp1z/nontype-auto27.C: New test.
+	* g++.dg/cpp1z/nontype-auto28.C: New test.
+	* g++.dg/cpp2a/nontype-class75.C: New test.
+
+2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	* g++.dg/reflect/bases_of5.C: Use decltype (sizeof 0) instead of
+	unsigned long.
+
+2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-12  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125208
+	* g++.dg/reflect/alias3.C: New test.
+	* g++.dg/reflect/bases_of5.C: New test.
+
+2026-05-12  Artemiy Volkov  <artemiy.volkov@arm.com>
+
+	Backported from master:
+	2026-05-12  Artemiy Volkov  <artemiy.volkov@arm.com>
+
+	PR middle-end/125259
+	* gcc.dg/tree-ssa/pr125259.c: New test.
+
+2026-05-10  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/enum6.adb: New test.
+
+2026-05-08  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	Backported from master:
+	2026-05-08  Torbjörn SVENSSON  <torbjorn.svensson@foss.st.com>
+
+	* g++.dg/modules/modules.exp: Replace colon with dash on
+	Windows.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-05  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125185
+	* gcc.dg/torture/pr125185.c: New testcase.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-05-04  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125153
+	* gcc.dg/torture/pr125153.c: New testcase.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Revert:
+	2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/120003
+	* gcc.dg/tree-ssa/ssa-thread-23.c: New testcase.
+	* gcc.dg/tree-ssa/ssa-dom-thread-7.c: Adjust.
+
+2026-05-08  Richard Biener  <rguenther@suse.de>
+
+	Backported from master:
+	2026-04-27  Richard Biener  <rguenther@suse.de>
+
+	PR tree-optimization/125025
+	* gcc.dg/torture/pr125025.c: New testcase.
+
+2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124770
+	* g++.dg/reflect/init18.C: New test.
+
+2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-07  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125206
+	* g++.dg/reflect/bases_of4.C: New test.
+
+2026-05-06  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-05  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124957
+	* g++.dg/modules/attrib-6_a.C: New test.
+	* g++.dg/modules/attrib-6_b.C: New test.
+	* g++.dg/modules/attrib-6_c.C: New test.
+
+2026-05-06  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-05  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/120587
+	PR target/125155
+	* gcc.target/or1k/pr125155.c: New test.
+
+2026-05-06  Lulu Cheng  <chenglulu@loongson.cn>
+
+	Backported from master:
+	2026-05-06  Lulu Cheng  <chenglulu@loongson.cn>
+
+	PR target/125057
+	* gcc.target/loongarch/vector/lasx/pr125057.c: New test.
+	* gcc.target/loongarch/vector/lsx/lsx-mov-2.c: New test.
+
+2026-05-05  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	Backported from master:
+	2026-05-05  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	PR d/125089
+	* gdc.dg/pr125089.d: New test.
+
+2026-05-05  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-05  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/125180
+	* gcc.target/i386/pr125180.c: New test.
+
+2026-05-01  Jeff Law  <jeffrey.law@oss.qualcomm.com>
+
+	Revert:
+	2026-05-01  Daniel Barboza  <daniel.barboza@oss.qualcomm.com>
+
+	PR rtl-optimization/123967
+	* gcc.dg/tree-ssa/pr123967-2.c: New test.
+	* gcc.dg/tree-ssa/pr123967-3.c: New test.
+	* gcc.dg/tree-ssa/pr123967.c: New test.
+
+2026-05-01  Daniel Barboza  <daniel.barboza@oss.qualcomm.com>
+
+	PR rtl-optimization/123967
+	* gcc.dg/tree-ssa/pr123967-2.c: New test.
+	* gcc.dg/tree-ssa/pr123967-3.c: New test.
+	* gcc.dg/tree-ssa/pr123967.c: New test.
+
+2026-05-01  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-01  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125115
+	* g++.dg/modules/auto-9.h: New test.
+	* g++.dg/modules/auto-9_a.H: New test.
+	* g++.dg/modules/auto-9_b.C: New test.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-04-23  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124926
+	* g++.dg/reflect/dep15.C: New test.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-04-23  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124989
+	* g++.dg/reflect/member24.C: New test.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-04-28  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/124756
+	* g++.dg/reflect/identifier_of3.C: Add dg-error.
+	* g++.dg/reflect/pr123612.C: Likewise.
+	* g++.dg/reflect/error13.C: New test.
+
+2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	Backported from master:
+	2026-05-01  Marek Polacek  <polacek@redhat.com>
+
+	PR c++/125096
+	* g++.dg/reflect/mangle4.C: Move dg-error.
+	* g++.dg/reflect/dep16.C: New test.
+
+2026-05-01  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-05-01  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/125079
+	* gcc.dg/strlenopt-97.c: New test.
+
+2026-05-01  H.J. Lu  <hjl.tools@gmail.com>
+
+	Backported from master:
+	2026-05-01  H.J. Lu  <hjl.tools@gmail.com>
+
+	PR target/125117
+	* gcc.dg/pr125117.c: New test.
+	* gfortran.dg/pr125117.f90: Likewise.
+	* gcc.target/i386/builtin-memmove-10.c: Updated.
+	* gcc.target/i386/builtin-memmove-15.c: Likewise.
+	* gcc.target/i386/builtin-memmove-2a.c: Likewise.
+	* gcc.target/i386/builtin-memmove-2b.c: Likewise.
+	* gcc.target/i386/builtin-memmove-2c.c: Likewise.
+	* gcc.target/i386/builtin-memmove-2d.c: Likewise.
+	* gcc.target/i386/builtin-memmove-3a.c: Likewise.
+	* gcc.target/i386/builtin-memmove-3b.c: Likewise.
+	* gcc.target/i386/builtin-memmove-3c.c: Likewise.
+	* gcc.target/i386/builtin-memmove-4a.c: Likewise.
+	* gcc.target/i386/builtin-memmove-4b.c: Likewise.
+	* gcc.target/i386/builtin-memmove-4c.c: Likewise.
+	* gcc.target/i386/builtin-memmove-5b.c: Likewise.
+	* gcc.target/i386/builtin-memmove-5c.c: Likewise.
+
+2026-05-01  Jeff Law  <jeffrey.law@oss.qualcomm.com>
+
+	Backported from master:
+	2026-04-25  Jeff Law  <jeffrey.law@oss.qualcomm.com>
+
+	PR target/124984
+	* gcc.target/riscv/pr124984.c: New test.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-29  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/125035
+	* g++.dg/modules/merge-22.h: New test.
+	* g++.dg/modules/merge-22_a.H: New test.
+	* g++.dg/modules/merge-22_b.C: New test.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-29  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124582
+	PR c++/123810
+	* g++.dg/modules/anon-4.h: New test.
+	* g++.dg/modules/anon-4_a.H: New test.
+	* g++.dg/modules/anon-4_b.C: New test.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-27  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124953
+	* g++.dg/modules/tpl-nttp-3_a.H: New test.
+	* g++.dg/modules/tpl-nttp-3_b.C: New test.
+
+2026-04-30  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-04-23  Patrick Palka  <ppalka@redhat.com>
+
+	PR c++/124981
+	* g++.dg/modules/ptrmem-1_a.C: New test.
+	* g++.dg/modules/ptrmem-1_b.C: New test.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-29  Jakub Jelinek  <jakub@redhat.com>
+
+	* g++.dg/reflect/compare12.C: New test.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-29  Jakub Jelinek  <jakub@redhat.com>
+
+	* g++.dg/plugin/uglification_plugin.cc (plugin_check_tree): Walk
+	REQUIRES_EXPR_PARMS of REQUIRES_EXPR.
+	(plugin_walk_decl): Walk TEMPLATE_PARMS_CONSTRAINTS using
+	plugin_check_tree.  Walk DECL_INITIAL of CONCEPT_DECL as well.
+	* g++.dg/plugin/uglification.C: Add tests for non-uglified names
+	in lambda parameters, lambda captures and requires expressions.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-29  Jakub Jelinek  <jakub@redhat.com>
+
+	* g++.dg/plugin/plugin.exp: Set PLUGIN_DEFAULT_REPO.  Add
+	set*module*exports* to plugin_test_list.  Remove *.gcm files
+	at the start and end.
+	* g++.dg/plugin/std_module_exports_plugin.cc: New file.
+	* g++.dg/plugin/std-module-exports-c++20.C: New test.
+	* g++.dg/plugin/std-module-exports-c++23.C: New test.
+	* g++.dg/plugin/std-module-exports-c++26.C: New test.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-29  Jakub Jelinek  <jakub@redhat.com>
+
+	* g++.dg/plugin/plugin.exp (plugin_test_list): Add uglification tests.
+	* g++.dg/plugin/uglification_plugin.cc: New file.
+	* g++.dg/plugin/uglification.C: New test.
+	* g++.dg/plugin/uglification-c++98.C: New test.
+	* g++.dg/plugin/uglification-c++11.C: New test.
+	* g++.dg/plugin/uglification-c++14.C: New test.
+	* g++.dg/plugin/uglification-c++17.C: New test.
+	* g++.dg/plugin/uglification-c++20.C: New test.
+	* g++.dg/plugin/uglification-c++23.C: New test.
+	* g++.dg/plugin/uglification-c++26.C: New test.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-28  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/125039
+	* gcc.c-torture/compile/pr125039.c: New test.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR tree-optimization/124988
+	* gcc.dg/torture/bitint-95.c: Add bitint effective targets and
+	guard parts of test which need _BitInt(192) support with
+	__BITINT_MAXWIDTH__ >= 192.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR target/124133
+	* g++.target/powerpc/pr124133-1.C: New test.
+	* g++.target/powerpc/pr124133-2.C: New test.
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-24  Jakub Jelinek  <jakub@redhat.com>
+
+	PR middle-end/123635
+	PR tree-optimization/124988
+	* gcc.dg/torture/bitint-91.c: New test.
+	* gcc.dg/torture/bitint-92.c: New test.
+	* gcc.dg/torture/bitint-93.c: New test.
+	* gcc.dg/torture/bitint-94.c: New test.
+	* gcc.dg/torture/bitint-95.c: New test.
+
+2026-04-30  Eric Botcazou  <ebotcazou@adacore.com>
+
+	* gnat.dg/task6.ads, gnat.dg/task6.adb: New test.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/c-c++-common/pr124532.c
@@ -0,0 +1,13 @@
+/* { dg-do compile { target { musttail && { c || c++11 } } } } */
+
+extern int f(void);
+
+static int g(void) {
+  [[gnu::musttail]] return f();
+  return 42;
+}
+
+static int g2(void) {
+  if (1) [[gnu::musttail]] return f();
+  return 42;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/coroutines/pr125376.C
@@ -0,0 +1,40 @@
+// PR c++/125376
+// { dg-do run { target c++26 } }
+
+#include <coroutine>
+
+struct task {
+  struct promise_type {
+    task get_return_object () noexcept { return {}; }
+    std::suspend_never initial_suspend () noexcept { return {}; }
+    std::suspend_never final_suspend ()   noexcept { return {}; }
+    void return_void () noexcept {}
+    void unhandled_exception () {}
+  };
+};
+
+struct A {
+  unsigned value = 42;
+  A () {}
+  ~A () { if (value != 42) __builtin_abort (); }
+};
+
+struct B {
+  unsigned value = 43;
+  B () {}
+  ~B () { if (value != 43) __builtin_abort (); }
+};
+
+task
+foo ()
+{
+  auto _ = A {};
+  auto _ = B {};
+  co_return;
+}
+
+int
+main ()
+{
+  foo ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp0x/implicit18.C
@@ -0,0 +1,20 @@
+// PR c++/125135
+// { dg-do compile { target c++11 } }
+
+template <typename T>
+struct A
+{
+  template <typename... Ts> // variadic causea ICE.
+  A(T&, const Ts&...){} // T& arg causes ICE.
+
+  A(const A&) = delete; // causes ICE.
+};
+
+struct RE
+{
+  RE(): a(*this) {}
+
+  A<RE> a;
+};
+
+RE re;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-this23.C
@@ -0,0 +1,19 @@
+// PR c++/125384
+// { dg-do compile { target c++11 } }
+
+template <class,class> struct assert_same;
+template <class T> struct assert_same<T,T> {};
+
+template<typename C>
+struct At {
+  void b() {
+    [this](){
+      assert_same <decltype (this), At*> as2;
+    }();
+  }
+};
+
+int main()
+{
+  At<int>{}.b();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp1z/nontype-auto27.C
@@ -0,0 +1,5 @@
+// PR c++/115181
+// { dg-do compile { target c++17 } }
+
+template <auto> struct S {};
+__extension__ S<(int[]){1}> x;  // { dg-error "not a valid template argument" }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp1z/nontype-auto28.C
@@ -0,0 +1,14 @@
+// PR c++/125043
+// { dg-do compile { target c++17 } }
+
+template <auto V>
+struct wrapper {
+    static constexpr const auto& value = V;
+};
+
+template <int const& I>
+auto f() -> void;
+
+auto main() -> int {
+    f<wrapper<42>::value>();  // { dg-error "no matching function|not a valid template argument" }
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp1z/using-variadic4.C
@@ -0,0 +1,16 @@
+// PR c++/125284
+// { dg-do compile { target c++17 } }
+
+template<typename T>
+struct foo {
+    operator T();
+    operator T*();
+};
+
+template<typename... T>
+struct bar : foo<T>... {
+    using foo<T>::operator T...;
+    using foo<T>::operator T*...;
+};
+
+bar<int> z;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp1z/using-variadic5.C
@@ -0,0 +1,19 @@
+// PR c++/125333
+// { dg-do compile { target c++17 } }
+
+template<typename... T>
+struct X {};
+
+template <typename U>
+struct Y {
+    operator U();
+};
+
+template <typename... V>
+struct Z : Y<V>... {
+    using Y<V>::operator V...;
+
+    X<V...> x;
+};
+
+Z<int, double> z;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp26/expansion-stmt42.C
@@ -0,0 +1,22 @@
+// PR c++/125123
+// { dg-do compile { target c++20 } }
+// { dg-options "-g" }
+
+struct A
+{
+  int a[2];
+  constexpr int const *begin () const { return a; }
+  constexpr int const *end () const { return a + 2; }
+};
+
+template <typename T>
+requires true
+void
+foo ()
+{
+  template for (constexpr int i : A { 0, 1 })	// { dg-warning "'template for' only available with" "" { target c++23_down } }
+    ;
+  template for (constexpr int i : A { 0, 1 })	// { dg-warning "'template for' only available with" "" { target c++23_down } }
+    ;
+}
+template void foo <void> ();
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp2a/concepts-pr125490.C
@@ -0,0 +1,10 @@
+// PR c++/125490
+// { dg-do compile { target c++20 } }
+
+void f();
+
+template<class T>
+concept C = f() == 42; // { dg-error "invalid operands" }
+
+template<class T>
+concept D = requires { requires f() == 42; }; // { dg-error "invalid operands" }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp2a/concepts-pr125490a.C
@@ -0,0 +1,15 @@
+// PR c++/125490
+// { dg-do compile { target c++20 } }
+
+namespace N {
+  struct A { };
+}
+
+constexpr bool operator==(N::A, auto) { return true; } // #1
+
+template<class T>
+concept C = T{} == T{};
+
+constexpr bool operator==(N::A, N::A) { return false; } // #2
+
+static_assert(C<N::A>); // must only consider #1
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp2a/no_unique_address16.C
@@ -0,0 +1,10 @@
+// PR c++/125315
+// { dg-do compile { target c++20 } }
+// { dg-prune-output "used but never defined" }
+
+struct S{~S(){}};
+constexpr S& f(S& t);
+struct W{[[no_unique_address]]S v;};
+struct R:W{};
+S s;
+auto x=R{{f(s)}};
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp2a/nontype-class75.C
@@ -0,0 +1,34 @@
+// PR c++/124979
+// { dg-do compile { target c++20 } }
+
+template<auto X, class = decltype(X)>
+struct cw;
+
+struct base {
+
+    template <class L>
+    friend constexpr auto operator &(L) noexcept
+        -> cw<(&L::value)> {
+        return {};
+    }
+};
+
+template<auto X, class>
+struct cw : base {
+    static constexpr const auto& value = X;
+};
+    template <auto L, auto R>
+    constexpr auto operator ->*(cw<L>, cw<R>) noexcept
+        -> cw<L ->* R> {
+        return {};
+    }
+
+struct Divide { int value; };
+auto cvalue = cw<&Divide::value>{};
+constexpr const Divide &t = {42};
+auto co = cw<Divide{42}>{};
+auto co1 = cw<&t>{};  // { dg-error "not a valid template argument|is invalid" }
+
+template<class> class TD;
+template<int t> class TD<cw<t>>{};
+TD<decltype((co1)->*cvalue)> _;	  // { dg-error "is invalid" }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/cpp2a/spaceship-warn1.C
@@ -0,0 +1,10 @@
+// PR c++/100903
+// { dg-additional-options -Wzero-as-null-pointer-constant }
+// { dg-do compile { target c++20 } }
+
+#include <compare>
+
+int main()
+{
+  return (1.0 <=> 2.0) < 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/lookup/operator-8b.C
@@ -0,0 +1,40 @@
+// PR c++/125378
+// A version of operator-8a.C where the operator<=> returns char instead of int.
+
+// { dg-do compile { target c++20 } }
+
+struct A {
+  bool operator==(int);
+  char operator<=>(int);
+};
+
+template<class T>
+void f() {
+  A a;
+  (void)(a != 0);
+  (void)(0 != a);
+  (void)(a < 0);
+  (void)(0 < a);
+  (void)(a <= 0);
+  (void)(0 <= a);
+  (void)(a > 0);
+  (void)(0 > a);
+  (void)(a >= 0);
+  (void)(0 >= a);
+}
+
+// These later-declared namespace-scope overloads shouldn't be considered
+// when instantiating f<int>.
+bool operator!=(A, int) = delete;
+bool operator<(A, int) = delete;
+bool operator<=(A, int) = delete;
+bool operator>(A, int) = delete;
+bool operator>=(A, int) = delete;
+
+bool operator!=(int, A) = delete;
+bool operator<(int, A) = delete;
+bool operator<=(int, A) = delete;
+bool operator>(int, A) = delete;
+bool operator>=(int, A) = delete;
+
+template void f<int>();
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/lookup/operator-8c.C
@@ -0,0 +1,40 @@
+// PR c++/125378
+// A version of operator-8a.C where the operator<=> returns long instead of int.
+
+// { dg-do compile { target c++20 } }
+
+struct A {
+  bool operator==(int);
+  long operator<=>(int);
+};
+
+template<class T>
+void f() {
+  A a;
+  (void)(a != 0);
+  (void)(0 != a);
+  (void)(a < 0);
+  (void)(0 < a);
+  (void)(a <= 0);
+  (void)(0 <= a);
+  (void)(a > 0);
+  (void)(0 > a);
+  (void)(a >= 0);
+  (void)(0 >= a);
+}
+
+// These later-declared namespace-scope overloads shouldn't be considered
+// when instantiating f<int>.
+bool operator!=(A, int) = delete;
+bool operator<(A, int) = delete;
+bool operator<=(A, int) = delete;
+bool operator>(A, int) = delete;
+bool operator>=(A, int) = delete;
+
+bool operator!=(int, A) = delete;
+bool operator<(int, A) = delete;
+bool operator<=(int, A) = delete;
+bool operator>(int, A) = delete;
+bool operator>=(int, A) = delete;
+
+template void f<int>();
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/lookup/operator-9a.C
@@ -0,0 +1,19 @@
+// PR c++/125378
+// A version of operator-9.C where the operator<=> returns char instead of int.
+
+// { dg-do compile { target c++20 } }
+
+#include <compare>
+
+struct A {
+  bool operator==(int);
+  char operator<=>(int);
+};
+
+template<class T>
+void f() {
+  A a;
+  (void)(0 <=> a);
+}
+
+template void f<int>();
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/lookup/operator-9b.C
@@ -0,0 +1,19 @@
+// PR c++/125378
+// A version of operator-9.C where the operator<=> returns long instead of int.
+
+// { dg-do compile { target c++20 } }
+
+#include <compare>
+
+struct A {
+  bool operator==(int);
+  long operator<=>(int);
+};
+
+template<class T>
+void f() {
+  A a;
+  (void)(0 <=> a);
+}
+
+template void f<int>();
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/anon-4.h
@@ -0,0 +1,3 @@
+typedef struct { } A;
+struct B { typedef struct { } C; };
+template<class T> struct D { typedef struct { } E; };
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/anon-4_a.H
@@ -0,0 +1,6 @@
+// PR c++/124582
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-fmodule-header -freflection" }
+// { dg-module-cmi {} }
+
+#include "anon-4.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/anon-4_b.C
@@ -0,0 +1,6 @@
+// PR c++/124582
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-fmodules -fno-module-lazy -freflection" }
+
+#include "anon-4.h"
+import "anon-4_a.H";
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/attrib-6_a.C
@@ -0,0 +1,10 @@
+// PR c++/124957
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-fmodules" }
+
+export module mod:partition;
+
+int dummy;
+struct [[gnu::abi_tag("cxx11")]] A { int m; };
+export inline int A::*x = &A::m;
+// x does not get mangled in this TU => cxx11 abi_tag not propagated to x
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/attrib-6_b.C
@@ -0,0 +1,8 @@
+// PR c++/124957
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-fmodules" }
+
+export module mod; // { dg-module-cmi "mod" }
+export import :partition;
+
+// x gets mangled in this TU => cxx11 abi_tag propagated to x
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/attrib-6_c.C
@@ -0,0 +1,8 @@
+// PR c++/124957
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-fmodules -fno-module-lazy" }
+
+module mod;
+import :partition;
+
+// OK, no bogus abi_tag mismatch error for the imported x's
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/auto-9.h
@@ -0,0 +1,42 @@
+namespace ranges {
+struct _Begin {
+  template <typename _Tp> auto operator()(_Tp __t) { return __t.begin(); }
+};
+struct _Data {
+  template <typename _Tp> auto operator()(_Tp __t) { return __t.data(); }
+};
+inline _Begin begin;
+inline _Data data;
+struct subrange;
+template <typename _Tp> struct view_interface {
+  subrange _M_derived();
+  auto data() noexcept(noexcept(begin(_M_derived()))) { return begin(_M_derived()); }
+};
+} // namespace ranges
+struct basic_string_view {
+  basic_string_view(const char *);
+  template <typename _Range>
+  basic_string_view(_Range __r) : _M_str(ranges::data(__r)) {}
+  char *_M_str;
+} typedef string_view;
+namespace ranges {
+struct subrange : view_interface<int> {
+  char *begin();
+};
+struct split_view {
+  struct _Iterator {
+    subrange operator*();
+  };
+  template <typename _Range> split_view(_Range, _Range);
+  _Iterator begin();
+};
+namespace views {
+inline
+struct _Split {
+  template <typename _Range, typename _Pattern>
+  auto operator()(_Range, _Pattern) {
+    return split_view(0, 0);
+  }
+} split;
+} // namespace views
+} // namespace ranges
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/auto-9_a.H
@@ -0,0 +1,9 @@
+// PR c++/125115
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-fmodule-header" }
+
+#include "auto-9.h"
+
+inline void foo() {
+  auto x = string_view(*ranges::views::split(string_view("1.2"), '.').begin());
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/auto-9_b.C
@@ -0,0 +1,6 @@
+// PR c++/125115
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-fmodules -fno-module-lazy" }
+
+#include "auto-9.h"
+import "auto-9_a.H";
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/merge-22.h
@@ -0,0 +1,39 @@
+struct A {
+  void f(int) const;
+  static void f(const A*, int);
+
+#if __cpp_explicit_this_parameter
+  void g(this A*, int);
+  static void g(A*, int);
+
+  void h(int);
+  void h(this A*, int);
+#endif
+};
+
+template<class T>
+struct B {
+  void f(int) const;
+  static void f(const B*, int);
+
+#if __cpp_explicit_this_parameter
+  void g(this B*, int);
+  static void g(B*, int);
+
+  void h(int);
+  void h(this B*, int);
+#endif
+};
+
+struct C {
+  template<class T> void f(int) const;
+  template<class T> static void f(const C*, int);
+
+#if __cpp_explicit_this_parameter
+  template<class T> void g(this C*, int);
+  template<class T> static void g(C*, int);
+
+  template<class T> void h(int);
+  template<class T> void h(this C*, int);
+#endif
+};
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/merge-22_a.H
@@ -0,0 +1,4 @@
+// PR c++/125035
+// { dg-additional-options "-fmodule-header" }
+
+#include "merge-22.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/merge-22_b.C
@@ -0,0 +1,5 @@
+// PR c++/125035
+// { dg-additional-options "-fmodules -fno-module-lazy" }
+
+#include "merge-22.h"
+import "merge-22_a.H";
--- a/src/gcc/testsuite/g++.dg/modules/modules.exp
+++ b/src/gcc/testsuite/g++.dg/modules/modules.exp
@@ -83,7 +83,10 @@ proc host_header_path {hname} {
 
 # Return the pathname CMI munged like the compiler.
 proc munge_cmi {cmi} {
-    if { [string index $cmi 0] == "/" } {
+    if { [string index $cmi 1] == ":" && [info exists ::env(OS)] && [string match "Windows*" $::env(OS)] } {
+	# Windows paths like C:/some/path should be munged to C-/some/path
+	set cmi [string replace $cmi 1 1 "-"]
+    } elseif { [string index $cmi 0] == "/" } {
 	set cmi [string range $cmi 1 end]
     } else {
 	set cmi ",/$cmi"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/ptrmem-1_a.C
@@ -0,0 +1,21 @@
+// PR c++/124981
+// { dg-additional-options "-fmodules" }
+// { dg-module-cmi M }
+
+export module M;
+
+template<class T, void (T::*F)() const>
+struct A {
+  void f(const T& t) {
+    (t.*F)();
+  }
+};
+
+export
+template<class T>
+struct B {
+  void g() const { }
+  A<B, &B::g> m;
+};
+
+B<void> b;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/ptrmem-1_b.C
@@ -0,0 +1,10 @@
+// PR c++/124981
+// { dg-additional-options "-fmodules" }
+// { dg-module-do link }
+
+import M;
+
+int main() {
+  B<void> b;
+  b.m.f(b);
+}
--- a/src/gcc/testsuite/g++.dg/modules/test-p1689.py
+++ b/src/gcc/testsuite/g++.dg/modules/test-p1689.py
@@ -131,6 +131,16 @@ def _inspect_ordering(arr):
 
     return arr, req_ordering
 
+def _get_predictable_ordered_array(arr):
+    if not arr:
+        return arr
+
+    # Convert to list of string to get predictable order.
+    # Using set() here causes issue with complex arrays
+    arr = [json.dumps(x) for x in arr]
+    arr.sort()
+    return [json.loads(x) for x in arr]
+
 
 def compare_json(path, actual, expect):
     actual_type = type(actual)
@@ -146,8 +156,8 @@ def compare_json(path, actual, expect):
     elif actual_type == list:
         expect, req_ordering = _inspect_ordering(expect)
         if not req_ordering:
-            actual = set(actual)
-            expect = set(expect)
+            actual = _get_predictable_ordered_array(actual)
+            expect = _get_predictable_ordered_array(expect)
         is_ok = _compare_array(path, actual, expect)
     elif actual_type == str:
         is_ok = _compare_string(path, actual, expect)
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/tpl-nttp-3_a.H
@@ -0,0 +1,11 @@
+// PR c++/124953
+// { dg-do compile { target c++20 } }
+// { dg-additional-options "-fmodule-header" }
+
+template <class T> struct wrap { using type = T; };
+template <auto V> using unwrap = decltype(V)::type;
+
+struct Foo {
+  struct Storage {};
+  unwrap<wrap<Storage>{}> data_{};
+};
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/modules/tpl-nttp-3_b.C
@@ -0,0 +1,5 @@
+// PR c++/124953
+// { dg-do compile { target c++20 } }
+// { dg-additional-options "-fmodules -fno-module-lazy" }
+
+import "tpl-nttp-3_a.H";
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/other/array8.C
@@ -0,0 +1,15 @@
+// PR c++/125454
+// { dg-do compile { target c++11 } }
+
+template <typename T>
+void
+foo()
+{
+  T a = a[a]; // { dg-error "array subscript is not an integer" }
+}
+
+void
+bar ()
+{
+  foo<int[]>;
+}
--- a/src/gcc/testsuite/g++.dg/plugin/plugin.exp
+++ b/src/gcc/testsuite/g++.dg/plugin/plugin.exp
@@ -51,6 +51,8 @@ if ![gcc_parallel_test_run_p plugin] {
 }
 gcc_parallel_test_enable 0
 
+set PLUGIN_DEFAULT_REPO "gcm.cache"
+
 # Specify the plugin source file and the associated test files in a list.
 # plugin_test_list={ {plugin1 test1 test2 ...} {plugin2 test1 ...} ... }
 set plugin_test_list [list \
@@ -78,9 +80,26 @@ set plugin_test_list [list \
     	  show-template-tree-color-no-highlight-colors.C \
     	  show-template-tree-color-labels.C \
     	  show-template-tree-color-no-elide-type.C } \
+    { uglification_plugin.cc \
+	  uglification.C \
+    	  uglification-c++98.C \
+    	  uglification-c++11.C \
+    	  uglification-c++14.C \
+    	  uglification-c++17.C \
+    	  uglification-c++20.C \
+    	  uglification-c++23.C \
+    	  uglification-c++26.C } \
+    { std_module_exports_plugin.cc \
+	  std-module-exports-c++20.C \
+	  std-module-exports-c++23.C \
+	  std-module-exports-c++26.C } \
     { comment_plugin.cc comments-1.C } \
 ]
 
+foreach file [find $PLUGIN_DEFAULT_REPO *.gcm] {
+    file_on_host delete $file
+}
+
 foreach plugin_test $plugin_test_list {
     # Replace each source file with its full-path name
     for {set i 0} {$i < [llength $plugin_test]} {incr i} {
@@ -96,4 +115,8 @@ foreach plugin_test $plugin_test_list {
     plugin-test-execute $plugin_src $plugin_input_tests
 }
 
+foreach file [find $PLUGIN_DEFAULT_REPO *.gcm] {
+    file_on_host delete $file
+}
+
 gcc_parallel_test_enable 1
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/std-module-exports-c++20.C
@@ -0,0 +1,11 @@
+// Test bits/std.cc exports everything it should.
+// This is done using a plugin to walk std namespace and
+// its child namespaces, looking for decls with non-uglified
+// names which aren't deprecated and are not exported.
+// { dg-do link }
+// { dg-options "-O0 -std=c++20 -fmodules -x c++-system-module bits/std.cc -x none" }
+
+int
+main ()
+{
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/std-module-exports-c++23.C
@@ -0,0 +1,11 @@
+// Test bits/std.cc exports everything it should.
+// This is done using a plugin to walk std namespace and
+// its child namespaces, looking for decls with non-uglified
+// names which aren't deprecated and are not exported.
+// { dg-do link }
+// { dg-options "-O0 -std=c++23 -fmodules -x c++-system-module bits/std.cc -x none" }
+
+int
+main ()
+{
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/std-module-exports-c++26.C
@@ -0,0 +1,11 @@
+// Test bits/std.cc exports everything it should.
+// This is done using a plugin to walk std namespace and
+// its child namespaces, looking for decls with non-uglified
+// names which aren't deprecated and are not exported.
+// { dg-do link }
+// { dg-options "-O0 -std=c++26 -fmodules -freflection -fcontracts -x c++-system-module bits/std.cc -x none" }
+
+int
+main ()
+{
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/std_module_exports_plugin.cc
@@ -0,0 +1,219 @@
+#include "gcc-plugin.h"
+#include <stdlib.h>
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "intl.h"
+#include "cp/cp-tree.h"
+#include "cp/name-lookup.h"
+#include "diagnostic.h"
+#include "stringpool.h"
+#include "attribs.h"
+
+int plugin_is_GPL_compatible;
+
+void plugin_dump_ns (tree, char *, hash_set<tree> **);
+
+enum class whitelist_std {
+  cxx20 = 1 << 0,
+  cxx23 = 1 << 1,
+  cxx26 = 1 << 2,
+  all = (1 << 3) - 1
+};
+struct {
+  const char *name;
+  whitelist_std enabled_in;
+} whitelist[] = {
+  // [zombie.names] in C++20-C++26, supported as an extension.
+  { "std::result_of", whitelist_std::all },
+  { "std::result_of_t", whitelist_std::all },
+  // [zombie.names] in C++20-C++26, supported in C++20 as an extension.
+  { "std::unexpected_handler", whitelist_std::cxx20 },
+  // [zombie.names] in C++23-C++26, not exported in C++20.
+  { "std::declare_no_pointers", whitelist_std::cxx20 },
+  { "std::declare_reachable", whitelist_std::cxx20 },
+  { "std::get_pointer_safety", whitelist_std::cxx20 },
+  { "std::pointer_safety", whitelist_std::cxx20 },
+  { "std::undeclare_no_pointers", whitelist_std::cxx20 },
+  { "std::undeclare_reachable", whitelist_std::cxx20 }
+};
+
+void
+plugin_dump_decl (tree decl, char *scope, hash_set<tree> **exported_usings)
+{
+  if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
+    return;
+
+  tree name = DECL_NAME (decl);
+  if (!name)
+    return;
+
+  if (IDENTIFIER_ANON_P (name))
+    return;
+
+  if (TREE_CODE (decl) == CONST_DECL)
+    return;
+
+  if (TREE_CODE (decl) == NAMESPACE_DECL && DECL_NAMESPACE_INLINE_P (decl))
+    {
+      plugin_dump_ns (decl, scope, exported_usings);
+      return;
+    }
+
+  if (IDENTIFIER_POINTER (name)[0] == '_'
+      || strchr (IDENTIFIER_POINTER (name), ' '))
+    return;
+
+  if (TREE_CODE (decl) == NAMESPACE_DECL)
+    {
+      char *p = strchr (scope, '\0');
+      strcpy (p, IDENTIFIER_POINTER (name));
+      strcat (p, "::");
+      plugin_dump_ns (decl, scope, exported_usings);
+      *p = '\0';
+      return;
+    }
+
+  if (DECL_MODULE_EXPORT_P (decl))
+    return;
+  if (TREE_DEPRECATED (decl)
+      || lookup_attribute ("deprecated", DECL_ATTRIBUTES (decl)))
+    return;
+  if (TREE_CODE (decl) == TEMPLATE_DECL
+      && DECL_TEMPLATE_RESULT (decl)
+      && (TREE_DEPRECATED (DECL_TEMPLATE_RESULT (decl))
+	  || lookup_attribute ("deprecated",
+			       DECL_ATTRIBUTES (DECL_TEMPLATE_RESULT (decl)))))
+    return;
+  if (*exported_usings
+      && (*exported_usings)->contains (DECL_NAME (decl)))
+    return;
+
+  size_t scope_len = strlen (scope);
+  whitelist_std this_std;
+  if (cxx_dialect == cxx20)
+    this_std = whitelist_std::cxx20;
+  else if (cxx_dialect == cxx23)
+    this_std = whitelist_std::cxx23;
+  else if (cxx_dialect == cxx26)
+    this_std = whitelist_std::cxx26;
+  for (int i = 0; i < ARRAY_SIZE (whitelist); ++i)
+    if (strncmp (whitelist[i].name, scope, scope_len) == 0
+	&& strcmp (whitelist[i].name + scope_len,
+		   IDENTIFIER_POINTER (name)) == 0)
+      {
+	if (((int) whitelist[i].enabled_in & (int) this_std) != 0)
+	  {
+	    inform (DECL_SOURCE_LOCATION (decl),
+		    "missing using %s%D; whitelisted", scope, name);
+	    return;
+	  }
+	break;
+      }
+
+  error_at (DECL_SOURCE_LOCATION (decl), "missing using %s%D;", scope, name);
+}
+
+void
+plugin_dump_binding (tree binding, char *scope,
+		     hash_set<tree> **exported_usings)
+{
+  tree value = NULL_TREE;
+
+  if (TREE_CODE (binding) == OVERLOAD)
+    {
+      tree ovl = ovl_skip_hidden (binding);
+      if (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_EXPORT_P (ovl))
+	return;
+    }
+
+  if (STAT_HACK_P (binding))
+    {
+      if (!STAT_TYPE_HIDDEN_P (binding)
+          && STAT_TYPE (binding))
+        return plugin_dump_decl (STAT_TYPE (binding), scope, exported_usings);
+      else if (!STAT_DECL_HIDDEN_P (binding))
+        value = STAT_DECL (binding);
+    }
+  else
+    value = binding;
+
+  value = ovl_skip_hidden (value);
+  if (value)
+    {
+      value = OVL_FIRST (value);
+      return plugin_dump_decl (value, scope, exported_usings);
+    }
+}
+
+void
+plugin_dump_ns (tree ns, char *scope, hash_set<tree> **exported_usings)
+{
+  using itert = hash_table<named_decl_hash>::iterator;
+  itert end (DECL_NAMESPACE_BINDINGS (ns)->end ());
+  hash_set<tree> *my_exported_usings = NULL;
+  if (DECL_NAMESPACE_INLINE_P (ns))
+    {
+      if (*exported_usings == NULL)
+	{
+	  *exported_usings = new hash_set<tree>;
+	  tree parent = DECL_CONTEXT (ns);
+	  itert pend (DECL_NAMESPACE_BINDINGS (parent)->end ());
+	  for (itert iter (DECL_NAMESPACE_BINDINGS (parent)->begin ());
+	       iter != pend; ++iter)
+	    {
+	      tree b = *iter;
+	      if (TREE_CODE (b) == USING_DECL
+		  && DECL_MODULE_EXPORT_P (b)
+		  && DECL_NAME (b))
+		(*exported_usings)->add (DECL_NAME (b));
+	      else if (TREE_CODE (b) == OVERLOAD)
+		{
+		  tree ovl = ovl_skip_hidden (b);
+		  if (ovl && TREE_CODE (ovl) == OVERLOAD && OVL_EXPORT_P (ovl))
+		    {
+		      b = OVL_FIRST (ovl);
+		      if (DECL_NAME (b))
+			(*exported_usings)->add (DECL_NAME (b));
+		    }
+		}
+	    }
+	}
+    }
+  else
+    exported_usings = &my_exported_usings;
+  for (itert iter (DECL_NAMESPACE_BINDINGS (ns)->begin ());
+       iter != end; ++iter)
+    {
+      tree b = *iter;
+      gcc_assert (TREE_CODE (b) != BINDING_VECTOR);
+      plugin_dump_binding (b, scope, exported_usings);
+    }
+  delete my_exported_usings;
+}
+
+void
+plugin_finish_unit (void *, void *)
+{
+  if (!main_input_filename
+      || strstr (main_input_filename, "/std.cc") == NULL)
+    return;
+
+  char buf[4096];
+  strcpy (buf, "std::");
+  hash_set<tree> *exported_usings = NULL;
+  plugin_dump_ns (std_node, buf, &exported_usings);
+  delete exported_usings;
+}
+
+int
+plugin_init (struct plugin_name_args *plugin_info,
+             struct plugin_gcc_version *version)
+{
+  const char *plugin_name = plugin_info->base_name;
+
+  register_callback (plugin_name, PLUGIN_FINISH_UNIT,
+                     plugin_finish_unit, NULL);
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++11.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++11" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++14.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++14" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++17.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++17" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++20.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++20" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++23.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++23" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++26.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++26 -freflection -fcontracts" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification-c++98.C
@@ -0,0 +1,9 @@
+// Verify template parameter names, names of arguments and block scope decls
+// in functions and function templates are uglified and don't contain
+// badnames.
+// { dg-options "-O0 -std=c++98" }
+
+#include <bits/stdc++.h>
+
+// { dg-bogus "note: non-uglified name" "" { target *-*-* } 0 }
+// { dg-bogus "note: badname" "" { target *-*-* } 0 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification.C
@@ -0,0 +1,163 @@
+// Test that uglification_plugin.cc works properly.
+// { dg-options "-O0 -std=c++20" }
+
+// Pretend this is in a libstdc++-v3 header.
+#line 6 "gcc/libstdc++-v3/include/bits/universe.h"
+
+// Stuff outside of namespace std not reported.
+int
+foo (int a, int b)			// { dg-bogus "note: non-uglified name '\[ab]'" }
+{
+  int c = a + b;			// { dg-bogus "note: non-uglified name 'c'" }
+  return c;
+}
+
+namespace std {
+  struct foo {
+    int bar (int d, int __e) {		// { dg-message "note: non-uglified name 'd'" }
+      int f = d + __e;			// { dg-message "note: non-uglified name 'f'" }
+      int _E12 = f;			// { dg-message "note: badname '_E12'" }
+      using g = int;			// { dg-message "note: non-uglified name 'g'" }
+      return f + _E12;
+    }
+    template <typename T>		// { dg-message "note: non-uglified name 'T'" }
+    int baz (int __h, int __tg_foo) {	// { dg-message "note: badname '__tg_foo'" }
+      int i = __h;			// { dg-message "note: non-uglified name 'i'" }
+      using j = int;			// { dg-message "note: non-uglified name 'j'" }
+      return i;
+    }
+    template <double>
+    int baz (int aa) {			// { dg-message "note: non-uglified name 'aa'" }
+      int ab = aa;			// { dg-message "note: non-uglified name 'ab'" }
+      using ac = double;		// { dg-message "note: non-uglified name 'ac'" }
+      return ab;
+    }
+    int zz;				// { dg-bogus "note: non-uglified name 'zz'" }
+  };
+  template <typename _T>		// { dg-message "note: badname '_T'" }
+  struct qux {
+    int corge (int k, int __l) {	// { dg-message "note: non-uglified name 'k'" }
+      int __maskrune = k + __l;		// { dg-message "note: badname '__maskrune'" }
+      typedef std::foo __in_opt;	// { dg-message "note: badname '__in_opt'" }
+      return __maskrune;
+    }
+    template <typename _Tp>
+    int garply (int m) {		// { dg-message "note: non-uglified name 'm'" }
+      int n = m;			// { dg-message "note: non-uglified name 'n'" }
+      struct foo { int baz; } __o;	// { dg-message "note: non-uglified whitelisted name 'foo'" }
+      __o.baz = n;
+      return __o.baz;
+    }
+  };
+  template <typename _Tp, typename _Up>
+  struct S {
+    S () = delete;
+    ~S () = delete;
+  };
+  template <typename _Tp>
+  struct S <_Tp, _Tp> {
+    int grault (int ad) {		// { dg-message "note: non-uglified name 'ad'" }
+      int ae = ad;			// { dg-message "note: non-uglified name 'ae'" }
+      return ae;
+    }
+    int quux () { return 0; }
+  };
+  template <>
+  struct S <int, long> {
+    int grault (int af) {		// { dg-message "note: non-uglified name 'af'" }
+      int ag = af;			// { dg-message "note: non-uglified name 'ag'" }
+      return ag;
+    }
+  };
+
+  inline namespace __cxx11 {
+    enum freddy {
+      frog, waldo
+    };
+    struct fred {
+      int garply (int p) {		// { dg-message "note: non-uglified name 'p'" }
+	int _res_ext = p;		// { dg-message "note: non-uglified name '_res_ext'" }
+	return _res_ext;
+      }
+    };
+  }
+  namespace __gnu_cxx {
+    template <typename ...U>		// { dg-message "note: non-uglified name 'U'" }
+    int foo (U... q) {			// { dg-message "note: non-uglified name 'q'" }
+      return 0;				// { dg-message "note: non-uglified whitelisted name 'foo'" "" { target *-*-* } .-1 }
+    }
+    enum blah {				// { dg-message "note: non-uglified name 'blah'" }
+      plugh,				// { dg-message "note: non-uglified name 'plugh'" }
+      thud,				// { dg-message "note: non-uglified name 'thud'" }
+      _E5,				// { dg-message "note: badname '_E5'" }
+      garply,				// { dg-message "note: non-uglified whitelisted name 'garply'" }
+      grault,				// { dg-message "note: non-uglified whitelisted name 'grault'" }
+      quux,				// { dg-message "note: non-uglified whitelisted name 'quux'" }
+      lorem,				// { dg-message "note: non-uglified whitelisted name 'lorem'" }
+      ipsum,				// { dg-message "note: non-uglified whitelisted name 'ipsum'" }
+      dolor,				// { dg-message "note: non-uglified whitelisted name 'dolor'" }
+      sit,				// { dg-message "note: non-uglified whitelisted name 'sit'" }
+      amet,				// { dg-message "note: non-uglified whitelisted name 'amet'" }
+      consectetur,			// { dg-message "note: non-uglified whitelisted name 'consectetur'" }
+      adipiscing,			// { dg-message "note: non-uglified whitelisted name 'adipiscing'" }
+      elit				// { dg-message "note: non-uglified whitelisted name 'elit'" }
+    };
+    int waldo (int r) {			// { dg-message "note: non-uglified name 'r'" }
+      using s = std::foo;		// { dg-message "note: non-uglified name 's'" }
+      return r;				// { dg-message "note: non-uglified whitelisted name 'waldo'" "" { target *-*-* } .-2 }
+    }
+    int xyzzy () { return 0; }		// { dg-message "note: non-uglified whitelisted name 'xyzzy'" }
+    int barf () { return 0; }		// { dg-message "note: non-uglified name 'barf'" }
+    int __foobar () { return 0; }
+    struct V {				// { dg-message "note: non-uglified name 'V'" }
+      union {
+	int t;				// { dg-message "note: non-uglified name 't'" }
+      };
+      int zz () { return 0; }		// { dg-message "note: non-uglified whitelisted name 'zz'" }
+      int ww () { return 0; }		// { dg-message "note: non-uglified name 'ww'" }
+    };
+  }
+  int xyzzy (int s) {			// { dg-message "note: non-uglified name 's'" }
+    return s;
+  }
+  template <int _Idx>
+  struct lorem {
+    template <int _Idx2>
+    friend int ipsum (int ah) {		// { dg-message "note: non-uglified name 'ah'" }
+      int ai = ah;			// { dg-message "note: non-uglified name 'ai'" }
+      return ai;
+    }
+  };
+  template <int _Idx>
+  struct dolor {
+    friend int sit (int aj) {		// { dg-message "note: non-uglified name 'aj'" }
+      int ak = aj;			// { dg-message "note: non-uglified name 'ak'" }
+      return ak;
+    }
+  };
+  struct amet {
+    template <int _Idx>
+    friend int consectetur (int al) {	// { dg-message "note: non-uglified name 'al'" }
+      int am = al;			// { dg-message "note: non-uglified name 'am'" }
+      return am;
+    }
+  };
+  struct adipiscing {
+    friend int elit (int an) {		// { dg-message "note: non-uglified name 'an'" }
+      int ao = an;			// { dg-message "note: non-uglified name 'ao'" }
+      return ao;
+    }
+  };
+  void sed (int __ap) {
+    auto __aq = [] (int ar) {};		// { dg-message "note: non-uglified name 'ar'" }
+    auto __as = [at = __ap] () {};	// { dg-message "note: non-uglified name 'at'" }
+  }
+  template <typename _Tp>
+  concept eiusmod = requires (_Tp au) {	// { dg-message "note: non-uglified name 'au'" }
+    au++;
+  };
+  template <typename ..._Tp>
+  requires ((requires (const _Tp av) {	// { dg-message "note: non-uglified name 'av'" }
+    av++; }) && ...)
+  void tempor (_Tp ...aw) {}		// { dg-message "note: non-uglified name 'aw'" }
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/plugin/uglification_plugin.cc
@@ -0,0 +1,364 @@
+#include "gcc-plugin.h"
+#include <stdlib.h>
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "intl.h"
+#include "cp/cp-tree.h"
+#include "cp/name-lookup.h"
+#include "diagnostic.h"
+#include "stringpool.h"
+
+int plugin_is_GPL_compatible;
+
+void plugin_walk_ns (tree);
+
+const char *badnames[] = {
+  /* See libstdc++-v3/testsuite/17_intro/{,bad}names.cc.  */
+  "_A", "_B", "_C", "_G", "_L", "_N", "_P", "_S", "_T", "_U", "_X",
+  "__deref", "__used", "__unused", "__inline", "_Complex",
+  "__istype", "__maskrune", "__tolower", "__toupper", "__wchar_t",
+  "__wint_t", "_res", "_res_ext", "_C2", "__lockable", "__null_sentinel",
+  "__packed", "__weak", "__strong", "_In_", "_Inout_", "_Out_",
+  "_Reserved_", "__inout", "__in_opt", "__out_opt"
+};
+
+vec<tree> nonugly_names;
+hash_set<tree> whitelist;
+bool impl_ns;
+
+void
+plugin_check_decl (tree decl)
+{
+  if (decl == NULL_TREE)
+    return;
+
+  if (VAR_OR_FUNCTION_DECL_P (decl)
+      && DECL_EXTERNAL (decl)
+      && DECL_CONTEXT (decl)
+      && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
+    return;
+
+  tree name = DECL_NAME (decl);
+  if (name == NULL_TREE
+      || IDENTIFIER_ANON_P (name)
+      || name == this_identifier
+      || IDENTIFIER_ANY_OP_P (name))
+    return;
+
+  const char *cname = IDENTIFIER_POINTER (name);
+  if (memcmp (cname, "auto:", 5) == 0)
+    return;
+
+  if (cname[0] != '_'
+      || (cname[1] != '_'
+	  && !ISUPPER (cname[1])
+	  && cname[1]))
+    {
+      nonugly_names.safe_push (decl);
+      return;
+    }
+
+  bool badname = false;
+  for (int i = 0; i < ARRAY_SIZE (badnames); ++i)
+    if (strcmp (badnames[i], cname) == 0)
+      {
+	badname = true;
+	break;
+      }
+  if (!badname && cname[1] == 'E' && ISDIGIT (cname[2]))
+    {
+      if (cname[2] != '0'
+	  && (!cname[3] || ((cname[2] == '1' || cname[2] == '2')
+			    && ISDIGIT (cname[3])
+			    && !cname[4])))
+	badname = true;
+    }
+  else if (memcmp (cname + 1, "_tg_", 4) == 0)
+    badname = true;
+  if (badname)
+    inform (DECL_SOURCE_LOCATION (decl), "badname %qs", cname);
+}
+
+tree
+plugin_check_tree (tree *tp, int */*walk_subtrees*/, void */*data*/)
+{
+  if (TREE_CODE (*tp) == BIND_EXPR)
+    for (tree var = BIND_EXPR_VARS (*tp); var; var = DECL_CHAIN (var))
+      plugin_check_decl (var);
+  if (TREE_CODE (*tp) == DECL_EXPR)
+    plugin_check_decl (DECL_EXPR_DECL (*tp));
+  if (TREE_CODE (*tp) == REQUIRES_EXPR)
+    for (tree parm = REQUIRES_EXPR_PARMS (*tp); parm; parm = DECL_CHAIN (parm))
+      plugin_check_decl (parm);
+  return NULL_TREE;
+}
+
+void
+plugin_check_fn (tree decl)
+{
+  for (tree arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
+    plugin_check_decl (arg);
+
+  if (DECL_DEFAULTED_FN (decl))
+    return;
+  cp_walk_tree_without_duplicates (&DECL_SAVED_TREE (decl), plugin_check_tree,
+				   NULL);
+}
+
+bool
+plugin_header_check (tree decl)
+{
+  expanded_location eloc = expand_location (DECL_SOURCE_LOCATION (decl));
+  if (eloc.file == NULL)
+    return false;
+  if (strstr (eloc.file, "/libstdc++-v3/include/") == NULL
+      && strstr (eloc.file, "/libstdc++-v3/libsupc++/") == NULL)
+    return false;
+  return true;
+}
+
+void
+plugin_walk_decl (tree decl)
+{
+  if (TREE_CODE (decl) == NAMESPACE_DECL)
+    {
+      if (impl_ns
+	  || (DECL_NAME (decl)
+	      && IDENTIFIER_POINTER (DECL_NAME (decl))[0] != '_'
+	      && !IDENTIFIER_ANON_P (DECL_NAME (decl)))
+	  || DECL_NAMESPACE_INLINE_P (decl))
+	plugin_walk_ns (decl);
+      else
+	{
+	  impl_ns = true;
+	  plugin_walk_ns (decl);
+	  impl_ns = false;
+	}
+      return;
+    }
+
+  if (!plugin_header_check (decl))
+    return;
+
+  if (!impl_ns
+      && DECL_NAME (decl)
+      && !IDENTIFIER_ANON_P (DECL_NAME (decl))
+      && !IDENTIFIER_ANY_OP_P (DECL_NAME (decl))
+      && IDENTIFIER_POINTER (DECL_NAME (decl))[0] != '_')
+    whitelist.add (DECL_NAME (decl));
+  else if (impl_ns && DECL_NAME (decl))
+    plugin_check_decl (decl);
+
+  if (TREE_CODE (decl) == TEMPLATE_DECL)
+    {
+      tree parms = DECL_INNERMOST_TEMPLATE_PARMS (decl);
+      for (tree node : tree_vec_range (parms))
+	plugin_check_decl (TREE_VALUE (node));
+      if (tree constr
+	  = TEMPLATE_PARMS_CONSTRAINTS (DECL_TEMPLATE_PARMS (decl)))
+        cp_walk_tree_without_duplicates (&constr, plugin_check_tree,
+					 NULL);
+    }
+
+  if (DECL_FUNCTION_TEMPLATE_P (decl))
+    plugin_check_fn (DECL_TEMPLATE_RESULT (decl));
+  else if (TREE_CODE (decl) == FUNCTION_DECL
+	   && DECL_LANG_SPECIFIC (decl)
+	   && DECL_TEMPLATE_INFO (decl))
+    plugin_check_fn (decl);
+
+  if (TREE_CODE (STRIP_TEMPLATE (decl)) == CONCEPT_DECL)
+    cp_walk_tree_without_duplicates (&DECL_INITIAL (STRIP_TEMPLATE (decl)),
+				     plugin_check_tree, NULL);
+
+  if (DECL_CLASS_TEMPLATE_P (decl))
+    decl = DECL_TEMPLATE_RESULT (decl);
+  if (TREE_CODE (decl) == TYPE_DECL
+      && DECL_IMPLICIT_TYPEDEF_P (decl))
+    {
+      bool save_impl_ns = impl_ns;
+      if (impl_ns
+	  && DECL_NAME (decl)
+	  && id_equal (DECL_NAME (decl), "_Promise_erased")
+	  && DECL_CONTEXT (decl)
+	  && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
+	  && DECL_NAME (DECL_CONTEXT (decl))
+	  && id_equal (DECL_NAME (DECL_CONTEXT (decl)), "__gen"))
+	/* Workaround: std::generator<R, V, A>::promise_type in
+	   the standard is actually defined as std::__gen::_Promise_erased,
+	   but we want to whitelist its members.  Temporarily clear
+	   impl_ns in that class.  */
+	impl_ns = false;
+      if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
+	{
+	  for (tree fld = TYPE_FIELDS (TREE_TYPE (decl));
+	       fld; fld = DECL_CHAIN (fld))
+	    plugin_walk_decl (fld);
+	  for (tree f = DECL_FRIENDLIST (decl); f; f = TREE_CHAIN (f))
+	    for (tree l = FRIEND_DECLS (f); l; l = TREE_CHAIN (l))
+	      plugin_walk_decl (TREE_VALUE (l));
+	}
+      else if (TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
+	for (tree en = TYPE_VALUES (TREE_TYPE (decl));
+	     en; en = TREE_CHAIN (en))
+	  plugin_walk_decl (TREE_VALUE (en));
+      impl_ns = save_impl_ns;
+    }
+}
+
+void
+plugin_walk_binding (tree binding)
+{
+  tree value = NULL_TREE;
+
+  if (STAT_HACK_P (binding))
+    {
+      if (!STAT_TYPE_HIDDEN_P (binding)
+	  && STAT_TYPE (binding))
+	return plugin_walk_decl (STAT_TYPE (binding));
+      else if (!STAT_DECL_HIDDEN_P (binding))
+	value = STAT_DECL (binding);
+    }
+  else
+    value = binding;
+
+  value = ovl_skip_hidden (value);
+  if (value)
+    {
+      value = OVL_FIRST (value);
+      return plugin_walk_decl (value);
+    }
+}
+
+void
+plugin_walk_ns (tree ns)
+{
+  using itert = hash_table<named_decl_hash>::iterator;
+  itert end (DECL_NAMESPACE_BINDINGS (ns)->end ());
+  for (itert iter (DECL_NAMESPACE_BINDINGS (ns)->begin ());
+       iter != end; ++iter)
+    {
+      tree b = *iter;
+      gcc_assert (TREE_CODE (b) != BINDING_VECTOR);
+      plugin_walk_binding (b);
+    }
+}
+
+int
+plugin_ctx_check (tree decl)
+{
+  int ret = 1;
+  tree ctx = DECL_CONTEXT (decl);
+  while (ctx)
+    {
+      if (ctx == std_node)
+	return ret;
+      if (TREE_CODE (ctx) == NAMESPACE_DECL
+	  && DECL_NAME (ctx)
+	  && id_equal (DECL_NAME (ctx), "__gnu_cxx")
+	  && CP_DECL_CONTEXT (ctx) == global_namespace)
+	return 2;
+      if (TREE_CODE (ctx) == NAMESPACE_DECL
+	  && (!DECL_NAME (ctx)
+	      || IDENTIFIER_POINTER (DECL_NAME (ctx))[0] == '_'
+	      || IDENTIFIER_ANON_P (DECL_NAME (ctx)))
+	  && !DECL_NAMESPACE_INLINE_P (ctx))
+	ret = 2;
+      if (TYPE_P (ctx))
+	ctx = TYPE_CONTEXT (ctx);
+      else
+	ctx = DECL_CONTEXT (ctx);
+    }
+  return 0;
+}
+
+void
+plugin_finish_parse_function (void *event_data, void *)
+{
+  tree decl = (tree) event_data;
+  if (!plugin_header_check (decl))
+    return;
+
+  /* Only diagnose stuff nested in ::std or ::__gnu_cxx
+     namespaces.  */
+  if (!plugin_ctx_check (decl))
+    return;
+
+  /* Templates are handled from plugin_walk_ns.  */
+  if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
+    return;
+  plugin_check_fn (decl);
+}
+
+void
+plugin_walk_specialization (bool, spec_entry *entry, void *)
+{
+  tree info;
+  if (TYPE_P (entry->spec))
+    info = TYPE_TEMPLATE_INFO (entry->spec);
+  else
+    info = DECL_TEMPLATE_INFO (entry->spec);
+  if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (info)) && TI_PARTIAL_INFO (info))
+    info = TI_PARTIAL_INFO (info);
+  tree decl = TI_TEMPLATE (info);
+  if (int c = plugin_ctx_check (decl))
+    {
+      impl_ns = c == 2;
+      plugin_walk_decl (decl);
+    }
+}
+
+void
+plugin_finish_unit (void *, void *)
+{
+  plugin_walk_ns (std_node);
+  tree gnucxx_ns = lookup_qualified_name (global_namespace, "__gnu_cxx");
+  if (gnucxx_ns && TREE_CODE (gnucxx_ns) == NAMESPACE_DECL)
+    plugin_walk_ns (gnucxx_ns);
+  walk_specializations (false, plugin_walk_specialization, NULL);
+  walk_specializations (true, plugin_walk_specialization, NULL);
+  unsigned int i;
+  tree decl;
+  FOR_EACH_VEC_ELT (nonugly_names, i, decl)
+    if (!whitelist.contains (DECL_NAME (decl)))
+      inform (DECL_SOURCE_LOCATION (decl), "non-uglified name %qs",
+	      IDENTIFIER_POINTER (DECL_NAME (decl)));
+    else
+      inform (DECL_SOURCE_LOCATION (decl), "non-uglified whitelisted name %qs",
+	      IDENTIFIER_POINTER (DECL_NAME (decl)));
+}
+
+void
+plugin_ggc_walker (void *)
+{
+  unsigned int i;
+  tree decl;
+  FOR_EACH_VEC_ELT (nonugly_names, i, decl)
+    gt_ggc_m_9tree_node (decl);
+  for (hash_set<tree>::iterator it = whitelist.begin ();
+       it != whitelist.end (); ++it)
+    gt_ggc_m_9tree_node (*it);
+}
+
+static const struct ggc_root_tab xtratab[] = {
+  { (void *) &xtratab, 1, 1, plugin_ggc_walker, NULL },
+  LAST_GGC_ROOT_TAB
+};
+
+int
+plugin_init (struct plugin_name_args *plugin_info,
+	     struct plugin_gcc_version *version)
+{
+  const char *plugin_name = plugin_info->base_name;
+
+  register_callback (plugin_name, PLUGIN_FINISH_UNIT,
+		     plugin_finish_unit, NULL);
+  register_callback (plugin_name, PLUGIN_FINISH_PARSE_FUNCTION,
+		     plugin_finish_parse_function, NULL);
+  register_callback (plugin_name, PLUGIN_REGISTER_GGC_ROOTS,
+		     NULL, (void *) xtratab);
+
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/alias3.C
@@ -0,0 +1,15 @@
+// PR c++/125208
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+using A = int;
+using B = int;
+using C = A;
+static_assert (^^A == ^^A);
+static_assert (^^const A == ^^const A);
+static_assert (^^A != ^^const A);
+static_assert (^^B == ^^B);
+static_assert (^^C == ^^C);
+static_assert (^^A != ^^B);
+static_assert (^^A != ^^C);
+static_assert (^^B != ^^C);
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/anon5.C
@@ -0,0 +1,16 @@
+// PR c++/124991
+// { dg-do run { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+struct X { union { char b; float c; }; };
+constexpr auto ctx = std::meta::access_context::unchecked ();
+
+int
+main ()
+{
+  if (typeid (typename [: parent_of (^^X::b) :])
+      != typeid (typename [: members_of (^^X, ctx)[0] :]))
+    __builtin_abort ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/bases_of4.C
@@ -0,0 +1,45 @@
+// PR c++/125206
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+#include <type_traits>
+
+template<auto...> struct mp_list_v
+{
+};
+
+template<class...> struct mp_list
+{
+};
+
+template<auto V> using mp_value = std::integral_constant<decltype(V), V>;
+
+template<class L, template<class...> class B> struct mp_rename_impl;
+
+template<template<class...> class L, class... T, template<class...> class B> struct mp_rename_impl<L<T...>, B>
+{
+    using type = B<T...>;
+};
+
+template<template<auto...> class L, auto... A, template<class...> class B> struct mp_rename_impl<L<A...>, B>
+{
+    using type = B<mp_value<A>...>;
+};
+
+template<class L, template<class...> class B> using mp_rename = typename mp_rename_impl<L, B>::type;
+
+class X1
+{
+};
+
+class Z: public X1
+{
+};
+
+int main()
+{
+    constexpr auto all = std::meta::access_context::unchecked();
+    constexpr auto L1 = ^^mp_list_v< bases_of(^^Z, all)[0] >;
+    using L2 = mp_rename<typename [: L1 :], mp_list>;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/bases_of5.C
@@ -0,0 +1,128 @@
+// PR c++/125208
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+namespace std {
+template <class _E> struct initializer_list {
+  typedef _E *const_iterator;
+  _E *_M_array;
+  decltype (sizeof 0) _M_len;
+  constexpr long size() { return _M_len; }
+  constexpr const_iterator begin() { return _M_array; }
+  constexpr const_iterator end() { return begin() + size(); }
+};
+template <typename> struct allocator_traits;
+} // namespace std
+constexpr void *operator new(decltype (sizeof 0), void *__p) { return __p; }
+namespace std {
+template <typename _Tp, typename... _Args>
+constexpr void _Construct(_Tp *__p, _Args... __args) {
+  new (__p) _Tp(__args...);
+}
+template <typename _Tp> struct __new_allocator {
+  constexpr _Tp *allocate(long __n) {
+    return static_cast<_Tp *>(__builtin_operator_new(__n * sizeof(_Tp)));
+  }
+  constexpr void deallocate(_Tp *__p, long) { __builtin_operator_delete(__p); }
+};
+template <typename _Tp> struct allocator_traits<__new_allocator<_Tp>> {
+  using allocator_type = __new_allocator<_Tp>;
+  using value_type = _Tp;
+  using pointer = _Tp *;
+  template <typename _Up> using rebind_alloc = __new_allocator<_Up>;
+  static constexpr pointer allocate(allocator_type __a, long __n) {
+    return __a.allocate(__n);
+  }
+  static constexpr void deallocate(allocator_type __a, pointer __p, long __n) {
+    __a.deallocate(__p, __n);
+  }
+};
+} // namespace std
+template <typename _Alloc>
+struct __alloc_traits : std::allocator_traits<_Alloc> {
+  typedef std::allocator_traits<_Alloc> _Base_type;
+  typedef _Base_type::value_type reference;
+  template <typename _Tp> struct rebind {
+    typedef _Base_type::template rebind_alloc<_Tp> other;
+  };
+};
+namespace std {
+template <typename _InputIterator, typename _Sentinel,
+          typename _ForwardIterator>
+constexpr void __do_uninit_copy(_InputIterator __first, _Sentinel __last,
+                                _ForwardIterator __result) {
+  for (; __first != __last; ++__first, ++__result)
+    _Construct(__result, *__first);
+}
+template <typename _InputIterator, typename _ForwardIterator>
+constexpr void uninitialized_copy(_InputIterator __first, _InputIterator __last,
+                                  _ForwardIterator __result) {
+  __do_uninit_copy(__first, __last, __result);
+}
+template <typename _InputIterator, typename _Sentinel,
+          typename _ForwardIterator, typename _Tp>
+constexpr void __uninitialized_copy_a(_InputIterator __first, _Sentinel __last,
+                                      _ForwardIterator __result, _Tp) {
+  uninitialized_copy(__first, __last, __result);
+}
+template <typename _Tp, typename _Alloc> struct _Vector_base {
+  typedef __alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;
+  typedef __alloc_traits<_Tp_alloc_type>::pointer pointer;
+  struct _Vector_impl : _Tp_alloc_type {
+    constexpr _Vector_impl(_Tp_alloc_type) {}
+    pointer _M_start;
+  };
+  constexpr ~_Vector_base() { _M_deallocate(_M_impl._M_start); }
+  _Vector_impl _M_impl;
+  constexpr pointer _M_allocate(long __n) {
+    return __n ? __alloc_traits<_Tp_alloc_type>::allocate(_M_impl, __n)
+               : pointer();
+  }
+  constexpr void _M_deallocate(pointer __p) {
+    __alloc_traits<_Tp_alloc_type>::deallocate(_M_impl, __p, 0);
+  }
+};
+template <typename _Tp, typename _Alloc = __new_allocator<_Tp>>
+struct vector : _Vector_base<_Tp, _Alloc> {
+  typedef _Vector_base<_Tp, _Alloc> _Base;
+  typedef _Base::_Tp_alloc_type _Tp_alloc_type;
+  typedef _Alloc allocator_type;
+  constexpr vector(initializer_list<_Tp> __l,
+                   allocator_type __a = allocator_type())
+      : _Base(__a) {
+    long __trans_tmp_1 = __l.size();
+    _M_range_initialize_n(__l.begin(), __l.end(), __trans_tmp_1);
+  }
+  constexpr __alloc_traits<_Tp_alloc_type>::reference operator[](long __n) {
+    return *(this->_M_impl._M_start + __n);
+  }
+  template <typename _Iterator, typename _Sentinel>
+  constexpr void _M_range_initialize_n(_Iterator __first, _Sentinel __last,
+                                       long __n) {
+    typename _Base::pointer __start = this->_M_allocate(__n);
+    this->_M_impl._M_start = __start;
+    _Tp_alloc_type __trans_tmp_2;
+    __uninitialized_copy_a(__first, __last, __start, __trans_tmp_2);
+  }
+};
+namespace meta {
+using info = decltype(^^int);
+struct access_context {
+  info _M_scope;
+  info _M_designating_class;
+};
+consteval vector<info> bases_of(info, access_context);
+} // namespace meta
+} // namespace std
+template <class L> using mp_is_value_list = L;
+template <template <class> class, class...> long cx_count_if;
+template <std::meta::info> struct rf_base_desc;
+struct X1 {};
+struct X2 {};
+struct Z : X1, X2 {};
+int main() {
+  constexpr auto all = std::meta::access_context();
+  using B1 = rf_base_desc<bases_of(^^Z, all)[0]>;
+  using B2 = rf_base_desc<bases_of(^^Z, all)[1]>;
+  (void) cx_count_if<mp_is_value_list, B1, B2>;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/bases_of6.C
@@ -0,0 +1,33 @@
+// PR c++/125423
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+struct Base
+{
+};
+struct Derived : Base
+{
+};
+
+template <typename Tp, Tp v> struct get_type
+{
+    inline constexpr static auto info = ^^void;
+};
+
+template <std::meta::info base> struct get_type<std::meta::info, base>
+{
+    inline constexpr static auto info = std::meta::type_of(base);
+};
+
+template <std::meta::info currField> struct ReflectionSubPanel
+{
+    static constexpr auto _ranges = []()
+    {
+        constexpr auto b = std::meta::bases_of(^^Derived, std::meta::access_context::unchecked())[0];
+        return get_type<decltype(b), b>::info;
+    }();
+};
+
+int main() { ReflectionSubPanel<^^Derived> panel; }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/can_substitute2.C
@@ -0,0 +1,19 @@
+// [meta.reflection.substitute] Example 1
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+template<class T>
+auto fn1();
+
+static_assert(!can_substitute(^^fn1, {^^int}));
+constexpr auto r1 = substitute(^^fn1, {^^int}); // { dg-error "can_substitute returned false" }
+
+template<class T>
+auto fn2() {
+  static_assert(false); // { dg-error "assert" }
+  return T{};
+}
+
+constexpr bool r2 = can_substitute(^^fn2, {^^int}); // { dg-message "required from here" }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/compare12.C
@@ -0,0 +1,12 @@
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+struct A {};
+struct B {};
+struct C : A, B {};
+struct D : A, B {};
+constexpr auto ctx = std::meta::access_context::unchecked ();
+static_assert (bases_of (^^C, ctx)[0] != bases_of (^^C, ctx)[1]);
+static_assert (bases_of (^^C, ctx)[1] != bases_of (^^D, ctx)[1]);
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/dep15.C
@@ -0,0 +1,85 @@
+// PR c++/124926
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+template <typename T, typename U>
+constexpr bool is_same_v = false;
+
+template <typename T>
+constexpr bool is_same_v<T, T> = true;
+
+// Class template
+template <typename>
+struct C1 {
+  template <typename> struct Inner {};
+};
+
+template <typename T>
+constexpr auto vt1 = ^^C1<T>::template Inner;
+constexpr auto r1 = vt1<int>;
+typename [:r1:]<int> a;
+static_assert(r1 == ^^C1<int>::template Inner);
+static_assert(is_same_v<decltype(a), C1<int>::Inner<int>>);
+
+// Class template with typename
+template <typename>
+struct C6 {
+  template <typename> struct Inner {};
+};
+
+template <typename T>
+constexpr auto vt6 = ^^typename C6<T>::template Inner<T>;
+constexpr auto r6 = vt6<int>;
+typename [:r6:] d;
+static_assert(r6 == ^^C6<int>::template Inner<int>);
+static_assert(is_same_v<decltype(d), C6<int>::Inner<int>>);
+
+// Variable template
+template <typename>
+struct C2 {
+  template <typename> static constexpr int Inner = 42;
+};
+
+template <typename T>
+constexpr auto vt2 = ^^C2<T>::template Inner;
+constexpr auto r2 = vt2<int>;
+constexpr int i = template [:r2:]<int>;
+static_assert(i == 42);
+static_assert(vt2<int> == ^^C2<int>::template Inner);
+
+// Function template
+template <typename>
+struct C3 {
+  template <typename T> static constexpr int Inner (T t) { return t; };
+};
+template <typename T>
+constexpr auto vt3 = ^^C3<T>::template Inner;
+constexpr auto r3 = vt3<int>;
+static_assert(template [:r3:](42) == 42);
+static_assert(vt3<int> == ^^C3<int>::template Inner);
+
+// Alias template
+template <typename>
+struct C4 {
+  template <typename T> using Inner = C4<T>;
+};
+template <typename T>
+constexpr auto vt4 = ^^C4<T>::template Inner;
+constexpr auto r4 = vt4<int>;
+typename [:r4:]<int> b;
+static_assert(is_same_v<decltype(b), C4<int>>);
+static_assert(vt4<int> == ^^C4<int>::template Inner);
+
+// Alias template with typename
+template<typename T> struct X { };
+
+template <typename>
+struct C5 {
+  template <typename T> using Inner = X<T>;
+};
+template <typename T>
+constexpr auto vt5 = ^^typename C5<T>::template Inner<T>;
+constexpr auto r5 = vt5<int>;
+typename [:r5:] c;
+static_assert(is_same_v<decltype(c), X<int>>);
+static_assert(vt5<int> == ^^C5<int>::template Inner<int>);
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/dep16.C
@@ -0,0 +1,28 @@
+// PR c++/125096
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+#include <vector>
+
+namespace ctp {
+    template <class T> struct Reflect;
+
+    namespace impl {
+        template <class T> using custom_target = Reflect<T>::target_type;
+    }
+
+    template <class T>
+    using target = [: is_scalar_type(^^T) ? ^^T : substitute(^^impl::custom_target, {^^T}) :];
+
+    template <class T>
+    struct Reflect<std::vector<T>> {
+        using underlying = target<T> const;
+        using target_type = std::span<const target<T>>;
+    };
+}
+
+static_assert(dealias(^^ctp::target<int>) == ^^int);
+static_assert(dealias(^^ctp::target<std::vector<int>>) == ^^std::span<int const>);
+static_assert(dealias(^^ctp::Reflect<std::vector<int>>::underlying) == ^^int const);
+static_assert(dealias(^^ctp::Reflect<std::vector<int>>::target_type) == ^^std::span<int const>);
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/error13.C
@@ -0,0 +1,30 @@
+// PR c++/124756
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+template<typename T>
+consteval void
+f0 ()
+{
+  void fun(T);
+  auto _ = ^^fun;  // { dg-error "cannot take the reflection of a block-scope extern .fun." }
+  extern int arr[3];
+  auto _ = ^^arr;  // { dg-error "cannot take the reflection of a block-scope extern .arr." }
+  extern int e;
+  auto _ = ^^e;  // { dg-error "cannot take the reflection of a block-scope extern .e." }
+}
+
+consteval {
+  f0<int>();
+}
+
+consteval void
+f1 ()
+{
+  void fun(int);
+  auto _ = ^^fun;  // { dg-error "cannot take the reflection of a block-scope extern .fun." }
+  extern int arr[3];
+  auto _ = ^^arr;  // { dg-error "cannot take the reflection of a block-scope extern .arr." }
+  extern int e;
+  auto _ = ^^e;  // { dg-error "cannot take the reflection of a block-scope extern .e." }
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/extract12.C
@@ -0,0 +1,14 @@
+// PR c++/125111
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+using A = void ();
+extern A &a;
+constexpr auto b = ^^a;
+constexpr auto c = std::meta::extract <A &> (b);	// { dg-error "uncaught exception of type 'std::meta::exception'; 'what\\\(\\\)': 'value cannot be extracted'" }
+using B = int [];
+extern B &d;
+constexpr auto e = ^^d;
+constexpr auto f = std::meta::extract <B &> (e);	// { dg-error "uncaught exception of type 'std::meta::exception'; 'what\\\(\\\)': 'value cannot be extracted'" }
--- a/src/gcc/testsuite/g++.dg/reflect/identifier_of3.C
+++ b/src/gcc/testsuite/g++.dg/reflect/identifier_of3.C
@@ -4,6 +4,7 @@
 // Test std::meta::identifier_of.
 
 #include <meta>
+using namespace std::meta;
 
 void foo (int, int x, int y, int z);
 
@@ -38,10 +39,10 @@ baz ()
   void foo (int w, int, int v, int z);
   int bar (int, int, int v, int z, int u);
   void qux (int, int x, int y, int z);
-  constexpr auto qux1 = parameters_of (^^qux)[0];
-  constexpr auto qux2 = parameters_of (^^qux)[1];
-  constexpr auto qux3 = parameters_of (^^qux)[2];
-  constexpr auto qux4 = parameters_of (^^qux)[3];
+  constexpr auto qux1 = parameters_of (^^qux)[0]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
+  constexpr auto qux2 = parameters_of (^^qux)[1]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
+  constexpr auto qux3 = parameters_of (^^qux)[2]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
+  constexpr auto qux4 = parameters_of (^^qux)[3]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
   static_assert (!has_identifier (qux1));
   static_assert (identifier_of (qux2) == std::string_view ("x"));
   static_assert (identifier_of (qux3) == std::string_view ("y"));
@@ -62,10 +63,10 @@ void
 fred ()
 {
   void qux (int w, int, int v, int z);
-  constexpr auto qux1 = parameters_of (^^qux)[0];
-  constexpr auto qux2 = parameters_of (^^qux)[1];
-  constexpr auto qux3 = parameters_of (^^qux)[2];
-  constexpr auto qux4 = parameters_of (^^qux)[3];
+  constexpr auto qux1 = parameters_of (^^qux)[0]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
+  constexpr auto qux2 = parameters_of (^^qux)[1]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
+  constexpr auto qux3 = parameters_of (^^qux)[2]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
+  constexpr auto qux4 = parameters_of (^^qux)[3]; // { dg-error "cannot take the reflection of a block-scope extern .qux." }
   static_assert (identifier_of (qux1) == std::string_view ("w"));
   static_assert (identifier_of (qux2) == std::string_view ("x"));
   static_assert (!has_identifier (qux3));
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/init18.C
@@ -0,0 +1,14 @@
+// PR c++/124770
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+using info = decltype(^^::);
+
+constexpr inline info v{};
+static_assert(v == info{});
+extern constexpr inline info v2{};
+static_assert(v2 == info{});
+constexpr inline info v3;
+static_assert(v3 == info{});
+
+extern constexpr inline info v4; // { dg-error "not a definition|consteval-only" }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/init19.C
@@ -0,0 +1,12 @@
+// PR c++/125280
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+struct C { decltype(^^::) i; };
+struct N { int i; };
+
+template<typename T>
+struct X : T { };
+
+auto a = X<C>{}; // { dg-error "outside a constant-evaluated context" }
+auto b = X<N>{};
--- a/src/gcc/testsuite/g++.dg/reflect/mangle4.C
+++ b/src/gcc/testsuite/g++.dg/reflect/mangle4.C
@@ -20,7 +20,6 @@ template<random_access_iterator I>
 }
 
 int main() {
-  // ??? It's not clear which of these should error.
-  std::default_accessor<int>       _ = std::iterator_accessor<int*>();
-  std::default_accessor<const int> _ = std::iterator_accessor<int*>(); // { dg-error "conversion" }
+  std::default_accessor<int>       _ = std::iterator_accessor<int*>(); // { dg-error "conversion" }
+  std::default_accessor<const int> _ = std::iterator_accessor<int*>();
 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/mangle7.C
@@ -0,0 +1,65 @@
+// PR c++/125498
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+using namespace std::meta;
+
+template<info>
+void
+xyzzy ()
+{
+}
+
+struct S {
+  void fn1 (const S &)
+  {
+    xyzzy<parameters_of (^^S::fn1)[0]> ();
+  }
+  void fn2 (this S)
+  {
+    xyzzy<parameters_of (^^S::fn2)[0]> ();
+  }
+  static void fn3 (int)
+  {
+    xyzzy<parameters_of (^^S::fn3)[0]> ();
+  }
+};
+
+struct V : virtual S {
+  void fn1 (const V &)
+  {
+    xyzzy<parameters_of (^^V::fn1)[0]> ();
+  }
+  void fn2 (this V)
+  {
+    xyzzy<parameters_of (^^V::fn2)[0]> ();
+  }
+  static void fn3 (int)
+  {
+    xyzzy<parameters_of (^^V::fn3)[0]> ();
+  }
+};
+
+void
+g (int)
+{
+  xyzzy<parameters_of (^^g)[0]> ();
+  S s;
+  s.fn1 (s);
+  s.fn2 ();
+  S::fn3 (42);
+  V v;
+  v.fn1 (v);
+  v.fn2 ();
+  V::fn3 (42);
+}
+
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_N1S3fn1ERKS0_EEvv" } }
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_NH1S3fn2ES0_EEvv" } }
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_N1S3fn3EiEEvv" } }
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_N1V3fn1ERKS0_EEvv" } }
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_NH1V3fn2ES0_EEvv" } }
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_N1V3fn3EiEEvv" } }
+// { dg-final { scan-assembler "_Z5xyzzyILDmpa_1giEEvv" } }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/member24.C
@@ -0,0 +1,25 @@
+// PR c++/124989
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+using info = decltype(^^::);
+
+template <info R>
+constexpr auto pointer_of()
+{
+  return &[: R :];
+}
+
+struct X
+{
+    int a;
+protected:
+    int b;
+private:
+    int c;
+
+public:
+    static constexpr auto pa = pointer_of<^^X::a>();
+    static constexpr auto pb = pointer_of<^^X::b>();
+    static constexpr auto pc = pointer_of<^^X::c>();
+};
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/members_of14.C
@@ -0,0 +1,29 @@
+// PR c++/124628
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+template<class T> void f();
+
+template<class T>
+struct A {
+  void g() noexcept(noexcept(T{}));
+  auto h() { return T{}; }
+  static inline auto m = T{};
+  // A& operator=(const A&) noexcept;
+  // A& operator=(A&&) noexcept;
+};
+
+int main() {
+  constexpr auto ac = std::meta::access_context::current();
+  template for (constexpr auto mem : define_static_array(members_of(^^A<int>, ac)))
+    if constexpr (!is_constructor(mem) && !is_destructor(mem))
+      f<typename [:type_of(mem):]>();
+}
+
+// { dg-final { scan-assembler _Z1fIDoFvvEEvv } } void f<void () noexcept>()
+// { dg-final { scan-assembler _Z1fIFivEEvv } } void f<int ()>()
+// { dg-final { scan-assembler _Z1fIiEvv } } void f<int>()
+// { dg-final { scan-assembler _Z1fIDoFR1AIiERKS1_EEvv } } void f<A<int>& (A<int> const&) noexcept>()
+// { dg-final { scan-assembler _Z1fIDoFR1AIiEOS1_EEvv } } void f<A<int>& (A<int>&&) noexcept>()
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/parameters_of9.C
@@ -0,0 +1,45 @@
+// PR c++/125498
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection -g" }
+
+#include <meta>
+
+struct tag {};
+
+struct S {
+  S(int) {}
+};
+
+struct B { };
+struct A : virtual B { A(int); };
+
+template <auto Param> struct GetAnnotations {
+  static constexpr auto value = std::define_static_array(
+      std::meta::annotations_of_with_type(Param, ^^tag));
+};
+
+consteval bool test() {
+  template for (constexpr auto member :
+		std::define_static_array(std::meta::members_of(
+		    ^^S, std::meta::access_context::unchecked()))) {
+    if constexpr (std::meta::is_constructor(member)) {
+      constexpr auto parameters =
+	  std::define_static_array(std::meta::parameters_of(member));
+      constexpr auto annotations = GetAnnotations<parameters[0]>::value;
+      return annotations.empty();
+    }
+  }
+}
+
+consteval bool test2() {
+  template for (constexpr auto member :
+		std::define_static_array(std::meta::members_of(
+		    ^^A, std::meta::access_context::unchecked()))) {
+    if constexpr (std::meta::is_constructor(member)) {
+      constexpr auto parameters =
+	  std::define_static_array(std::meta::parameters_of(member));
+      constexpr auto annotations = GetAnnotations<parameters[0]>::value;
+      return annotations.empty();
+    }
+  }
+}
--- a/src/gcc/testsuite/g++.dg/reflect/pr123612.C
+++ b/src/gcc/testsuite/g++.dg/reflect/pr123612.C
@@ -3,6 +3,7 @@
 // { dg-additional-options "-freflection" }
 
 #include <meta>
+using namespace std::meta;
 
 int a;
 extern int b;
@@ -12,14 +13,14 @@ consteval auto
 bar ()
 {
   extern int a;
-  return ^^a;
+  return ^^a;	// { dg-error "cannot take the reflection of a block-scope extern .a." }
 }
 
 consteval auto
 baz ()
 {
   extern int b;
-  return ^^b;
+  return ^^b;	// { dg-error "cannot take the reflection of a block-scope extern .b." }
 }
 
 consteval auto
@@ -30,10 +31,10 @@ qux ()
   static_assert (has_default_argument (parameters_of (^^foo)[2]));
   {
     extern int foo (int x, int y = 5, int z = 16);
-    static_assert (!has_default_argument (parameters_of (^^foo)[0]));
-    static_assert (has_default_argument (parameters_of (^^foo)[1]));
-    static_assert (has_default_argument (parameters_of (^^foo)[2]));
-    return ^^foo;
+    static_assert (!has_default_argument (parameters_of (^^foo)[0]));  // { dg-error "cannot take the reflection of a block-scope extern .foo." }
+    static_assert (has_default_argument (parameters_of (^^foo)[1]));  // { dg-error "cannot take the reflection of a block-scope extern .foo." }
+    static_assert (has_default_argument (parameters_of (^^foo)[2]));  // { dg-error "cannot take the reflection of a block-scope extern .foo." }
+    return ^^foo;  // { dg-error "cannot take the reflection of a block-scope extern .foo." }
   }
 }
 
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/pr125007.C
@@ -0,0 +1,46 @@
+// PR c++/125007
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+[[=1]] void foo (int x, int y);
+[[=2]] void foo (int x, int z);
+
+struct A { int a; };
+struct B { int b; };
+struct C : public A, B {};
+struct D : public A, B {};
+
+constexpr auto ctx = std::meta::access_context::unchecked ();
+static_assert (annotations_of (^^foo)[0] == annotations_of (^^foo)[1]);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(\\\^\\\^\\\[\\\[=1\\\]\\\] == \\\^\\\^\\\[\\\[=2\\\]\\\]\\\)'" "" { target *-*-* } .-1 }
+static_assert (parameters_of (^^foo)[0] == parameters_of (^^foo)[1]);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(parameters_of\\\(\\\^\\\^foo\\\(int, int\\\)\\\)\\\[0\\\] \\\{aka x\\\} == parameters_of\\\(\\\^\\\^foo\\\(int, int\\\)\\\)\\\[1\\\]\\\)'" "" { target *-*-* } .-1 }
+static_assert (bases_of (^^C, ctx)[0] == bases_of (^^C, ctx)[1]);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(bases_of\\\(\\\^\\\^C,std::meta::access_context::unchecked\\\(\\\)\\\)\\\[0\\\] \\\{aka A\\\} == bases_of\\\(\\\^\\\^C,std::meta::access_context::unchecked\\\(\\\)\\\)\\\[1\\\] \\\{aka B\\\}\\\)'" "" { target *-*-* } .-1 }
+static_assert (bases_of (^^C, ctx)[1] == bases_of (^^D, ctx)[1]);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(bases_of\\\(\\\^\\\^C,std::meta::access_context::unchecked\\\(\\\)\\\)\\\[1\\\] \\\{aka B\\\} == bases_of\\\(\\\^\\\^D,std::meta::access_context::unchecked\\\(\\\)\\\)\\\[1\\\] \\\{aka B\\\}\\\)'" "" { target *-*-* } .-1 }
+constexpr auto an1 = annotations_of (^^foo)[0];
+constexpr auto an2 = annotations_of (^^foo)[1];
+constexpr auto an3 = std::meta::reflect_constant (3);
+static_assert (data_member_spec (^^int, { .name = "foo", .alignment = 64, .no_unique_address = true, .annotations = { an1, an2, an3 } }) == ^^::);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(data_member_spec\\\(\\\^\\\^int,\\\{.name=\\\"foo\\\",.alignment=64,.no_unique_address=true,.annotations=\\\{std::meta::reflect_constant\\\(1\\\),std::meta::reflect_constant\\\(2\\\),std::meta::reflect_constant\\\(3\\\)\\\}\\\}\\\) == \\\^\\\^::\\\)'" "" { target *-*-* } .-1 }
+static_assert (data_member_spec (^^int, { .bit_width = 5 }) == ^^::);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(data_member_spec\\\(\\\^\\\^int,\\\{.bit_width=5\\\}\\\) == \\\^\\\^::\\\)'" "" { target *-*-* } .-1 }
+static_assert (std::meta::reflect_constant (42) == std::meta::reflect_constant (A { 42 })); // { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(std::meta::reflect_constant\\\(42\\\) == std::meta::reflect_object\\\(A\\\{42\\\}\\\)\\\)'" "" { target *-*-* } .-1 }
+int v[42];
+static_assert (std::meta::reflect_object (v[4]) == std::meta::reflect_object (v[5])); // { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(std::meta::reflect_object\\\(v\\\[4\\\]\\\) == std::meta::reflect_object\\\(v\\\[5\\\]\\\)\\\)'" "" { target *-*-* } .-1 }
+
+void
+qux (int, int)
+{
+}
+
+void qux (int x, int y);
+void qux (int x, int y);
+
+static_assert (parameters_of (^^qux)[0] == parameters_of (^^qux)[1]);	// { dg-error "static assertion failed" }
+// { dg-message "note: the comparison reduces to '\\\(parameters_of\\\(\\\^\\\^qux\\\(int, int\\\)\\\)\\\[0\\\] \\\{aka x\\\} == parameters_of\\\(\\\^\\\^qux\\\(int, int\\\)\\\)\\\[1\\\] \\\{aka y\\\}\\\)'" "" { target *-*-* } .-1 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/pr125412.C
@@ -0,0 +1,24 @@
+// PR c++/125412
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+void
+foo ()
+{
+}
+
+auto bar ();
+
+template <typename T>
+auto a = foo ();	// { dg-error "variable or field 'a' declared void" }
+template <typename T>
+auto b = bar ();	// { dg-error "use of 'auto bar\\\(\\\)' before deduction of 'auto'" }
+
+consteval {
+  auto c = substitute (^^a, { ^^int });
+  std::meta::extract <int> (c);
+  auto d = substitute (^^b, { ^^int });
+  std::meta::extract <int> (d);
+}
--- a/src/gcc/testsuite/g++.dg/reflect/substitute3.C
+++ b/src/gcc/testsuite/g++.dg/reflect/substitute3.C
@@ -7,9 +7,7 @@
 
 template<typename>
 auto
-f ()
-{
-}
+f ();
 
 consteval bool
 g ()
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/type12.C
@@ -0,0 +1,28 @@
+// PR c++/125280
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+template <class T, int N>
+struct Array {
+  T mElements[N];
+};
+
+struct Element {
+  static const Array<Element, 9> mData;
+};
+const Array<Element, 9> Element::mData;
+
+struct CE { decltype(^^::) i; };
+
+struct A {
+  static const Array<CE, 10> mData;
+};
+const Array<CE, 10> A::mData{}; // { dg-error "outside a constant-evaluated context" }
+
+struct B {
+  static constexpr Array<CE, 11> mData{};
+};
+
+struct C {
+  static const Array<CE, 12> mData;
+};
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/type13.C
@@ -0,0 +1,13 @@
+// PR c++/125280
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+template <class T, int N>
+struct Array {
+  T mElements[N]; // { dg-error "incomplete type" }
+};
+
+struct Element {
+  static const Array<Element, 10> mData{}; // { dg-error "initialization of static data member" }
+};
+const Array<Element, 10> Element::mData;
--- a/src/gcc/testsuite/g++.dg/reflect/type_of3.C
+++ b/src/gcc/testsuite/g++.dg/reflect/type_of3.C
@@ -10,4 +10,10 @@ struct S {
 };
 int h() { return 0; }
 
+template<class T>
+struct ST {
+    auto g() { return T{}; }
+};
+
 static_assert(type_of(^^S::g) == type_of(^^h));
+static_assert(type_of(^^ST<int>::g) == type_of(^^h));
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.dg/reflect/using3.C
@@ -0,0 +1,11 @@
+// PR c++/125184
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <meta>
+
+void
+foo ()
+{
+  using std::meta::info;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.target/i386/mv33.C
@@ -0,0 +1,42 @@
+// Test that dispatching can choose the right multiversion
+// for HYGON CPUs with the same internal GCC processor id
+
+// { dg-do run }
+// { dg-require-ifunc "" }
+// { dg-options "-O2" }
+
+#include <assert.h>
+
+int __attribute__ ((target("default")))
+foo ()
+{
+  return 0;
+}
+
+int __attribute__ ((target("arch=c86-4g-m4"))) foo () {
+  return 1;
+}
+
+int __attribute__ ((target("arch=c86-4g-m6"))) foo () {
+  return 2;
+}
+
+int __attribute__ ((target("arch=c86-4g-m7"))) foo () {
+  return 3;
+}
+
+int main ()
+{
+  int val = foo ();
+
+  if  (__builtin_cpu_is ("c86-4g-m4"))
+    assert (val == 1);
+  else if (__builtin_cpu_is ("c86-4g-m6"))
+    assert (val == 2);
+  else if (__builtin_cpu_is ("c86-4g-m7"))
+    assert (val == 3);
+  else
+    assert (val == 0);
+
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.target/powerpc/pr124133-1.C
@@ -0,0 +1,12 @@
+// PR target/124133
+// { dg-options "-mdejagnu-cpu=power8 -mvsx" }
+// { dg-require-effective-target powerpc_vsx }
+
+typedef __INTPTR_TYPE__ intptr_t;
+
+template <int>
+void
+foo (int x, short *y, intptr_t z)
+{
+  __builtin_vec_vsx_ld ((x + z) * 2, y);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/g++.target/powerpc/pr124133-2.C
@@ -0,0 +1,14 @@
+// PR target/124133
+// { dg-options "-mdejagnu-cpu=power8 -mvsx -O2" }
+// { dg-require-effective-target powerpc_vsx }
+
+#include <altivec.h>                                                                                                                                                                  
+                                                                                                                                                                                      
+struct S { float d; unsigned char e[16]; };                                                                                                                                           
+                                                                                                                                                                                      
+template <typename T>                                                                                                                                                                 
+void                                                                                                                                                                                  
+foo (const S *s)                                                                                                                                                                      
+{                                                                                                                                                                                     
+  vector signed char a = (vector signed char) vec_xl (0, s->e);                                                                                                                       
+}                                                                                                                                                                                     
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.c-torture/compile/pr125039.c
@@ -0,0 +1,12 @@
+/* PR tree-optimization/125039 */
+
+void
+foo ()
+{
+  double b = b, c = c;
+  if (c)
+    c = -c;
+  double d = b == c ? b : c;
+  if (c != d)
+    foo ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.c-torture/compile/pr125373.c
@@ -0,0 +1,20 @@
+/* PR target/125373 */
+
+int foo (int);
+
+void
+bar (int *v, int w)
+{
+  for (int i = 0; i < (__INTPTR_TYPE__) (v - 1); i++)
+    if (v)
+      v[i] = v[w];
+}
+
+int
+main ()
+{
+  int a[] = { 0, 0, 0, 0 };
+  bar (a, 4);
+  for (int i = 0; i < 4; i++)
+    foo (a[i]);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.c-torture/execute/pr125291.c
@@ -0,0 +1,39 @@
+/* PR tree-optimization/125291 */
+
+char buf[1111];
+char *archive_le16dec_filename = buf;
+unsigned int archive_le16dec_end, archive_le16dec_fn_end,
+    archive_le16dec_filename_size, archive_le16dec_offset;
+char archive_le16dec_p[] = { 21, 0x7f };
+
+[[gnu::noipa]]
+void
+archive_le16dec ()
+{
+  archive_le16dec_filename_size = (short)archive_le16dec_filename_size;
+  unsigned char flagbits = 0, flagbyte;
+  archive_le16dec_end = archive_le16dec_filename_size;
+  archive_le16dec_fn_end = archive_le16dec_filename_size * 2;
+  archive_le16dec_filename_size = flagbits = 0;
+  while (archive_le16dec_offset < archive_le16dec_end
+         && archive_le16dec_filename_size < archive_le16dec_fn_end)
+    {
+      if (!flagbits)
+        {
+          flagbyte = archive_le16dec_p[archive_le16dec_offset++];
+          flagbits = 8;
+        }
+      flagbits -= 2;
+      if (!(flagbyte >> flagbits & 3))
+        archive_le16dec_filename_size++;
+    }
+}
+
+int
+main ()
+{
+  archive_le16dec_filename_size = 2;
+  archive_le16dec ();
+  if (archive_le16dec_filename_size != 1)
+    __builtin_trap ();
+}
--- a/src/gcc/testsuite/gcc.dg/lto/toplevel-simple-asm-1_0.c
+++ b/src/gcc/testsuite/gcc.dg/lto/toplevel-simple-asm-1_0.c
@@ -4,8 +4,23 @@
 void asm_fn();
 void asm_fn_used();
 
+#ifdef __ELF__
+#ifdef __sparc__
+#define TYPE_PFX "#"
+#elif defined (__arm__) || defined (__aarch64__)
+#define TYPE_PFX "%"
+#else
+#define TYPE_PFX "@"
+#endif
+#endif
+
+#ifdef TYPE_PFX
+asm(".global asm_fn\n.type asm_fn, " TYPE_PFX "function\nasm_fn:");
+asm(".global asm_fn_used\n.type asm_fn_used, " TYPE_PFX "function\nasm_fn_used:");
+#else
 asm(".global asm_fn\nasm_fn:");
 asm(".global asm_fn_used\nasm_fn_used:");
+#endif
 
 
 __attribute__((noinline))
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/pr125117.c
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-O0" } */
+
+#include <string.h>
+#include <stdlib.h>
+
+#define OFFSET 32
+
+char buffer[128];
+char expected[64];
+
+void
+foo (char *dest, char *src, size_t n)
+{
+  if (n == 64)
+    __builtin_memmove (dest, src, n);
+}
+
+int
+main ()
+{
+  memset (buffer, -2, sizeof (buffer));
+  memset (buffer + OFFSET, -1, sizeof (buffer) - OFFSET);
+  memset (expected, -2, sizeof (expected));
+  memset (expected + OFFSET / 2, -1, OFFSET + OFFSET / 2);
+  foo (buffer, buffer + OFFSET / 2, 64);
+  if (memcmp (expected, buffer, 64) != 0)
+    abort ();
+
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/pr125375.c
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fno-inline -fno-compare-elim" } */
+
+int a, c = 1;
+short b = 1, e;
+volatile unsigned short d;
+static int f() {
+  unsigned g = 2;
+  if (c >= a)
+    if ((c || b) && b) {
+      unsigned h = c && d;
+      int i = e = d;
+      if (d)
+        i = d = 0;
+      g = c ^ g * i;
+      c = ~c;
+      b = b * (g | 9) & ((1 && a) - i);
+      h && i && d;
+      a = c ^ e ^ (g && a) * h;
+      d = e;
+      if (a)
+        return g;
+    }
+}
+int main() {
+  if (f() != 1)
+    __builtin_abort();
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/strlenopt-97.c
@@ -0,0 +1,33 @@
+/* PR tree-optimization/125079 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-strlen1" } */
+/* { dg-final { scan-tree-dump-times "__builtin___strcpy_chk \\\(" 1 "strlen1" } } */
+/* { dg-final { scan-tree-dump-not "__builtin___strcpy_chk \\\(\[^\n\r]*, 64\\\)" "strlen1" } } */
+/* { dg-final { scan-tree-dump-times "__builtin___stpcpy_chk \\\(" 1 "strlen1" } } */
+/* { dg-final { scan-tree-dump-not "__builtin___stpcpy_chk \\\(\[^\n\r]*, 128\\\)" "strlen1" } } */
+
+typedef __SIZE_TYPE__ size_t;
+void foo (char *, int);
+char *stpcpy (char *, const char *);
+
+size_t
+bar (char *r)
+{
+  char buf[64];
+  foo (buf, 0);
+  size_t ret = __builtin_strlen (buf);
+  __builtin___strcat_chk (buf, r, 64);
+  foo (buf, 1);
+  return ret;
+}
+
+size_t
+baz (char *r)
+{
+  char buf[128];
+  foo (buf, 2);
+  __builtin___strcat_chk (buf, r, 128);
+  size_t ret = __builtin_strlen (buf);
+  foo (buf, 3);
+  return ret;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/bitint-91.c
@@ -0,0 +1,140 @@
+/* PR middle-end/123635 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 513
+_BitInt(513) a, b, c, d;
+unsigned _BitInt(513) e, f, g, h;
+#endif
+
+#include "../bitintext.h"
+
+#if __BITINT_MAXWIDTH__ >= 513
+[[gnu::noipa]] bool
+f1 (_BitInt(513) q, _BitInt(513) r, _BitInt(513) s, _BitInt(513) t,
+    _BitInt(513) u, _BitInt(513) v, _BitInt(513) w, _BitInt(513) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_add_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_sub_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_sub_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f2 (unsigned _BitInt(513) q, unsigned _BitInt(513) r, unsigned _BitInt(513) s,
+    unsigned _BitInt(513) t, unsigned _BitInt(513) u, unsigned _BitInt(513) v,
+    unsigned _BitInt(513) w, unsigned _BitInt(513) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_add_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_sub_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_sub_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 1025
+[[gnu::noipa]] bool
+f3 (_BitInt(1025) q, _BitInt(1025) r, _BitInt(1025) s, _BitInt(1025) t,
+    _BitInt(1025) u, _BitInt(1025) v, _BitInt(1025) w, _BitInt(1025) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_add_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_sub_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_sub_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f4 (unsigned _BitInt(1025) q, unsigned _BitInt(1025) r,
+    unsigned _BitInt(1025) s, unsigned _BitInt(1025) t,
+    unsigned _BitInt(1025) u, unsigned _BitInt(1025) v,
+    unsigned _BitInt(1025) w, unsigned _BitInt(1025) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_add_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_sub_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_sub_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 513
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f1 (9655959669318785079954371230049554909200604556467603939808122955133717885340333846085453917625768204337699198414625928325836300792547598919086330010444969wb,
+      7603664655075175676551887792243938044412742856114886907427675169347553852589402599411290168288930382377283108890322269708884902998253293780483440129483327wb,
+      -10324098565034498465875215630604107238940128063553910460445433007166121079968132667074154355395844552937058899426253790777657675901838010055644316728526393wb,
+      -12236477238783553839340584917720106564483878483173525158555406923388638347150144919001024905877475401353674848301774791298367823029012449896858367218938488wb,
+      9966990594172406012310078765295767555782555285684385899869231608869471023379202086947215337899533069949801311225161562404400717858011700306179102121342515wb,
+      -12983782114594329520373595420695508584715919272703648469298375086460508080215963268729027546042229893937296428010493668720716318664505339275354851120734372wb,
+      -9655954001341551443087909192198932353132996418457245295521644079521230896558300756133292365213357603788911695147437530569709679437147630523365259553067954wb,
+      7072009366582949478473862650011262253783850301083169883440824883235985480601391689101153902500460700035282434290760483209786664550714449512762684388339187wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f2 (2964639554149490973596341394839758078409778829067653681666106821776834568408151111543733982288078570825867875863050348925537769671189456471968723686512034uwb,
+      5957364445683686818410817200949409124779631391545643887373796564697563753416937684648786338497928327653380765964317808469492623477785654419190708204181795uwb,
+      19191677104746999910669997770314557441327241058126327798712726258248174396859949489325836442238807787970653545840621658707862487865809500322706194229135252uwb,
+      24586718166970605619478065808613217078037607297232337682881885486187967367467012073369595089067814569116855119567799143349802467998026209123576080005659752uwb,
+      10462823982820178661190434713437061473290880952772417752401116804833406586088773886481041433195457558834409214235712063242433511929332344716172942804205442uwb,
+      16419753656873030796354060609416030388733546880849213639440646945524833982946459564500329809304700518677496254061943255280441489964246119308925190525772266uwb,
+      10405391186665161836576844847101505242465502880093273915903880455941412499859291312405803977208427105275040816651924471784587928355909534429001102837285163uwb,
+      17157919740278597151158601296325640095140225651359053582867340974133209625747219873488488134575281986967033985073454136035802749428039704256375550535464357uwb);
+#endif
+#if __BITINT_MAXWIDTH__ >= 1025
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f3 (9655959669318785079954371230049554909200604556467603939808122955133717885340333846085453917625768204337699198414625928325836300792547598919086330010444969wb,
+      7603664655075175676551887792243938044412742856114886907427675169347553852589402599411290168288930382377283108890322269708884902998253293780483440129483327wb,
+      -10324098565034498465875215630604107238940128063553910460445433007166121079968132667074154355395844552937058899426253790777657675901838010055644316728526393wb,
+      -12236477238783553839340584917720106564483878483173525158555406923388638347150144919001024905877475401353674848301774791298367823029012449896858367218938488wb,
+      9966990594172406012310078765295767555782555285684385899869231608869471023379202086947215337899533069949801311225161562404400717858011700306179102121342515wb,
+      -12983782114594329520373595420695508584715919272703648469298375086460508080215963268729027546042229893937296428010493668720716318664505339275354851120734372wb,
+      -9655954001341551443087909192198932353132996418457245295521644079521230896558300756133292365213357603788911695147437530569709679437147630523365259553067954wb,
+      7072009366582949478473862650011262253783850301083169883440824883235985480601391689101153902500460700035282434290760483209786664550714449512762684388339187wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f4 (2964639554149490973596341394839758078409778829067653681666106821776834568408151111543733982288078570825867875863050348925537769671189456471968723686512034uwb,
+      5957364445683686818410817200949409124779631391545643887373796564697563753416937684648786338497928327653380765964317808469492623477785654419190708204181795uwb,
+      19191677104746999910669997770314557441327241058126327798712726258248174396859949489325836442238807787970653545840621658707862487865809500322706194229135252uwb,
+      24586718166970605619478065808613217078037607297232337682881885486187967367467012073369595089067814569116855119567799143349802467998026209123576080005659752uwb,
+      10462823982820178661190434713437061473290880952772417752401116804833406586088773886481041433195457558834409214235712063242433511929332344716172942804205442uwb,
+      16419753656873030796354060609416030388733546880849213639440646945524833982946459564500329809304700518677496254061943255280441489964246119308925190525772266uwb,
+      10405391186665161836576844847101505242465502880093273915903880455941412499859291312405803977208427105275040816651924471784587928355909534429001102837285163uwb,
+      17157919740278597151158601296325640095140225651359053582867340974133209625747219873488488134575281986967033985073454136035802749428039704256375550535464357uwb);
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/bitint-92.c
@@ -0,0 +1,140 @@
+/* PR middle-end/123635 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 511
+_BitInt(511) a, b, c, d;
+unsigned _BitInt(511) e, f, g, h;
+#endif
+
+#include "../bitintext.h"
+
+#if __BITINT_MAXWIDTH__ >= 511
+[[gnu::noipa]] bool
+f1 (_BitInt(511) q, _BitInt(511) r, _BitInt(511) s, _BitInt(511) t,
+    _BitInt(511) u, _BitInt(511) v, _BitInt(511) w, _BitInt(511) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_add_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_sub_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_sub_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f2 (unsigned _BitInt(511) q, unsigned _BitInt(511) r, unsigned _BitInt(511) s,
+    unsigned _BitInt(511) t, unsigned _BitInt(511) u, unsigned _BitInt(511) v,
+    unsigned _BitInt(511) w, unsigned _BitInt(511) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_add_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_sub_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_sub_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 1023
+[[gnu::noipa]] bool
+f3 (_BitInt(1023) q, _BitInt(1023) r, _BitInt(1023) s, _BitInt(1023) t,
+    _BitInt(1023) u, _BitInt(1023) v, _BitInt(1023) w, _BitInt(1023) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_add_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_sub_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_sub_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f4 (unsigned _BitInt(1023) q, unsigned _BitInt(1023) r,
+    unsigned _BitInt(1023) s, unsigned _BitInt(1023) t,
+    unsigned _BitInt(1023) u, unsigned _BitInt(1023) v,
+    unsigned _BitInt(1023) w, unsigned _BitInt(1023) x)
+{
+  bool res = false;
+  res |= __builtin_add_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_add_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_sub_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_sub_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 511
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f1 (1390399912725058458200009048198820064492005235154664882378103191585647121798330571086629470693362953212791514491575158989602893218788902339652768462242628wb,
+      249177562235295607181226393168319684003354962277368763264203376508018272147140149371861361061154101827443514415658157865648522550758405852726010180808769wb,
+      -1780354034824880726793039893594299865138723691931754426795433194731471391545042339625233657837435887106690554340836104535849707683265009199435873463559020wb,
+      -740336545197937933670467416719493466419101689845476460441897613938923219348614699785899092241758652210632646359181180435230820349533052964898247331288194wb,
+      1264371856933908934004928210670432922219833109703326669407665736158573607996286450258750907679580905729735376144263375732104941574779989141805339934906103wb,
+      -1800762928143884868360591340947709805381121865559594609800602059770468706915015121333590484473244364203044167384984634798933392092472849088487188206919199wb,
+      -1874437506355165235214302048933351258782970556591446143241539194417790344619692436179305620246514867157285378788470027340983415072326706619779323878095044wb,
+      465089731165341206127432983731596524669687828142734277104372042775063012806153170457800193495447488542433104457447397078966750100194606523184187779891236wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f2 (1769288740652242299842741192560763693851113543365386227639113810655132281658311706354953254148690319453722073610881280531971362644037227748091681178317919uwb,
+      6609813168053391222543030306163941663953801084514170716266507032727748531561564744911045686719066313628734721154746698442483812155667254002473644708866548uwb,
+      2165581935187317546841478283262759103626305739168208417811840048675479552879740382682893926794456473657370285890451624909369445002539226077543796184885282uwb,
+      5583940649350967625413437252987234424283831963591403609577766560068787593281191860443568915932187805635333850527113490331304189378639908270408210201131036uwb,
+      4709767295913180049914868365292708657912010821088789452741841268048043047122882916441448275499420638756517585965684291097104349699944179639251796038947955uwb,
+      6280470013560252695084315130173483896550287179700449102345092527255864285425735025909066687910837200841028187788564127729392389462477148514426504126205653uwb,
+      5729764965697040092309843504303102973344572729567710548288594203184644343090550648393517676044608898029180050379384056057530481830153485215690201926045860uwb,
+      2025545578012992696919009225822788038691815646525577733706021933464568718262575612415581176797970841793616511309641023298056786955966008679910134224064441uwb);
+#endif
+#if __BITINT_MAXWIDTH__ >= 1023
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f3 (1390399912725058458200009048198820064492005235154664882378103191585647121798330571086629470693362953212791514491575158989602893218788902339652768462242628wb,
+      249177562235295607181226393168319684003354962277368763264203376508018272147140149371861361061154101827443514415658157865648522550758405852726010180808769wb,
+      -1780354034824880726793039893594299865138723691931754426795433194731471391545042339625233657837435887106690554340836104535849707683265009199435873463559020wb,
+      -740336545197937933670467416719493466419101689845476460441897613938923219348614699785899092241758652210632646359181180435230820349533052964898247331288194wb,
+      1264371856933908934004928210670432922219833109703326669407665736158573607996286450258750907679580905729735376144263375732104941574779989141805339934906103wb,
+      -1800762928143884868360591340947709805381121865559594609800602059770468706915015121333590484473244364203044167384984634798933392092472849088487188206919199wb,
+      -1874437506355165235214302048933351258782970556591446143241539194417790344619692436179305620246514867157285378788470027340983415072326706619779323878095044wb,
+      465089731165341206127432983731596524669687828142734277104372042775063012806153170457800193495447488542433104457447397078966750100194606523184187779891236wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f4 (1769288740652242299842741192560763693851113543365386227639113810655132281658311706354953254148690319453722073610881280531971362644037227748091681178317919uwb,
+      6609813168053391222543030306163941663953801084514170716266507032727748531561564744911045686719066313628734721154746698442483812155667254002473644708866548uwb,
+      2165581935187317546841478283262759103626305739168208417811840048675479552879740382682893926794456473657370285890451624909369445002539226077543796184885282uwb,
+      5583940649350967625413437252987234424283831963591403609577766560068787593281191860443568915932187805635333850527113490331304189378639908270408210201131036uwb,
+      4709767295913180049914868365292708657912010821088789452741841268048043047122882916441448275499420638756517585965684291097104349699944179639251796038947955uwb,
+      6280470013560252695084315130173483896550287179700449102345092527255864285425735025909066687910837200841028187788564127729392389462477148514426504126205653uwb,
+      5729764965697040092309843504303102973344572729567710548288594203184644343090550648393517676044608898029180050379384056057530481830153485215690201926045860uwb,
+      2025545578012992696919009225822788038691815646525577733706021933464568718262575612415581176797970841793616511309641023298056786955966008679910134224064441uwb);
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/bitint-93.c
@@ -0,0 +1,140 @@
+/* PR middle-end/123635 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 513
+_BitInt(513) a, b, c, d;
+unsigned _BitInt(513) e, f, g, h;
+#endif
+
+#include "../bitintext.h"
+
+#if __BITINT_MAXWIDTH__ >= 513
+[[gnu::noipa]] bool
+f1 (_BitInt(513) q, _BitInt(513) r, _BitInt(513) s, _BitInt(513) t,
+    _BitInt(513) u, _BitInt(513) v, _BitInt(513) w, _BitInt(513) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_mul_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_mul_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_mul_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f2 (unsigned _BitInt(513) q, unsigned _BitInt(513) r, unsigned _BitInt(513) s,
+    unsigned _BitInt(513) t, unsigned _BitInt(513) u, unsigned _BitInt(513) v,
+    unsigned _BitInt(513) w, unsigned _BitInt(513) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_mul_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_mul_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_mul_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 1025
+[[gnu::noipa]] bool
+f3 (_BitInt(1025) q, _BitInt(1025) r, _BitInt(1025) s, _BitInt(1025) t,
+    _BitInt(1025) u, _BitInt(1025) v, _BitInt(1025) w, _BitInt(1025) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_mul_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_mul_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_mul_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f4 (unsigned _BitInt(1025) q, unsigned _BitInt(1025) r,
+    unsigned _BitInt(1025) s, unsigned _BitInt(1025) t,
+    unsigned _BitInt(1025) u, unsigned _BitInt(1025) v,
+    unsigned _BitInt(1025) w, unsigned _BitInt(1025) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_mul_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_mul_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_mul_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 513
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f1 (9655959669318785079954371230049554909200604556467603939808122955133717885340333846085453917625768204337699198414625928325836300792547598919086330010444969wb,
+      7603664655075175676551887792243938044412742856114886907427675169347553852589402599411290168288930382377283108890322269708884902998253293780483440129483327wb,
+      -10324098565034498465875215630604107238940128063553910460445433007166121079968132667074154355395844552937058899426253790777657675901838010055644316728526393wb,
+      -12236477238783553839340584917720106564483878483173525158555406923388638347150144919001024905877475401353674848301774791298367823029012449896858367218938488wb,
+      9966990594172406012310078765295767555782555285684385899869231608869471023379202086947215337899533069949801311225161562404400717858011700306179102121342515wb,
+      -12983782114594329520373595420695508584715919272703648469298375086460508080215963268729027546042229893937296428010493668720716318664505339275354851120734372wb,
+      -9655954001341551443087909192198932353132996418457245295521644079521230896558300756133292365213357603788911695147437530569709679437147630523365259553067954wb,
+      7072009366582949478473862650011262253783850301083169883440824883235985480601391689101153902500460700035282434290760483209786664550714449512762684388339187wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f2 (2964639554149490973596341394839758078409778829067653681666106821776834568408151111543733982288078570825867875863050348925537769671189456471968723686512034uwb,
+      5957364445683686818410817200949409124779631391545643887373796564697563753416937684648786338497928327653380765964317808469492623477785654419190708204181795uwb,
+      19191677104746999910669997770314557441327241058126327798712726258248174396859949489325836442238807787970653545840621658707862487865809500322706194229135252uwb,
+      24586718166970605619478065808613217078037607297232337682881885486187967367467012073369595089067814569116855119567799143349802467998026209123576080005659752uwb,
+      10462823982820178661190434713437061473290880952772417752401116804833406586088773886481041433195457558834409214235712063242433511929332344716172942804205442uwb,
+      16419753656873030796354060609416030388733546880849213639440646945524833982946459564500329809304700518677496254061943255280441489964246119308925190525772266uwb,
+      10405391186665161836576844847101505242465502880093273915903880455941412499859291312405803977208427105275040816651924471784587928355909534429001102837285163uwb,
+      17157919740278597151158601296325640095140225651359053582867340974133209625747219873488488134575281986967033985073454136035802749428039704256375550535464357uwb);
+#endif
+#if __BITINT_MAXWIDTH__ >= 1025
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f3 (9655959669318785079954371230049554909200604556467603939808122955133717885340333846085453917625768204337699198414625928325836300792547598919086330010444969wb,
+      7603664655075175676551887792243938044412742856114886907427675169347553852589402599411290168288930382377283108890322269708884902998253293780483440129483327wb,
+      -10324098565034498465875215630604107238940128063553910460445433007166121079968132667074154355395844552937058899426253790777657675901838010055644316728526393wb,
+      -12236477238783553839340584917720106564483878483173525158555406923388638347150144919001024905877475401353674848301774791298367823029012449896858367218938488wb,
+      9966990594172406012310078765295767555782555285684385899869231608869471023379202086947215337899533069949801311225161562404400717858011700306179102121342515wb,
+      -12983782114594329520373595420695508584715919272703648469298375086460508080215963268729027546042229893937296428010493668720716318664505339275354851120734372wb,
+      -9655954001341551443087909192198932353132996418457245295521644079521230896558300756133292365213357603788911695147437530569709679437147630523365259553067954wb,
+      7072009366582949478473862650011262253783850301083169883440824883235985480601391689101153902500460700035282434290760483209786664550714449512762684388339187wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f4 (2964639554149490973596341394839758078409778829067653681666106821776834568408151111543733982288078570825867875863050348925537769671189456471968723686512034uwb,
+      5957364445683686818410817200949409124779631391545643887373796564697563753416937684648786338497928327653380765964317808469492623477785654419190708204181795uwb,
+      19191677104746999910669997770314557441327241058126327798712726258248174396859949489325836442238807787970653545840621658707862487865809500322706194229135252uwb,
+      24586718166970605619478065808613217078037607297232337682881885486187967367467012073369595089067814569116855119567799143349802467998026209123576080005659752uwb,
+      10462823982820178661190434713437061473290880952772417752401116804833406586088773886481041433195457558834409214235712063242433511929332344716172942804205442uwb,
+      16419753656873030796354060609416030388733546880849213639440646945524833982946459564500329809304700518677496254061943255280441489964246119308925190525772266uwb,
+      10405391186665161836576844847101505242465502880093273915903880455941412499859291312405803977208427105275040816651924471784587928355909534429001102837285163uwb,
+      17157919740278597151158601296325640095140225651359053582867340974133209625747219873488488134575281986967033985073454136035802749428039704256375550535464357uwb);
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/bitint-94.c
@@ -0,0 +1,140 @@
+/* PR middle-end/123635 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 511
+_BitInt(511) a, b, c, d;
+unsigned _BitInt(511) e, f, g, h;
+#endif
+
+#include "../bitintext.h"
+
+#if __BITINT_MAXWIDTH__ >= 511
+[[gnu::noipa]] bool
+f1 (_BitInt(511) q, _BitInt(511) r, _BitInt(511) s, _BitInt(511) t,
+    _BitInt(511) u, _BitInt(511) v, _BitInt(511) w, _BitInt(511) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_mul_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_mul_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_mul_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f2 (unsigned _BitInt(511) q, unsigned _BitInt(511) r, unsigned _BitInt(511) s,
+    unsigned _BitInt(511) t, unsigned _BitInt(511) u, unsigned _BitInt(511) v,
+    unsigned _BitInt(511) w, unsigned _BitInt(511) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_mul_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_mul_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_mul_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+#if __BITINT_MAXWIDTH__ >= 1023
+[[gnu::noipa]] bool
+f3 (_BitInt(1023) q, _BitInt(1023) r, _BitInt(1023) s, _BitInt(1023) t,
+    _BitInt(1023) u, _BitInt(1023) v, _BitInt(1023) w, _BitInt(1023) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &a);
+  BEXTC (a);
+  res |= __builtin_mul_overflow (s, t, &b);
+  BEXTC (b);
+  res |= __builtin_mul_overflow (u, v, &c);
+  BEXTC (c);
+  res |= __builtin_mul_overflow (w, x, &d);
+  BEXTC (d);
+  return res;
+}
+
+[[gnu::noipa]] bool
+f4 (unsigned _BitInt(1023) q, unsigned _BitInt(1023) r,
+    unsigned _BitInt(1023) s, unsigned _BitInt(1023) t,
+    unsigned _BitInt(1023) u, unsigned _BitInt(1023) v,
+    unsigned _BitInt(1023) w, unsigned _BitInt(1023) x)
+{
+  bool res = false;
+  res |= __builtin_mul_overflow (q, r, &e);
+  BEXTC (e);
+  res |= __builtin_mul_overflow (s, t, &f);
+  BEXTC (f);
+  res |= __builtin_mul_overflow (u, v, &g);
+  BEXTC (g);
+  res |= __builtin_mul_overflow (w, x, &h);
+  BEXTC (h);
+  return res;
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 511
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f1 (1390399912725058458200009048198820064492005235154664882378103191585647121798330571086629470693362953212791514491575158989602893218788902339652768462242628wb,
+      249177562235295607181226393168319684003354962277368763264203376508018272147140149371861361061154101827443514415658157865648522550758405852726010180808769wb,
+      -1780354034824880726793039893594299865138723691931754426795433194731471391545042339625233657837435887106690554340836104535849707683265009199435873463559020wb,
+      -740336545197937933670467416719493466419101689845476460441897613938923219348614699785899092241758652210632646359181180435230820349533052964898247331288194wb,
+      1264371856933908934004928210670432922219833109703326669407665736158573607996286450258750907679580905729735376144263375732104941574779989141805339934906103wb,
+      -1800762928143884868360591340947709805381121865559594609800602059770468706915015121333590484473244364203044167384984634798933392092472849088487188206919199wb,
+      -1874437506355165235214302048933351258782970556591446143241539194417790344619692436179305620246514867157285378788470027340983415072326706619779323878095044wb,
+      465089731165341206127432983731596524669687828142734277104372042775063012806153170457800193495447488542433104457447397078966750100194606523184187779891236wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f2 (1769288740652242299842741192560763693851113543365386227639113810655132281658311706354953254148690319453722073610881280531971362644037227748091681178317919uwb,
+      6609813168053391222543030306163941663953801084514170716266507032727748531561564744911045686719066313628734721154746698442483812155667254002473644708866548uwb,
+      2165581935187317546841478283262759103626305739168208417811840048675479552879740382682893926794456473657370285890451624909369445002539226077543796184885282uwb,
+      5583940649350967625413437252987234424283831963591403609577766560068787593281191860443568915932187805635333850527113490331304189378639908270408210201131036uwb,
+      4709767295913180049914868365292708657912010821088789452741841268048043047122882916441448275499420638756517585965684291097104349699944179639251796038947955uwb,
+      6280470013560252695084315130173483896550287179700449102345092527255864285425735025909066687910837200841028187788564127729392389462477148514426504126205653uwb,
+      5729764965697040092309843504303102973344572729567710548288594203184644343090550648393517676044608898029180050379384056057530481830153485215690201926045860uwb,
+      2025545578012992696919009225822788038691815646525577733706021933464568718262575612415581176797970841793616511309641023298056786955966008679910134224064441uwb);
+#endif
+#if __BITINT_MAXWIDTH__ >= 1023
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  f3 (1390399912725058458200009048198820064492005235154664882378103191585647121798330571086629470693362953212791514491575158989602893218788902339652768462242628wb,
+      249177562235295607181226393168319684003354962277368763264203376508018272147140149371861361061154101827443514415658157865648522550758405852726010180808769wb,
+      -1780354034824880726793039893594299865138723691931754426795433194731471391545042339625233657837435887106690554340836104535849707683265009199435873463559020wb,
+      -740336545197937933670467416719493466419101689845476460441897613938923219348614699785899092241758652210632646359181180435230820349533052964898247331288194wb,
+      1264371856933908934004928210670432922219833109703326669407665736158573607996286450258750907679580905729735376144263375732104941574779989141805339934906103wb,
+      -1800762928143884868360591340947709805381121865559594609800602059770468706915015121333590484473244364203044167384984634798933392092472849088487188206919199wb,
+      -1874437506355165235214302048933351258782970556591446143241539194417790344619692436179305620246514867157285378788470027340983415072326706619779323878095044wb,
+      465089731165341206127432983731596524669687828142734277104372042775063012806153170457800193495447488542433104457447397078966750100194606523184187779891236wb);
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f4 (1769288740652242299842741192560763693851113543365386227639113810655132281658311706354953254148690319453722073610881280531971362644037227748091681178317919uwb,
+      6609813168053391222543030306163941663953801084514170716266507032727748531561564744911045686719066313628734721154746698442483812155667254002473644708866548uwb,
+      2165581935187317546841478283262759103626305739168208417811840048675479552879740382682893926794456473657370285890451624909369445002539226077543796184885282uwb,
+      5583940649350967625413437252987234424283831963591403609577766560068787593281191860443568915932187805635333850527113490331304189378639908270408210201131036uwb,
+      4709767295913180049914868365292708657912010821088789452741841268048043047122882916441448275499420638756517585965684291097104349699944179639251796038947955uwb,
+      6280470013560252695084315130173483896550287179700449102345092527255864285425735025909066687910837200841028187788564127729392389462477148514426504126205653uwb,
+      5729764965697040092309843504303102973344572729567710548288594203184644343090550648393517676044608898029180050379384056057530481830153485215690201926045860uwb,
+      2025545578012992696919009225822788038691815646525577733706021933464568718262575612415581176797970841793616511309641023298056786955966008679910134224064441uwb);
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/bitint-95.c
@@ -0,0 +1,26 @@
+/* PR tree-optimization/124988 */
+/* { dg-do run { target bitint } } */
+
+int a;
+#if __BITINT_MAXWIDTH__ >= 192
+unsigned _BitInt(132) b;
+
+unsigned _BitInt(128)
+foo (unsigned _BitInt(192) d)
+{
+  bool o = __builtin_mul_overflow (d, 1, &b);
+  if (!o)
+    __atomic_sub_fetch (&a, 1, 0);
+  return b >> 8;
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 192
+  unsigned _BitInt(128) x = foo (0x1100ffeeddccbbaa998877665544332211wb);
+  if (x != 0x100ffeeddccbbaa9988776655443322wb)
+    __builtin_abort ();
+#endif
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/pr125025.c
@@ -0,0 +1,20 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-fsanitize=undefined" } */
+
+void f2(signed char a0)
+{
+  signed char v4;
+  _Bool c7;
+  signed char v8 = 91;
+  v4 = v8 + v8;
+  v8 = 15 - 50;
+  a0 = v8 * v4;
+  v8 = v4 - a0;
+lbl_br10:
+  c7 = a0 <= 0;
+  if (c7)
+    return;
+  v4 = v8 - 24;
+  a0 = a0 + v4;
+  goto lbl_br10;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/pr125153.c
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+
+int a, b, c;
+_Bool d, e;
+
+void
+foo (void)
+{
+  if (d)
+    {
+    l: b = -1;
+    }
+  e = c <= b;
+  a = a - 7;
+  if (e)
+    goto l;
+}
+
+int
+main ()
+{
+  foo ();
+  if (a != -14)
+    __builtin_abort ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/pr125156.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+
+#include <stdint.h>
+
+int64_t g1, g8;
+
+void g14()
+{
+  int16_t v5;
+  goto lbl_cont30;
+lbl_bf2:
+  g8 = 0;
+lbl_b5:
+  g1 = g1 - 8366249724514421075;
+  switch (v5)
+case 5:
+case 2:
+    goto lbl_b5;
+    goto lbl_bf2;
+lbl_cont30:
+    switch (v5)
+      {
+      case 0: goto lbl_bf2;
+      case 5: goto lbl_b5;
+      }
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/pr125185.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-additional-options "-ftree-vectorize" } */
+/* { dg-additional-options "-mxop" { target { x86_64-*-* || i?86-*-* } } } */
+
+long sum;
+int *coef1;
+
+void ac3_sum_square_butterfly_int32_c(int i, int cap) {
+  for (; i < cap; i++) {
+    int md = i + coef1[i];
+    sum += (long)md * md;
+  }
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/torture/pr125250.c
@@ -0,0 +1,32 @@
+/* { dg-do run } */
+
+short __chk, g9, g6;
+_Bool g0, g1;
+void *g4;
+
+void __attribute__((noipa)) f5(_Bool a2, int a5)
+{
+  void *a1 = &a2;
+lbl_br11:
+  *(_Bool *)a1 = 0;
+  a1 = &a5;
+  if (!a2)
+    {
+      g1 = *(_Bool *)g4;
+      if (g1)
+        {
+          g9 = -g9;
+          goto lbl_br11;
+        }
+    }
+  g6 = a5;
+}
+
+int main()
+{
+  g4 = &g0;
+  f5(0, 8);
+  __chk = g6;
+  if (__chk != 8)
+    __builtin_abort ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/tree-ssa/pr124151.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O1" } */
+
+typedef struct {
+  _Bool : 1;
+} Http2Identifier;
+typedef struct {
+  _Bool is_end;
+  Http2Identifier identifier;
+} Http2DataFrame;
+typedef struct {
+  Http2Identifier identifier;
+  _Bool end_headers;
+} Http2ContinuationFrame;
+typedef struct {
+  union {
+    Http2DataFrame data;
+    Http2ContinuationFrame continuation;
+  };
+} Http2Frame;
+typedef struct {
+  Http2Identifier stream_identifier;
+} Http2RawHeader;
+Http2RawHeader parse_http2_continuation_frame_http2_raw_header;
+Http2Frame gh2f;
+void http2_send_and_receive_preface() {
+  Http2ContinuationFrame continuation_frame = {
+      parse_http2_continuation_frame_http2_raw_header.stream_identifier, 0};
+  Http2Frame frame = {.continuation = continuation_frame};
+  gh2f = frame;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.dg/tree-ssa/pr125259.c
@@ -0,0 +1,14 @@
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-O2 -fdump-tree-forwprop1" } */
+
+typedef __attribute__((__vector_size__(4))) char V4;
+typedef __attribute__((__vector_size__(8))) char V8;
+
+_BitInt(17) foo(V8 *xx)
+{
+	V8 x = *xx;
+	V4 v = *(V4 *)&x;
+	return *(_BitInt(17) *)&v;
+}
+
+/* { dg-final { scan-tree-dump "VIEW_CONVERT_EXPR" "forwprop1" } } */
deleted file mode 100644
--- a/src/gcc/testsuite/gcc.dg/tree-ssa/ssa-thread-23.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/* PR120003 */
-/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-cddce3-details" } */
-
-extern _Bool g(int);
-
-_Bool f()
-{
-  _Bool retval = 0;
-  for(int i=0; i<1000000; ++i)
-    retval = retval || g(i);
-  return retval;
-}
-
-/* Jump threading after loop optimization should get the counting loop
-   separated from the loop until retval is true and CD-DCE elide it.
-   It's difficult to check for the fact that a true retval terminates
-   the loop so check CD-DCE eliminates one loop instead.  */
-/* { dg-final { scan-tree-dump "fix_loop_structure: removing loop" "cddce3" } } */
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/aarch64/narrow-gp-writes-8.c
@@ -0,0 +1,10 @@
+/* PR target/124895 */
+/* { dg-do compile } */
+/* { dg-options "-Os -fpath-coverage -fno-tree-ccp -fprofile-generate -mnarrow-gp-writes" } */
+
+void
+foo (unsigned u)
+{
+  while (u)
+    ;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/aarch64/sve/pr122827.c
@@ -0,0 +1,96 @@
+/* PR target/122827.
+
+   With -msve-vector-bits=128 and SVE-only autovec, the inlined
+   madd_v3 calls are vectorised into SVE partial-mode FMLAs that share
+   a single vec_duplicate of the scalar FAC.
+   Before the fix, the register allocator placed the VNx2SF
+   broadcast in V14 across the call to clobber() because IRA thought
+   V14 was preserved (only the low 64 bits, D14, are callee-saved under
+   AAPCS64).  The SVE FMLA reads the full Z register, so the upper
+   lanes of the broadcast are corrupted by the call and the result of
+   the FMLA is wrong.  */
+
+/* { dg-do run { target aarch64_sve128_hw } } */
+/* { dg-options "-Ofast -msve-vector-bits=128 --param=aarch64-autovec-preference=sve-only" } */
+/* { dg-require-effective-target aarch64_little_endian } */
+
+struct R
+{
+  float combined[3];
+  float spec[3];
+  float diff[3];
+  float diffshad[3];
+  float shad[3];
+};
+
+struct I
+{
+  float fac;
+  int passflag;
+};
+
+/* AAPCS64 only requires callees to preserve the low 64 bits of V8-V15;
+   the upper lanes are caller-clobbered.  The buggy register allocator
+   in this test places the broadcast in V14 specifically, so clobbering
+   V14s upper bits here is sufficient to expose the miscompile.  The
+   asm clobber list lets GCC save/restore D14 around the write, so we
+   honour the ABI contract for the low half while leaving the upper
+   half trashed, what any normal callee is permitted to do.  */
+__attribute__((noipa)) static void
+clobber (struct I *si, struct R *r)
+{
+  asm volatile ("movi v14.16b, #0xff" : : : "v14");
+}
+
+static inline __attribute__((always_inline)) void
+madd_v3 (float r[3], const float a[3], float f)
+{
+  r[0] += a[0] * f;
+  r[1] += a[1] * f;
+  r[2] += a[2] * f;
+}
+
+__attribute__((noipa)) void
+test (struct I *si, struct R *r)
+{
+  struct R t = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 },
+		 { 10, 11, 12 }, { 13, 14, 15 } };
+
+  clobber (si, r);
+  if (si->fac != 0.0f)
+    {
+      float fac = si->fac;
+      clobber (si, &t);
+      madd_v3 (r->combined, t.combined, fac);
+      if (si->passflag & 1)
+	madd_v3 (r->spec, t.spec, fac);
+      if (si->passflag & 2)
+	{
+	  madd_v3 (r->diff, t.diff, fac);
+	  madd_v3 (r->diffshad, t.diffshad, fac);
+	}
+      if (si->passflag & 4)
+	madd_v3 (r->shad, t.shad, fac);
+    }
+}
+
+int
+main (void)
+{
+  struct I si = { 2.0f, 7 };
+  struct R r = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
+		 { 0, 0, 0 }, { 0, 0, 0 } };
+  test (&si, &r);
+  if (r.combined[0] != 2.f || r.combined[1] != 4.f || r.combined[2] != 6.f)
+    __builtin_abort ();
+  if (r.spec[0] != 8.f || r.spec[1] != 10.f || r.spec[2] != 12.f)
+    __builtin_abort ();
+  if (r.diff[0] != 14.f || r.diff[1] != 16.f || r.diff[2] != 18.f)
+    __builtin_abort ();
+  if (r.diffshad[0] != 20.f || r.diffshad[1] != 22.f || r.diffshad[2] != 24.f)
+    __builtin_abort ();
+  if (r.shad[0] != 26.f || r.shad[1] != 28.f || r.shad[2] != 30.f)
+    __builtin_abort ();
+  return 0;
+}
+
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/arm/mve/intrinsics/pr124870.c
@@ -0,0 +1,31 @@
+/* { dg-require-effective-target arm_v8_1m_mve_fp_ok } */
+/* { dg-add-options arm_v8_1m_mve_fp } */
+/* { dg-additional-options "-O2" } */
+
+/* PR target/124870.  */
+
+#include <arm_mve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void fn (int n, uint32_t *strides, float32_t *f)
+{
+    uint32x4_t vecScGathAddr = vld1q_u32(strides);
+    float32x4_t vecA = vldrwq_gather_base_wb_f32(&vecScGathAddr, 64);
+    float32x4_t vecB = vecA;
+    int i;
+    for (i = 0; i < n; ++i)
+    {
+        vecA = vldrwq_gather_base_wb_f32(&vecScGathAddr, 64);
+        vecB = vaddq_f32 (vecB, vecA);
+    }
+    vstrwq_f32 (f, vecB);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* { dg-final { scan-assembler-times "vadd.f32\tq\[0-9\]+, q\[0-9\]+, q\[0-9\]+" 1 } } */
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/fx-to-double.c
@@ -0,0 +1,88 @@
+/* { dg-do run { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+typedef long double DD;
+
+typedef long long _Fract dq_t;
+typedef long long _Accum ta_t;
+typedef long _Accum da_t;
+typedef unsigned long long _Fract udq_t;
+typedef unsigned long long _Accum uta_t;
+typedef unsigned long _Accum uda_t;
+
+#define NI __attribute__((noipa))
+
+#define MK_CONV(T)				\
+  NI DD T##2d (T##_t x)				\
+  {						\
+    __asm ("" : "+r" (x));			\
+    return (DD) x;				\
+  }						\
+						\
+  NI T##_t d2##T (DD x)				\
+  {						\
+    __asm ("" : "+r" (x));			\
+    return (T##_t) x;				\
+  }
+
+
+MK_CONV (da)
+MK_CONV (ta)
+MK_CONV (dq)
+
+MK_CONV (uda)
+MK_CONV (uta)
+MK_CONV (udq)
+
+#define TEST(T)					\
+  do {						\
+    T##_t fx = d2##T (x);			\
+    DD y = T##2d (fx);				\
+    if (y != x)					\
+      __builtin_exit (__LINE__);		\
+  } while (0)
+
+
+NI void test_s (DD x)
+{
+  TEST (da);
+  TEST (ta);
+
+  if (x < 1.0L && x >= -1.0L)
+    TEST (dq);
+}
+
+
+NI void test_u (long double x)
+{
+  TEST (uda);
+  TEST (uta);
+
+  if (x < 1.0L)
+    TEST (udq);
+}
+
+void test (DD x)
+{
+  if (x >= 0)
+    test_u (x);
+
+  test_s (x);
+}
+
+int main (void)
+{
+  test (+0.0L);
+  test (-0.0L);
+
+  test (+1.0L);
+  test (-1.0L);
+
+  test (-0x0.cafe123p0);
+  test (+0x0.cafe123p0);
+
+  test (+0x1234.cafe123p0);
+  test (-0x1234.cafe123p0);
+
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-ssk.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __int24
+#define UU signed
+#define FX _Accum
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-ssr.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __int24
+#define UU signed
+#define FX _Fract
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-suk.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __int24
+#define UU unsigned
+#define FX _Accum
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-sur.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __int24
+#define UU unsigned
+#define FX _Fract
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-usk.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __uint24
+#define UU signed
+#define FX _Accum
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-usr.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __uint24
+#define UU signed
+#define FX _Fract
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-uuk.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __uint24
+#define UU unsigned
+#define FX _Accum
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409-fx24-uur.c
@@ -0,0 +1,8 @@
+/* { dg-do link { target { ! avr_tiny } } } */
+/* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
+
+#define TT __uint24
+#define UU unsigned
+#define FX _Fract
+
+#include "pr125409.h"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/avr/torture/pr125409.h
@@ -0,0 +1,16 @@
+UU FX fx_fun (TT x) { return x; }
+TT fun_fx (UU FX x) { return x; }
+
+short UU FX hfx_fun (TT x) { return x; }
+TT fun_hfx (UU short FX x) { return x; }
+
+long UU FX lfx_fun (TT x) { return x; }
+TT fun_lfx (UU long FX x) { return x; }
+
+long long UU FX llfx_fun (TT x) { return x; }
+TT fun_llfx (UU long long FX x) { return x; }
+
+int main (void)
+{
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/apx-zu-4.c
@@ -0,0 +1,5 @@
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-mapxf -march=x86-64 -O2 -mtune-ctrl=disable_setzucc" } */
+/* { dg-final { scan-assembler-not "setzu" } } */
+
+#include "apx-zu-3.c"
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-10.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-10.c
@@ -9,25 +9,25 @@
 **.LFB0:
 **	.cfi_startproc
 **	cmpq	\$63, %rdx
-**	ja	.L12
+**	ja	.L13
 **.L1:
 **	ret
 **	.p2align 4,,10
 **	.p2align 3
-**.L12:
+**.L13:
 **	movq	%rdi, %rcx
 **	movq	%rsi, %rax
 **	cmpq	\$128, %rdx
-**	jbe	.L13
+**	jbe	.L14
 **	movq	%rdx, %rsi
 **	cmpq	%rdi, %rax
-**	jb	.L6
+**	jb	.L7
 **	je	.L1
 **	movdqu	-16\(%rax,%rdx\), %xmm7
 **	movdqu	-32\(%rax,%rdx\), %xmm6
 **	movdqu	-48\(%rax,%rdx\), %xmm5
 **	movdqu	-64\(%rax,%rdx\), %xmm4
-**.L7:
+**.L8:
 **	movdqu	\(%rax\), %xmm3
 **	subq	\$64, %rsi
 **	addq	\$64, %rcx
@@ -40,7 +40,7 @@
 **	movups	%xmm1, -32\(%rcx\)
 **	movups	%xmm0, -16\(%rcx\)
 **	cmpq	\$64, %rsi
-**	ja	.L7
+**	ja	.L8
 **	movups	%xmm7, -16\(%rdi,%rdx\)
 **	movups	%xmm6, -32\(%rdi,%rdx\)
 **	movups	%xmm5, -48\(%rdi,%rdx\)
@@ -48,7 +48,9 @@
 **	ret
 **	.p2align 4,,10
 **	.p2align 3
-**.L13:
+**.L14:
+**	cmpq	\$64, %rdx
+**	jbe	.L6
 **	movdqu	\(%rsi\), %xmm7
 **	movdqu	16\(%rsi\), %xmm6
 **	movdqu	32\(%rsi\), %xmm5
@@ -69,13 +71,25 @@
 **	.p2align 4,,10
 **	.p2align 3
 **.L6:
+**	movdqu	\(%rsi\), %xmm3
+**	movdqu	16\(%rsi\), %xmm2
+**	movdqu	-16\(%rsi,%rdx\), %xmm1
+**	movdqu	-32\(%rsi,%rdx\), %xmm0
+**	movups	%xmm3, \(%rdi\)
+**	movups	%xmm2, 16\(%rdi\)
+**	movups	%xmm1, -16\(%rdi,%rdx\)
+**	movups	%xmm0, -32\(%rdi,%rdx\)
+**	ret
+**	.p2align 4,,10
+**	.p2align 3
+**.L7:
 **	movdqu	\(%rax\), %xmm3
 **	movdqu	16\(%rax\), %xmm2
 **	leaq	\(%rdi,%rdx\), %rcx
 **	movdqu	32\(%rax\), %xmm1
 **	movdqu	48\(%rax\), %xmm0
 **	addq	%rdx, %rax
-**.L8:
+**.L9:
 **	movdqu	-16\(%rax\), %xmm7
 **	movdqu	-32\(%rax\), %xmm6
 **	subq	\$64, %rsi
@@ -88,7 +102,7 @@
 **	movups	%xmm5, 16\(%rcx\)
 **	movups	%xmm4, \(%rcx\)
 **	cmpq	\$64, %rsi
-**	ja	.L8
+**	ja	.L9
 **	movups	%xmm3, \(%rdi\)
 **	movups	%xmm2, 16\(%rdi\)
 **	movups	%xmm1, 32\(%rdi\)
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-15.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-15.c
@@ -42,7 +42,7 @@
 **	.p2align 3
 **.L5:
 **	cmpl	\$64, %edx
-**	jnb	.L14
+**	ja	.L14
 **	movl	%edx, %edx
 **	movdqu	\(%rsi\), %xmm3
 **	movdqu	16\(%rsi\), %xmm2
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2a.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2a.c
@@ -76,7 +76,7 @@
 **	.p2align 3
 **.L18:
 **	cmpq	\$64, %rdx
-**	jb	.L10
+**	jbe	.L10
 **	movdqu	\(%rsi\), %xmm7
 **	movdqu	16\(%rsi\), %xmm6
 **	movdqu	32\(%rsi\), %xmm5
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2b.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2b.c
@@ -80,7 +80,7 @@
 **	.p2align 3
 **.L19:
 **	cmpq	\$128, %rdx
-**	jb	.L11
+**	jbe	.L11
 **	vmovdqu	\(%rsi\), %ymm7
 **	vmovdqu	32\(%rsi\), %ymm6
 **	vmovdqu	64\(%rsi\), %ymm5
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2c.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2c.c
@@ -83,7 +83,7 @@
 **	.p2align 3
 **.L20:
 **	cmpq	\$256, %rdx
-**	jb	.L12
+**	jbe	.L12
 **	vmovdqu64	\(%rsi\), %zmm7
 **	vmovdqu64	64\(%rsi\), %zmm6
 **	vmovdqu64	-64\(%rsi,%rdx\), %zmm3
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2d.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-2d.c
@@ -94,7 +94,7 @@
 **.L20:
 **	.cfi_def_cfa_offset 40
 **	cmpq	\$32, %rdx
-**	jb	.L9
+**	jbe	.L9
 **	movq	%rbx, \(%rsp\)
 **	movq	%r14, 16\(%rsp\)
 **	.cfi_offset 3, -40
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-3a.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-3a.c
@@ -22,7 +22,7 @@
 **	cmpq	\$128, %rdx
 **	ja	.L5
 **	cmpq	\$64, %rdx
-**	jnb	.L15
+**	ja	.L15
 **	movdqu	\(%rsi\), %xmm3
 **	movdqu	16\(%rsi\), %xmm2
 **	movdqu	-16\(%rsi,%rdx\), %xmm1
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-3b.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-3b.c
@@ -72,7 +72,7 @@
 **	.p2align 3
 **.L17:
 **	cmpq	\$128, %rdx
-**	jb	.L8
+**	jbe	.L8
 **	vmovdqu	\(%rsi\), %ymm7
 **	vmovdqu	32\(%rsi\), %ymm6
 **	vmovdqu	64\(%rsi\), %ymm5
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-3c.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-3c.c
@@ -83,7 +83,7 @@
 **	.p2align 3
 **.L20:
 **	cmpq	\$256, %rdx
-**	jb	.L9
+**	jbe	.L9
 **	vmovdqu64	\(%rsi\), %zmm7
 **	vmovdqu64	64\(%rsi\), %zmm6
 **	vmovdqu64	-64\(%rsi,%rdx\), %zmm3
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-4a.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-4a.c
@@ -50,7 +50,7 @@
 **	.p2align 3
 **.L14:
 **	cmpq	\$64, %rdx
-**	jb	.L6
+**	jbe	.L6
 **	movdqu	\(%rsi\), %xmm7
 **	movdqu	16\(%rsi\), %xmm6
 **	movdqu	32\(%rsi\), %xmm5
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-4b.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-4b.c
@@ -22,7 +22,7 @@
 **	cmpq	\$256, %rdx
 **	ja	.L5
 **	cmpq	\$128, %rdx
-**	jnb	.L16
+**	ja	.L16
 **	vmovdqu	\(%rsi\), %ymm3
 **	vmovdqu	32\(%rsi\), %ymm2
 **	vmovdqu	-32\(%rsi,%rdx\), %ymm1
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-4c.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-4c.c
@@ -73,7 +73,7 @@
 **	.p2align 3
 **.L17:
 **	cmpq	\$256, %rdx
-**	jb	.L8
+**	jbe	.L8
 **	vmovdqu64	\(%rsi\), %zmm7
 **	vmovdqu64	64\(%rsi\), %zmm6
 **	vmovdqu64	-64\(%rsi,%rdx\), %zmm3
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-5b.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-5b.c
@@ -51,7 +51,7 @@
 **	.p2align 3
 **.L15:
 **	cmpq	\$128, %rdx
-**	jb	.L6
+**	jbe	.L6
 **	vmovdqu	\(%rsi\), %ymm7
 **	vmovdqu	32\(%rsi\), %ymm6
 **	vmovdqu	64\(%rsi\), %ymm5
--- a/src/gcc/testsuite/gcc.target/i386/builtin-memmove-5c.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin-memmove-5c.c
@@ -22,7 +22,7 @@
 **	cmpq	\$512, %rdx
 **	ja	.L5
 **	cmpq	\$256, %rdx
-**	jnb	.L16
+**	ja	.L16
 **	vmovdqu64	\(%rsi\), %zmm3
 **	vmovdqu64	64\(%rsi\), %zmm2
 **	vmovdqu64	-64\(%rsi,%rdx\), %zmm1
--- a/src/gcc/testsuite/gcc.target/i386/builtin_target.c
+++ b/src/gcc/testsuite/gcc.target/i386/builtin_target.c
@@ -54,6 +54,10 @@ check_detailed ()
       assert (__builtin_cpu_is ("amd"));
       get_amd_cpu (&cpu_model, &cpu_model2, cpu_features2);
       break;
+    case VENDOR_HYGON:
+      assert (__builtin_cpu_is ("hygon"));
+      get_hygon_cpu (&cpu_model, &cpu_model2, cpu_features2);
+      break;
     default:
       break;
     }
@@ -127,6 +131,8 @@ quick_check ()
 
   assert (__builtin_cpu_is ("bdver2") >= 0);
 
+  assert (__builtin_cpu_is ("c86-4g-m4") >= 0);
+
   return 0;
 }
 
--- a/src/gcc/testsuite/gcc.target/i386/funcspec-56.inc
+++ b/src/gcc/testsuite/gcc.target/i386/funcspec-56.inc
@@ -239,6 +239,9 @@ extern void test_arch_znver3 (void)             __attribute__((__target__("arch=
 extern void test_arch_znver4 (void)             __attribute__((__target__("arch=znver4")));
 extern void test_arch_znver5 (void)             __attribute__((__target__("arch=znver5")));
 extern void test_arch_znver6 (void)             __attribute__((__target__("arch=znver6")));
+extern void test_arch_c86_4g_m4 (void)          __attribute__((__target__("arch=c86-4g-m4")));
+extern void test_arch_c86_4g_m6 (void)          __attribute__((__target__("arch=c86-4g-m6")));
+extern void test_arch_c86_4g_m7 (void)          __attribute__((__target__("arch=c86-4g-m7")));
 
 extern void test_tune_nocona (void)		__attribute__((__target__("tune=nocona")));
 extern void test_tune_core2 (void)		__attribute__((__target__("tune=core2")));
@@ -267,6 +270,9 @@ extern void test_tune_znver3 (void)             __attribute__((__target__("tune=
 extern void test_tune_znver4 (void)             __attribute__((__target__("tune=znver4")));
 extern void test_tune_znver5 (void)             __attribute__((__target__("tune=znver5")));
 extern void test_tune_znver6 (void)             __attribute__((__target__("tune=znver6")));
+extern void test_tune_c86_4g_m4 (void)          __attribute__((__target__("tune=c86-4g-m4")));
+extern void test_tune_c86_4g_m6 (void)          __attribute__((__target__("tune=c86-4g-m6")));
+extern void test_tune_c86_4g_m7 (void)          __attribute__((__target__("tune=c86-4g-m7")));
 
 extern void test_fpmath_sse (void)		__attribute__((__target__("sse2,fpmath=sse")));
 extern void test_fpmath_387 (void)		__attribute__((__target__("sse2,fpmath=387")));
--- a/src/gcc/testsuite/gcc.target/i386/pr117416-2.c
+++ b/src/gcc/testsuite/gcc.target/i386/pr117416-2.c
@@ -9,5 +9,5 @@ void* p;
 void extern
 prefetch_test (void)
 {
-  __builtin_ia32_prefetch (p, 0, 0, 2); /* { dg-warning "invalid forth argument to '__builtin_ia32_prefetch'; using zero" } */
+  __builtin_ia32_prefetch (p, 0, 0, 2); /* { dg-warning "invalid fourth argument to '__builtin_ia32_prefetch'; using zero" } */
 }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr120870-1.c
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-options "-O0 -march=x86-64-v3" } */
+
+void
+ext (long a, long b, long c, long d, long e, long f, long g)
+{
+}
+
+void
+tail (long a, long b)
+{
+}
+
+__attribute__ ((preserve_none)) void
+caller (long a, long b, long c, long d, long e, long f, long g)
+{
+  __attribute__ ((aligned (32))) long x[4]; // for stack alignment
+  ext (a, b, c, d, e, f, g);
+  __attribute__ ((musttail)) return tail (a + b, b + c);
+}
+
+__attribute__ ((noipa))
+static void
+do_test ()
+{
+  caller (1, 2, 3, 4, 5, 6, 7);
+}
+
+int
+main (void)
+{
+  if (__builtin_cpu_supports ("x86-64-v3"))
+    do_test ();
+  return 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr120870-2.c
@@ -0,0 +1,6 @@
+/* { dg-do run } */
+/* { dg-options "-O0 -march=x86-64-v3" } */
+
+#define preserve_none no_callee_saved_registers
+
+#include "pr120870-1.c"
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr124316.c
@@ -0,0 +1,14 @@
+/* { dg-do compile { target { ! ia32 } } } */
+/* { dg-options "-mptwrite" } */
+#include <x86gprintrin.h>
+
+unsigned long long ull;
+unsigned u;
+void foo()
+{
+    _ptwrite64(ull);
+    _ptwrite32(u);
+}
+
+/* { dg-final { scan-assembler-times "ptwritel" 1 } } */
+/* { dg-final { scan-assembler-times "ptwriteq" 1 } } */
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr125180.c
@@ -0,0 +1,14 @@
+/* PR target/125180 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -masm=att" } */
+/* { dg-final { scan-assembler "\ttestl\t\\\$1, \\\(" } } */
+/* { dg-final { scan-assembler-not "\ttestb\t\\\$1, \\\(" } } */
+
+void foo (void);
+
+void
+bar (unsigned volatile *x)
+{
+  if (*x & 1)
+    foo ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr125308.c
@@ -0,0 +1,12 @@
+/* PR target/125308 */
+/* { dg-do compile } */
+/* { dg-options "-msse2 -O2 -ffloat-store" } */
+
+float a[4];
+
+void
+foo ()
+{
+  for (int i = 0; i < 4; i++)
+    a[i] = a[i] > 0 ? a[i] : 0;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr125351.c
@@ -0,0 +1,3 @@
+/* { dg-do compile } */
+/* { dg-options "-mptwrite -masm=intel" } */
+void foo() { __builtin_ia32_ptwrite32(0); }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr125355-2.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -mtune=generic" } */
+/* { dg-add-options check_function_bodies } */
+/* Keep labels and directives ('.cfi_startproc', '.cfi_endproc').  */
+/* { dg-final { check-function-bodies "**" "" "" { target "*-*-*" } {^\t?\.} } } */
+
+/*
+**foo.cold:
+**...
+**	call	memmove
+**	call	abort
+**	.cfi_endproc
+**...
+*/
+
+#include <stddef.h>
+#include <string.h>
+
+void
+foo (char *d, char *s, size_t n)
+{
+  if (n < 80)
+    {
+      memmove (d, s, n);
+      __builtin_abort ();
+    }
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/pr125355.c
@@ -0,0 +1,23 @@
+/* { dg-do compile } */
+/* { dg-options "-Os -mtune=generic" } */
+/* { dg-add-options check_function_bodies } */
+/* Keep labels and directives ('.cfi_startproc', '.cfi_endproc').  */
+/* { dg-final { check-function-bodies "**" "" "" { target "*-*-*" } {^\t?\.} } } */
+
+/*
+**foo:
+**.LFB0:
+**	.cfi_startproc
+**	jmp	memmove
+**	.cfi_endproc
+**...
+*/
+
+#include <stddef.h>
+#include <string.h>
+
+void
+foo (char *d, char *s, size_t n)
+{
+  memmove(d, s, n);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/i386/ssse3-pr125611.c
@@ -0,0 +1,12 @@
+/* PR target/125611 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -mssse3 -mno-sse4.1" } */
+
+typedef __attribute__((__vector_size__(16))) short V;
+struct __attribute__((__packed__)) { V v[4]; } *u;
+
+void
+foo (void)
+{
+  u->v[2] &= __builtin_ia32_pmulhrsw128 (u->v[0], u->v[1]);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/loongarch/pr125049.c
@@ -0,0 +1,50 @@
+/* PR 125049: ensure stack canary and its address are not leaked.  */
+/* { dg-options "-O2 -fstack-protector-strong -ffixed-r30 -ffixed-r31" } */
+/* { dg-do run } */
+/* { dg-require-effective-target fstack_protector } */
+
+extern long __stack_chk_guard;
+register long s7 asm ("s7"), *s8 asm ("s8");
+
+[[gnu::zero_call_used_regs ("all"), gnu::noipa]] void
+init_test (void)
+{
+  s7 = __stack_chk_guard;
+  s8 = &__stack_chk_guard;
+}
+
+[[gnu::always_inline]] static inline void
+check_reg (void)
+{
+#pragma GCC unroll 30
+  for (int i = 4; i < 30; i++)
+    asm goto (
+      "beq $r%0,$s7,%l[error]\n\t"
+      "beq $r%0,$s8,%l[error]\n\t"
+      :
+      : "i" (i)
+      :
+      : error
+    );
+  return;
+error:
+  __builtin_trap ();
+}
+
+[[gnu::noipa]] void
+test (void)
+{
+  char buf[256];
+  asm ("":"+m"(buf));
+
+  check_reg ();
+}
+
+int
+main (void)
+{
+  init_test ();
+  test ();
+
+  check_reg ();
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/loongarch/vector/lasx/pr125057.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-mlasx -O2" } */
+
+#include <lasxintrin.h>
+#include <lsxintrin.h>
+
+#define TEST(to, from)								\
+__m256i										\
+vext2xv_##to##_##from (const short *p)						\
+{										\
+  return __lasx_vext2xv_##to##_##from (__lasx_cast_128 (__lsx_vld (p, 0)));	\
+}
+
+TEST (h, b)
+TEST (w, b)
+TEST (d, b)
+TEST (w, h)
+TEST (d, h)
+TEST (d, w)
+TEST (hu, bu)
+TEST (wu, bu)
+TEST (du, bu)
+TEST (wu, hu)
+TEST (du, hu)
+TEST (du, wu)
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/loongarch/vector/lsx/lsx-mov-2.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-mlsx -O2" } */
+
+#include <lsxintrin.h>
+
+extern __m128i bar (void);
+extern int *p;
+
+void
+foo ()
+{
+  __lsx_vst (bar(), (void *)p, 0);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/or1k/pr125155.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+int __pthread_keys_0_0;
+int
+___pthread_key_delete (void)
+{
+  int result = 22;
+  int __atg3_old = 0;
+  if (__atomic_compare_exchange_n (&__pthread_keys_0_0, &__atg3_old,
+				   0, 0, 2, 0))
+    result = 0;
+  return result;
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/riscv/pr124984.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-mcpu=thead-c906 -ftracer -fno-tree-dominator-opts -O2 -fharden-conditional-branches" } */
+
+int g;
+
+void
+foo(int s)
+{
+  g = 0x258d9b711584058072a68c6c9d0ff404fd077b87d59ee75dd2e349825d3a288c61a054e3aa1804c26adb2b9ce2287f17888af3aca18a430bcb4f334672553aecd010e5618a1293691bfd6f3e1d0d8ea3dbdb9176a53d1f657032263707cae4e5e70badc7769309b006495fbd3e76ca25f4d02df66107dc351e928wb >> (s & 1023);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/riscv/pr125320.c
@@ -0,0 +1,10 @@
+/* { dg-do assemble } */
+/* { dg-options "-O2 -mabi=lp64d -march=rv64gc_xtheadmemidx -fstack-protector-strong" } */
+
+void __gen_tempname (char *, int, int, int);
+void
+tempnam ()
+{
+  char buf[4096];
+  __gen_tempname (buf, 0, 0, 2);
+}
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr125215.c
@@ -0,0 +1,24 @@
+/* { dg-do run { target { riscv_v } } } */
+/* { dg-options "-O3 -march=rv64gcv -mabi=lp64d -fno-vect-cost-model" } */
+
+#include <stdint-gcc.h>
+
+__attribute__((noipa)) 
+void foo(uint8_t *d) 
+{
+  d[0] = 128; d[1] = 135; d[2] = 130; d[3] = 149;
+  d[4] = 132; d[5] = 163; d[6] = 134; d[7] = 177;
+  d[8] = 136; d[9] = 191; d[10] = 138; d[11] = 205;
+  d[12] = 140; d[13] = 219; d[14] = 142; d[15] = 233;
+}
+
+int main()
+{
+  uint8_t d[16];
+  uint8_t e[] = {128, 135, 130, 149, 132, 163, 134, 177, 136, 191, 138, 205, 140, 219, 142, 233};
+  foo(d);
+  for (int i = 0; i < 16; i++)
+    if (d[i] != e[i])
+      __builtin_abort ();
+  return 0;
+}
deleted file mode 100644
--- a/src/gcc/testsuite/gcc.target/riscv/rvv/autovec/slp-interleave-1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-vect-cost-model -mrvv-max-lmul=m8 -O3 -fdump-tree-optimized-details" } */
-
-struct S { int a, b; } s[8];
-
-void
-foo ()
-{
-  int i;
-  for (i = 0; i < 8; i++)
-    {
-      s[i].b = 0;
-      s[i].a = i;
-    }
-}
-
-/* { dg-final { scan-tree-dump-times "\{ 0, 0, 1, 0, 2, 0, ... \}" 1 "optimized" } } */
deleted file mode 100644
--- a/src/gcc/testsuite/gcc.target/riscv/rvv/autovec/slp-interleave-2.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-vect-cost-model -mrvv-max-lmul=m8 -O3 -fdump-tree-optimized-details" } */
-
-struct S { int a, b; } s[8];
-
-void
-foo ()
-{
-  int i;
-  for (i = 0; i < 8; i++)
-    {
-      s[i].b = 1;
-      s[i].a = i;
-    }
-}
-
-/* { dg-final { scan-tree-dump-times "\{ 0, 1, 1, 1, 2, 1, ... \}" 1 "optimized" } } */
-/* { dg-final { scan-assembler-times {slli\t[a-x0-9]+,\s*[a-x0-9]+,\s*32} 1 } } */
deleted file mode 100644
--- a/src/gcc/testsuite/gcc.target/riscv/rvv/autovec/slp-interleave-3.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-march=rv64gcv_zvl1024b -mabi=lp64d -fno-vect-cost-model -mrvv-max-lmul=m8 -O3 -fdump-tree-optimized-details" } */
-
-struct S { int a, b; } s[8];
-
-void
-foo ()
-{
-  int i;
-  for (i = 0; i < 8; i++)
-    {
-      s[i].b = i*3 + 100;
-      s[i].a = i + 200;
-    }
-}
-
-/* { dg-final { scan-tree-dump-times "\{ 200, 100, 201, 103, 202, 106, ... \}" 1 "optimized" } } */
-/* { dg-final { scan-assembler-times {vsll\.vx} 1 } } */
-/* { dg-final { scan-assembler-times {vor\.vv} 1 } } */
deleted file mode 100644
--- a/src/gcc/testsuite/gcc.target/riscv/rvv/autovec/slp-interleave-4.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-march=rv64gc_zve32f_zvl1024b -mabi=lp64d -fno-vect-cost-model -mrvv-max-lmul=m8 -O3 -fdump-tree-optimized-details" } */
-
-struct S { int a, b; } s[8];
-
-void
-foo ()
-{
-  int i;
-  for (i = 0; i < 8; i++)
-    {
-      s[i].b = i*3 + 100;
-      s[i].a = i + 200;
-    }
-}
-
-/* { dg-final { scan-tree-dump-times "\{ 200, 100, 201, 103, 202, 106, ... \}" 1 "optimized" } } */
-/* { dg-final { scan-assembler-times {vand\.vi} 1 } } */
-/* { dg-final { scan-assembler-times {vmseq\.vi} 1 } } */
deleted file mode 100644
--- a/src/gcc/testsuite/gcc.target/riscv/rvv/autovec/slp-interleave-5.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-march=rv64gcv_zvl1024b -mabi=lp64d -O3 -fdump-tree-optimized-details" } */
-
-struct S { int a, b; } s[8];
-
-void
-foo ()
-{
-  int i;
-  for (i = 0; i < 8; i++)
-    {
-      s[i].b = 1;
-      s[i].a = i+1;
-    }
-}
-
-/* { dg-final { scan-tree-dump-times "\{ 1, 1, 2, 1, 3, 1, 4, 1 \}" 1 "optimized" } } */
-/* { dg-final { scan-assembler {vid\.v} } } */
-/* { dg-final { scan-assembler {vadd\.v} } } */
-/* { dg-final { scan-assembler {vor\.v} } } */
-
-void
-foo2 ()
-{
-  int i;
-  for (i = 0; i < 8; i++)
-    {
-      s[i].b = 0;
-      s[i].a = i+1;
-    }
-}
-
-/* { dg-final { scan-tree-dump-times "\{ 1, 0, 2, 0, 3, 0, 4, 0 \}" 1 "optimized" } } */
-/* { dg-final { scan-assembler {vid\.v} } } */
-/* { dg-final { scan-assembler {vadd\.v} } } */
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gdc.dg/pr125089.d
@@ -0,0 +1,20 @@
+// { dg-do compile }
+struct R125089
+{
+    S125089.T st;
+}
+
+struct S125089
+{
+    struct T
+    {
+        void* v;
+        ~this() {}
+    }
+
+    T t;
+    this(R125089 r)
+    {
+        this.t = r.st;
+    }
+}
--- a/src/gcc/testsuite/gdc.test/compilable/dtoh_TemplateDeclaration.d
+++ b/src/gcc/testsuite/gdc.test/compilable/dtoh_TemplateDeclaration.d
@@ -336,7 +336,7 @@ struct NotAA(T)
     T[foo(1)] calcBuffer;
 }
 
-// Same name but hidden by the template paramter
+// Same name but hidden by the template parameter
 extern (D) struct Buffer {}
 extern (D) struct ActualBuffer {}
 
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/argument_checking_28.f90
@@ -0,0 +1,45 @@
+! { dg-do compile }
+! { dg-additional-options "-std=f2018 -Wcharacter-truncation" }
+!
+! PR fortran/125393 - checking of passed character length
+
+module test
+  implicit none
+contains
+
+  subroutine a(string)
+    character(len=2) string
+  end subroutine a
+
+  subroutine b
+    character(len=2)               :: s1
+    character(len=2), dimension(2) :: s2
+    character(len=1)               :: s3(2)
+    character(len=4)               :: s4
+    call a(s1)
+    call a(s1(1:2))
+    call a(s2(1)) ! This gave a bogus warning
+    call a(s2(1)(1:2))
+    call a(s3(1)) ! { dg-error "Character length of actual argument shorter" }
+    call a(s4(1:2))
+    call a(c1())  ! { dg-error "Character length of actual argument shorter" }
+    call a(c2())
+    call a(c3())  ! { dg-warning "Character length of actual argument longer" }
+  end subroutine b
+
+  function c1 ()
+    character(len=1) :: c1
+    c1 = "a"
+  end function c1
+
+  function c2 ()
+    character(len=2) :: c2
+    c2 = "ab"
+  end function c2
+
+  function c3 ()
+    character(len=3) :: c3
+    c3 = "abc"
+  end function c3
+
+end module test
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/block_proc_ptr_1.f90
@@ -0,0 +1,43 @@
+! { dg-do run }
+! PR fortran/105582
+! Procedure pointer declared inside a BLOCK construct in a program that has
+! contained procedures used to cause an ICE in convert_nonlocal_reference_op
+! (tree-nested.cc) because get_proc_pointer_decl erroneously called
+! gfc_add_decl_to_parent_function instead of gfc_add_decl_to_function,
+! leaving the decl with DECL_CONTEXT set to NULL instead of the enclosing
+! program's function_decl.
+
+module iface_m
+  implicit none
+  abstract interface
+    pure function init_i(x) result(y)
+      double precision, intent(in) :: x(:)
+      double precision, allocatable :: y(:)
+    end function
+  end interface
+end module
+
+program test_block_proc_ptr
+  use iface_m, only : init_i
+  implicit none
+  integer :: n = 0
+
+  block
+    procedure(init_i), pointer :: p
+    double precision, allocatable :: vals(:)
+    p => linear
+    vals = p([1d0, 2d0, 3d0])
+    if (any(abs(vals - [1d0, 2d0, 3d0]) > 1d-10)) n = n + 1
+  end block
+
+  if (n /= 0) stop 1
+
+contains
+
+  pure function linear(x) result(y)
+    double precision, intent(in) :: x(:)
+    double precision, allocatable :: y(:)
+    y = x
+  end function
+
+end program
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/bounds_check_29.f90
@@ -0,0 +1,62 @@
+! { dg-do run }
+! { dg-additional-options "-fcheck=bounds" }
+!
+! Check that if an array descriptor reference uses variables, they are
+! not used uninitialized by the bounds-checking code.
+
+
+! PR fortran/125192
+! Original example from Philippe Wautelet <philippe.wautelet at cnrs dot fr>
+
+subroutine boundcheck_bug
+  implicit none
+
+  type isba_pe_t
+    real, pointer, dimension(:,:) :: xwg
+  end type isba_pe_t
+  type isba_npe_t
+    type(isba_pe_t), dimension(:), pointer :: al=>null()
+  end type isba_npe_t
+  type(isba_npe_t) :: npe
+
+  allocate(npe%al(10))
+  allocate(npe%al(1)%xwg(3,4))
+
+  call random_number( npe%al(1)%xwg(:,3) )
+end subroutine boundcheck_bug
+
+
+! PR fortran/125198
+! Original example from Neil Carlson <neil.n.carlson at gmail dot com>
+
+module unstr_mesh_type
+  type unstr_mesh
+    real, allocatable :: normal(:,:)
+  contains
+    procedure :: compute_geometry
+  end type
+contains
+  subroutine compute_geometry(this)
+    class(unstr_mesh), intent(inout) :: this
+    character(64) :: buf
+    !print *, this%normal(1,1) ! THIS IS OKAY
+    write(buf,*) this%normal(1,1)
+    if (trim(buf) /= '   0.00000000') error stop 1
+    !print *, this%normal(:,1) ! SPURIOUS BOUNDS ERROR HERE
+    write(buf,*) this%normal(:,1)
+    if (trim(buf) /= '   0.00000000       0.00000000       0.00000000') error stop 2
+    !if (any(this%normal(:,1) /= 0.0)) error stop 2
+  end subroutine
+end module
+
+subroutine test_pr125198
+use unstr_mesh_type
+type(unstr_mesh) :: mesh
+allocate(mesh%normal(3,10), source=0.0)
+call mesh%compute_geometry
+end subroutine
+
+
+call boundcheck_bug
+call test_pr125198
+end
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/coarray/pr125021.f90
@@ -0,0 +1,21 @@
+!{ dg-do run }
+
+! Contributed by Neil Carlson  <neil.n.carlson@gmail.com>
+! Test for PR fortran/125021
+
+type box
+  integer, allocatable :: data(:)
+end type
+type(box), allocatable :: buffer[:]
+
+integer :: i, n
+
+allocate(buffer[*])
+allocate(buffer%data(1), source=this_image())
+sync all
+
+i = 1 + modulo(this_image(), num_images())
+n = buffer[i]%data(1)
+if (n /= i ) error stop
+end
+
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/dtio_37.f90
@@ -0,0 +1,36 @@
+! { dg-do run }
+! { dg-additional-options "-O2" }
+!
+! PR fortran/125059 - derived type IO and automatic deallocation
+! PR fortran/111952
+
+module m
+  type t
+     integer :: i = 42
+   contains
+     procedure :: w
+     generic :: write(formatted) => w
+  end type t
+contains
+  subroutine w(dtv,unit,iotype,v_list,iostat,iomsg)
+    class(t),        intent(in)    :: dtv
+    integer,         intent(in)    :: unit
+    character(len=*),intent(in)    :: iotype
+    integer,         intent(in)    :: v_list(:)
+    integer,         intent(out)   :: iostat
+    character(len=*),intent(inout) :: iomsg
+    write(unit,*,iostat=iostat,iomsg=iomsg) dtv%i
+  end subroutine w
+end
+
+program p
+  use m
+  call f()
+  call f()
+contains
+  subroutine f()
+    type(t), allocatable :: a(:)
+    allocate (a(1))
+    print *, a(1)
+  end subroutine f
+end
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/inline_matmul_27.f90
@@ -0,0 +1,63 @@
+! { dg-do run }
+! { dg-options "-O2 -fcheck=bounds -fno-automatic" }
+! PR fortran/106546 - FE temporaries have to be automatic
+! Original test case by Solomon Gibbs
+
+subroutine do_multiply()
+  implicit none
+  
+  integer :: rank
+  real(8) :: draw
+
+  real(8) :: x1(6), x2(6)
+  real(8), allocatable :: K(:,:), J(:,:), z(:)
+
+  character(len=300) :: out
+  ! Randomly select rank of operation 0 ... 6
+  call random_number(draw)
+  if (draw .lt. 1/7.0d0) then
+     rank = 0
+  elseif (draw .lt. 2/7.0d0) then
+     rank = 1
+  elseif (draw .lt. 3/7.0d0) then
+     rank = 2
+  elseif (draw .lt. 4/7.0d0) then
+     rank = 3
+  elseif (draw .lt. 5/7.0d0) then
+     rank = 4
+  elseif (draw .lt. 6/7.0d0) then
+     rank = 5
+  else
+     rank = 6
+  endif
+
+  allocate(K(rank, 6))
+  allocate(J(rank, rank))
+  allocate(z(rank))
+
+  call random_number(x1)
+  call random_number(x2)
+  call random_number(K)
+  call random_number(J)
+  call random_number(z)
+
+  ! multiply allocatables using array temporaries
+  ! Problem occurs here
+  z = matmul(J, matmul(K, x2 - x1))
+
+  ! Output z to prevent optimizer elimination
+  write (out,*) rank," ",z
+
+  deallocate(z, J, K)
+  
+end subroutine do_multiply
+  
+program bogus
+  implicit none
+
+  integer :: i
+  do i=1,100
+     call do_multiply()
+  end do
+  
+end program bogus
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/loc_3.f90
@@ -0,0 +1,36 @@
+! { dg-do compile }
+! { dg-additional-options "-O1" }
+!
+! PR fortran/125606
+!
+! Derived from Fujitsu testsuite
+! Reported by David Binderman
+
+module m
+  implicit none
+  type ty
+     class(*), allocatable :: c1(:)
+  end type ty
+  type tt
+     class(*), allocatable :: node1(:)
+  end type tt
+  type,extends(tt)::tte
+     class(*), allocatable :: c2e(:)
+  end type tte
+contains
+  subroutine put_addr
+    class(*), allocatable :: t(:)
+    integer :: unit
+    select type (t)
+    class is (tt)
+       select type (p=>t(2)%node1)
+       class is (ty)
+          write (unit) loc(p(2)%c1)
+       end select
+       select type (t)
+       type is (tte)
+          write (7) loc(t(2)%c2e)
+       end select
+    end select
+  end subroutine put_addr
+end module m
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/namelist_102.f90
@@ -0,0 +1,248 @@
+! { dg-do run }
+! { dg-additional-options "-O2" }
+!
+! PR fortran/125095 - test namelist read with comments
+!
+! Based on testcases by Andy Nelson and Steven G. Kargl
+
+program nmlbug
+  implicit none
+  call test_int
+  call test_real
+  call test_complex
+  call test_logical
+  call test_char
+
+contains
+
+  subroutine test_int
+
+    integer :: array(4), barray(4), carray(4), darray(4)
+
+    namelist/nml1/  array
+    namelist/nml2/ barray
+    namelist/nml3/ carray
+    namelist/nml4/ darray
+
+    open(10,status='scratch')
+    write(10,'(A)') '&nml1'
+    write(10,'(A)') '  array = 1, 2, 3, 4,'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml2'
+    write(10,'(A)') '  barray = 5,    ! comment'
+    write(10,'(A)') '           6,'
+    write(10,'(A)') '           7     ! another comment'
+    write(10,'(A)') '           8,'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml3'
+    write(10,'(A)') '  carray =  9     ! New comment'
+    write(10,'(A)') '           10'
+    write(10,'(A)') '           11     ! another new comment'
+    write(10,'(A)') '           12'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml4'
+    write(10,'(A)') '  darray = 13, 14, 15, 16,'
+    write(10,'(A)') '/'
+    flush(10)
+    rewind(10)
+
+    read(10,nml1)
+    if (any( array /= [ 1,  2,  3,  4])) stop 1
+    read(10,nml2)
+    if (any(barray /= [ 5,  6,  7,  8])) stop 2
+    read(10,nml3)
+    if (any(carray /= [ 9, 10, 11, 12])) stop 3
+    read(10,nml4)
+    if (any(darray /= [13, 14, 15, 16])) stop 4
+    close(10)
+
+  end subroutine test_int
+
+  subroutine test_real
+
+    real :: array(4), barray(4), carray(4), darray(4)
+
+    namelist/nml1/  array
+    namelist/nml2/ barray
+    namelist/nml3/ carray
+    namelist/nml4/ darray
+
+    open(10,status='scratch')
+    write(10,'(A)') '&nml1'
+    write(10,'(A)') '  array = 1, 2, 3, 4,'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml2'
+    write(10,'(A)') '  barray = 5,    ! comment'
+    write(10,'(A)') '           6,'
+    write(10,'(A)') '           7     ! another comment'
+    write(10,'(A)') '           8,'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml3'
+    write(10,'(A)') '  carray =  9     ! New comment'
+    write(10,'(A)') '           10'
+    write(10,'(A)') '           11     ! another new comment'
+    write(10,'(A)') '           12'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml4'
+    write(10,'(A)') '  darray = 13, 14, 15, 16,'
+    write(10,'(A)') '/'
+    flush(10)
+    rewind(10)
+
+    read(10,nml1)
+    if (any( array /= [ 1,  2,  3,  4])) stop 1
+    read(10,nml2)
+    if (any(barray /= [ 5,  6,  7,  8])) stop 2
+    read(10,nml3)
+    if (any(carray /= [ 9, 10, 11, 12])) stop 3
+    read(10,nml4)
+    if (any(darray /= [13, 14, 15, 16])) stop 4
+    close(10)
+
+  end subroutine test_real
+
+  subroutine test_complex
+
+    complex :: array(4), barray(4), carray(4), darray(4)
+
+    namelist/nml1/  array
+    namelist/nml2/ barray
+    namelist/nml3/ carray
+    namelist/nml4/ darray
+
+    open(10,status='scratch')
+    write(10,'(A)') '&nml1'
+    write(10,'(A)') '  array = (1,0), (2,0), (3,0), (4,0),'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml2'
+    write(10,'(A)') '  barray = (5,0),    ! comment'
+    write(10,'(A)') '           (6,0),'
+    write(10,'(A)') '           (7,0)     ! another comment'
+    write(10,'(A)') '           (8,0),'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml3'
+    write(10,'(A)') '  carray =  (9,0)     ! New comment'
+    write(10,'(A)') '           (10,0)'
+    write(10,'(A)') '           (11,0)     ! another new comment'
+    write(10,'(A)') '           (12,0)'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml4'
+    write(10,'(A)') '  darray = (13,0), (14,0), (15,0), (16,0),'
+    write(10,'(A)') '/'
+    flush(10)
+    rewind(10)
+
+    read(10,nml1)
+    if (any( array /= [ 1,  2,  3,  4])) stop 1
+    read(10,nml2)
+    if (any(barray /= [ 5,  6,  7,  8])) stop 2
+    read(10,nml3)
+    if (any(carray /= [ 9, 10, 11, 12])) stop 3
+    read(10,nml4)
+    if (any(darray /= [13, 14, 15, 16])) stop 4
+    close(10)
+
+  end subroutine test_complex
+
+  subroutine test_logical
+
+    logical :: array(4), barray(4), carray(4), darray(4)
+
+    namelist/nml1/  array
+    namelist/nml2/ barray
+    namelist/nml3/ carray
+    namelist/nml4/ darray
+
+    open(10,status='scratch')
+    write(10,'(A)') '&nml1'
+    write(10,'(A)') '  array = T,F,F,T'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml2'
+    write(10,'(A)') '  barray = T,    ! comment'
+    write(10,'(A)') '           F,'
+    write(10,'(A)') '           F     ! another comment'
+    write(10,'(A)') '           T,'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml3'
+    write(10,'(A)') '  carray =  T     ! New comment'
+    write(10,'(A)') '            F'
+    write(10,'(A)') '            F     ! another new comment'
+    write(10,'(A)') '            T'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml4'
+    write(10,'(A)') '  darray =  T,F,F,T'
+    write(10,'(A)') '/'
+    flush(10)
+    rewind(10)
+
+    read(10,nml1)
+    if (any( array .neqv. [ .true.,.false.,.false.,.true. ])) stop 1
+    read(10,nml2)
+    if (any(barray .neqv. [ .true.,.false.,.false.,.true. ])) stop 2
+    read(10,nml3)
+    if (any(carray .neqv. [ .true.,.false.,.false.,.true. ])) stop 3
+    read(10,nml4)
+    if (any(darray .neqv. [ .true.,.false.,.false.,.true. ])) stop 4
+    close(10)
+
+  end subroutine test_logical
+
+  subroutine test_char
+
+    character(8) :: array(4), barray(4), carray(4), darray(4)
+
+    namelist/nml1/  array
+    namelist/nml2/ barray
+    namelist/nml3/ carray
+    namelist/nml4/ darray
+
+    open(10,status='scratch')
+    write(10,'(A)') '&nml1'
+    write(10,'(A)') '  array = "a", "b", "c", "d",'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml2'
+    write(10,'(A)') '  barray = "a",    ! comment'
+    write(10,'(A)') '           "b",'
+    write(10,'(A)') '           "c"     ! another comment'
+    write(10,'(A)') '           "d",'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml3'
+    write(10,'(A)') '  carray = "a"     ! New comment'
+    write(10,'(A)') '           "b"'
+    write(10,'(A)') '           "c"     ! another new comment'
+    write(10,'(A)') '           "d"'
+    write(10,'(A)') '/'
+    write(10,*)
+    write(10,'(A)') '&nml4'
+    write(10,'(A)') '  darray = "a", "b", "c", "d",'
+    write(10,'(A)') '/'
+    flush(10)
+    rewind(10)
+
+    read(10,nml1)
+    if (any( array /= [ "a", "b", "c", "d" ])) stop 1
+    read(10,nml2)
+    if (any(barray /= [ "a", "b", "c", "d" ])) stop 2
+    read(10,nml3)
+    if (any(carray /= [ "a", "b", "c", "d" ])) stop 3
+    read(10,nml4)
+    if (any(darray /= [ "a", "b", "c", "d" ])) stop 4
+    close(10)
+
+  end subroutine test_char
+
+end program nmlbug
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/pdt_92.f03
@@ -0,0 +1,25 @@
+! { dg-do compile }
+! { dg-options "-fdump-tree-original" }
+!
+! Test the fix for pr125669, in which the components 'v' and 'c' below were
+! allocated and freed unnecessarily.
+!
+module m
+  implicit none
+  type :: t(k1, k2)
+    integer, kind :: k1, k2
+    real :: v(k1*k2, max(k1,k2))
+    character(len = k1+k2-1) :: c
+  end type
+end module
+
+program p
+  use m
+  implicit none
+  integer, parameter :: n=3, k=2
+  type(t(n,k)) :: x
+  if (any (shape(x%v) /= [6,3])) stop 1
+  if (len(x%c) /= 4) stop 2
+end program
+! { dg-final { scan-tree-dump-times "__builtin_malloc" 0 "original" } }
+! { dg-final { scan-tree-dump-times "__builtin_free" 0 "original" } }
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/pr115260.f90
@@ -0,0 +1,35 @@
+! { dg-do run }
+! PR 115260 - this got corrupted output.
+! Original test case by Steve Mullerworth
+
+program usegnufields
+  implicit none
+  type :: field_type
+    real,    allocatable :: data(:)
+    integer, allocatable :: idata(:)
+  end type field_type
+  type :: fieldholder
+    type(field_type) :: fieldset(2,4)
+  end type fieldholder
+  type(fieldholder) :: myfields
+
+  allocate(myfields%fieldset(2,1)%data(3))
+  allocate(myfields%fieldset(2,1)%idata(3))
+  myfields%fieldset(2,1)%data =1.0
+  myfields%fieldset(2,1)%idata=2
+
+  call setfields (myfields%fieldset(2,1:4))
+!  print *,'After calling setfields with fieldset(2,1:4)'
+!  print *,myfields%fieldset(2,1)%data
+!  print *,myfields%fieldset(2,1)%idata
+  if (any (myfields%fieldset(2,1)%data  /= 1.0)) stop 1
+  if (any (myfields%fieldset(2,1)%idata /= 2  )) stop 2
+
+contains
+  subroutine setfields (fieldset)
+    type(field_type), intent(inout) :: fieldset(1:4) ! corruption with -O
+!    print *,'In setfields:'
+!    print *,fieldset(1)%data
+!    print *,fieldset(1)%idata
+  end subroutine setfields
+end
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/pr125117.f90
@@ -0,0 +1,23 @@
+! { dg-do run }
+! { dg-options "-O0" }
+! PR fortran/125117
+
+program test
+  implicit none
+  character(len=64) :: fixed
+  character(:), allocatable :: got
+  fixed = 'hello world'
+  got = getName(fixed)
+  if (trim(got) == 'hello world') then
+    print *, 'PASS'
+  else
+    print *, 'FAIL: got=[', trim(got), ']'
+    call abort()
+  end if
+contains
+  function getName(fixed) result(name)
+    character(len=64), intent(in) :: fixed
+    character(:), allocatable :: name
+    name = fixed
+  end function
+end program
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gfortran.dg/pr125391.f90
@@ -0,0 +1,83 @@
+! { dg-do run }
+!
+! Fix for PR125391 due to :
+! gfortran ICE: in gimplify_var_or_parm_decl, at gimplify.cc:3416 (26.2) 
+!               in gimplify_var_or_parm_decl, at gimplify.cc:3166 (trunk, 16/5/10) 
+!
+!
+! Contributed by Federico Perini  <federico.perini@gmail.com>
+!
+module m
+  implicit none
+  type :: inner
+    integer :: x = 0
+  contains
+    final :: inner_final
+  end type
+
+  type :: outer2
+    type(inner) :: items(1)
+  end type
+
+  type :: outer1
+    type(inner), allocatable :: items(:)
+  end type
+
+  integer :: ctr = 0
+
+contains
+  impure elemental subroutine inner_final(this)
+    type(inner), intent(inout) :: this
+    ctr = ctr + 1
+  end subroutine
+
+
+  ! Variant A: whole-array component assignment.
+  subroutine copy_whole1(lhs, rhs)
+    class(outer1), intent(inout) :: lhs
+    type(outer1),  intent(in)    :: rhs
+    lhs%items = rhs%items   ! ICE!
+  end subroutine
+
+  ! Variant B: assignment from an array constructor.
+  subroutine make_singleton1(lhs, x)
+    class(outer1), intent(inout) :: lhs
+    type(inner),  intent(in)    :: x
+    lhs%items = [x]         ! ICE!
+  end subroutine
+
+  ! Variant A: whole-array component assignment.
+  subroutine copy_whole2(lhs, rhs)
+    class(outer2), intent(inout) :: lhs
+    type(outer2),  intent(in)    :: rhs
+    lhs%items = rhs%items
+  end subroutine
+
+  ! Variant B: assignment from an array constructor.
+  subroutine make_singleton2(lhs, x)
+    class(outer2), intent(inout) :: lhs
+    type(inner),  intent(in)    :: x
+    lhs%items = [x]
+  end subroutine
+end module
+
+program p
+  use m
+  type(outer1) :: x
+  type(outer2) :: y
+
+  ! Verify that the original problem is fixed
+  x%items = [inner(2)]
+  if (ctr /= 0) stop 1            ! x%items not allocated
+  call make_singleton1 (x, inner(42))
+  call copy_whole1 (x, outer1([inner(S)]))
+  if (ctr /= 2) stop 2            ! one finalization for each call
+
+  ! Verify that the fix has not broken non-allocatable component references
+  y%items = [inner(2)]            ! y%items finalized before assignment
+  if (ctr /= 3) stop 3
+  call make_singleton2 (y, inner(42))
+  call copy_whole2 (y, outer2([inner(42)]))
+  if (ctr /= 5) stop 4            ! one finalization for each call
+
+end program
--- a/src/gcc/testsuite/gnat.dg/atomic9.adb
+++ b/src/gcc/testsuite/gnat.dg/atomic9.adb
@@ -14,8 +14,9 @@ procedure Atomic9 is
       with
         Import,
         Atomic,
-        Size    => 32,
-        Address => Register'Address;
+        Alignment => 4,
+        Size      => 32,
+        Address   => Register'Address;
 
    begin
       NVIC_STIR := IRQ;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gnat.dg/bigint1.adb
@@ -0,0 +1,27 @@
+-- { dg-do run }
+-- { dg-options "-gnat2022 -gnata" }
+
+with Ada.Numerics.Big_Numbers.Big_Integers;
+use Ada.Numerics.Big_Numbers.Big_Integers;
+
+procedure Bigint1 is
+
+  Minus_One   : constant Big_Integer := To_Big_Integer (-1);
+  Minus_Two   : constant Big_Integer := To_Big_Integer (-2);
+  Minus_Three : constant Big_Integer := To_Big_Integer (-3);
+
+begin
+
+  pragma Assert (Minus_One ** 1 = Minus_One);
+  pragma Assert (Minus_One ** 2 = To_Big_Integer (1));
+  pragma Assert (Minus_One ** 3 = Minus_One);
+
+  pragma Assert (Minus_Two ** 1 = Minus_Two);
+  pragma Assert (Minus_Two ** 2 = To_Big_Integer (4));
+  pragma Assert (Minus_Two ** 3 = To_Big_Integer (-8));
+
+  pragma Assert (Minus_Three ** 1 = Minus_Three);
+  pragma Assert (Minus_Three ** 2 = To_Big_Integer (9));
+  pragma Assert (Minus_Three ** 3 = To_Big_Integer (-27));
+
+end;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gnat.dg/enum6.adb
@@ -0,0 +1,43 @@
+--  { dg-do run }
+
+procedure Enum6 is
+
+  type Base_Enum is (Ten, Twenty);
+
+  type Derived_Enum is new Base_Enum;
+  for Derived_Enum use (Ten => 10, Twenty => 20);
+
+  type Rep_Enum is (Ten, Twenty);
+  for Rep_Enum use (Ten => 10, Twenty => 20);
+
+  OK : Boolean := True;
+
+begin
+  for E in Base_Enum loop
+    if (E = Ten and then Base_Enum'Image(E) /= "TEN")
+      or else (E = Twenty and then Base_Enum'Image(E) /= "TWENTY")
+    then
+      OK := False;
+    end if;
+  end loop;
+
+  for E in Derived_Enum loop
+    if (E = Ten and then Derived_Enum'Image(E) /= "TEN")
+       or else (E = Twenty and then Derived_Enum'Image(E) /= "TWENTY")
+    then
+      OK := False;
+    end if;
+  end loop;
+
+  for E in Rep_Enum loop
+    if (E = Ten and then Rep_Enum'Image(E) /= "TEN")
+      or else (E = Twenty and then Rep_Enum'Image(E) /= "TWENTY")
+    then
+      OK := False;
+    end if;
+  end loop;
+
+  if not OK then
+    raise Program_Error;
+  end if;
+end;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gnat.dg/task6.adb
@@ -0,0 +1,15 @@
+-- { dg-do compile }
+
+package body Task6 is
+
+   task body T is
+   begin
+     accept E;
+   end T;
+
+   function Make return T is
+   begin
+     return Ret : T;
+   end;
+
+end Task6;
new file mode 100644
--- /dev/null
+++ b/src/gcc/testsuite/gnat.dg/task6.ads
@@ -0,0 +1,13 @@
+package Task6 is
+
+  type Int is task interface;
+
+  procedure E (T: Int) is abstract;
+
+  task type T is new Int with
+    entry E;
+  end T;
+
+  function Make return T;
+
+end Task6;
--- a/src/gcc/testsuite/lib/lto.exp
+++ b/src/gcc/testsuite/lib/lto.exp
@@ -711,9 +711,19 @@ proc lto-execute-1 { src1 sid } {
     set i 1
     set done 0
     while { !$done } {
-	set names [glob -nocomplain -types f -- "${dir}/${base}_${i}.{c,C,ii,\[fF\]{,90,95,03,08},d,m,mm}"]
+	set prefix "${dir}/${base}_${i}"
+
+	# glob returns a case insensitive list if filesystem is case
+	# insensitive.  To have a case sensitive list, fetch the extended list
+	# and then filter it to avoid duplicates.
+	regsub -all {([.^$*+?()$${}|])} $prefix {\\\1} pattern
+	set pattern [format {^%s.(c|C|ii|[fF](|90|95|03|08)|d|m|mm)$} $pattern]
+	set names [lsearch -inline -all -regexp \
+	  [glob -nocomplain -types f -- "${prefix}.*"] $pattern]
+
 	if { [llength ${names}] > 1 } {
-	    warning "lto-execute: more than one file matched ${dir}/${base}_${i}.{c,C,ii,\[fF\]{,90,95,03,08},d,m,mm}"
+	    warning "lto-execute: more than one file matched $pattern"
+	    verbose "matching files: $names"
 	}
 	if { [llength ${names}] == 1 } {
 	    lappend src_list [lindex ${names} 0]
--- a/src/gcc/testsuite/lib/target-supports.exp
+++ b/src/gcc/testsuite/lib/target-supports.exp
@@ -6383,10 +6383,9 @@ proc check_effective_target_arm_mixed_fp { } {
     }
 
     return [check_no_compiler_messages arm_mixed_fp assembly {
-	#ifndef __ARM_FP
-	# error __ARM_FP not defined
-	#elif ((__ARM_FP & 0xc) == 0xc)
-	# error __ARM_FP indicates that both single- and double-precision FP are supported
+	// Mixed FP means we have hw FP, but only for SFmode (ignores HFmode)
+	#if !defined(__ARM_FP) || ((__ARM_FP & 0xc) != 0x4)
+	#error Not mixed FP
 	#endif
 	int main (void) { return 0; }
     } "" ]
--- a/src/gcc/tree-cfgcleanup.cc
+++ b/src/gcc/tree-cfgcleanup.cc
@@ -240,7 +240,8 @@ cleanup_control_expr_graph (basic_block bb, gimple_stmt_iterator gsi)
 
   bitmap_set_bit (cfgcleanup_altered_bbs, bb->index);
   gsi_remove (&gsi, true);
-  taken_edge->flags = EDGE_FALLTHRU;
+  taken_edge->flags &= ~(EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
+  taken_edge->flags |= EDGE_FALLTHRU;
 
   return retval;
 }
--- a/src/gcc/tree-scalar-evolution.cc
+++ b/src/gcc/tree-scalar-evolution.cc
@@ -1391,10 +1391,19 @@ simplify_peeled_chrec (class loop *loop, tree arg, tree init_cond)
 	  && wi::to_widest (init_cond) == wi::to_widest (left_before)
 	  && !scev_probably_wraps_p (NULL_TREE, left_before, right, NULL,
 				     loop, false))
-	return build_polynomial_chrec (loop->num, init_cond,
-				       chrec_convert (TREE_TYPE (ev),
-						      right, NULL,
-						      false, NULL_TREE));
+	{
+	  tree tp = TREE_TYPE (right);
+
+	  /* We need a sign-extension to make things like
+	     u8(6, 4, 2) => i32(6, 4, 2), instead of i32(6, 260, 514).  */
+	  if (TYPE_UNSIGNED (tp))
+	    right = fold_convert (signed_type_for (tp), right);
+
+	  return build_polynomial_chrec (loop->num, init_cond,
+					 chrec_convert (TREE_TYPE (ev),
+							right, NULL,
+							false, NULL_TREE));
+	}
       return chrec_dont_know;
     }
 
--- a/src/gcc/tree-sra.cc
+++ b/src/gcc/tree-sra.cc
@@ -2091,16 +2091,20 @@ build_debug_ref_for_model (location_t loc, tree base, HOST_WIDE_INT offset,
 }
 
 /* Construct a memory reference consisting of component_refs and array_refs to
-   a part of an aggregate *RES (which is of type TYPE).  The requested part
-   should have type EXP_TYPE at be the given OFFSET.  This function might not
-   succeed, it returns true when it does and only then *RES points to something
-   meaningful.  This function should be used only to build expressions that we
-   might need to present to user (e.g. in warnings).  In all other situations,
+   a part of an aggregate *RES which is of type TYPE.  The requested part
+   should have type EXP_TYPE at the given OFFSET.  CUR_SIZE must be the size of
+   *RES unless it is known that *RES alone cannot be the result.  This function
+   might not succeed, it returns true when it does and only then *RES points to
+   something meaningful.
+
+   This function should be used only to build expressions that we might need to
+   present to user (e.g. in warnings).  In all other situations,
    build_ref_for_model or build_ref_for_offset should be used instead.  */
 
 static bool
 build_user_friendly_ref_for_offset (tree *res, tree type, HOST_WIDE_INT offset,
-				    tree exp_type)
+				    HOST_WIDE_INT cur_size, tree exp_type,
+				    HOST_WIDE_INT exp_size)
 {
   while (1)
     {
@@ -2108,7 +2112,8 @@ build_user_friendly_ref_for_offset (tree *res, tree type, HOST_WIDE_INT offset,
       tree tr_size, index, minidx;
       HOST_WIDE_INT el_size;
 
-      if (offset == 0 && exp_type
+      if (offset == 0
+	  && cur_size == exp_size
 	  && types_compatible_p (exp_type, type))
 	return true;
 
@@ -2146,7 +2151,8 @@ build_user_friendly_ref_for_offset (tree *res, tree type, HOST_WIDE_INT offset,
 			     NULL_TREE);
 	      expr_ptr = &expr;
 	      if (build_user_friendly_ref_for_offset (expr_ptr, TREE_TYPE (fld),
-						      offset - pos, exp_type))
+						      offset - pos, size,
+						      exp_type, exp_size))
 		{
 		  *res = expr;
 		  return true;
@@ -2169,17 +2175,12 @@ build_user_friendly_ref_for_offset (tree *res, tree type, HOST_WIDE_INT offset,
 	  *res = build4 (ARRAY_REF, TREE_TYPE (type), *res, index,
 			 NULL_TREE, NULL_TREE);
 	  offset = offset % el_size;
+	  cur_size = el_size;
 	  type = TREE_TYPE (type);
 	  break;
 
 	default:
-	  if (offset != 0)
-	    return false;
-
-	  if (exp_type)
-	    return false;
-	  else
-	    return true;
+	  return false;
 	}
     }
 }
@@ -3070,7 +3071,8 @@ create_artificial_child_access (struct access *parent, struct access *model,
   struct access *access = access_pool.allocate ();
   memset (access, 0, sizeof (struct access));
   if (!build_user_friendly_ref_for_offset (&expr, TREE_TYPE (expr), new_offset,
-					   model->type))
+					   parent->size, model->type,
+					   model->size))
     {
       access->grp_no_warning = true;
       expr = build_ref_for_model (EXPR_LOCATION (parent->base), parent->base,
@@ -3211,8 +3213,11 @@ propagate_subaccesses_from_rhs (struct access *lacc, struct access *racc)
 	  tree t = lacc->base;
 
 	  lacc->type = racc->type;
+	  /* We know racc and lacc are of different types so can pass -1 as
+	     cur_size.  */
 	  if (build_user_friendly_ref_for_offset (&t, TREE_TYPE (t),
-						  lacc->offset, racc->type))
+						  lacc->offset, -1,
+						  racc->type, racc->size))
 	    {
 	      lacc->expr = t;
 	      lacc->grp_same_access_path = true;
@@ -3270,7 +3275,6 @@ propagate_subaccesses_from_rhs (struct access *lacc, struct access *racc)
 	}
 
       if (rchild->grp_unscalarizable_region
-	  || (rchild->size % BITS_PER_UNIT) != 0
 	  || !budget_for_propagation_access (lacc->base))
 	{
 	  if (!lacc->grp_write && access_or_its_child_written (rchild))
@@ -3330,7 +3334,6 @@ propagate_subaccesses_from_lhs (struct access *lacc, struct access *racc)
       HOST_WIDE_INT norm_offset = lchild->offset + norm_delta;
 
       if (lchild->grp_unscalarizable_region
-	  || (lchild->size % BITS_PER_UNIT) != 0
 	  || child_would_conflict_in_acc (racc, norm_offset, lchild->size,
 					  &matching_acc)
 	  || !budget_for_propagation_access (racc->base))
--- a/src/gcc/tree-ssa-loop-im.cc
+++ b/src/gcc/tree-ssa-loop-im.cc
@@ -2323,7 +2323,14 @@ execute_sm (class loop *loop, im_mem_ref *ref,
   bool always_stored = ref_always_accessed_p (loop, ref, true);
   if (maybe_mt
       && (bb_in_transaction (loop_preheader_edge (loop)->src)
-	  || (ref_can_have_store_data_races (ref->mem.ref) && ! always_stored)))
+	  || (ref_can_have_store_data_races (ref->mem.ref) && ! always_stored)
+	  /* Do not speculate a load/store when that's not a noop, either
+	     because the mode cannot be transferred or because there's
+	     UB involved for out-of-bound values.  */
+	  || !mode_can_transfer_bits (TYPE_MODE (TREE_TYPE (ref->mem.ref)))
+	  || TREE_CODE (TREE_TYPE (ref->mem.ref)) == BOOLEAN_TYPE
+	  || (TREE_CODE (ref->mem.ref) == COMPONENT_REF
+	      && DECL_BIT_FIELD (TREE_OPERAND (ref->mem.ref, 1)))))
     multi_threaded_model_p = true;
 
   if (multi_threaded_model_p && !use_other_flag_var)
--- a/src/gcc/tree-ssa-loop-niter.cc
+++ b/src/gcc/tree-ssa-loop-niter.cc
@@ -988,8 +988,8 @@ number_of_iterations_ne (class loop *loop, tree type, affine_iv *iv,
      if BNDS->below in the result is nonnegative.  */
   if (tree_int_cst_sign_bit (iv->step))
     {
-      s = fold_convert (niter_type,
-			fold_build1 (NEGATE_EXPR, type, iv->step));
+      s = fold_build1 (NEGATE_EXPR, niter_type,
+		       fold_convert (niter_type, iv->step));
       c = fold_build2 (MINUS_EXPR, niter_type,
 		       fold_convert (niter_type, iv->base),
 		       fold_convert (niter_type, final));
@@ -1633,8 +1633,8 @@ number_of_iterations_lt (class loop *loop, tree type, affine_iv *iv0,
   if (integer_nonzerop (iv0->step))
     step = fold_convert (niter_type, iv0->step);
   else
-    step = fold_convert (niter_type,
-			 fold_build1 (NEGATE_EXPR, type, iv1->step));
+    step = fold_build1 (NEGATE_EXPR, niter_type,
+			fold_convert (niter_type, iv1->step));
 
   /* If we can determine the final value of the control iv exactly, we can
      transform the condition to != comparison.  In particular, this will be
--- a/src/gcc/tree-ssa-strlen.cc
+++ b/src/gcc/tree-ssa-strlen.cc
@@ -848,7 +848,7 @@ get_string_length (strinfo *si)
      attempt to compute the length from the call statement.  */
   if (si->stmt)
     {
-      gimple *stmt = si->stmt, *lenstmt;
+      gimple *stmt = si->stmt, *lenstmt = NULL, *g;
       tree callee, lhs, fn, tem;
       location_t loc;
       gimple_stmt_iterator gsi;
@@ -883,11 +883,11 @@ get_string_length (strinfo *si)
               lhs = force_gimple_operand_gsi (&gsi, lhs, true, NULL_TREE,
                                               true, GSI_SAME_STMT);
             }
-	  lenstmt = gimple_build_assign
+	  g = gimple_build_assign
 			(make_ssa_name (TREE_TYPE (gimple_call_arg (stmt, 0))),
 			 POINTER_PLUS_EXPR,tem, lhs);
-	  gsi_insert_before (&gsi, lenstmt, GSI_SAME_STMT);
-	  gimple_call_set_arg (stmt, 0, gimple_assign_lhs (lenstmt));
+	  gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+	  gimple_call_set_arg (stmt, 0, gimple_assign_lhs (g));
 	  lhs = NULL_TREE;
 	  /* FALLTHRU */
 	case BUILT_IN_STRCPY:
@@ -906,6 +906,17 @@ get_string_length (strinfo *si)
 	  gimple_call_set_fndecl (stmt, fn);
 	  lhs = make_ssa_name (TREE_TYPE (TREE_TYPE (fn)), stmt);
 	  gimple_call_set_lhs (stmt, lhs);
+	  if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STRCAT_CHK)
+	    {
+	      tree objsz = gimple_call_lhs (lenstmt);
+	      gimple *g
+		= gimple_build_assign (make_ssa_name (TREE_TYPE (objsz)),
+				       MINUS_EXPR, gimple_call_arg (stmt, 2),
+				       objsz);
+	      gimple_set_location (g, gimple_location (stmt));
+	      gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+	      gimple_call_set_arg (stmt, 2, gimple_assign_lhs (g));
+	    }
 	  update_stmt (stmt);
 	  if (dump_file && (dump_flags & TDF_DETAILS) != 0)
 	    {
--- a/src/gcc/tree-ssa-threadbackward.cc
+++ b/src/gcc/tree-ssa-threadbackward.cc
@@ -349,6 +349,9 @@ back_threader::find_paths_to_names (basic_block bb, bitmap interesting,
 				    unsigned overall_paths,
 				    back_threader_profitability &profit)
 {
+  if (m_visited_bbs.add (bb))
+    return;
+
   m_path.safe_push (bb);
 
   // Try to resolve the path without looking back.  Avoid resolving paths
@@ -374,8 +377,7 @@ back_threader::find_paths_to_names (basic_block bb, bitmap interesting,
   // Continue looking for ways to extend the path but limit the
   // search space along a branch
   else if ((overall_paths = overall_paths * EDGE_COUNT (bb->preds))
-	   <= (unsigned)param_max_jump_thread_paths
-	   && !m_visited_bbs.add (bb))
+	   <= (unsigned)param_max_jump_thread_paths)
     {
       // For further greedy searching we want to remove interesting
       // names defined in BB but add ones on the PHI edges for the
@@ -487,7 +489,6 @@ back_threader::find_paths_to_names (basic_block bb, bitmap interesting,
 	 backtracking we have to restore it.  */
       for (int j : new_imports)
 	bitmap_clear_bit (m_imports, j);
-      m_visited_bbs.remove (bb);
     }
   else if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "  FAIL: Search space limit %d reached.\n",
@@ -495,6 +496,7 @@ back_threader::find_paths_to_names (basic_block bb, bitmap interesting,
 
   // Reset things to their original state.
   m_path.pop ();
+  m_visited_bbs.remove (bb);
 }
 
 // Search backwards from BB looking for paths where the final
--- a/src/gcc/tree-vect-slp.cc
+++ b/src/gcc/tree-vect-slp.cc
@@ -4281,32 +4281,39 @@ vect_analyze_slp_reduc_chain (loop_vec_info vinfo,
       auto_vec<chain_op_t> chain;
       auto_vec<std::pair<tree_code, gimple *> > worklist;
       gimple *op_stmt = NULL, *other_op_stmt = NULL;
-      vect_slp_linearize_chain (vinfo, worklist, chain, (tree_code)code,
-				scalar_stmts[0]->stmt, op_stmt, other_op_stmt,
-				NULL);
-
-      scalar_stmts.truncate (0);
-      stmt_vec_info tail = NULL;
-      for (auto el : chain)
+      if (is_a <gassign *> (scalar_stmts[0]->stmt)
+	  /* We cannot linearize an operation that vect_slp_linearize_chain
+	     would not put on its worklist.  */
+	  && gimple_assign_rhs_code (scalar_stmts[0]->stmt) == (tree_code)code)
 	{
-	  if (el.dt == vect_external_def
-	      || el.dt == vect_constant_def
-	      || el.code != (tree_code) code)
-	    {
-	      scalar_stmts.release ();
-	      return false;
-	    }
-	  stmt_vec_info stmt = vinfo->lookup_def (el.op);
-	  if (STMT_VINFO_REDUC_IDX (stmt) != -1
-	      || STMT_VINFO_REDUC_DEF (stmt))
+	  vect_slp_linearize_chain (vinfo, worklist, chain, (tree_code)code,
+				    scalar_stmts[0]->stmt, op_stmt,
+				    other_op_stmt,
+				    NULL);
+
+	  scalar_stmts.truncate (0);
+	  stmt_vec_info tail = NULL;
+	  for (auto el : chain)
 	    {
-	      gcc_assert (tail == NULL);
-	      tail = stmt;
-	      continue;
+	      if (el.dt == vect_external_def
+		  || el.dt == vect_constant_def
+		  || el.code != (tree_code) code)
+		{
+		  scalar_stmts.release ();
+		  return false;
+		}
+	      stmt_vec_info stmt = vinfo->lookup_def (el.op);
+	      if (STMT_VINFO_REDUC_IDX (stmt) != -1
+		  || STMT_VINFO_REDUC_DEF (stmt))
+		{
+		  gcc_assert (tail == NULL);
+		  tail = stmt;
+		  continue;
+		}
+	      scalar_stmts.safe_push (stmt);
 	    }
-	  scalar_stmts.safe_push (stmt);
+	  gcc_assert (tail);
 	}
-      gcc_assert (tail);
 
       /* When this linearization didn't produce a chain see if stripping
 	 a wrapping sign conversion produces one.  */
@@ -4336,7 +4343,7 @@ vect_analyze_slp_reduc_chain (loop_vec_info vinfo,
 				    stmt, op_stmt, other_op_stmt, NULL);
 
 	  scalar_stmts.truncate (0);
-	  tail = NULL;
+	  stmt_vec_info tail = NULL;
 	  for (auto el : chain)
 	    {
 	      if (el.dt == vect_external_def
--- a/src/libgcc/config/avr/libf7/ChangeLog
+++ b/src/libgcc/config/avr/libf7/ChangeLog
@@ -1,3 +1,22 @@
+2026-06-11  Georg-Johann Lay  <avr@gjlay.de>
+
+	Backported from master:
+	2026-06-11  Georg-Johann Lay  <avr@gjlay.de>
+
+	PR target/125752
+	* libf7-asm.sx (ufx64_to_d, d_to_fx64): New DEFUNs.
+	(__fractdadf, __fractudadf, __fracttadf, __fractutadf)
+	(__fractdqdf, __fractudqdf): New _DEFUNs.
+	* libf7-common.mk (F7_ASM_PARTS) Add: fx2D, D2fx,
+	dq2D, udq2D, da2D, uda2D, ta2D uta2D.
+	(F7F): Add d_to_fx64, ufx64_to_d, sfx64_to_d.
+	* libf7.c (d_to_ufx, d_to_sfx): New protos.
+	(__fractdfda, __fractdfuda, __fractdfta, __fractdfuta)
+	(__fractdfdq, __fractdfudq): New modules.
+	* t-libf7 (LIBF7_DF_CONV): Add fractdfda,
+	fractdfta, fractdfdq, fractdfuda, fractdfuta, fractdfudq.
+	* f7-renames.h: Rebuild.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/libgcc/config/avr/libf7/f7-renames.h
+++ b/src/libgcc/config/avr/libf7/f7-renames.h
@@ -222,6 +222,9 @@
 #define f7_sqrt16_floor_asm __f7_sqrt16_floor_asm
 #define f7_lshrdi3_asm __f7_lshrdi3_asm
 #define f7_ashldi3_asm __f7_ashldi3_asm
+#define f7_d_to_fx64_asm __f7_d_to_fx64_asm
+#define f7_ufx64_to_d_asm __f7_ufx64_to_d_asm
+#define f7_sfx64_to_d_asm __f7_sfx64_to_d_asm
 #define f7_class_D_asm __f7_class_D_asm
 #define f7_call_ddd_asm __f7_call_ddd_asm
 #define f7_call_xdd_asm __f7_call_xdd_asm
--- a/src/libgcc/config/avr/libf7/libf7-asm.sx
+++ b/src/libgcc/config/avr/libf7/libf7-asm.sx
@@ -2308,8 +2308,85 @@ _ENDF __fractqqdf
 #endif /* F7MOD_qq2D_ */
 
 
+#ifdef F7MOD_fx2D_
+;;; Convert an [un]signed 64-bit fixed point value R18[] to double.
+;;;    double ufx64_to_d (ufx64_t R18, uint8_t fbit R30);
+;;;    double sfx64_to_d (sfx64_t R18, uint8_t fbit R30);
+;;; FBIT accounts for the fractional bits of the fixed point type,
+;;; e.g. pass __DA_FBIT__ for long accum etc.
+DEFUN ufx64_to_d
+    push    r30
+    XCALL __floatundidf
+    rjmp  1f
+
+LABEL sfx64_to_d
+    push    r30
+    XCALL __floatdidf
+1:  pop     r30
+
+    ;; The MSB indicates a value of 0.  Notice that at this point,
+    ;; we have a normal floating point number with a biased exponent
+    ;; that won't underflow below.
+    tst     r25
+    breq 0f
+
+    ;; Subtract fbit from the double exponent.  R30[] = fbit << 4.
+    swap    r30
+    mov     r31, r30
+    andi    r30, lo8 (0x0ff0)
+    andi    r31, hi8 (0x0ff0)
+    sub     r24, r30
+    sbc     r25, r31
+
+0:  ret
+ENDF ufx64_to_d
+#endif /* F7MOD_fx2D_ */
+
+#ifdef F7MOD_da2D_
+_DEFUN __fractdadf
+    ldi     r30, __DA_FBIT__
+    F7jmp   sfx64_to_d
+_ENDF __fractdadf
+#endif /* F7MOD_da2D_ */
+
+#ifdef F7MOD_uda2D_
+_DEFUN __fractudadf
+    ldi     r30, __UDA_FBIT__
+    F7jmp   ufx64_to_d
+_ENDF __fractudadf
+#endif /* F7MOD_uda2D_ */
+
+#ifdef F7MOD_ta2D_
+_DEFUN __fracttadf
+    ldi     r30, __TA_FBIT__
+    F7jmp   sfx64_to_d
+_ENDF __fracttadf
+#endif /* F7MOD_ta2D_ */
+
+#ifdef F7MOD_uta2D_
+_DEFUN __fractutadf
+    ldi     r30, __UTA_FBIT__
+    F7jmp   ufx64_to_d
+_ENDF __fractutadf
+#endif /* F7MOD_uta2D_ */
+
+#ifdef F7MOD_dq2D_
+_DEFUN __fractdqdf
+    ldi     r30, __DQ_FBIT__
+    F7jmp   sfx64_to_d
+_ENDF __fractdqdf
+#endif /* F7MOD_dq2D_ */
+
+#ifdef F7MOD_udq2D_
+_DEFUN __fractudqdf
+    ldi     r30, __UDQ_FBIT__
+    F7jmp   ufx64_to_d
+_ENDF __fractudqdf
+#endif /* F7MOD_udq2D_ */
+
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Fixed-point -> double conversions.
+;;; Double -> fixed-point conversions.
 
 #ifdef F7MOD_D2qq_
 _DEFUN __fractdfqq
@@ -2389,6 +2466,49 @@ _ENDF __fractdfusa
 #endif /* F7MOD_D2usa_ */
 
 
+#ifdef F7MOD_D2fx_
+;;; Convert double R18 to a 64-bit fixed point value.
+;;; R18 d_to_fx64 (double R18, int8_t fbit R16);
+;;; |FBIT| accounts for the extra fbits compared to [u]int64_t.
+;;; FBIT < 0 indicates a signed conversion.
+;;; FBIT > 0 indicates an unsigned conversion.
+DEFUN d_to_fx64
+    do_prologue_saves  4, F7_SIZEOF
+
+    ;; Y = FramePointer + 1
+    adiw    Y,      1
+
+    ;; FP + 1 = (f7_t) arg
+    wmov    r16,    Y
+
+    ;; Convert double R18 to f7_t *R16.
+    XCALL   F7_NAME (set_double_impl)
+
+    ;; Prepare for *R24 = ldexp (*R24, R22).  ldexp() accounts for the
+    ;; fractional bits of the fixed point value, i.e. we have to <<= FBIT.
+    wmov    r24,    r16
+    ;; Zero-extend FBIT.
+    clr     r23
+    ;; R16 has been clobbered.  Fetch it from where prologue_saves put it.
+    ldd     r22,    Y + F7_SIZEOF + 3       ; Saved R16
+    tst     r22
+    brmi 1f
+
+    ;; Positive FBIT indicates an unsigned conversion.
+    XCALL   F7_NAME (Ildexp)
+    XCALL   F7_NAME (get_u64)
+    rjmp 9f
+
+1:  ;; Negative FBIT indicates a signed conversion.
+    neg     r22                 ; FBIT := |FBIT|
+    XCALL   F7_NAME (Ildexp)
+    XCALL   F7_NAME (get_s64)
+
+9:  do_epilogue_restores  4, F7_SIZEOF
+ENDF d_to_fx64
+#endif /* F7MOD_D2fx_ */
+
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; [u]int32_t -> double conversions.
 
--- a/src/libgcc/config/avr/libf7/libf7-common.mk
+++ b/src/libgcc/config/avr/libf7/libf7-common.mk
@@ -29,12 +29,14 @@ F7_ASM_PARTS += D_cmp D_eq D_ne D_ge D_gt D_le D_lt D_unord D_fminfmax
 F7_ASM_PARTS += call_dd call_ddd
 
 # Fixed-point -> double conversions
-F7_ASM_PARTS += qq2D uqq2D            sq2D usq2D
-F7_ASM_PARTS +=            ha2D uha2D sa2D usa2D
+F7_ASM_PARTS += qq2D uqq2D            sq2D usq2D dq2D udq2D
+F7_ASM_PARTS +=            ha2D uha2D sa2D usa2D da2D uda2D ta2D uta2D
+F7_ASM_PARTS += fx2D
 
 # Double -> fixed-point conversions
 F7_ASM_PARTS += D2qq D2uqq D2hq D2uhq
 F7_ASM_PARTS +=            D2ha D2uha D2sa D2usa
+F7_ASM_PARTS += D2fx
 
 # Integer -> double conversions
 F7_ASM_PARTS += D_floatsidf D_floatunsidf
@@ -107,7 +109,7 @@ F7F_asm += set_u64 set_s64 addsub_mant_scaled mul_mant
 F7F_asm += to_integer to_unsigned clr_mant_lsbs
 F7F_asm += div sqrt_approx sqrt16_round sqrt16_floor
 F7F_asm += lshrdi3 ashldi3
-
+F7F_asm += d_to_fx64 ufx64_to_d sfx64_to_d
 F7F_asm += class_D
 
 F7F_asm += call_ddd call_xdd call_ddx
--- a/src/libgcc/config/avr/libf7/libf7.c
+++ b/src/libgcc/config/avr/libf7/libf7.c
@@ -140,6 +140,58 @@ f7_double_t __floatdidf (int64_t x)
 #endif // F7MOD_floatdidf_
 
 
+extern uint64_t d_to_ufx (f7_double_t, int8_t) F7ASM(f7_d_to_fx64_asm);
+extern int64_t  d_to_sfx (f7_double_t, int8_t) F7ASM(f7_d_to_fx64_asm);
+
+#ifdef F7MOD_fractdfda_
+F7_WEAK
+int64_t __fractdfda (f7_double_t d)
+{
+  return d_to_sfx (d, -__DA_FBIT__);
+}
+#endif // F7MOD_fractdfda_
+
+#ifdef F7MOD_fractdfuda_
+F7_WEAK
+uint64_t __fractdfuda (f7_double_t d)
+{
+  return d_to_ufx (d, __UDA_FBIT__);
+}
+#endif // F7MOD_fractdfuda_
+
+#ifdef F7MOD_fractdfta_
+F7_WEAK
+int64_t __fractdfta (f7_double_t d)
+{
+  return d_to_sfx (d, -__TA_FBIT__);
+}
+#endif // F7MOD_fractdfta_
+
+#ifdef F7MOD_fractdfuta_
+F7_WEAK
+uint64_t __fractdfuta (f7_double_t d)
+{
+  return d_to_ufx (d, __UTA_FBIT__);
+}
+#endif // F7MOD_fractdfuta_
+
+#ifdef F7MOD_fractdfdq_
+F7_WEAK
+int64_t __fractdfdq (f7_double_t d)
+{
+  return d_to_sfx (d, -__DQ_FBIT__);
+}
+#endif // F7MOD_fractdfdq_
+
+#ifdef F7MOD_fractdfudq_
+F7_WEAK
+uint64_t __fractdfudq (f7_double_t d)
+{
+  return d_to_ufx (d, __UDQ_FBIT__);
+}
+#endif // F7MOD_fractdfudq_
+
+
 #ifdef F7MOD_init_
 f7_t* f7_init_impl (uint64_t mant, uint8_t flags, f7_t *cc, int16_t expo)
 {
--- a/src/libgcc/config/avr/libf7/t-libf7
+++ b/src/libgcc/config/avr/libf7/t-libf7
@@ -9,6 +9,8 @@ F7_PREFIX = __f7_
 include $(libf7)/libf7-common.mk
 
 LIBF7_DF_CONV +=  floatundidf floatdidf # floatunsidf floatsidf
+LIBF7_DF_CONV +=  fractdfda fractdfta fractdfdq
+LIBF7_DF_CONV +=  fractdfuda fractdfuta fractdfudq
 
 # Wrappers like f7_lt_impl for f7_lt etc. because the latter is inline.
 LIBF7_DF_CMP  += lt le gt ge ne eq unord
--- a/src/libgfortran/ChangeLog
+++ b/src/libgfortran/ChangeLog
@@ -1,3 +1,37 @@
+2026-05-22  Tobias Burnus  <tburnus@baylibre.com>
+
+	Backported from master:
+	2026-05-22  Tobias Burnus  <tburnus@baylibre.com>
+
+	* m4/matmul.m4: Fix comment typo.
+	* generated/matmul_c10.c: Regenerate.
+	* generated/matmul_c16.c: Regenerate.
+	* generated/matmul_c17.c: Regenerate.
+	* generated/matmul_c4.c: Regenerate.
+	* generated/matmul_c8.c: Regenerate.
+	* generated/matmul_i1.c: Regenerate.
+	* generated/matmul_i16.c: Regenerate.
+	* generated/matmul_i2.c: Regenerate.
+	* generated/matmul_i4.c: Regenerate.
+	* generated/matmul_i8.c: Regenerate.
+	* generated/matmul_r10.c: Regenerate.
+	* generated/matmul_r16.c: Regenerate.
+	* generated/matmul_r17.c: Regenerate.
+	* generated/matmul_r4.c: Regenerate.
+	* generated/matmul_r8.c: Regenerate.
+
+2026-05-13  Harald Anlauf  <anlauf@gmx.de>
+
+	Backported from master:
+	2026-05-06  Harald Anlauf  <anlauf@gmx.de>
+
+	PR libfortran/125095
+	* io/list_read.c (read_logical): Eat comments in namelist read mode.
+	(read_integer): Likewise.
+	(read_character): Likewise.
+	(read_complex): Likewise.
+	(read_real): Likewise.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/libgfortran/generated/matmul_c10.c
+++ b/src/libgfortran/generated/matmul_c10.c
@@ -1785,7 +1785,7 @@ matmul_c10_avx512f (gfc_array_c10 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_c16.c
+++ b/src/libgfortran/generated/matmul_c16.c
@@ -1785,7 +1785,7 @@ matmul_c16_avx512f (gfc_array_c16 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_c17.c
+++ b/src/libgfortran/generated/matmul_c17.c
@@ -1785,7 +1785,7 @@ matmul_c17_avx512f (gfc_array_c17 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_c4.c
+++ b/src/libgfortran/generated/matmul_c4.c
@@ -1785,7 +1785,7 @@ matmul_c4_avx512f (gfc_array_c4 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_c8.c
+++ b/src/libgfortran/generated/matmul_c8.c
@@ -1785,7 +1785,7 @@ matmul_c8_avx512f (gfc_array_c8 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_i1.c
+++ b/src/libgfortran/generated/matmul_i1.c
@@ -1785,7 +1785,7 @@ matmul_i1_avx512f (gfc_array_m1 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_i16.c
+++ b/src/libgfortran/generated/matmul_i16.c
@@ -1785,7 +1785,7 @@ matmul_i16_avx512f (gfc_array_m16 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_i2.c
+++ b/src/libgfortran/generated/matmul_i2.c
@@ -1785,7 +1785,7 @@ matmul_i2_avx512f (gfc_array_m2 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_i4.c
+++ b/src/libgfortran/generated/matmul_i4.c
@@ -1785,7 +1785,7 @@ matmul_i4_avx512f (gfc_array_m4 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_i8.c
+++ b/src/libgfortran/generated/matmul_i8.c
@@ -1785,7 +1785,7 @@ matmul_i8_avx512f (gfc_array_m8 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_r10.c
+++ b/src/libgfortran/generated/matmul_r10.c
@@ -1785,7 +1785,7 @@ matmul_r10_avx512f (gfc_array_r10 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_r16.c
+++ b/src/libgfortran/generated/matmul_r16.c
@@ -1785,7 +1785,7 @@ matmul_r16_avx512f (gfc_array_r16 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_r17.c
+++ b/src/libgfortran/generated/matmul_r17.c
@@ -1785,7 +1785,7 @@ matmul_r17_avx512f (gfc_array_r17 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_r4.c
+++ b/src/libgfortran/generated/matmul_r4.c
@@ -1785,7 +1785,7 @@ matmul_r4_avx512f (gfc_array_r4 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/generated/matmul_r8.c
+++ b/src/libgfortran/generated/matmul_r8.c
@@ -1785,7 +1785,7 @@ matmul_r8_avx512f (gfc_array_r8 * const restrict retarray,
 
 #endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 void
--- a/src/libgfortran/io/list_read.c
+++ b/src/libgfortran/io/list_read.c
@@ -917,6 +917,7 @@ read_logical (st_parameter_dt *dtp, int length)
   if (parse_repeat (dtp))
     return;
 
+next:
   c = safe_tolower (next_char (dtp));
   l_push_char (dtp, c);
   switch (c)
@@ -961,6 +962,9 @@ read_logical (st_parameter_dt *dtp, int length)
     case '!':
       if (!dtp->u.p.namelist_mode)
         goto bad_logical;
+      eat_line (dtp);
+      eat_spaces (dtp);
+      goto next;
 
     CASE_SEPARATORS:
     case EOF:
@@ -1076,6 +1080,7 @@ read_integer (st_parameter_dt *dtp, int length, bt type)
   int c, negative;
   negative = 0;
 
+next:
   c = next_char (dtp);
   switch (c)
     {
@@ -1091,6 +1096,9 @@ read_integer (st_parameter_dt *dtp, int length, bt type)
     case '!':
       if (!dtp->u.p.namelist_mode)
         goto bad_integer;
+      eat_line (dtp);
+      eat_spaces (dtp);
+      goto next;
 
     CASE_SEPARATORS:		/* Single null.  */
       unget_char (dtp, c);
@@ -1260,6 +1268,7 @@ read_character (st_parameter_dt *dtp, int length __attribute__ ((unused)))
 
   quote = ' ';			/* Space means no quote character.  */
 
+next:
   if ((c = next_char (dtp)) == EOF)
     goto eof;
   if (c == ';')
@@ -1284,6 +1293,15 @@ read_character (st_parameter_dt *dtp, int length __attribute__ ((unused)))
       quote = c;
       goto get_string;
 
+    case '!':
+      if (dtp->u.p.namelist_mode)
+	{
+	  eat_line (dtp);
+	  eat_spaces (dtp);
+	  goto next;
+	}
+      /* Fall through...  */
+
     default:
       if (dtp->u.p.namelist_mode)
 	{
@@ -1703,6 +1721,7 @@ read_complex (st_parameter_dt *dtp, void *dest, int kind, size_t size)
   if (parse_repeat (dtp))
     return;
 
+next:
   c = next_char (dtp);
   switch (c)
     {
@@ -1712,6 +1731,9 @@ read_complex (st_parameter_dt *dtp, void *dest, int kind, size_t size)
     case '!':
       if (!dtp->u.p.namelist_mode)
 	goto bad_complex;
+      eat_line (dtp);
+      eat_spaces (dtp);
+      goto next;
 
     CASE_SEPARATORS:
     case EOF:
@@ -1813,6 +1835,7 @@ read_real (st_parameter_dt *dtp, void *dest, int length)
 
   seen_dp = 0;
 
+next:
   c = next_char (dtp);
   if (dtp->u.p.current_unit->decimal_status == DECIMAL_COMMA)
     {
@@ -1844,6 +1867,9 @@ read_real (st_parameter_dt *dtp, void *dest, int length)
     case '!':
       if (!dtp->u.p.namelist_mode)
 	goto bad_real;
+      eat_line (dtp);
+      eat_spaces (dtp);
+      goto next;
 
     CASE_SEPARATORS:
       unget_char (dtp, c);		/* Single null.  */
--- a/src/libgfortran/m4/matmul.m4
+++ b/src/libgfortran/m4/matmul.m4
@@ -109,7 +109,7 @@ static' include(matmul_internal.m4)dnl
 static' include(matmul_internal.m4)dnl
 `#endif  /* HAVE_AVX512F */
 
-/* AMD-specifix funtions with AVX128 and FMA3/FMA4.  */
+/* AMD-specific functions with AVX128 and FMA3/FMA4.  */
 
 #if defined(HAVE_AVX) && defined(HAVE_FMA3) && defined(HAVE_AVX128)
 'define(`matmul_name',`matmul_'rtype_code`_avx128_fma3')dnl
--- a/src/libstdc++-v3/ChangeLog
+++ b/src/libstdc++-v3/ChangeLog
@@ -1,3 +1,265 @@
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-29  Patrick Palka  <ppalka@redhat.com>
+
+	* include/std/flat_set (_Flat_set_impl::swap): Swap _M_cont
+	first.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-28  Patrick Palka  <ppalka@redhat.com>
+
+	* include/std/flat_map (flat_map): Bring in operator= from
+	_Flat_map_base.
+	(flat_multimap): Likewise.
+	* include/std/flat_set (flat_set): Bring in operator= from
+	_Flat_set_base.
+	(flat_multiset): Likewise.
+	* testsuite/23_containers/flat_map/1.cc (test11): Simplify by
+	using = {...}.
+	(test12): New test.
+	* testsuite/23_containers/flat_multimap/1.cc (test10): Simplify
+	by using = {...}.
+	(test11): New test.
+	* testsuite/23_containers/flat_multiset/1.cc (test10): Simplify
+	by using = {...}.
+	(test11): New test.
+	* testsuite/23_containers/flat_set/1.cc (test10): Simplify by
+	using = {...}.
+	(test11): New test.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-28  Patrick Palka  <ppalka@redhat.com>
+
+	* include/bits/version.def (flat_map): Bump to 202511.
+	(flat_set): Likewise.
+	* include/bits/version.h: Regenerate.
+	* include/std/flat_map (_Flat_map_impl): Remove
+	is_nothrow_swappable_v assertions.
+	(_Flat_map_impl::_Flat_map_impl): Explicitly default copy ctor.
+	Define move ctor with corrected exception handling as per
+	P3567R2.
+	(_Flat_map_impl::operator=): Likewise.
+	(_Flat_map_impl::insert_range): Define new __sorted_t overload
+	as per P3567R2.
+	(_Flat_map_impl::swap): Make conditionally noexcept as per
+	P3567R2.
+	* include/std/flat_set (_Flat_set_impl): Remove
+	is_nothrow_swappable_v assertion.
+	(_Flat_set_impl::_Flat_set_impl): Explicitly default copy ctor.
+	Define move ctor with correct invariant preserving behavior as
+	per P3567R2.
+	(_Flat_set_impl::operator=): Likewise.
+	(_Flat_set_impl::_M_insert_range): Factored out from
+	insert_range.  Add bool parameter __is_sorted defaulted to
+	false.
+	(_Flat_set_impl::insert_range): Define new __sorted_t overload
+	as per P3567R2.
+	(_Flat_set_impl::swap): Make conditionally noexcept as per
+	P3567R2.  Correct to use ranges::swap instead of ADL swap.
+	* testsuite/23_containers/flat_map/1.cc (test11, test12):
+	New tests.
+	* testsuite/23_containers/flat_multimap/1.cc (test10, test11):
+	New tests.
+	* testsuite/23_containers/flat_multiset/1.cc (test10, test11):
+	New tests.
+	* testsuite/23_containers/flat_set/1.cc (test10, test11):
+	New tests.
+
+2026-06-04  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-28  Patrick Palka  <ppalka@redhat.com>
+
+	* include/std/flat_map (_Flat_map_impl::_M_insert): New bool
+	parameter __is_sorted defaulted to false.  Reimplement using
+	views::zip and ranges::inplace_merge.
+	(_Flat_map_impl::insert): In the __sorted_t overload, pass
+	__is_sorted=true to _M_insert.
+
+2026-06-04  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-06-04  Jonathan Wakely  <jwakely@redhat.com>
+
+	* include/debug/safe_iterator.h: Remove trailing whitespace.
+
+2026-05-27  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-26  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/125450
+	* include/std/optional (range_format): Do not define for
+	freestanding.
+
+2026-05-21  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-21  Patrick Palka  <ppalka@redhat.com>
+
+	* testsuite/23_containers/flat_map/1.cc (test_constexpr):
+	If std::string isn't constexpr don't run test10.
+
+2026-05-21  Patrick Palka  <ppalka@redhat.com>
+
+	Backported from master:
+	2026-05-19  Patrick Palka  <ppalka@redhat.com>
+
+	PR libstdc++/125374
+	* include/std/flat_map (_Flat_map_impl::_M_try_emplace): Forward
+	instead of unconditionally moving __k when inserting it.
+	* testsuite/23_containers/flat_map/1.cc (test10): New test.
+
+2026-05-21  Tomasz Kamiński  <tkaminsk@redhat.com>
+
+	Backported from master:
+	2026-05-18  Tomasz Kamiński  <tkaminsk@redhat.com>
+
+	* include/std/mdspan (layout_left_padded::is_exhaustive)
+	(layout_righ_padded::is_exhaustive): Mark as const.
+	* testsuite/23_containers/mdspan/layouts/mapping.cc: Test noexcept and
+	const-invocability for is_exhaustive, is_strided, and is_unique.
+	* testsuite/23_containers/mdspan/layouts/padded.cc: Test is_exhaustive on
+	const mapping..
+	* testsuite/23_containers/mdspan/layouts/stride.cc: Likewise.
+	* testsuite/23_containers/mdspan/mdspan.cc: Checks const-invocability
+	for is_exhaustive, is_strided, is_unique.
+
+2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	* src/c++20/tzdata.zi: Import new file from 2026b release.
+
+2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-18  Jonathan Wakely  <jwakely@redhat.com>
+
+	* testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc:
+	Reduce iterations for debug mode.
+
+2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/125369
+	* include/bits/chrono_io.h (__detail::_Parser::operator()):
+	Check for errors when parsing digits for a %z format.
+	* testsuite/std/time/parse/125369.cc: New test.
+
+2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-13  Jonathan Wakely  <jwakely@redhat.com>
+
+	* testsuite/std/time/clock/local/io.cc: Call test_format.
+
+2026-05-19  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-07  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/78302
+	PR libstdc++/71301
+	* include/std/tuple [C++20] (tuple(tuple&&)): Add
+	requires-clause.
+	* testsuite/20_util/tuple/cons/78302.cc: New test.
+
+2026-05-18  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-18  Jonathan Wakely  <jwakely@redhat.com>
+
+	* testsuite/23_containers/bitset/lwg4294.cc: Move to...
+	* testsuite/20_util/bitset/cons/lwg4294.cc: ...here.
+
+2026-05-16  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-16  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/125312
+	* acinclude.m4 (GLIBCXX_ENABLE_ATOMIC_BUILTINS): Copy header
+	into cwd instead of including it via an absolute path.
+	* configure: Regenerate.
+
+2026-05-16  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-04-24  Jonathan Wakely  <jwakely@redhat.com>
+
+	* src/c++20/tzdata.zi: Import new file from 2026a release.
+
+2026-05-16  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-13  Jonathan Wakely  <jwakely@redhat.com>
+
+	* include/bits/shared_ptr_atomic.h: Remove trailing whitespace.
+
+2026-05-05  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-05  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/109965
+	* doc/doxygen/mainpage.html: Link to topics.html instead of
+	modules.html
+
+2026-05-05  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-05  Jonathan Wakely  <jwakely@redhat.com>
+
+	* include/bits/unique_ptr.h (unique_ptr::_Nothrow_deref): New
+	helper for pre-C++20.
+	(unique_ptr::operator*): Either constrain or use _Nothrow_deref.
+	* testsuite/20_util/unique_ptr/lwg4324.cc: New test.
+
+2026-05-05  Jonathan Wakely  <jwakely@redhat.com>
+
+	Backported from master:
+	2026-05-01  Jonathan Wakely  <jwakely@redhat.com>
+
+	PR libstdc++/121919
+	* include/bits/ranges_algo.h (__sample_fn, __shuffle_fn): Use
+	decltype(__g()) instead of remove_reference_t<_G>::result_type.
+	* include/bits/uniform_int_dist.h
+	(uniform_int_distribution::operator()): Use decltype(__urng())
+	instead of _UniformRandomBitGenerator::result_type
+	(uniform_int_distribution::__generate_impl): Likewise.
+	* testsuite/25_algorithms/sample/121919.cc: New test.
+	* testsuite/25_algorithms/shuffle/121919.cc: New test.
+
+2026-04-30  Felix Morgner  <felix.morgner@gmail.com>
+
+	Backported from master:
+	2026-04-30  Felix Morgner  <felix.morgner@gmail.com>
+
+	PR libstdc++/125112
+	* include/Makefile.am: Move bits/binders.h from bits_headers to
+	bits_freestanding.
+	* include/Makefile.in:
+
+2026-04-30  Jakub Jelinek  <jakub@redhat.com>
+
+	Backported from master:
+	2026-04-27  Jakub Jelinek  <jakub@redhat.com>
+
+	PR libstdc++/125024
+	* include/std/type_traits (std::is_scalar): For
+	__cpp_impl_reflection >= 202506L handle is_reflection types as
+	scalar.
+	* testsuite/20_util/is_scalar/reflection.cc: New test.
+
 2026-04-30  Release Manager
 
 	* GCC 16.1.0 released.
--- a/src/libstdc++-v3/acinclude.m4
+++ b/src/libstdc++-v3/acinclude.m4
@@ -3755,6 +3755,15 @@ AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
     esac
   fi
 
+  # The $glibcxx_builddir/include/$target/bits/atomic_word.h header is created
+  # by include/Makefile so isn't available during configure. Copy it from the
+  # source dir to $PWD so that we don't include it using an absolute path,
+  # which does not work for win32 native builds (PR libstdc++/125312).
+  if ! $LN_S "${glibcxx_srcdir}/config/${atomic_word_dir}/atomic_word.h" ./
+  then
+    AC_MSG_ERROR([cannot create ./atomic_word.h])
+  fi
+
   if test "$atomic_builtins_link_tests" = yes; then
 
     # Do link tests.
@@ -3763,7 +3772,7 @@ AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
 
     AC_CACHE_CHECK([for atomic builtins for _Atomic_word],
 	glibcxx_cv_atomic_word,
-	[AC_TRY_LINK([#include "${glibcxx_srcdir}/config/$atomic_word_dir/atomic_word.h"],
+	[AC_TRY_LINK([#include "atomic_word.h"],
 		     [_Atomic_word a = 0, b;
 		      b = __atomic_fetch_add(&a, 1, __ATOMIC_ACQ_REL);],
 		     [glibcxx_cv_atomic_word=yes],
@@ -3779,7 +3788,7 @@ AC_DEFUN([GLIBCXX_ENABLE_ATOMIC_BUILTINS], [
 
     cat > conftest.$ac_ext << EOF
 [#]line __oline__ "configure"
-[#]include "${glibcxx_srcdir}/config/$atomic_word_dir/atomic_word.h"
+[#]include "atomic_word.h"
 int main()
 {
   _Atomic_word a = 0, b;
@@ -3799,6 +3808,8 @@ EOF
     rm -f conftest*
   fi
 
+  rm -f ./atomic_word.h
+
   CXXFLAGS="$old_CXXFLAGS"
   AC_LANG_RESTORE
 
--- a/src/libstdc++-v3/configure
+++ b/src/libstdc++-v3/configure
@@ -16422,6 +16422,15 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     esac
   fi
 
+  # The $glibcxx_builddir/include/$target/bits/atomic_word.h header is created
+  # by include/Makefile so isn't available during configure. Copy it from the
+  # source dir to $PWD so that we don't include it using an absolute path,
+  # which does not work for win32 native builds (PR libstdc++/125312).
+  if ! $LN_S "${glibcxx_srcdir}/config/${atomic_word_dir}/atomic_word.h" ./
+  then
+    as_fn_error $? "cannot create ./atomic_word.h" "$LINENO" 5
+  fi
+
   if test "$atomic_builtins_link_tests" = yes; then
 
     # Do link tests.
@@ -16438,7 +16447,7 @@ else
 fi
 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
-#include "${glibcxx_srcdir}/config/$atomic_word_dir/atomic_word.h"
+#include "atomic_word.h"
 int
 main ()
 {
@@ -16468,8 +16477,8 @@ $as_echo "$glibcxx_cv_atomic_word" >&6; }
     # Fake what AC_TRY_COMPILE does.
 
     cat > conftest.$ac_ext << EOF
-#line 16471 "configure"
-#include "${glibcxx_srcdir}/config/$atomic_word_dir/atomic_word.h"
+#line 16480 "configure"
+#include "atomic_word.h"
 int main()
 {
   _Atomic_word a = 0, b;
@@ -16495,6 +16504,8 @@ $as_echo "$glibcxx_cv_atomic_word" >&6; }
     rm -f conftest*
   fi
 
+  rm -f ./atomic_word.h
+
   CXXFLAGS="$old_CXXFLAGS"
   ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
@@ -16614,7 +16625,7 @@ $as_echo "mutex" >&6; }
   # unnecessary for this test.
 
     cat > conftest.$ac_ext << EOF
-#line 16617 "configure"
+#line 16628 "configure"
 int main()
 {
   _Decimal32 d1;
@@ -16656,7 +16667,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
   # unnecessary for this test.
 
   cat > conftest.$ac_ext << EOF
-#line 16659 "configure"
+#line 16670 "configure"
 template<typename T1, typename T2>
   struct same
   { typedef T2 type; };
@@ -54145,7 +54156,7 @@ $as_echo "$glibcxx_cv_libbacktrace_atomics" >&6; }
     CXXFLAGS='-O0 -S'
 
     cat > conftest.$ac_ext << EOF
-#line 54148 "configure"
+#line 54159 "configure"
 #include <stddef.h>
 int main()
 {
--- a/src/libstdc++-v3/doc/doxygen/mainpage.html
+++ b/src/libstdc++-v3/doc/doxygen/mainpage.html
@@ -38,7 +38,7 @@
 
 <p>Here are entry points to all the pages generated by Doxygen:
    <ul>
-    <li><a href="modules.html">Modules</a></li>
+    <li><a href="topics.html">Topics</a></li>
 
     <li>Namespaces
     <ul>
--- a/src/libstdc++-v3/include/Makefile.am
+++ b/src/libstdc++-v3/include/Makefile.am
@@ -129,6 +129,7 @@ bits_freestanding = \
 	${bits_srcdir}/alloc_traits.h \
 	${bits_srcdir}/atomic_base.h \
 	${bits_srcdir}/c++0x_warning.h \
+	${bits_srcdir}/binders.h \
 	${bits_srcdir}/boost_concept_check.h \
 	${bits_srcdir}/concept_check.h \
 	${bits_srcdir}/char_traits.h \
@@ -201,7 +202,6 @@ bits_headers = \
 	${bits_srcdir}/basic_ios.tcc \
 	${bits_srcdir}/basic_string.h \
 	${bits_srcdir}/basic_string.tcc \
-	${bits_srcdir}/binders.h \
 	${bits_srcdir}/charconv.h \
 	${bits_srcdir}/chrono.h \
 	${bits_srcdir}/chrono_io.h \
--- a/src/libstdc++-v3/include/Makefile.in
+++ b/src/libstdc++-v3/include/Makefile.in
@@ -487,6 +487,7 @@ bits_freestanding = \
 	${bits_srcdir}/alloc_traits.h \
 	${bits_srcdir}/atomic_base.h \
 	${bits_srcdir}/c++0x_warning.h \
+	${bits_srcdir}/binders.h \
 	${bits_srcdir}/boost_concept_check.h \
 	${bits_srcdir}/concept_check.h \
 	${bits_srcdir}/char_traits.h \
@@ -557,7 +558,6 @@ bits_freestanding = \
 @GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/basic_ios.tcc \
 @GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/basic_string.h \
 @GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/basic_string.tcc \
-@GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/binders.h \
 @GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/charconv.h \
 @GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/chrono.h \
 @GLIBCXX_HOSTED_TRUE@	${bits_srcdir}/chrono_io.h \
--- a/src/libstdc++-v3/include/bits/chrono_io.h
+++ b/src/libstdc++-v3/include/bits/chrono_io.h
@@ -5234,8 +5234,12 @@ namespace __detail
 		      else
 			{
 			  // Read hh
-			  __hh = 10 * _S_try_read_digit(__is, __err);
-			  __hh += _S_try_read_digit(__is, __err);
+			  auto __d1 = _S_try_read_digit(__is, __err);
+			  auto __d2 = _S_try_read_digit(__is, __err);
+			  if (__d1 >= 0 && __d2 >= 0) [[likely]]
+			    __hh = 10 * __d1 + __d2;
+			  else
+			    __err |= ios_base::failbit;
 			}
 
 		      if (__is_failed(__err))
@@ -5269,8 +5273,12 @@ namespace __detail
 		      int_least32_t __mm = 0;
 		      if (__read_mm)
 			{
-			  __mm = 10 * _S_try_read_digit(__is, __err);
-			  __mm += _S_try_read_digit(__is, __err);
+			  auto __d1 = _S_try_read_digit(__is, __err);
+			  auto __d2 = _S_try_read_digit(__is, __err);
+			  if (__d1 >= 0 && __d2 >= 0) [[likely]]
+			    __mm = 10 * __d1 + __d2;
+			  else
+			    __err |= ios_base::failbit;
 			}
 
 		      if (!__is_failed(__err))
--- a/src/libstdc++-v3/include/bits/ranges_algo.h
+++ b/src/libstdc++-v3/include/bits/ranges_algo.h
@@ -1850,8 +1850,7 @@ namespace ranges
 	    using __distrib_type = uniform_int_distribution<_Size>;
 	    using __param_type = typename __distrib_type::param_type;
 	    using _USize = __detail::__make_unsigned_like_t<_Size>;
-	    using __uc_type
-	      = common_type_t<typename remove_reference_t<_Gen>::result_type, _USize>;
+	    using __uc_type = common_type_t<decltype(__g()), _USize>;
 
 	    if (__first == __last)
 	      return __out;
@@ -1964,9 +1963,7 @@ namespace ranges
 	using __ud_type = __detail::__make_unsigned_like_t<_DistanceType>;
 	using __distr_type = std::uniform_int_distribution<__ud_type>;
 	using __p_type = typename __distr_type::param_type;
-
-	using __uc_type
-	  = common_type_t<typename remove_reference_t<_Gen>::result_type, __ud_type>;
+	using __uc_type = common_type_t<decltype(__g()), __ud_type>;
 
 	if constexpr (sized_sentinel_for<_Sent, _Iter>)
 	  {
--- a/src/libstdc++-v3/include/bits/shared_ptr_atomic.h
+++ b/src/libstdc++-v3/include/bits/shared_ptr_atomic.h
@@ -501,7 +501,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  auto __old_ptr = __ptr;
 	  _GLIBCXX_TSAN_MUTEX_PRE_UNLOCK(&_M_val);
-	  uintptr_t __old_pi 
+	  uintptr_t __old_pi
 	    = _AtomicRef(&_M_val).fetch_sub(1, memory_order_relaxed) - 1u;
 	  _GLIBCXX_TSAN_MUTEX_POST_UNLOCK(&_M_val);
 
--- a/src/libstdc++-v3/include/bits/uniform_int_dist.h
+++ b/src/libstdc++-v3/include/bits/uniform_int_dist.h
@@ -288,7 +288,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       operator()(_UniformRandomBitGenerator& __urng,
 		 const param_type& __param)
       {
-	typedef typename _UniformRandomBitGenerator::result_type _Gresult_type;
+	typedef decltype(__urng()) _Gresult_type;
 	typedef typename make_unsigned<result_type>::type __utype;
 	typedef typename common_type<_Gresult_type, __utype>::type __uctype;
 
@@ -386,7 +386,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		      const param_type& __param)
       {
 	__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
-	typedef typename _UniformRandomBitGenerator::result_type _Gresult_type;
+	typedef decltype(__urng()) _Gresult_type;
 	typedef typename make_unsigned<result_type>::type __utype;
 	typedef typename common_type<_Gresult_type, __utype>::type __uctype;
 
--- a/src/libstdc++-v3/include/bits/unique_ptr.h
+++ b/src/libstdc++-v3/include/bits/unique_ptr.h
@@ -289,6 +289,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  __not_<is_array<_Up>>
         >;
 
+#if ! __cpp_concepts
+      template<typename _Ptr, typename = void>
+	struct _Nothrow_deref
+	: false_type { };
+
+      template<typename _Ptr>
+	struct _Nothrow_deref<_Ptr, __void_t<decltype(*std::declval<_Ptr>())>>
+	: __bool_constant<noexcept(*std::declval<_Ptr>())> { };
+#endif
+
     public:
       // Constructors.
 
@@ -442,7 +452,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       /// Dereference the stored pointer.
       _GLIBCXX23_CONSTEXPR
       typename add_lvalue_reference<element_type>::type
-      operator*() const noexcept(noexcept(*std::declval<pointer>()))
+      operator*() const
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // 2762. unique_ptr operator*() should be noexcept
+      // 4324. unique_ptr<void>::operator* is not SFINAE-friendly
+#if __cpp_concepts
+      noexcept(noexcept(*std::declval<pointer>()))
+      requires requires { *std::declval<pointer>(); }
+#else
+      noexcept(_Nothrow_deref<pointer>::value)
+#endif
       {
 #if _GLIBCXX_USE_BUILTIN_TRAIT(__reference_converts_from_temporary)
 	// _GLIBCXX_RESOLVE_LIB_DEFECTS
--- a/src/libstdc++-v3/include/bits/version.def
+++ b/src/libstdc++-v3/include/bits/version.def
@@ -1898,16 +1898,21 @@ ftms = {
 
 ftms = {
   name = flat_map;
+  // 202207 P0429R9 A Standard flat_map
+  // 202511 P3567R2 flat_meow Fixes
   values = {
-    v = 202207;
+    v = 202511; // P3567R2 applied as DR for C++23
     cxxmin = 23;
   };
 };
 
 ftms = {
   name = flat_set;
+  // 202207 P1222R4 A Standard flat_set
+  //        LWG3751 Missing feature macro for flat_set
+  // 202511 P3567R2 flat_meow Fixes
   values = {
-    v = 202207;
+    v = 202511; // P3567R2 applied as DR for C++23
     cxxmin = 23;
   };
 };
--- a/src/libstdc++-v3/include/bits/version.h
+++ b/src/libstdc++-v3/include/bits/version.h
@@ -2108,9 +2108,9 @@
 
 #if !defined(__cpp_lib_flat_map)
 # if (__cplusplus >= 202100L)
-#  define __glibcxx_flat_map 202207L
+#  define __glibcxx_flat_map 202511L
 #  if defined(__glibcxx_want_all) || defined(__glibcxx_want_flat_map)
-#   define __cpp_lib_flat_map 202207L
+#   define __cpp_lib_flat_map 202511L
 #  endif
 # endif
 #endif /* !defined(__cpp_lib_flat_map) */
@@ -2118,9 +2118,9 @@
 
 #if !defined(__cpp_lib_flat_set)
 # if (__cplusplus >= 202100L)
-#  define __glibcxx_flat_set 202207L
+#  define __glibcxx_flat_set 202511L
 #  if defined(__glibcxx_want_all) || defined(__glibcxx_want_flat_set)
-#   define __cpp_lib_flat_set 202207L
+#   define __cpp_lib_flat_set 202511L
 #  endif
 # endif
 #endif /* !defined(__cpp_lib_flat_set) */
--- a/src/libstdc++-v3/include/debug/safe_iterator.h
+++ b/src/libstdc++-v3/include/debug/safe_iterator.h
@@ -1149,7 +1149,7 @@ namespace __gnu_debug
     inline bool
     __can_advance(const _Safe_iterator<_Iterator, _Sequence, _Category>& __it,
 		  _Size __n)
-    { 
+    {
       if (std::__is_constant_evaluated())
 	return true;
 
@@ -1166,7 +1166,7 @@ namespace __gnu_debug
     {
       if (std::__is_constant_evaluated())
 	return true;
-    
+
       return __it._M_can_advance(__dist, __way);
     }
 
--- a/src/libstdc++-v3/include/std/flat_map
+++ b/src/libstdc++-v3/include/std/flat_map
@@ -74,9 +74,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
       static_assert(is_same_v<_Tp, typename _MappedContainer::value_type>);
 
-      static_assert(is_nothrow_swappable_v<_KeyContainer>);
-      static_assert(is_nothrow_swappable_v<_MappedContainer>);
-
       using _Derived = __conditional_t<_Multi,
 				       flat_multimap<_Key, _Tp, _Compare,
 						     _KeyContainer, _MappedContainer>,
@@ -395,6 +392,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	: _Flat_map_impl(__s, __il.begin(), __il.end(), __comp, __a)
 	{ }
 
+      _Flat_map_impl(const _Flat_map_impl&) = default;
+      _Flat_map_impl& operator=(const _Flat_map_impl&) = default;
+
+      _GLIBCXX26_CONSTEXPR
+      _Flat_map_impl(_Flat_map_impl&& __other)
+      noexcept(is_nothrow_move_constructible_v<containers>
+	       && is_nothrow_move_constructible_v<key_compare>)
+#if __cpp_exceptions
+      try
+#endif
+      : _M_cont(std::move(__other._M_cont)), _M_comp(std::move(__other._M_comp))
+      { __other.clear(); }
+#if __cpp_exceptions
+      catch (...)
+      { __other.clear(); }
+#endif
+
+      _GLIBCXX26_CONSTEXPR
+      _Flat_map_impl&
+      operator=(_Flat_map_impl&& __other)
+      noexcept(is_nothrow_move_assignable_v<containers>
+	       && is_nothrow_move_assignable_v<key_compare>)
+      {
+	auto __guard = _M_make_clear_guard();
+	auto __guard_other = _ClearGuard{__other._M_cont};
+	_M_cont = std::move(__other._M_cont);
+	_M_comp = std::move(__other._M_comp);
+	__guard._M_disable();
+	// __guard_other._M_disable is deliberately not called.
+	return *this;
+      }
+
       _GLIBCXX26_CONSTEXPR
       _Derived&
       operator=(initializer_list<value_type> __il)
@@ -534,7 +563,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      return {iterator{this, __key_it}, false};
 
 	  auto __guard = _M_make_clear_guard();
-	  __key_it = _M_cont.keys.insert(__key_it, std::move(__k));
+	  __key_it = _M_cont.keys.insert(__key_it, std::forward<_Key2>(__k));
 	  __value_it = _M_cont.values.begin() + (__key_it - _M_cont.keys.begin());
 	  _M_cont.values.emplace(__value_it, std::forward<_Args>(__args)...);
 	  __guard._M_disable();
@@ -602,13 +631,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _Iter, typename _Sent>
 	_GLIBCXX26_CONSTEXPR
 	void
-	_M_insert(_Iter __first, _Sent __last)
+	_M_insert(_Iter __first, _Sent __last, bool __is_sorted = false)
 	{
-	  // FIXME: This implementation fails its complexity requirements.
-	  // We can't idiomatically implement an efficient version (as in the
-	  // disabled code) until ranges::inplace_merge is fixed to dispatch
-	  // on iterator concept instead of iterator category.
-#if 0
 	  auto __guard = _M_make_clear_guard();
 	  auto __n = size();
 	  for (; __first != __last; ++__first)
@@ -618,22 +642,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      _M_cont.values.emplace_back(std::move(__value.second));
 	    }
 	  auto __zv = views::zip(_M_cont.keys, _M_cont.values);
-	  ranges::sort(__zv.begin() + __n, __zv.end(), value_comp());
-	  ranges::inplace_merge(__zv.begin(), __zv.begin() + __n, __zv.end(), value_comp());
+	  if (__is_sorted)
+	    _GLIBCXX_DEBUG_ASSERT(ranges::is_sorted(__zv.begin() + __n, __zv.end(),
+						    value_comp()));
+	  else
+	    ranges::sort(__zv.begin() + __n, __zv.end(), value_comp());
+	  ranges::inplace_merge(__zv.begin(), __zv.begin() + __n, __zv.end(),
+				value_comp());
 	  if constexpr (!_Multi)
 	    _M_unique();
-	  __guard._M_cont = nullptr;
-#else
-	  auto __guard = _M_make_clear_guard();
-	  for (; __first != __last; ++__first)
-	    {
-	      value_type __value = *__first;
-	      _M_cont.keys.emplace_back(std::move(__value.first));
-	      _M_cont.values.emplace_back(std::move(__value.second));
-	    }
-	  _M_sort_uniq();
 	  __guard._M_disable();
-#endif
 	}
 
     public:
@@ -647,10 +665,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_GLIBCXX26_CONSTEXPR
 	void
 	insert(__sorted_t, _InputIterator __first, _InputIterator __last)
-	{
-	  // FIXME: This implementation fails its complexity requirements; see above.
-	  insert(std::move(__first), std::move(__last));
-	}
+	{ _M_insert(std::move(__first), std::move(__last), true); }
 
       template<__detail::__container_compatible_range<value_type> _Rg>
 	_GLIBCXX26_CONSTEXPR
@@ -658,6 +673,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	insert_range(_Rg&& __rg)
 	{ _M_insert(ranges::begin(__rg), ranges::end(__rg)); }
 
+      template<__detail::__container_compatible_range<value_type> _Rg>
+	_GLIBCXX26_CONSTEXPR
+	void
+	insert_range(__sorted_t, _Rg&& __rg)
+	{ _M_insert(ranges::begin(__rg), ranges::end(__rg), true); }
+
       _GLIBCXX26_CONSTEXPR
       void
       insert(initializer_list<value_type> __il)
@@ -742,11 +763,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       _GLIBCXX26_CONSTEXPR
       void
-      swap(_Derived& __y) noexcept
+      swap(_Derived& __y)
+      noexcept(is_nothrow_swappable_v<key_container_type>
+	       && is_nothrow_swappable_v<mapped_container_type>
+	       && is_nothrow_swappable_v<key_compare>)
       {
-	ranges::swap(_M_comp, __y._M_comp);
+	auto __guard = _M_make_clear_guard();
+	auto __guard_y = _ClearGuard{__y._M_cont};
 	ranges::swap(_M_cont.keys, __y._M_cont.keys);
 	ranges::swap(_M_cont.values, __y._M_cont.values);
+	ranges::swap(_M_comp, __y._M_comp);
+	__guard._M_disable();
+	__guard_y._M_disable();
       }
 
       _GLIBCXX26_CONSTEXPR
@@ -988,7 +1016,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
 
       friend _GLIBCXX26_CONSTEXPR void
-      swap(_Derived& __x, _Derived& __y) noexcept
+      swap(_Derived& __x, _Derived& __y) noexcept(noexcept(__x.swap(__y)))
       { return __x.swap(__y); }
 
       template<typename _Predicate>
@@ -1247,6 +1275,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // constructors
       using _Impl::_Impl;
 
+      // operator=(initializer_list<value_type>)
+      // Although this also brings in the base move/copy assignment operators,
+      // they will be hidden by our synthesized ones.
+      using _Impl::operator=;
+
       // iterators
       using _Impl::begin;
       using _Impl::end;
@@ -1600,6 +1633,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // constructors
       using _Impl::_Impl;
 
+      // operator=(initializer_list<value_type>)
+      // Although this also brings in the base move/copy assignment operators,
+      // they will be hidden by our synthesized ones.
+      using _Impl::operator=;
+
       // iterators
       using _Impl::begin;
       using _Impl::end;
--- a/src/libstdc++-v3/include/std/flat_set
+++ b/src/libstdc++-v3/include/std/flat_set
@@ -71,7 +71,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class _Flat_set_impl
     {
       static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
-      static_assert(is_nothrow_swappable_v<_KeyContainer>);
 
       using _Derived = __conditional_t<_Multi,
 				       flat_multiset<_Key, _Compare, _KeyContainer>,
@@ -324,6 +323,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	: _Flat_set_impl(__s, __il.begin(), __il.end(), __comp, __a)
 	{ }
 
+      _Flat_set_impl(const _Flat_set_impl&) = default;
+      _Flat_set_impl& operator=(const _Flat_set_impl&) = default;
+
+      _GLIBCXX26_CONSTEXPR
+      _Flat_set_impl(_Flat_set_impl&& __other)
+      noexcept(is_nothrow_move_constructible_v<container_type>
+	       && is_nothrow_move_constructible_v<key_compare>)
+#if __cpp_exceptions
+      try
+#endif
+      : _M_cont(std::move(__other._M_cont)), _M_comp(std::move(__other._M_comp))
+      { __other.clear(); }
+#if __cpp_exceptions
+      catch (...)
+      { __other.clear(); }
+#endif
+
+      _GLIBCXX26_CONSTEXPR
+      _Flat_set_impl&
+      operator=(_Flat_set_impl&& __other)
+      noexcept(is_nothrow_move_assignable_v<container_type>
+	       && is_nothrow_move_assignable_v<key_compare>)
+      {
+	auto __guard = _M_make_clear_guard();
+	auto __guard_other = _ClearGuard{__other._M_cont};
+	_M_cont = std::move(__other._M_cont);
+	_M_comp = std::move(__other._M_comp);
+	__guard._M_disable();
+	// __guard_other._M_disable is deliberately not called.
+	return *this;
+      }
+
       _GLIBCXX26_CONSTEXPR
       _Derived&
       operator=(initializer_list<value_type> __il)
@@ -540,10 +571,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  __guard._M_disable();
 	}
 
-      template<__detail::__container_compatible_range<value_type> _Rg>
+      template<typename _Rg>
 	_GLIBCXX26_CONSTEXPR
 	void
-	insert_range(_Rg&& __rg)
+	_M_insert_range(_Rg&& __rg, bool __is_sorted = false)
 	{
 	  auto __guard = _M_make_clear_guard();
 	  typename container_type::iterator __it;
@@ -561,13 +592,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 		_M_cont.emplace_back(*__first);
 	      __it = _M_cont.begin() + __n;
 	    }
-	  std::sort(__it, _M_cont.end(), _M_comp);
+	  if (__is_sorted)
+	    _GLIBCXX_DEBUG_ASSERT(ranges::is_sorted(__it, _M_cont.end(), _M_comp));
+	  else
+	    std::sort(__it, _M_cont.end(), _M_comp);
 	  std::inplace_merge(_M_cont.begin(), __it, _M_cont.end(), _M_comp);
 	  if constexpr (!_Multi)
 	    _M_unique();
 	  __guard._M_disable();
 	}
 
+    template<__detail::__container_compatible_range<value_type> _Rg>
+      _GLIBCXX26_CONSTEXPR
+      void
+      insert_range(_Rg&& __rg)
+      { _M_insert_range(std::forward<_Rg>(__rg)); }
+
+    template<__detail::__container_compatible_range<value_type> _Rg>
+      _GLIBCXX26_CONSTEXPR
+      void
+      insert_range(__sorted_t, _Rg&& __rg)
+      { _M_insert_range(std::forward<_Rg>(__rg), true); }
+
       _GLIBCXX26_CONSTEXPR
       void
       insert(initializer_list<value_type> __il)
@@ -628,11 +674,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       _GLIBCXX26_CONSTEXPR
       void
-      swap(_Derived& __x) noexcept
+      swap(_Derived& __y)
+      noexcept(is_nothrow_swappable_v<container_type>
+	       && is_nothrow_swappable_v<key_compare>)
       {
-	using std::swap;
-	swap(_M_cont, __x._M_cont);
-	swap(_M_comp, __x._M_comp);
+	auto __guard = _M_make_clear_guard();
+	auto __guard_y = _ClearGuard{__y._M_cont};
+	ranges::swap(_M_cont, __y._M_cont);
+	ranges::swap(_M_comp, __y._M_comp);
+	__guard._M_disable();
+	__guard_y._M_disable();
       }
 
       _GLIBCXX26_CONSTEXPR
@@ -830,7 +881,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
 
       friend _GLIBCXX26_CONSTEXPR void
-      swap(_Derived& __x, _Derived& __y) noexcept
+      swap(_Derived& __x, _Derived& __y) noexcept(noexcept(__x.swap(__y)))
       { return __x.swap(__y); }
 
       template<typename _Predicate>
@@ -916,6 +967,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // constructors
       using _Impl::_Impl;
 
+      // operator=(initializer_list<value_type>)
+      // Although this also brings in the base move/copy assignment operators,
+      // they will be hidden by our synthesized ones.
+      using _Impl::operator=;
+
       // iterators
       using _Impl::begin;
       using _Impl::end;
@@ -1064,6 +1120,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // constructors
       using _Impl::_Impl;
 
+      // operator=(initializer_list<value_type>)
+      // Although this also brings in the base move/copy assignment operators,
+      // they will be hidden by our synthesized ones.
+      using _Impl::operator=;
+
       // iterators
       using _Impl::begin;
       using _Impl::end;
--- a/src/libstdc++-v3/include/std/mdspan
+++ b/src/libstdc++-v3/include/std/mdspan
@@ -2628,7 +2628,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ return _PaddedStorage::_M_is_always_exhaustive(); }
 
 	constexpr bool
-	is_exhaustive() noexcept
+	is_exhaustive() const noexcept
 	{ return _M_storage._M_is_exhaustive(); }
 
 	static constexpr bool
@@ -2801,7 +2801,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{ return _PaddedStorage::_M_is_always_exhaustive(); }
 
 	constexpr bool
-	is_exhaustive() noexcept
+	is_exhaustive() const noexcept
 	{ return _M_storage._M_is_exhaustive(); }
 
 	static constexpr bool
--- a/src/libstdc++-v3/include/std/optional
+++ b/src/libstdc++-v3/include/std/optional
@@ -60,7 +60,9 @@
 # include <concepts>
 #endif
 #ifdef __cpp_lib_optional_range_support // C++ >= 26
-# include <bits/formatfwd.h>
+# if _GLIBCXX_HOSTED
+#  include <bits/formatfwd.h>
+# endif
 # include <bits/ranges_base.h>
 # include <bits/stl_iterator.h>
 #endif
@@ -2285,9 +2287,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     ranges::enable_borrowed_range<optional<_Tp&>> = true;
 #endif
 
+#if _GLIBCXX_HOSTED
   template<typename _Tp>
     inline constexpr range_format
       format_kind<optional<_Tp>> = range_format::disabled;
+#endif
 #endif // __cpp_lib_optional_range_support
 
 #undef _GLIBCXX_USE_CONSTRAINTS_FOR_OPTIONAL
--- a/src/libstdc++-v3/include/std/tuple
+++ b/src/libstdc++-v3/include/std/tuple
@@ -993,7 +993,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       constexpr tuple(const tuple&) = default;
 
-      constexpr tuple(tuple&&) = default;
+      constexpr
+      tuple(tuple&&) requires (is_move_constructible_v<_Elements> && ...)
+	= default;
 
       template<typename... _UTypes>
 	requires (__constructible<const _UTypes&...>())
--- a/src/libstdc++-v3/include/std/type_traits
+++ b/src/libstdc++-v3/include/std/type_traits
@@ -871,7 +871,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp>
     struct is_scalar
     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
-                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
+                   is_member_pointer<_Tp>, is_null_pointer<_Tp>
+#if __cpp_impl_reflection >= 202506L
+		   , is_reflection<_Tp>
+#endif
+		   >::type
     { };
 
   /// is_compound
--- a/src/libstdc++-v3/src/c++20/tzdata.zi
+++ b/src/libstdc++-v3/src/c++20/tzdata.zi
@@ -1,4 +1,5 @@
-# version 2025c
+# version 2026b
+# redo posix_only
 # This zic input file is in the public domain.
 R d 1916 o - Jun 14 23s 1 S
 R d 1916 1919 - O Su>=1 23s 0 -
@@ -1304,8 +1305,8 @@ R MT 1974 o - S 16 0s 0 -
 R MT 1975 1979 - Ap Su>=15 2 1 S
 R MT 1975 1980 - S Su>=15 2 0 -
 R MT 1980 o - Mar 31 2 1 S
-R MD 1997 ma - Mar lastSu 2 1 S
-R MD 1997 ma - O lastSu 3 0 -
+R MD 1997 2021 - Mar lastSu 2 1 S
+R MD 1997 2021 - O lastSu 3 0 -
 R O 1918 1919 - S 16 2s 0 -
 R O 1919 o - Ap 15 2s 1 S
 R O 1944 o - Ap 3 2s 1 S
@@ -2965,7 +2966,9 @@ Z America/Toronto -5:17:32 - LMT 1895
 -5 C E%sT
 Z America/Vancouver -8:12:28 - LMT 1884
 -8 Va P%sT 1987
--8 C P%sT
+-8 C P%sT 2026 Mar 9
+-8 1 PDT 2026 N 1 2
+-7 - MST
 Z America/Whitehorse -9:0:12 - LMT 1900 Au 20
 -9 Y Y%sT 1965
 -9 Yu Y%sT 1966 F 27
@@ -3666,7 +3669,8 @@ Z Europe/Chisinau 1:55:20 - LMT 1880
 3 R MSK/MSD 1990 May 6 2
 2 R EE%sT 1992
 2 e EE%sT 1997
-2 MD EE%sT
+2 MD EE%sT 2022
+2 E EE%sT
 Z Europe/Dublin -0:25:21 - LMT 1880 Au 2
 -0:25:21 - DMT 1916 May 21 2s
 -0:25:21 1 IST 1916 O 1 2s
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/20_util/bitset/cons/lwg4294.cc
@@ -0,0 +1,11 @@
+// { dg-do compile { target c++11 } }
+
+// Bug 121046
+// Asking is_constructible_v<std::bitset<1>, NonTrivial*> is ill-formed
+
+// LWG 4294. bitset(const CharT*) constructor needs to be constrained
+
+#include <bitset>
+struct NonTrivial { ~NonTrivial() { } };
+static_assert( ! std::is_constructible<std::bitset<1>, NonTrivial*>::value,
+	       "std::bitset cannot be constructed from this pointer" );
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/20_util/is_scalar/reflection.cc
@@ -0,0 +1,13 @@
+// { dg-do compile { target c++26 } }
+// { dg-additional-options "-freflection" }
+
+#include <type_traits>
+#include <testsuite_tr1.h>
+
+void test01()
+{
+  using std::is_scalar;
+  using namespace __gnu_test;
+
+  static_assert(test_category<is_scalar, decltype (^^::)>(true), "");
+}
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/20_util/tuple/cons/78302.cc
@@ -0,0 +1,17 @@
+// { dg-do compile { target c++20 } }
+
+// Bug 78302 is_move_constructible_v<tuple<nonmovable>> should be false
+// LWG 2899. is_(nothrow_)move_constructible and tuple, optional and unique_ptr
+
+#include <tuple>
+#include <type_traits>
+
+struct NotMovable { NotMovable(NotMovable&&) = delete; };
+static_assert(!std::is_move_constructible_v<std::tuple<NotMovable>>);
+static_assert(!std::is_move_constructible_v<std::tuple<int, NotMovable>>);
+static_assert(!std::is_move_constructible_v<std::tuple<int&, NotMovable>>);
+static_assert(!std::is_move_constructible_v<std::tuple<int&&, NotMovable>>);
+static_assert(std::is_nothrow_move_constructible_v<std::tuple<int>>);
+static_assert(std::is_nothrow_move_constructible_v<std::tuple<int&>>);
+static_assert(std::is_nothrow_move_constructible_v<std::tuple<int&&>>);
+static_assert(std::is_nothrow_move_constructible_v<std::tuple<int&&, int&>>);
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/20_util/unique_ptr/lwg4324.cc
@@ -0,0 +1,22 @@
+// { dg-do compile { target c++11 } }
+
+// LWG 4324. unique_ptr<void>::operator* is not SFINAE-friendly
+
+#include <memory>
+
+template<class T, bool = true>
+struct nothrow_dereference
+: std::false_type { };
+
+template<class T>
+struct nothrow_dereference<T, noexcept(*std::declval<T>())>
+: std::true_type { };
+
+static_assert( nothrow_dereference<std::unique_ptr<int>>::value, "");
+static_assert( ! nothrow_dereference<std::unique_ptr<void>>::value, "");
+
+#if __cplusplus >= 202002L // C++20
+template<class T> concept dereferenceable = requires(T& t) { *t; };
+static_assert( dereferenceable<std::unique_ptr<int>>);
+static_assert(!dereferenceable<std::unique_ptr<void>>);
+#endif
deleted file mode 100644
--- a/src/libstdc++-v3/testsuite/23_containers/bitset/lwg4294.cc
+++ /dev/null
@@ -1,11 +0,0 @@
-// { dg-do compile { target c++11 } }
-
-// Bug 121046
-// Asking is_constructible_v<std::bitset<1>, NonTrivial*> is ill-formed
-
-// LWG 4294. bitset(const CharT*) constructor needs to be constrained
-
-#include <bitset>
-struct NonTrivial { ~NonTrivial() { } };
-static_assert( ! std::is_constructible<std::bitset<1>, NonTrivial*>::value,
-	       "std::bitset cannot be constructed from this pointer" );
--- a/src/libstdc++-v3/testsuite/23_containers/flat_map/1.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/flat_map/1.cc
@@ -3,7 +3,7 @@
 
 #include <flat_map>
 
-#if __cpp_lib_flat_map != 202207L
+#if __cpp_lib_flat_map != 202511L
 # error "Feature-test macro __cpp_lib_flat_map has wrong value in <flat_map>"
 #endif
 
@@ -13,6 +13,7 @@
 #include <testsuite_allocator.h>
 #include <testsuite_hooks.h>
 #include <testsuite_iterators.h>
+#include <string>
 #include <tuple>
 
 struct Gt {
@@ -283,6 +284,127 @@ test09()
   using value_type = std::pair<int, int>;
 }
 
+constexpr
+void
+test10()
+{
+  // PR libstdc++/125374 - flat_map unconditionally moves from lvalue keys in
+  // _M_try_emplace
+  std::flat_map<std::string, int, std::less<>> m;
+  std::string k = "hello";
+  m[k] = 1;
+  VERIFY (k == "hello");
+  k = "world";
+  m.try_emplace(k, 2);
+  VERIFY (k == "world");
+}
+
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+  static inline bool throw_on_move = false;
+
+  throwing_vector() = default;
+  throwing_vector(const throwing_vector&) = default;
+  throwing_vector& operator=(const throwing_vector&) = default;
+
+  throwing_vector(throwing_vector&& other)
+  : std::vector<T>(std::move(other))
+  {
+    if (throw_on_move)
+      throw std::runtime_error("move ctor");
+  }
+
+  throwing_vector&
+  operator=(throwing_vector&& other)
+  {
+    static_cast<std::vector<T>&>(*this) = std::move(other);
+    if (throw_on_move)
+      throw std::runtime_error("move assign");
+    return *this;
+  }
+};
+
+template<template<typename> class KC, template<typename> class MC>
+void
+test11()
+{
+#if __cpp_exceptions
+  using flat_map = std::flat_map<int, int, std::less<int>, KC<int>, MC<int>>;
+
+  auto is_really_empty = [](const flat_map& m) {
+    return m.empty() && m.keys().empty() && m.values().empty();
+  };
+  throwing_vector<int>::throw_on_move = true;
+
+  // Verify invariant preservation upon throwing move construction.
+  flat_map source;
+  source.insert({{1, 100}, {2, 200}});
+  try
+    {
+      flat_map target(std::move(source));
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( is_really_empty(source) );
+    }
+
+  // Verify invariant preservation upon throwing move assignment.
+  source = {{1, 100}, {2, 200}};
+  flat_map target;
+  target.insert({{3, 300}, {4, 400}});
+  try
+    {
+      target = std::move(source);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( is_really_empty(source) );
+      VERIFY( is_really_empty(target) );
+    }
+
+  // Verify invariant preservation upon throwing swap.
+  source = {{1, 100}, {2, 200}};
+  target = {{3, 300}, {4, 400}};
+  try
+    {
+      source.swap(target);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( is_really_empty(source) );
+      VERIFY( is_really_empty(target) );
+    }
+#endif
+}
+
+constexpr
+void
+test12()
+{
+  // Verify usability of flat_map::insert_range(sorted_unique_t, Rg&&).
+  std::flat_map<int, int> m = {{2, 200}};
+  std::pair<int, int> s[] = {{1, 100}, {3, 300}};
+  m.insert_range(std::sorted_unique, s);
+  VERIFY( std::ranges::equal(m.keys(), (int[]){1, 2, 3}) );
+  VERIFY( std::ranges::equal(m.values(), (int[]){100, 200, 300}) );
+}
+
+void
+test13()
+{
+  // Verify usability of flat_map::operator=(initializer_list).
+  throwing_vector<int>::throw_on_move = true;
+  std::flat_map<int, int, std::less<int>, throwing_vector<int>> s;
+  std::initializer_list<std::pair<int, int>> il = {{2, 1}, {3, 2}, {1, 3}};
+  s = il;
+  VERIFY( std::ranges::equal(s.keys(), (int[]){1, 2, 3}) );
+  VERIFY( std::ranges::equal(s.values(), (int[]){3, 1, 2}) );
+}
+
 void
 test()
 {
@@ -298,6 +420,11 @@ test()
   test07();
   test08();
   test09();
+  test10();
+  test11<std::vector, throwing_vector>();
+  test11<throwing_vector, std::vector>();
+  test12();
+  test13();
 }
 
 constexpr
@@ -313,6 +440,12 @@ test_constexpr()
   test07();
   test08();
   test09();
+#if __cpp_lib_constexpr_string >= 201907L
+  test10();
+#endif
+  // test11() is non-constexpr
+  test12();
+  // test13() is non-constexpr
   return true;
 }
 
--- a/src/libstdc++-v3/testsuite/23_containers/flat_multimap/1.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/flat_multimap/1.cc
@@ -252,6 +252,112 @@ test09()
   using value_type = std::pair<int, int>;
 }
 
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+  static inline bool throw_on_move = false;
+
+  throwing_vector() = default;
+  throwing_vector(const throwing_vector&) = default;
+  throwing_vector& operator=(const throwing_vector&) = default;
+
+  throwing_vector(throwing_vector&& other)
+  : std::vector<T>(std::move(other))
+  {
+    if (throw_on_move)
+      throw std::runtime_error("move ctor");
+  }
+
+  throwing_vector&
+  operator=(throwing_vector&& other)
+  {
+    static_cast<std::vector<T>&>(*this) = std::move(other);
+    if (throw_on_move)
+      throw std::runtime_error("move assign");
+    return *this;
+  }
+};
+
+template<template<typename> class KC, template<typename> class MC>
+void
+test10()
+{
+#if __cpp_exceptions
+  using flat_multimap = std::flat_multimap<int, int, std::less<int>, KC<int>, MC<int>>;
+
+  auto is_really_empty = [](const flat_multimap& m) {
+    return m.empty() && m.keys().empty() && m.values().empty();
+  };
+  throwing_vector<int>::throw_on_move = true;
+
+  // Verify invariant preservation upon throwing move construction.
+  flat_multimap source;
+  source.insert({{1, 100}, {2, 200}});
+  try
+    {
+      flat_multimap target(std::move(source));
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( is_really_empty(source) );
+    }
+
+  // Verify invariant preservation upon throwing move assignment.
+  source = {{1, 100}, {2, 200}};
+  flat_multimap target;
+  target.insert({{3, 300}, {4, 400}});
+  try
+    {
+      target = std::move(source);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( is_really_empty(source) );
+      VERIFY( is_really_empty(target) );
+    }
+
+  // Verify invariant preservation upon throwing swap.
+  source = {{1, 100}, {2, 200}};
+  target = {{3, 300}, {4, 400}};
+  try
+    {
+      source.swap(target);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( is_really_empty(source) );
+      VERIFY( is_really_empty(target) );
+    }
+#endif
+}
+
+constexpr
+void
+test11()
+{
+  // Verify usability of flat_multimap::insert_range(sorted_equivalent_t, Rg&&).
+  std::flat_multimap<int, int> m = {{2, 200}};;
+  std::pair<int, int> s[] = {{1, 100}, {3, 300}};
+  m.insert_range(std::sorted_equivalent, s);
+  VERIFY( std::ranges::equal(m.keys(), (int[]){1, 2, 3}) );
+  VERIFY( std::ranges::equal(m.values(), (int[]){100, 200, 300}) );
+}
+
+void
+test12()
+{
+  // Verify usability of flat_multimap::operator=(initializer_list).
+  throwing_vector<int>::throw_on_move = true;
+  std::flat_multimap<int, int, std::less<int>, throwing_vector<int>> s;
+  std::initializer_list<std::pair<int, int>> il = {{2, 1}, {3, 2}, {1, 3}};
+  s = il;
+  VERIFY( std::ranges::equal(s.keys(), (int[]){1, 2, 3}) );
+  VERIFY( std::ranges::equal(s.values(), (int[]){3, 1, 2}) );
+}
+
 void
 test()
 {
@@ -266,6 +372,10 @@ test()
   test06();
   test07();
   test09();
+  test10<std::vector, throwing_vector>();
+  test10<throwing_vector, std::vector>();
+  test11();
+  test12();
 }
 
 constexpr
@@ -280,6 +390,9 @@ test_constexpr()
   test06();
   test07();
   test09();
+  // test10() is non-constexpr
+  test11();
+  // test12() is non-constexpr
   return true;
 }
 
--- a/src/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc
@@ -265,6 +265,106 @@ test09()
   VERIFY( std::ranges::equal(s, (int[]){2,2,4}) );
 }
 
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+  static inline bool throw_on_move = false;
+
+  throwing_vector() = default;
+  throwing_vector(const throwing_vector&) = default;
+  throwing_vector& operator=(const throwing_vector&) = default;
+
+  throwing_vector(throwing_vector&& other)
+  : std::vector<T>(std::move(other))
+  {
+    if (throw_on_move)
+      throw std::runtime_error("move ctor");
+  }
+
+  throwing_vector&
+  operator=(throwing_vector&& other)
+  {
+    static_cast<std::vector<T>&>(*this) = std::move(other);
+    if (throw_on_move)
+      throw std::runtime_error("move assign");
+    return *this;
+  }
+
+  using std::vector<int>::operator=;
+};
+
+void
+test10()
+{
+#if __cpp_exceptions
+  using flat_multiset = std::flat_multiset<int, std::less<int>, throwing_vector<int>>;
+
+  throwing_vector<int>::throw_on_move = true;
+
+  // Verify invariant preservation upon throwing move construction.
+  flat_multiset source = {1, 2};
+  try
+    {
+      flat_multiset target(std::move(source));
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( source.empty() );
+    }
+
+  // Verify invariant preservation upon throwing move assignment.
+  source = {1, 2};
+  flat_multiset target = {3, 4};
+  try
+    {
+      target = std::move(source);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( source.empty() );
+      VERIFY( target.empty() );
+    }
+
+  // Verify invariant preservation upon throwing swap.
+  source = {1, 2};
+  target = {3, 4};
+  try
+    {
+      source.swap(target);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( source.empty() );
+      VERIFY( target.empty() );
+    }
+#endif
+}
+
+constexpr
+void
+test11()
+{
+  // Verify usability of flat_multiset::insert_range(sorted_equivalent_t, Rg&&).
+  std::flat_multiset<int> m = {2};
+  int s[] = {1, 3};
+  m.insert_range(std::sorted_equivalent, s);
+  VERIFY( std::ranges::equal(m, (int[]){1, 2, 3}) );
+}
+
+void
+test12()
+{
+  // Verify usability of flat_multiset::operator=(initializer_list).
+  throwing_vector<int>::throw_on_move = true;
+  std::flat_multiset<int, std::less<int>, throwing_vector<int>> s;
+  std::initializer_list<int> il = {2, 3, 1};
+  s = il;
+  VERIFY( std::ranges::equal(s, (int[]){1, 2, 3}) );
+}
+
 void
 test()
 {
@@ -278,6 +378,9 @@ test()
   test07();
   test08();
   test09();
+  test10();
+  test11();
+  test12();
 }
 
 constexpr
@@ -292,6 +395,9 @@ test_constexpr()
   test07();
   test08();
   test09();
+  // test10() is non-constexpr
+  test11();
+  // test12() is non-constexpr
   return true;
 }
 
--- a/src/libstdc++-v3/testsuite/23_containers/flat_set/1.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/flat_set/1.cc
@@ -2,7 +2,7 @@
 
 #include <flat_set>
 
-#if __cpp_lib_flat_set != 202207L
+#if __cpp_lib_flat_set != 202511L
 # error "Feature-test macro __cpp_lib_flat_set has wrong value in <flat_set>"
 #endif
 
@@ -277,6 +277,106 @@ test09()
   VERIFY( std::ranges::equal(s, (int[]){2,4}) );
 }
 
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+  static inline bool throw_on_move = false;
+
+  throwing_vector() = default;
+  throwing_vector(const throwing_vector&) = default;
+  throwing_vector& operator=(const throwing_vector&) = default;
+
+  throwing_vector(throwing_vector&& other)
+  : std::vector<T>(std::move(other))
+  {
+    if (throw_on_move)
+      throw std::runtime_error("move ctor");
+  }
+
+  throwing_vector&
+  operator=(throwing_vector&& other)
+  {
+    static_cast<std::vector<T>&>(*this) = std::move(other);
+    if (throw_on_move)
+      throw std::runtime_error("move assign");
+    return *this;
+  }
+
+  using std::vector<int>::operator=;
+};
+
+void
+test10()
+{
+#if __cpp_exceptions
+  using flat_set = std::flat_set<int, std::less<int>, throwing_vector<int>>;
+
+  throwing_vector<int>::throw_on_move = true;
+
+  // Verify invariant preservation upon throwing move construction.
+  flat_set source = {1, 2};
+  try
+    {
+      flat_set target(std::move(source));
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( source.empty() );
+    }
+
+  // Verify invariant preservation upon throwing move assignment.
+  source = {1, 2};
+  flat_set target = {3, 4};
+  try
+    {
+      target = std::move(source);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( source.empty() );
+      VERIFY( target.empty() );
+    }
+
+  // Verify invariant preservation upon throwing swap.
+  source = {1, 2};
+  target = {3, 4};
+  try
+    {
+      source.swap(target);
+      VERIFY( false );
+    }
+  catch (const std::runtime_error&)
+    {
+      VERIFY( source.empty() );
+      VERIFY( target.empty() );
+    }
+#endif
+}
+
+constexpr
+void
+test11()
+{
+  // Verify usability of flat_set::insert_range(sorted_unique_t, Rg&&).
+  std::flat_set<int> m = {2};
+  int s[] = {1, 3};
+  m.insert_range(std::sorted_unique, s);
+  VERIFY( std::ranges::equal(m, (int[]){1, 2, 3}) );
+}
+
+void
+test12()
+{
+  // Verify usability of flat_set::operator=(initializer_list).
+  throwing_vector<int>::throw_on_move = true;
+  std::flat_set<int, std::less<int>, throwing_vector<int>> s;
+  std::initializer_list<int> il = {2, 3, 1};
+  s = il;
+  VERIFY( std::ranges::equal(s, (int[]){1, 2, 3}) );
+}
+
 void
 test()
 {
@@ -290,6 +390,9 @@ test()
   test07();
   test08();
   test09();
+  test10();
+  test11();
+  test12();
 }
 
 constexpr
@@ -304,6 +407,9 @@ test_constexpr()
   test07();
   test08();
   test09();
+  // test10() is non-constexpr
+  test11();
+  // test12() is non-constexpr
   return true;
 }
 
--- a/src/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
@@ -44,6 +44,14 @@ template<typename Layout, typename Extents>
     static_assert(M::is_always_strided() && M::is_strided());
     if constexpr (has_static_is_exhaustive<M>)
       static_assert(M::is_always_exhaustive() && M::is_exhaustive());
+
+    static_assert(noexcept(M::is_always_unique()));
+    static_assert(noexcept(M::is_always_strided()));
+    static_assert(noexcept(M::is_always_exhaustive()));
+    static_assert(noexcept(std::declval<const M>().is_unique()));
+    static_assert(noexcept(std::declval<const M>().is_strided()));
+    static_assert(noexcept(std::declval<const M>().is_exhaustive()));
+
     return true;
   }
 
--- a/src/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded.cc
@@ -509,7 +509,7 @@ template<template<size_t> typename Layout>
   {
     auto exts = std::extents<int>{};
 
-    auto check = [](auto m)
+    auto check = [](const auto m)
     {
       static_assert(m.is_always_exhaustive());
       VERIFY(m.is_exhaustive());
@@ -529,7 +529,7 @@ constexpr void
     {
       auto check = [](auto exts)
       {
-	auto m = typename PaddedLayout::mapping(exts);
+	const auto m = typename PaddedLayout::mapping(exts);
 	static_assert(m.is_always_exhaustive());
 	VERIFY(m.is_exhaustive());
       };
@@ -554,7 +554,7 @@ template<template<size_t> typename Layout>
     auto ctrue = std::cw<true>;
     auto cfalse= std::cw<false>;
 
-    auto check = [](auto m, auto static_expected, auto runtime_expected)
+    auto check = [](const auto m, auto static_expected, auto runtime_expected)
     {
       static_assert(m.is_always_exhaustive() == static_expected);
       VERIFY(m.is_exhaustive() == runtime_expected);
--- a/src/libstdc++-v3/testsuite/23_containers/mdspan/layouts/stride.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/mdspan/layouts/stride.cc
@@ -278,7 +278,7 @@ template<typename Extents, typename Strides>
   constexpr void
   test_is_exhaustive(Extents extents, Strides strides, bool expected)
   {
-    std::layout_stride::mapping<Extents> m(extents, strides);
+    const std::layout_stride::mapping<Extents> m(extents, strides);
     VERIFY(m.is_exhaustive() == expected);
 
     bool always_exhaustive = extents.rank() == 0 || m.required_span_size() == 0;
--- a/src/libstdc++-v3/testsuite/23_containers/mdspan/mdspan.cc
+++ b/src/libstdc++-v3/testsuite/23_containers/mdspan/mdspan.cc
@@ -720,9 +720,9 @@ template<typename Layout, bool Expected>
     static_assert(noexcept(MDSpan::is_always_exhaustive()) == Expected);
     static_assert(noexcept(MDSpan::is_always_strided()) == Expected);
 
-    static_assert(noexcept(std::declval<MDSpan>().is_unique()) == Expected);
-    static_assert(noexcept(std::declval<MDSpan>().is_exhaustive()) == Expected);
-    static_assert(noexcept(std::declval<MDSpan>().is_strided()) == Expected);
+    static_assert(noexcept(std::declval<const MDSpan>().is_unique()) == Expected);
+    static_assert(noexcept(std::declval<const MDSpan>().is_exhaustive()) == Expected);
+    static_assert(noexcept(std::declval<const MDSpan>().is_strided()) == Expected);
   }
 
 int
--- a/src/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc
+++ b/src/libstdc++-v3/testsuite/25_algorithms/pstl/alg_sorting/minmax_element.cc
@@ -189,7 +189,11 @@ int
 main()
 {
     using TestUtils::float64_t;
+#ifndef _GLIBCXX_DEBUG
     const std::size_t N = 100000;
+#else
+    const std::size_t N = 10000;
+#endif
 
     for (std::size_t n = 0; n < N; n = n < 16 ? n + 1 : size_t(3.14159 * n))
     {
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/25_algorithms/sample/121919.cc
@@ -0,0 +1,28 @@
+// { dg-do compile { target c++20 } }
+
+// Bug 121919 ranges::sample assumes a uniform_random_bit_generator
+// provides result_type
+
+#include <algorithm>
+#include <testsuite_iterators.h>
+
+struct G
+{
+  constexpr static unsigned min() { return 0;  }
+  constexpr static unsigned max() { return 10; }
+  unsigned operator()() const;
+};
+
+static_assert(std::uniform_random_bit_generator<G>);
+
+void
+test_pr121919()
+{
+  int i2[2]{ 1, 2 };
+  __gnu_test::test_random_access_range from(i2);
+  int i1[1];
+  __gnu_test::test_random_access_range to(i1);
+  std::ranges::sample(from, std::ranges::begin(to), 1, G{});
+  std::ranges::sample(std::ranges::begin(from), std::ranges::end(to),
+		      std::ranges::begin(to), 1, G{});
+}
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/25_algorithms/shuffle/121919.cc
@@ -0,0 +1,25 @@
+// { dg-do compile { target c++20 } }
+
+// Bug 121919 ranges::shuffle assumes a uniform_random_bit_generator
+// provides result_type
+
+#include <algorithm>
+#include <testsuite_iterators.h>
+
+struct G
+{
+  constexpr static unsigned min() { return 0;  }
+  constexpr static unsigned max() { return 10; }
+  unsigned operator()() const;
+};
+
+static_assert(std::uniform_random_bit_generator<G>);
+
+void
+test_pr121919()
+{
+  int arr[2]{ 1, 2 };
+  __gnu_test::test_random_access_range r(arr);
+  std::ranges::shuffle(r, G{});
+  std::ranges::shuffle(std::ranges::begin(r), std::ranges::end(r), G{});
+}
--- a/src/libstdc++-v3/testsuite/std/time/clock/local/io.cc
+++ b/src/libstdc++-v3/testsuite/std/time/clock/local/io.cc
@@ -136,5 +136,6 @@ static_assert( ! ostream_insertable<std::chrono::local_time<D>> );
 int main()
 {
   test_ostream();
+  test_format();
   test_parse();
 }
new file mode 100644
--- /dev/null
+++ b/src/libstdc++-v3/testsuite/std/time/parse/125369.cc
@@ -0,0 +1,65 @@
+// { dg-do run { target c++20 } }
+
+#include <chrono>
+#include <sstream>
+#include <testsuite_hooks.h>
+
+using namespace std::chrono;
+
+const std::string input = "2026-05-18 15:26:48 ";
+const std::string fmt = "%F %T %";
+sys_seconds ss;
+minutes offset{};
+std::string abbrev;
+
+void
+test_parse_z()
+{
+  for (auto suffix : {"Z", "+", "+Z", "-A", "+1Z", "+010", "+010Z"})
+  {
+    std::istringstream in{input + suffix};
+    from_stream(in, (fmt + "z").c_str(), ss, &abbrev, &offset);
+
+    VERIFY( in.fail() );
+    VERIFY( ss == sys_seconds(0s) );
+    VERIFY( offset == 0min );
+    VERIFY( abbrev.empty() );
+  }
+}
+
+void
+test_parse_Ez()
+{
+  for (auto suffix : {"Z", "+", "-", "+01:", "+01:X"})
+  {
+    std::istringstream in{input + suffix};
+    from_stream(in, (fmt + "Ez").c_str(), ss, &abbrev, &offset);
+
+    VERIFY( in.fail() );
+    VERIFY( ss == sys_seconds(0s) );
+    VERIFY( offset == 0min );
+    VERIFY( abbrev.empty() );
+  }
+}
+
+void
+test_parse_Oz()
+{
+  for (auto suffix : {"Z", "+", "-", "+01:", "+01:X"})
+  {
+    std::istringstream in{input + suffix};
+    from_stream(in, (fmt + "Oz").c_str(), ss, &abbrev, &offset);
+
+    VERIFY( in.fail() );
+    VERIFY( ss == sys_seconds(0s) );
+    VERIFY( offset == 0min );
+    VERIFY( abbrev.empty() );
+  }
+}
+
+int main()
+{
+  test_parse_z();
+  test_parse_Ez();
+  test_parse_Oz();
+}
